0cd6c720a854b2e95164e4c86f21e36a30af231f
[linux-2.6.git] / drivers / hwmon / adt7473.c
1 /*
2  * A hwmon driver for the Analog Devices ADT7473
3  * Copyright (C) 2007 IBM
4  *
5  * Author: Darrick J. Wong <djwong@us.ibm.com>
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
20  */
21
22 #include <linux/module.h>
23 #include <linux/jiffies.h>
24 #include <linux/i2c.h>
25 #include <linux/hwmon.h>
26 #include <linux/hwmon-sysfs.h>
27 #include <linux/err.h>
28 #include <linux/mutex.h>
29 #include <linux/delay.h>
30 #include <linux/log2.h>
31
32 /* Addresses to scan */
33 static const unsigned short normal_i2c[] = { 0x2C, 0x2D, 0x2E, I2C_CLIENT_END };
34
35 /* Insmod parameters */
36 I2C_CLIENT_INSMOD_1(adt7473);
37
38 /* ADT7473 registers */
39 #define ADT7473_REG_BASE_ADDR                   0x20
40
41 #define ADT7473_REG_VOLT_BASE_ADDR              0x21
42 #define ADT7473_REG_VOLT_MIN_BASE_ADDR          0x46
43
44 #define ADT7473_REG_TEMP_BASE_ADDR              0x25
45 #define ADT7473_REG_TEMP_LIMITS_BASE_ADDR       0x4E
46 #define ADT7473_REG_TEMP_TMIN_BASE_ADDR         0x67
47 #define ADT7473_REG_TEMP_TMAX_BASE_ADDR         0x6A
48
49 #define ADT7473_REG_FAN_BASE_ADDR               0x28
50 #define ADT7473_REG_FAN_MIN_BASE_ADDR           0x54
51
52 #define ADT7473_REG_PWM_BASE_ADDR               0x30
53 #define ADT7473_REG_PWM_MIN_BASE_ADDR           0x64
54 #define ADT7473_REG_PWM_MAX_BASE_ADDR           0x38
55 #define ADT7473_REG_PWM_BHVR_BASE_ADDR          0x5C
56 #define         ADT7473_PWM_BHVR_MASK           0xE0
57 #define         ADT7473_PWM_BHVR_SHIFT          5
58
59 #define ADT7473_REG_CFG1                        0x40
60 #define         ADT7473_CFG1_START              0x01
61 #define         ADT7473_CFG1_READY              0x04
62 #define ADT7473_REG_CFG2                        0x73
63 #define ADT7473_REG_CFG3                        0x78
64 #define ADT7473_REG_CFG4                        0x7D
65 #define         ADT7473_CFG4_MAX_DUTY_AT_OVT    0x08
66 #define ADT7473_REG_CFG5                        0x7C
67 #define         ADT7473_CFG5_TEMP_TWOS          0x01
68 #define         ADT7473_CFG5_TEMP_OFFSET        0x02
69
70 #define ADT7473_REG_DEVICE                      0x3D
71 #define         ADT7473_VENDOR                  0x41
72 #define ADT7473_REG_VENDOR                      0x3E
73 #define         ADT7473_DEVICE                  0x73
74 #define ADT7473_REG_REVISION                    0x3F
75 #define         ADT7473_REV_68                  0x68
76 #define         ADT7473_REV_69                  0x69
77
78 #define ADT7473_REG_ALARM1                      0x41
79 #define         ADT7473_VCCP_ALARM              0x02
80 #define         ADT7473_VCC_ALARM               0x04
81 #define         ADT7473_R1T_ALARM               0x10
82 #define         ADT7473_LT_ALARM                0x20
83 #define         ADT7473_R2T_ALARM               0x40
84 #define         ADT7473_OOL                     0x80
85 #define ADT7473_REG_ALARM2                      0x42
86 #define         ADT7473_OVT_ALARM               0x02
87 #define         ADT7473_FAN1_ALARM              0x04
88 #define         ADT7473_FAN2_ALARM              0x08
89 #define         ADT7473_FAN3_ALARM              0x10
90 #define         ADT7473_FAN4_ALARM              0x20
91 #define         ADT7473_R1T_SHORT               0x40
92 #define         ADT7473_R2T_SHORT               0x80
93
94 #define ALARM2(x)       ((x) << 8)
95
96 #define ADT7473_VOLT_COUNT      2
97 #define ADT7473_REG_VOLT(x)     (ADT7473_REG_VOLT_BASE_ADDR + (x))
98 #define ADT7473_REG_VOLT_MIN(x) (ADT7473_REG_VOLT_MIN_BASE_ADDR + ((x) * 2))
99 #define ADT7473_REG_VOLT_MAX(x) (ADT7473_REG_VOLT_MIN_BASE_ADDR + \
100                                 ((x) * 2) + 1)
101
102 #define ADT7473_TEMP_COUNT      3
103 #define ADT7473_REG_TEMP(x)     (ADT7473_REG_TEMP_BASE_ADDR + (x))
104 #define ADT7473_REG_TEMP_MIN(x) (ADT7473_REG_TEMP_LIMITS_BASE_ADDR + ((x) * 2))
105 #define ADT7473_REG_TEMP_MAX(x) (ADT7473_REG_TEMP_LIMITS_BASE_ADDR + \
106                                 ((x) * 2) + 1)
107 #define ADT7473_REG_TEMP_TMIN(x)        (ADT7473_REG_TEMP_TMIN_BASE_ADDR + (x))
108 #define ADT7473_REG_TEMP_TMAX(x)        (ADT7473_REG_TEMP_TMAX_BASE_ADDR + (x))
109
110 #define ADT7473_FAN_COUNT       4
111 #define ADT7473_REG_FAN(x)      (ADT7473_REG_FAN_BASE_ADDR + ((x) * 2))
112 #define ADT7473_REG_FAN_MIN(x)  (ADT7473_REG_FAN_MIN_BASE_ADDR + ((x) * 2))
113
114 #define ADT7473_PWM_COUNT       3
115 #define ADT7473_REG_PWM(x)      (ADT7473_REG_PWM_BASE_ADDR + (x))
116 #define ADT7473_REG_PWM_MAX(x)  (ADT7473_REG_PWM_MAX_BASE_ADDR + (x))
117 #define ADT7473_REG_PWM_MIN(x)  (ADT7473_REG_PWM_MIN_BASE_ADDR + (x))
118 #define ADT7473_REG_PWM_BHVR(x) (ADT7473_REG_PWM_BHVR_BASE_ADDR + (x))
119
120 /* How often do we reread sensors values? (In jiffies) */
121 #define SENSOR_REFRESH_INTERVAL (2 * HZ)
122
123 /* How often do we reread sensor limit values? (In jiffies) */
124 #define LIMIT_REFRESH_INTERVAL  (60 * HZ)
125
126 /* datasheet says to divide this number by the fan reading to get fan rpm */
127 #define FAN_PERIOD_TO_RPM(x)    ((90000 * 60) / (x))
128 #define FAN_RPM_TO_PERIOD       FAN_PERIOD_TO_RPM
129 #define FAN_PERIOD_INVALID      65535
130 #define FAN_DATA_VALID(x)       ((x) && (x) != FAN_PERIOD_INVALID)
131
132 struct adt7473_data {
133         struct i2c_client       client;
134         struct device           *hwmon_dev;
135         struct attribute_group  attrs;
136         struct mutex            lock;
137         char                    sensors_valid;
138         char                    limits_valid;
139         unsigned long           sensors_last_updated;   /* In jiffies */
140         unsigned long           limits_last_updated;    /* In jiffies */
141
142         u8                      volt[ADT7473_VOLT_COUNT];
143         s8                      volt_min[ADT7473_VOLT_COUNT];
144         s8                      volt_max[ADT7473_VOLT_COUNT];
145
146         s8                      temp[ADT7473_TEMP_COUNT];
147         s8                      temp_min[ADT7473_TEMP_COUNT];
148         s8                      temp_max[ADT7473_TEMP_COUNT];
149         s8                      temp_tmin[ADT7473_TEMP_COUNT];
150         /* This is called the !THERM limit in the datasheet */
151         s8                      temp_tmax[ADT7473_TEMP_COUNT];
152
153         u16                     fan[ADT7473_FAN_COUNT];
154         u16                     fan_min[ADT7473_FAN_COUNT];
155
156         u8                      pwm[ADT7473_PWM_COUNT];
157         u8                      pwm_max[ADT7473_PWM_COUNT];
158         u8                      pwm_min[ADT7473_PWM_COUNT];
159         u8                      pwm_behavior[ADT7473_PWM_COUNT];
160
161         u8                      temp_twos_complement;
162         u8                      temp_offset;
163
164         u16                     alarm;
165         u8                      max_duty_at_overheat;
166 };
167
168 static int adt7473_attach_adapter(struct i2c_adapter *adapter);
169 static int adt7473_detect(struct i2c_adapter *adapter, int address, int kind);
170 static int adt7473_detach_client(struct i2c_client *client);
171
172 static struct i2c_driver adt7473_driver = {
173         .driver = {
174                 .name   = "adt7473",
175         },
176         .attach_adapter = adt7473_attach_adapter,
177         .detach_client  = adt7473_detach_client,
178 };
179
180 /*
181  * 16-bit registers on the ADT7473 are low-byte first.  The data sheet says
182  * that the low byte must be read before the high byte.
183  */
184 static inline int adt7473_read_word_data(struct i2c_client *client, u8 reg)
185 {
186         u16 foo;
187         foo = i2c_smbus_read_byte_data(client, reg);
188         foo |= ((u16)i2c_smbus_read_byte_data(client, reg + 1) << 8);
189         return foo;
190 }
191
192 static inline int adt7473_write_word_data(struct i2c_client *client, u8 reg,
193                                           u16 value)
194 {
195         return i2c_smbus_write_byte_data(client, reg, value & 0xFF)
196                && i2c_smbus_write_byte_data(client, reg + 1, value >> 8);
197 }
198
199 static void adt7473_init_client(struct i2c_client *client)
200 {
201         int reg = i2c_smbus_read_byte_data(client, ADT7473_REG_CFG1);
202
203         if (!(reg & ADT7473_CFG1_READY)) {
204                 dev_err(&client->dev, "Chip not ready.\n");
205         } else {
206                 /* start monitoring */
207                 i2c_smbus_write_byte_data(client, ADT7473_REG_CFG1,
208                                           reg | ADT7473_CFG1_START);
209         }
210 }
211
212 static struct adt7473_data *adt7473_update_device(struct device *dev)
213 {
214         struct i2c_client *client = to_i2c_client(dev);
215         struct adt7473_data *data = i2c_get_clientdata(client);
216         unsigned long local_jiffies = jiffies;
217         u8 cfg;
218         int i;
219
220         mutex_lock(&data->lock);
221         if (time_before(local_jiffies, data->sensors_last_updated +
222                 SENSOR_REFRESH_INTERVAL)
223                 && data->sensors_valid)
224                 goto no_sensor_update;
225
226         for (i = 0; i < ADT7473_VOLT_COUNT; i++)
227                 data->volt[i] = i2c_smbus_read_byte_data(client,
228                                                 ADT7473_REG_VOLT(i));
229
230         /* Determine temperature encoding */
231         cfg = i2c_smbus_read_byte_data(client, ADT7473_REG_CFG5);
232         data->temp_twos_complement = (cfg & ADT7473_CFG5_TEMP_TWOS);
233
234         /*
235          * What does this do? it implies a variable temperature sensor
236          * offset, but the datasheet doesn't say anything about this bit
237          * and other parts of the datasheet imply that "offset64" mode
238          * means that you shift temp values by -64 if the above bit was set.
239          */
240         data->temp_offset = (cfg & ADT7473_CFG5_TEMP_OFFSET);
241
242         for (i = 0; i < ADT7473_TEMP_COUNT; i++)
243                 data->temp[i] = i2c_smbus_read_byte_data(client,
244                                                          ADT7473_REG_TEMP(i));
245
246         for (i = 0; i < ADT7473_FAN_COUNT; i++)
247                 data->fan[i] = adt7473_read_word_data(client,
248                                                 ADT7473_REG_FAN(i));
249
250         for (i = 0; i < ADT7473_PWM_COUNT; i++)
251                 data->pwm[i] = i2c_smbus_read_byte_data(client,
252                                                 ADT7473_REG_PWM(i));
253
254         data->alarm = i2c_smbus_read_byte_data(client, ADT7473_REG_ALARM1);
255         if (data->alarm & ADT7473_OOL)
256                 data->alarm |= ALARM2(i2c_smbus_read_byte_data(client,
257                                                          ADT7473_REG_ALARM2));
258
259         data->sensors_last_updated = local_jiffies;
260         data->sensors_valid = 1;
261
262 no_sensor_update:
263         if (time_before(local_jiffies, data->limits_last_updated +
264                 LIMIT_REFRESH_INTERVAL)
265                 && data->limits_valid)
266                 goto out;
267
268         for (i = 0; i < ADT7473_VOLT_COUNT; i++) {
269                 data->volt_min[i] = i2c_smbus_read_byte_data(client,
270                                                 ADT7473_REG_VOLT_MIN(i));
271                 data->volt_max[i] = i2c_smbus_read_byte_data(client,
272                                                 ADT7473_REG_VOLT_MAX(i));
273         }
274
275         for (i = 0; i < ADT7473_TEMP_COUNT; i++) {
276                 data->temp_min[i] = i2c_smbus_read_byte_data(client,
277                                                 ADT7473_REG_TEMP_MIN(i));
278                 data->temp_max[i] = i2c_smbus_read_byte_data(client,
279                                                 ADT7473_REG_TEMP_MAX(i));
280                 data->temp_tmin[i] = i2c_smbus_read_byte_data(client,
281                                                 ADT7473_REG_TEMP_TMIN(i));
282                 data->temp_tmax[i] = i2c_smbus_read_byte_data(client,
283                                                 ADT7473_REG_TEMP_TMAX(i));
284         }
285
286         for (i = 0; i < ADT7473_FAN_COUNT; i++)
287                 data->fan_min[i] = adt7473_read_word_data(client,
288                                                 ADT7473_REG_FAN_MIN(i));
289
290         for (i = 0; i < ADT7473_PWM_COUNT; i++) {
291                 data->pwm_max[i] = i2c_smbus_read_byte_data(client,
292                                                 ADT7473_REG_PWM_MAX(i));
293                 data->pwm_min[i] = i2c_smbus_read_byte_data(client,
294                                                 ADT7473_REG_PWM_MIN(i));
295                 data->pwm_behavior[i] = i2c_smbus_read_byte_data(client,
296                                                 ADT7473_REG_PWM_BHVR(i));
297         }
298
299         i = i2c_smbus_read_byte_data(client, ADT7473_REG_CFG4);
300         data->max_duty_at_overheat = !!(i & ADT7473_CFG4_MAX_DUTY_AT_OVT);
301
302         data->limits_last_updated = local_jiffies;
303         data->limits_valid = 1;
304
305 out:
306         mutex_unlock(&data->lock);
307         return data;
308 }
309
310 /*
311  * On this chip, voltages are given as a count of steps between a minimum
312  * and maximum voltage, not a direct voltage.
313  */
314 static const int volt_convert_table[][2] = {
315         {2997, 3},
316         {4395, 4},
317 };
318
319 static int decode_volt(int volt_index, u8 raw)
320 {
321         int cmax = volt_convert_table[volt_index][0];
322         int cmin = volt_convert_table[volt_index][1];
323         return ((raw * (cmax - cmin)) / 255) + cmin;
324 }
325
326 static u8 encode_volt(int volt_index, int cooked)
327 {
328         int cmax = volt_convert_table[volt_index][0];
329         int cmin = volt_convert_table[volt_index][1];
330         u8 x;
331
332         if (cooked > cmax)
333                 cooked = cmax;
334         else if (cooked < cmin)
335                 cooked = cmin;
336
337         x = ((cooked - cmin) * 255) / (cmax - cmin);
338
339         return x;
340 }
341
342 static ssize_t show_volt_min(struct device *dev,
343                              struct device_attribute *devattr,
344                              char *buf)
345 {
346         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
347         struct adt7473_data *data = adt7473_update_device(dev);
348         return sprintf(buf, "%d\n",
349                        decode_volt(attr->index, data->volt_min[attr->index]));
350 }
351
352 static ssize_t set_volt_min(struct device *dev,
353                             struct device_attribute *devattr,
354                             const char *buf,
355                             size_t count)
356 {
357         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
358         struct i2c_client *client = to_i2c_client(dev);
359         struct adt7473_data *data = i2c_get_clientdata(client);
360         int volt = encode_volt(attr->index, simple_strtol(buf, NULL, 10));
361
362         mutex_lock(&data->lock);
363         data->volt_min[attr->index] = volt;
364         i2c_smbus_write_byte_data(client, ADT7473_REG_VOLT_MIN(attr->index),
365                                   volt);
366         mutex_unlock(&data->lock);
367
368         return count;
369 }
370
371 static ssize_t show_volt_max(struct device *dev,
372                              struct device_attribute *devattr,
373                              char *buf)
374 {
375         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
376         struct adt7473_data *data = adt7473_update_device(dev);
377         return sprintf(buf, "%d\n",
378                        decode_volt(attr->index, data->volt_max[attr->index]));
379 }
380
381 static ssize_t set_volt_max(struct device *dev,
382                             struct device_attribute *devattr,
383                             const char *buf,
384                             size_t count)
385 {
386         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
387         struct i2c_client *client = to_i2c_client(dev);
388         struct adt7473_data *data = i2c_get_clientdata(client);
389         int volt = encode_volt(attr->index, simple_strtol(buf, NULL, 10));
390
391         mutex_lock(&data->lock);
392         data->volt_max[attr->index] = volt;
393         i2c_smbus_write_byte_data(client, ADT7473_REG_VOLT_MAX(attr->index),
394                                   volt);
395         mutex_unlock(&data->lock);
396
397         return count;
398 }
399
400 static ssize_t show_volt(struct device *dev, struct device_attribute *devattr,
401                          char *buf)
402 {
403         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
404         struct adt7473_data *data = adt7473_update_device(dev);
405
406         return sprintf(buf, "%d\n",
407                        decode_volt(attr->index, data->volt[attr->index]));
408 }
409
410 /*
411  * This chip can report temperature data either as a two's complement
412  * number in the range -128 to 127, or as an unsigned number that must
413  * be offset by 64.
414  */
415 static int decode_temp(u8 twos_complement, u8 raw)
416 {
417         return twos_complement ? (s8)raw : raw - 64;
418 }
419
420 static u8 encode_temp(u8 twos_complement, int cooked)
421 {
422         return twos_complement ? cooked & 0xFF : cooked + 64;
423 }
424
425 static ssize_t show_temp_min(struct device *dev,
426                              struct device_attribute *devattr,
427                              char *buf)
428 {
429         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
430         struct adt7473_data *data = adt7473_update_device(dev);
431         return sprintf(buf, "%d\n", 1000 * decode_temp(
432                                                 data->temp_twos_complement,
433                                                 data->temp_min[attr->index]));
434 }
435
436 static ssize_t set_temp_min(struct device *dev,
437                             struct device_attribute *devattr,
438                             const char *buf,
439                             size_t count)
440 {
441         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
442         struct i2c_client *client = to_i2c_client(dev);
443         struct adt7473_data *data = i2c_get_clientdata(client);
444         int temp = simple_strtol(buf, NULL, 10) / 1000;
445         temp = encode_temp(data->temp_twos_complement, temp);
446
447         mutex_lock(&data->lock);
448         data->temp_min[attr->index] = temp;
449         i2c_smbus_write_byte_data(client, ADT7473_REG_TEMP_MIN(attr->index),
450                                   temp);
451         mutex_unlock(&data->lock);
452
453         return count;
454 }
455
456 static ssize_t show_temp_max(struct device *dev,
457                              struct device_attribute *devattr,
458                              char *buf)
459 {
460         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
461         struct adt7473_data *data = adt7473_update_device(dev);
462         return sprintf(buf, "%d\n", 1000 * decode_temp(
463                                                 data->temp_twos_complement,
464                                                 data->temp_max[attr->index]));
465 }
466
467 static ssize_t set_temp_max(struct device *dev,
468                             struct device_attribute *devattr,
469                             const char *buf,
470                             size_t count)
471 {
472         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
473         struct i2c_client *client = to_i2c_client(dev);
474         struct adt7473_data *data = i2c_get_clientdata(client);
475         int temp = simple_strtol(buf, NULL, 10) / 1000;
476         temp = encode_temp(data->temp_twos_complement, temp);
477
478         mutex_lock(&data->lock);
479         data->temp_max[attr->index] = temp;
480         i2c_smbus_write_byte_data(client, ADT7473_REG_TEMP_MAX(attr->index),
481                                   temp);
482         mutex_unlock(&data->lock);
483
484         return count;
485 }
486
487 static ssize_t show_temp(struct device *dev, struct device_attribute *devattr,
488                          char *buf)
489 {
490         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
491         struct adt7473_data *data = adt7473_update_device(dev);
492         return sprintf(buf, "%d\n", 1000 * decode_temp(
493                                                 data->temp_twos_complement,
494                                                 data->temp[attr->index]));
495 }
496
497 static ssize_t show_fan_min(struct device *dev,
498                             struct device_attribute *devattr,
499                             char *buf)
500 {
501         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
502         struct adt7473_data *data = adt7473_update_device(dev);
503
504         if (FAN_DATA_VALID(data->fan_min[attr->index]))
505                 return sprintf(buf, "%d\n",
506                                FAN_PERIOD_TO_RPM(data->fan_min[attr->index]));
507         else
508                 return sprintf(buf, "0\n");
509 }
510
511 static ssize_t set_fan_min(struct device *dev,
512                            struct device_attribute *devattr,
513                            const char *buf, size_t count)
514 {
515         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
516         struct i2c_client *client = to_i2c_client(dev);
517         struct adt7473_data *data = i2c_get_clientdata(client);
518         int temp = simple_strtol(buf, NULL, 10);
519
520         if (!temp)
521                 return -EINVAL;
522         temp = FAN_RPM_TO_PERIOD(temp);
523
524         mutex_lock(&data->lock);
525         data->fan_min[attr->index] = temp;
526         adt7473_write_word_data(client, ADT7473_REG_FAN_MIN(attr->index), temp);
527         mutex_unlock(&data->lock);
528
529         return count;
530 }
531
532 static ssize_t show_fan(struct device *dev, struct device_attribute *devattr,
533                         char *buf)
534 {
535         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
536         struct adt7473_data *data = adt7473_update_device(dev);
537
538         if (FAN_DATA_VALID(data->fan[attr->index]))
539                 return sprintf(buf, "%d\n",
540                                FAN_PERIOD_TO_RPM(data->fan[attr->index]));
541         else
542                 return sprintf(buf, "0\n");
543 }
544
545 static ssize_t show_max_duty_at_crit(struct device *dev,
546                                      struct device_attribute *devattr,
547                                      char *buf)
548 {
549         struct adt7473_data *data = adt7473_update_device(dev);
550         return sprintf(buf, "%d\n", data->max_duty_at_overheat);
551 }
552
553 static ssize_t set_max_duty_at_crit(struct device *dev,
554                                     struct device_attribute *devattr,
555                                     const char *buf,
556                                     size_t count)
557 {
558         u8 reg;
559         struct i2c_client *client = to_i2c_client(dev);
560         struct adt7473_data *data = i2c_get_clientdata(client);
561         int temp = simple_strtol(buf, NULL, 10);
562
563         mutex_lock(&data->lock);
564         data->max_duty_at_overheat = !!temp;
565         reg = i2c_smbus_read_byte_data(client, ADT7473_REG_CFG4);
566         if (temp)
567                 reg |= ADT7473_CFG4_MAX_DUTY_AT_OVT;
568         else
569                 reg &= ~ADT7473_CFG4_MAX_DUTY_AT_OVT;
570         i2c_smbus_write_byte_data(client, ADT7473_REG_CFG4, reg);
571         mutex_unlock(&data->lock);
572
573         return count;
574 }
575
576 static ssize_t show_pwm(struct device *dev, struct device_attribute *devattr,
577                         char *buf)
578 {
579         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
580         struct adt7473_data *data = adt7473_update_device(dev);
581         return sprintf(buf, "%d\n", data->pwm[attr->index]);
582 }
583
584 static ssize_t set_pwm(struct device *dev, struct device_attribute *devattr,
585                         const char *buf, size_t count)
586 {
587         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
588         struct i2c_client *client = to_i2c_client(dev);
589         struct adt7473_data *data = i2c_get_clientdata(client);
590         int temp = simple_strtol(buf, NULL, 10);
591
592         mutex_lock(&data->lock);
593         data->pwm[attr->index] = temp;
594         i2c_smbus_write_byte_data(client, ADT7473_REG_PWM(attr->index), temp);
595         mutex_unlock(&data->lock);
596
597         return count;
598 }
599
600 static ssize_t show_pwm_max(struct device *dev,
601                             struct device_attribute *devattr,
602                             char *buf)
603 {
604         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
605         struct adt7473_data *data = adt7473_update_device(dev);
606         return sprintf(buf, "%d\n", data->pwm_max[attr->index]);
607 }
608
609 static ssize_t set_pwm_max(struct device *dev,
610                            struct device_attribute *devattr,
611                            const char *buf,
612                            size_t count)
613 {
614         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
615         struct i2c_client *client = to_i2c_client(dev);
616         struct adt7473_data *data = i2c_get_clientdata(client);
617         int temp = simple_strtol(buf, NULL, 10);
618
619         mutex_lock(&data->lock);
620         data->pwm_max[attr->index] = temp;
621         i2c_smbus_write_byte_data(client, ADT7473_REG_PWM_MAX(attr->index),
622                                   temp);
623         mutex_unlock(&data->lock);
624
625         return count;
626 }
627
628 static ssize_t show_pwm_min(struct device *dev,
629                             struct device_attribute *devattr,
630                             char *buf)
631 {
632         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
633         struct adt7473_data *data = adt7473_update_device(dev);
634         return sprintf(buf, "%d\n", data->pwm_min[attr->index]);
635 }
636
637 static ssize_t set_pwm_min(struct device *dev,
638                            struct device_attribute *devattr,
639                            const char *buf,
640                            size_t count)
641 {
642         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
643         struct i2c_client *client = to_i2c_client(dev);
644         struct adt7473_data *data = i2c_get_clientdata(client);
645         int temp = simple_strtol(buf, NULL, 10);
646
647         mutex_lock(&data->lock);
648         data->pwm_min[attr->index] = temp;
649         i2c_smbus_write_byte_data(client, ADT7473_REG_PWM_MIN(attr->index),
650                                   temp);
651         mutex_unlock(&data->lock);
652
653         return count;
654 }
655
656 static ssize_t show_temp_tmax(struct device *dev,
657                               struct device_attribute *devattr,
658                               char *buf)
659 {
660         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
661         struct adt7473_data *data = adt7473_update_device(dev);
662         return sprintf(buf, "%d\n", 1000 * decode_temp(
663                                                 data->temp_twos_complement,
664                                                 data->temp_tmax[attr->index]));
665 }
666
667 static ssize_t set_temp_tmax(struct device *dev,
668                              struct device_attribute *devattr,
669                              const char *buf,
670                              size_t count)
671 {
672         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
673         struct i2c_client *client = to_i2c_client(dev);
674         struct adt7473_data *data = i2c_get_clientdata(client);
675         int temp = simple_strtol(buf, NULL, 10) / 1000;
676         temp = encode_temp(data->temp_twos_complement, temp);
677
678         mutex_lock(&data->lock);
679         data->temp_tmax[attr->index] = temp;
680         i2c_smbus_write_byte_data(client, ADT7473_REG_TEMP_TMAX(attr->index),
681                                   temp);
682         mutex_unlock(&data->lock);
683
684         return count;
685 }
686
687 static ssize_t show_temp_tmin(struct device *dev,
688                               struct device_attribute *devattr,
689                               char *buf)
690 {
691         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
692         struct adt7473_data *data = adt7473_update_device(dev);
693         return sprintf(buf, "%d\n", 1000 * decode_temp(
694                                                 data->temp_twos_complement,
695                                                 data->temp_tmin[attr->index]));
696 }
697
698 static ssize_t set_temp_tmin(struct device *dev,
699                              struct device_attribute *devattr,
700                              const char *buf,
701                              size_t count)
702 {
703         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
704         struct i2c_client *client = to_i2c_client(dev);
705         struct adt7473_data *data = i2c_get_clientdata(client);
706         int temp = simple_strtol(buf, NULL, 10) / 1000;
707         temp = encode_temp(data->temp_twos_complement, temp);
708
709         mutex_lock(&data->lock);
710         data->temp_tmin[attr->index] = temp;
711         i2c_smbus_write_byte_data(client, ADT7473_REG_TEMP_TMIN(attr->index),
712                                   temp);
713         mutex_unlock(&data->lock);
714
715         return count;
716 }
717
718 static ssize_t show_pwm_enable(struct device *dev,
719                                struct device_attribute *devattr,
720                                char *buf)
721 {
722         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
723         struct adt7473_data *data = adt7473_update_device(dev);
724
725         switch (data->pwm_behavior[attr->index] >> ADT7473_PWM_BHVR_SHIFT) {
726         case 3:
727                 return sprintf(buf, "0\n");
728         case 7:
729                 return sprintf(buf, "1\n");
730         default:
731                 return sprintf(buf, "2\n");
732         }
733 }
734
735 static ssize_t set_pwm_enable(struct device *dev,
736                               struct device_attribute *devattr,
737                               const char *buf,
738                               size_t count)
739 {
740         u8 reg;
741         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
742         struct i2c_client *client = to_i2c_client(dev);
743         struct adt7473_data *data = i2c_get_clientdata(client);
744         int temp = simple_strtol(buf, NULL, 10);
745
746         switch (temp) {
747         case 0:
748                 temp = 3;
749                 break;
750         case 1:
751                 temp = 7;
752                 break;
753         case 2:
754                 /* Enter automatic mode with fans off */
755                 temp = 4;
756                 break;
757         default:
758                 return -EINVAL;
759         }
760
761         mutex_lock(&data->lock);
762         reg = i2c_smbus_read_byte_data(client,
763                                        ADT7473_REG_PWM_BHVR(attr->index));
764         reg = (temp << ADT7473_PWM_BHVR_SHIFT) |
765               (reg & ~ADT7473_PWM_BHVR_MASK);
766         i2c_smbus_write_byte_data(client, ADT7473_REG_PWM_BHVR(attr->index),
767                                   reg);
768         data->pwm_behavior[attr->index] = reg;
769         mutex_unlock(&data->lock);
770
771         return count;
772 }
773
774 static ssize_t show_pwm_auto_temp(struct device *dev,
775                                   struct device_attribute *devattr,
776                                   char *buf)
777 {
778         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
779         struct adt7473_data *data = adt7473_update_device(dev);
780         int bhvr = data->pwm_behavior[attr->index] >> ADT7473_PWM_BHVR_SHIFT;
781
782         switch (bhvr) {
783         case 3:
784         case 4:
785         case 7:
786                 return sprintf(buf, "0\n");
787         case 0:
788         case 1:
789         case 5:
790         case 6:
791                 return sprintf(buf, "%d\n", bhvr + 1);
792         case 2:
793                 return sprintf(buf, "4\n");
794         }
795         /* shouldn't ever get here */
796         BUG();
797 }
798
799 static ssize_t set_pwm_auto_temp(struct device *dev,
800                                  struct device_attribute *devattr,
801                                  const char *buf,
802                                  size_t count)
803 {
804         u8 reg;
805         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
806         struct i2c_client *client = to_i2c_client(dev);
807         struct adt7473_data *data = i2c_get_clientdata(client);
808         int temp = simple_strtol(buf, NULL, 10);
809
810         switch (temp) {
811         case 1:
812         case 2:
813         case 6:
814         case 7:
815                 temp--;
816                 break;
817         case 0:
818                 temp = 4;
819                 break;
820         default:
821                 return -EINVAL;
822         }
823
824         mutex_lock(&data->lock);
825         reg = i2c_smbus_read_byte_data(client,
826                                        ADT7473_REG_PWM_BHVR(attr->index));
827         reg = (temp << ADT7473_PWM_BHVR_SHIFT) |
828               (reg & ~ADT7473_PWM_BHVR_MASK);
829         i2c_smbus_write_byte_data(client, ADT7473_REG_PWM_BHVR(attr->index),
830                                   reg);
831         data->pwm_behavior[attr->index] = reg;
832         mutex_unlock(&data->lock);
833
834         return count;
835 }
836
837 static ssize_t show_alarm(struct device *dev,
838                           struct device_attribute *devattr,
839                           char *buf)
840 {
841         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
842         struct adt7473_data *data = adt7473_update_device(dev);
843
844         if (data->alarm & attr->index)
845                 return sprintf(buf, "1\n");
846         else
847                 return sprintf(buf, "0\n");
848 }
849
850
851 static SENSOR_DEVICE_ATTR(in1_max, S_IWUSR | S_IRUGO, show_volt_max,
852                           set_volt_max, 0);
853 static SENSOR_DEVICE_ATTR(in2_max, S_IWUSR | S_IRUGO, show_volt_max,
854                           set_volt_max, 1);
855
856 static SENSOR_DEVICE_ATTR(in1_min, S_IWUSR | S_IRUGO, show_volt_min,
857                           set_volt_min, 0);
858 static SENSOR_DEVICE_ATTR(in2_min, S_IWUSR | S_IRUGO, show_volt_min,
859                           set_volt_min, 1);
860
861 static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, show_volt, NULL, 0);
862 static SENSOR_DEVICE_ATTR(in2_input, S_IRUGO, show_volt, NULL, 1);
863
864 static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL,
865                           ADT7473_VCCP_ALARM);
866 static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL,
867                           ADT7473_VCC_ALARM);
868
869 static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_temp_max,
870                           set_temp_max, 0);
871 static SENSOR_DEVICE_ATTR(temp2_max, S_IWUSR | S_IRUGO, show_temp_max,
872                           set_temp_max, 1);
873 static SENSOR_DEVICE_ATTR(temp3_max, S_IWUSR | S_IRUGO, show_temp_max,
874                           set_temp_max, 2);
875
876 static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO, show_temp_min,
877                           set_temp_min, 0);
878 static SENSOR_DEVICE_ATTR(temp2_min, S_IWUSR | S_IRUGO, show_temp_min,
879                           set_temp_min, 1);
880 static SENSOR_DEVICE_ATTR(temp3_min, S_IWUSR | S_IRUGO, show_temp_min,
881                           set_temp_min, 2);
882
883 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0);
884 static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp, NULL, 1);
885 static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, show_temp, NULL, 2);
886
887 static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL,
888                           ADT7473_R1T_ALARM | ALARM2(ADT7473_R1T_SHORT));
889 static SENSOR_DEVICE_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL,
890                           ADT7473_LT_ALARM);
891 static SENSOR_DEVICE_ATTR(temp3_alarm, S_IRUGO, show_alarm, NULL,
892                           ADT7473_R2T_ALARM | ALARM2(ADT7473_R2T_SHORT));
893
894 static SENSOR_DEVICE_ATTR(fan1_min, S_IWUSR | S_IRUGO, show_fan_min,
895                           set_fan_min, 0);
896 static SENSOR_DEVICE_ATTR(fan2_min, S_IWUSR | S_IRUGO, show_fan_min,
897                           set_fan_min, 1);
898 static SENSOR_DEVICE_ATTR(fan3_min, S_IWUSR | S_IRUGO, show_fan_min,
899                           set_fan_min, 2);
900 static SENSOR_DEVICE_ATTR(fan4_min, S_IWUSR | S_IRUGO, show_fan_min,
901                           set_fan_min, 3);
902
903 static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, show_fan, NULL, 0);
904 static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, show_fan, NULL, 1);
905 static SENSOR_DEVICE_ATTR(fan3_input, S_IRUGO, show_fan, NULL, 2);
906 static SENSOR_DEVICE_ATTR(fan4_input, S_IRUGO, show_fan, NULL, 3);
907
908 static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL,
909                           ALARM2(ADT7473_FAN1_ALARM));
910 static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL,
911                           ALARM2(ADT7473_FAN2_ALARM));
912 static SENSOR_DEVICE_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL,
913                           ALARM2(ADT7473_FAN3_ALARM));
914 static SENSOR_DEVICE_ATTR(fan4_alarm, S_IRUGO, show_alarm, NULL,
915                           ALARM2(ADT7473_FAN4_ALARM));
916
917 static SENSOR_DEVICE_ATTR(pwm_use_point2_pwm_at_crit, S_IWUSR | S_IRUGO,
918                           show_max_duty_at_crit, set_max_duty_at_crit, 0);
919
920 static SENSOR_DEVICE_ATTR(pwm1, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 0);
921 static SENSOR_DEVICE_ATTR(pwm2, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 1);
922 static SENSOR_DEVICE_ATTR(pwm3, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 2);
923
924 static SENSOR_DEVICE_ATTR(pwm1_auto_point1_pwm, S_IWUSR | S_IRUGO,
925                           show_pwm_min, set_pwm_min, 0);
926 static SENSOR_DEVICE_ATTR(pwm2_auto_point1_pwm, S_IWUSR | S_IRUGO,
927                           show_pwm_min, set_pwm_min, 1);
928 static SENSOR_DEVICE_ATTR(pwm3_auto_point1_pwm, S_IWUSR | S_IRUGO,
929                           show_pwm_min, set_pwm_min, 2);
930
931 static SENSOR_DEVICE_ATTR(pwm1_auto_point2_pwm, S_IWUSR | S_IRUGO,
932                           show_pwm_max, set_pwm_max, 0);
933 static SENSOR_DEVICE_ATTR(pwm2_auto_point2_pwm, S_IWUSR | S_IRUGO,
934                           show_pwm_max, set_pwm_max, 1);
935 static SENSOR_DEVICE_ATTR(pwm3_auto_point2_pwm, S_IWUSR | S_IRUGO,
936                           show_pwm_max, set_pwm_max, 2);
937
938 static SENSOR_DEVICE_ATTR(temp1_auto_point1_temp, S_IWUSR | S_IRUGO,
939                           show_temp_tmin, set_temp_tmin, 0);
940 static SENSOR_DEVICE_ATTR(temp2_auto_point1_temp, S_IWUSR | S_IRUGO,
941                           show_temp_tmin, set_temp_tmin, 1);
942 static SENSOR_DEVICE_ATTR(temp3_auto_point1_temp, S_IWUSR | S_IRUGO,
943                           show_temp_tmin, set_temp_tmin, 2);
944
945 static SENSOR_DEVICE_ATTR(temp1_auto_point2_temp, S_IWUSR | S_IRUGO,
946                           show_temp_tmax, set_temp_tmax, 0);
947 static SENSOR_DEVICE_ATTR(temp2_auto_point2_temp, S_IWUSR | S_IRUGO,
948                           show_temp_tmax, set_temp_tmax, 1);
949 static SENSOR_DEVICE_ATTR(temp3_auto_point2_temp, S_IWUSR | S_IRUGO,
950                           show_temp_tmax, set_temp_tmax, 2);
951
952 static SENSOR_DEVICE_ATTR(pwm1_enable, S_IWUSR | S_IRUGO, show_pwm_enable,
953                           set_pwm_enable, 0);
954 static SENSOR_DEVICE_ATTR(pwm2_enable, S_IWUSR | S_IRUGO, show_pwm_enable,
955                           set_pwm_enable, 1);
956 static SENSOR_DEVICE_ATTR(pwm3_enable, S_IWUSR | S_IRUGO, show_pwm_enable,
957                           set_pwm_enable, 2);
958
959 static SENSOR_DEVICE_ATTR(pwm1_auto_channels_temp, S_IWUSR | S_IRUGO,
960                           show_pwm_auto_temp, set_pwm_auto_temp, 0);
961 static SENSOR_DEVICE_ATTR(pwm2_auto_channels_temp, S_IWUSR | S_IRUGO,
962                           show_pwm_auto_temp, set_pwm_auto_temp, 1);
963 static SENSOR_DEVICE_ATTR(pwm3_auto_channels_temp, S_IWUSR | S_IRUGO,
964                           show_pwm_auto_temp, set_pwm_auto_temp, 2);
965
966 static struct attribute *adt7473_attr[] =
967 {
968         &sensor_dev_attr_in1_max.dev_attr.attr,
969         &sensor_dev_attr_in2_max.dev_attr.attr,
970         &sensor_dev_attr_in1_min.dev_attr.attr,
971         &sensor_dev_attr_in2_min.dev_attr.attr,
972         &sensor_dev_attr_in1_input.dev_attr.attr,
973         &sensor_dev_attr_in2_input.dev_attr.attr,
974         &sensor_dev_attr_in1_alarm.dev_attr.attr,
975         &sensor_dev_attr_in2_alarm.dev_attr.attr,
976
977         &sensor_dev_attr_temp1_max.dev_attr.attr,
978         &sensor_dev_attr_temp2_max.dev_attr.attr,
979         &sensor_dev_attr_temp3_max.dev_attr.attr,
980         &sensor_dev_attr_temp1_min.dev_attr.attr,
981         &sensor_dev_attr_temp2_min.dev_attr.attr,
982         &sensor_dev_attr_temp3_min.dev_attr.attr,
983         &sensor_dev_attr_temp1_input.dev_attr.attr,
984         &sensor_dev_attr_temp2_input.dev_attr.attr,
985         &sensor_dev_attr_temp3_input.dev_attr.attr,
986         &sensor_dev_attr_temp1_alarm.dev_attr.attr,
987         &sensor_dev_attr_temp2_alarm.dev_attr.attr,
988         &sensor_dev_attr_temp3_alarm.dev_attr.attr,
989         &sensor_dev_attr_temp1_auto_point1_temp.dev_attr.attr,
990         &sensor_dev_attr_temp2_auto_point1_temp.dev_attr.attr,
991         &sensor_dev_attr_temp3_auto_point1_temp.dev_attr.attr,
992         &sensor_dev_attr_temp1_auto_point2_temp.dev_attr.attr,
993         &sensor_dev_attr_temp2_auto_point2_temp.dev_attr.attr,
994         &sensor_dev_attr_temp3_auto_point2_temp.dev_attr.attr,
995
996         &sensor_dev_attr_fan1_min.dev_attr.attr,
997         &sensor_dev_attr_fan2_min.dev_attr.attr,
998         &sensor_dev_attr_fan3_min.dev_attr.attr,
999         &sensor_dev_attr_fan4_min.dev_attr.attr,
1000         &sensor_dev_attr_fan1_input.dev_attr.attr,
1001         &sensor_dev_attr_fan2_input.dev_attr.attr,
1002         &sensor_dev_attr_fan3_input.dev_attr.attr,
1003         &sensor_dev_attr_fan4_input.dev_attr.attr,
1004         &sensor_dev_attr_fan1_alarm.dev_attr.attr,
1005         &sensor_dev_attr_fan2_alarm.dev_attr.attr,
1006         &sensor_dev_attr_fan3_alarm.dev_attr.attr,
1007         &sensor_dev_attr_fan4_alarm.dev_attr.attr,
1008
1009         &sensor_dev_attr_pwm_use_point2_pwm_at_crit.dev_attr.attr,
1010
1011         &sensor_dev_attr_pwm1.dev_attr.attr,
1012         &sensor_dev_attr_pwm2.dev_attr.attr,
1013         &sensor_dev_attr_pwm3.dev_attr.attr,
1014         &sensor_dev_attr_pwm1_auto_point1_pwm.dev_attr.attr,
1015         &sensor_dev_attr_pwm2_auto_point1_pwm.dev_attr.attr,
1016         &sensor_dev_attr_pwm3_auto_point1_pwm.dev_attr.attr,
1017         &sensor_dev_attr_pwm1_auto_point2_pwm.dev_attr.attr,
1018         &sensor_dev_attr_pwm2_auto_point2_pwm.dev_attr.attr,
1019         &sensor_dev_attr_pwm3_auto_point2_pwm.dev_attr.attr,
1020
1021         &sensor_dev_attr_pwm1_enable.dev_attr.attr,
1022         &sensor_dev_attr_pwm2_enable.dev_attr.attr,
1023         &sensor_dev_attr_pwm3_enable.dev_attr.attr,
1024         &sensor_dev_attr_pwm1_auto_channels_temp.dev_attr.attr,
1025         &sensor_dev_attr_pwm2_auto_channels_temp.dev_attr.attr,
1026         &sensor_dev_attr_pwm3_auto_channels_temp.dev_attr.attr,
1027
1028         NULL
1029 };
1030
1031 static int adt7473_attach_adapter(struct i2c_adapter *adapter)
1032 {
1033         if (!(adapter->class & I2C_CLASS_HWMON))
1034                 return 0;
1035         return i2c_probe(adapter, &addr_data, adt7473_detect);
1036 }
1037
1038 static int adt7473_detect(struct i2c_adapter *adapter, int address, int kind)
1039 {
1040         struct i2c_client *client;
1041         struct adt7473_data *data;
1042         int err = 0;
1043
1044         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
1045                 goto exit;
1046
1047         data = kzalloc(sizeof(struct adt7473_data), GFP_KERNEL);
1048         if (!data) {
1049                 err = -ENOMEM;
1050                 goto exit;
1051         }
1052
1053         client = &data->client;
1054         client->addr = address;
1055         client->adapter = adapter;
1056         client->driver = &adt7473_driver;
1057
1058         i2c_set_clientdata(client, data);
1059
1060         mutex_init(&data->lock);
1061
1062         if (kind <= 0) {
1063                 int vendor, device, revision;
1064
1065                 vendor = i2c_smbus_read_byte_data(client, ADT7473_REG_VENDOR);
1066                 if (vendor != ADT7473_VENDOR) {
1067                         err = -ENODEV;
1068                         goto exit_free;
1069                 }
1070
1071                 device = i2c_smbus_read_byte_data(client, ADT7473_REG_DEVICE);
1072                 if (device != ADT7473_DEVICE) {
1073                         err = -ENODEV;
1074                         goto exit_free;
1075                 }
1076
1077                 revision = i2c_smbus_read_byte_data(client,
1078                                                     ADT7473_REG_REVISION);
1079                 if (revision != ADT7473_REV_68 && revision != ADT7473_REV_69) {
1080                         err = -ENODEV;
1081                         goto exit_free;
1082                 }
1083         } else
1084                 dev_dbg(&adapter->dev, "detection forced\n");
1085
1086         strlcpy(client->name, "adt7473", I2C_NAME_SIZE);
1087
1088         err = i2c_attach_client(client);
1089         if (err)
1090                 goto exit_free;
1091
1092         dev_info(&client->dev, "%s chip found\n", client->name);
1093
1094         /* Initialize the ADT7473 chip */
1095         adt7473_init_client(client);
1096
1097         /* Register sysfs hooks */
1098         data->attrs.attrs = adt7473_attr;
1099         err = sysfs_create_group(&client->dev.kobj, &data->attrs);
1100         if (err)
1101                 goto exit_detach;
1102
1103         data->hwmon_dev = hwmon_device_register(&client->dev);
1104         if (IS_ERR(data->hwmon_dev)) {
1105                 err = PTR_ERR(data->hwmon_dev);
1106                 goto exit_remove;
1107         }
1108
1109         return 0;
1110
1111 exit_remove:
1112         sysfs_remove_group(&client->dev.kobj, &data->attrs);
1113 exit_detach:
1114         i2c_detach_client(client);
1115 exit_free:
1116         kfree(data);
1117 exit:
1118         return err;
1119 }
1120
1121 static int adt7473_detach_client(struct i2c_client *client)
1122 {
1123         struct adt7473_data *data = i2c_get_clientdata(client);
1124
1125         hwmon_device_unregister(data->hwmon_dev);
1126         sysfs_remove_group(&client->dev.kobj, &data->attrs);
1127         i2c_detach_client(client);
1128         kfree(data);
1129         return 0;
1130 }
1131
1132 static int __init adt7473_init(void)
1133 {
1134         return i2c_add_driver(&adt7473_driver);
1135 }
1136
1137 static void __exit adt7473_exit(void)
1138 {
1139         i2c_del_driver(&adt7473_driver);
1140 }
1141
1142 MODULE_AUTHOR("Darrick J. Wong <djwong@us.ibm.com>");
1143 MODULE_DESCRIPTION("ADT7473 driver");
1144 MODULE_LICENSE("GPL");
1145
1146 module_init(adt7473_init);
1147 module_exit(adt7473_exit);