hwmon: (coretemp) Drop duplicate function get_pkg_tjmax
[linux-2.6.git] / drivers / hwmon / emc2103.c
1 /*
2     emc2103.c - Support for SMSC EMC2103
3     Copyright (c) 2010 SMSC
4
5     This program is free software; you can redistribute it and/or modify
6     it under the terms of the GNU General Public License as published by
7     the Free Software Foundation; either version 2 of the License, or
8     (at your option) any later version.
9
10     This program is distributed in the hope that it will be useful,
11     but WITHOUT ANY WARRANTY; without even the implied warranty of
12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13     GNU General Public License for more details.
14
15     You should have received a copy of the GNU General Public License
16     along with this program; if not, write to the Free Software
17     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18 */
19
20 #include <linux/module.h>
21 #include <linux/init.h>
22 #include <linux/slab.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
30 /* Addresses scanned */
31 static const unsigned short normal_i2c[] = { 0x2E, I2C_CLIENT_END };
32
33 static const u8 REG_TEMP[4] = { 0x00, 0x02, 0x04, 0x06 };
34 static const u8 REG_TEMP_MIN[4] = { 0x3c, 0x38, 0x39, 0x3a };
35 static const u8 REG_TEMP_MAX[4] = { 0x34, 0x30, 0x31, 0x32 };
36
37 #define REG_CONF1               0x20
38 #define REG_TEMP_MAX_ALARM      0x24
39 #define REG_TEMP_MIN_ALARM      0x25
40 #define REG_FAN_CONF1           0x42
41 #define REG_FAN_TARGET_LO       0x4c
42 #define REG_FAN_TARGET_HI       0x4d
43 #define REG_FAN_TACH_HI         0x4e
44 #define REG_FAN_TACH_LO         0x4f
45 #define REG_PRODUCT_ID          0xfd
46 #define REG_MFG_ID              0xfe
47
48 /* equation 4 from datasheet: rpm = (3932160 * multipler) / count */
49 #define FAN_RPM_FACTOR          3932160
50
51 /* 2103-2 and 2103-4's 3rd temperature sensor can be connected to two diodes
52  * in anti-parallel mode, and in this configuration both can be read
53  * independently (so we have 4 temperature inputs).  The device can't
54  * detect if it's connected in this mode, so we have to manually enable
55  * it.  Default is to leave the device in the state it's already in (-1).
56  * This parameter allows APD mode to be optionally forced on or off */
57 static int apd = -1;
58 module_param(apd, bool, 0);
59 MODULE_PARM_DESC(init, "Set to zero to disable anti-parallel diode mode");
60
61 struct temperature {
62         s8      degrees;
63         u8      fraction;       /* 0-7 multiples of 0.125 */
64 };
65
66 struct emc2103_data {
67         struct device           *hwmon_dev;
68         struct mutex            update_lock;
69         bool                    valid;          /* registers are valid */
70         bool                    fan_rpm_control;
71         int                     temp_count;     /* num of temp sensors */
72         unsigned long           last_updated;   /* in jiffies */
73         struct temperature      temp[4];        /* internal + 3 external */
74         s8                      temp_min[4];    /* no fractional part */
75         s8                      temp_max[4];    /* no fractional part */
76         u8                      temp_min_alarm;
77         u8                      temp_max_alarm;
78         u8                      fan_multiplier;
79         u16                     fan_tach;
80         u16                     fan_target;
81 };
82
83 static int read_u8_from_i2c(struct i2c_client *client, u8 i2c_reg, u8 *output)
84 {
85         int status = i2c_smbus_read_byte_data(client, i2c_reg);
86         if (status < 0) {
87                 dev_warn(&client->dev, "reg 0x%02x, err %d\n",
88                         i2c_reg, status);
89         } else {
90                 *output = status;
91         }
92         return status;
93 }
94
95 static void read_temp_from_i2c(struct i2c_client *client, u8 i2c_reg,
96                                struct temperature *temp)
97 {
98         u8 degrees, fractional;
99
100         if (read_u8_from_i2c(client, i2c_reg, &degrees) < 0)
101                 return;
102
103         if (read_u8_from_i2c(client, i2c_reg + 1, &fractional) < 0)
104                 return;
105
106         temp->degrees = degrees;
107         temp->fraction = (fractional & 0xe0) >> 5;
108 }
109
110 static void read_fan_from_i2c(struct i2c_client *client, u16 *output,
111                               u8 hi_addr, u8 lo_addr)
112 {
113         u8 high_byte, lo_byte;
114
115         if (read_u8_from_i2c(client, hi_addr, &high_byte) < 0)
116                 return;
117
118         if (read_u8_from_i2c(client, lo_addr, &lo_byte) < 0)
119                 return;
120
121         *output = ((u16)high_byte << 5) | (lo_byte >> 3);
122 }
123
124 static void write_fan_target_to_i2c(struct i2c_client *client, u16 new_target)
125 {
126         u8 high_byte = (new_target & 0x1fe0) >> 5;
127         u8 low_byte = (new_target & 0x001f) << 3;
128         i2c_smbus_write_byte_data(client, REG_FAN_TARGET_LO, low_byte);
129         i2c_smbus_write_byte_data(client, REG_FAN_TARGET_HI, high_byte);
130 }
131
132 static void read_fan_config_from_i2c(struct i2c_client *client)
133
134 {
135         struct emc2103_data *data = i2c_get_clientdata(client);
136         u8 conf1;
137
138         if (read_u8_from_i2c(client, REG_FAN_CONF1, &conf1) < 0)
139                 return;
140
141         data->fan_multiplier = 1 << ((conf1 & 0x60) >> 5);
142         data->fan_rpm_control = (conf1 & 0x80) != 0;
143 }
144
145 static struct emc2103_data *emc2103_update_device(struct device *dev)
146 {
147         struct i2c_client *client = to_i2c_client(dev);
148         struct emc2103_data *data = i2c_get_clientdata(client);
149
150         mutex_lock(&data->update_lock);
151
152         if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
153             || !data->valid) {
154                 int i;
155
156                 for (i = 0; i < data->temp_count; i++) {
157                         read_temp_from_i2c(client, REG_TEMP[i], &data->temp[i]);
158                         read_u8_from_i2c(client, REG_TEMP_MIN[i],
159                                 &data->temp_min[i]);
160                         read_u8_from_i2c(client, REG_TEMP_MAX[i],
161                                 &data->temp_max[i]);
162                 }
163
164                 read_u8_from_i2c(client, REG_TEMP_MIN_ALARM,
165                         &data->temp_min_alarm);
166                 read_u8_from_i2c(client, REG_TEMP_MAX_ALARM,
167                         &data->temp_max_alarm);
168
169                 read_fan_from_i2c(client, &data->fan_tach,
170                         REG_FAN_TACH_HI, REG_FAN_TACH_LO);
171                 read_fan_from_i2c(client, &data->fan_target,
172                         REG_FAN_TARGET_HI, REG_FAN_TARGET_LO);
173                 read_fan_config_from_i2c(client);
174
175                 data->last_updated = jiffies;
176                 data->valid = true;
177         }
178
179         mutex_unlock(&data->update_lock);
180
181         return data;
182 }
183
184 static ssize_t
185 show_temp(struct device *dev, struct device_attribute *da, char *buf)
186 {
187         int nr = to_sensor_dev_attr(da)->index;
188         struct emc2103_data *data = emc2103_update_device(dev);
189         int millidegrees = data->temp[nr].degrees * 1000
190                 + data->temp[nr].fraction * 125;
191         return sprintf(buf, "%d\n", millidegrees);
192 }
193
194 static ssize_t
195 show_temp_min(struct device *dev, struct device_attribute *da, char *buf)
196 {
197         int nr = to_sensor_dev_attr(da)->index;
198         struct emc2103_data *data = emc2103_update_device(dev);
199         int millidegrees = data->temp_min[nr] * 1000;
200         return sprintf(buf, "%d\n", millidegrees);
201 }
202
203 static ssize_t
204 show_temp_max(struct device *dev, struct device_attribute *da, char *buf)
205 {
206         int nr = to_sensor_dev_attr(da)->index;
207         struct emc2103_data *data = emc2103_update_device(dev);
208         int millidegrees = data->temp_max[nr] * 1000;
209         return sprintf(buf, "%d\n", millidegrees);
210 }
211
212 static ssize_t
213 show_temp_fault(struct device *dev, struct device_attribute *da, char *buf)
214 {
215         int nr = to_sensor_dev_attr(da)->index;
216         struct emc2103_data *data = emc2103_update_device(dev);
217         bool fault = (data->temp[nr].degrees == -128);
218         return sprintf(buf, "%d\n", fault ? 1 : 0);
219 }
220
221 static ssize_t
222 show_temp_min_alarm(struct device *dev, struct device_attribute *da, char *buf)
223 {
224         int nr = to_sensor_dev_attr(da)->index;
225         struct emc2103_data *data = emc2103_update_device(dev);
226         bool alarm = data->temp_min_alarm & (1 << nr);
227         return sprintf(buf, "%d\n", alarm ? 1 : 0);
228 }
229
230 static ssize_t
231 show_temp_max_alarm(struct device *dev, struct device_attribute *da, char *buf)
232 {
233         int nr = to_sensor_dev_attr(da)->index;
234         struct emc2103_data *data = emc2103_update_device(dev);
235         bool alarm = data->temp_max_alarm & (1 << nr);
236         return sprintf(buf, "%d\n", alarm ? 1 : 0);
237 }
238
239 static ssize_t set_temp_min(struct device *dev, struct device_attribute *da,
240                             const char *buf, size_t count)
241 {
242         int nr = to_sensor_dev_attr(da)->index;
243         struct i2c_client *client = to_i2c_client(dev);
244         struct emc2103_data *data = i2c_get_clientdata(client);
245         long val;
246
247         int result = strict_strtol(buf, 10, &val);
248         if (result < 0)
249                 return -EINVAL;
250
251         val = DIV_ROUND_CLOSEST(val, 1000);
252         if ((val < -63) || (val > 127))
253                 return -EINVAL;
254
255         mutex_lock(&data->update_lock);
256         data->temp_min[nr] = val;
257         i2c_smbus_write_byte_data(client, REG_TEMP_MIN[nr], val);
258         mutex_unlock(&data->update_lock);
259
260         return count;
261 }
262
263 static ssize_t set_temp_max(struct device *dev, struct device_attribute *da,
264                             const char *buf, size_t count)
265 {
266         int nr = to_sensor_dev_attr(da)->index;
267         struct i2c_client *client = to_i2c_client(dev);
268         struct emc2103_data *data = i2c_get_clientdata(client);
269         long val;
270
271         int result = strict_strtol(buf, 10, &val);
272         if (result < 0)
273                 return -EINVAL;
274
275         val = DIV_ROUND_CLOSEST(val, 1000);
276         if ((val < -63) || (val > 127))
277                 return -EINVAL;
278
279         mutex_lock(&data->update_lock);
280         data->temp_max[nr] = val;
281         i2c_smbus_write_byte_data(client, REG_TEMP_MAX[nr], val);
282         mutex_unlock(&data->update_lock);
283
284         return count;
285 }
286
287 static ssize_t
288 show_fan(struct device *dev, struct device_attribute *da, char *buf)
289 {
290         struct emc2103_data *data = emc2103_update_device(dev);
291         int rpm = 0;
292         if (data->fan_tach != 0)
293                 rpm = (FAN_RPM_FACTOR * data->fan_multiplier) / data->fan_tach;
294         return sprintf(buf, "%d\n", rpm);
295 }
296
297 static ssize_t
298 show_fan_div(struct device *dev, struct device_attribute *da, char *buf)
299 {
300         struct emc2103_data *data = emc2103_update_device(dev);
301         int fan_div = 8 / data->fan_multiplier;
302         return sprintf(buf, "%d\n", fan_div);
303 }
304
305 /* Note: we also update the fan target here, because its value is
306    determined in part by the fan clock divider.  This follows the principle
307    of least surprise; the user doesn't expect the fan target to change just
308    because the divider changed. */
309 static ssize_t set_fan_div(struct device *dev, struct device_attribute *da,
310                            const char *buf, size_t count)
311 {
312         struct emc2103_data *data = emc2103_update_device(dev);
313         struct i2c_client *client = to_i2c_client(dev);
314         int new_range_bits, old_div = 8 / data->fan_multiplier;
315         long new_div;
316
317         int status = strict_strtol(buf, 10, &new_div);
318         if (status < 0)
319                 return -EINVAL;
320
321         if (new_div == old_div) /* No change */
322                 return count;
323
324         switch (new_div) {
325         case 1:
326                 new_range_bits = 3;
327                 break;
328         case 2:
329                 new_range_bits = 2;
330                 break;
331         case 4:
332                 new_range_bits = 1;
333                 break;
334         case 8:
335                 new_range_bits = 0;
336                 break;
337         default:
338                 return -EINVAL;
339         }
340
341         mutex_lock(&data->update_lock);
342
343         status = i2c_smbus_read_byte_data(client, REG_FAN_CONF1);
344         if (status < 0) {
345                 dev_dbg(&client->dev, "reg 0x%02x, err %d\n",
346                         REG_FAN_CONF1, status);
347                 mutex_unlock(&data->update_lock);
348                 return -EIO;
349         }
350         status &= 0x9F;
351         status |= (new_range_bits << 5);
352         i2c_smbus_write_byte_data(client, REG_FAN_CONF1, status);
353
354         data->fan_multiplier = 8 / new_div;
355
356         /* update fan target if high byte is not disabled */
357         if ((data->fan_target & 0x1fe0) != 0x1fe0) {
358                 u16 new_target = (data->fan_target * old_div) / new_div;
359                 data->fan_target = min(new_target, (u16)0x1fff);
360                 write_fan_target_to_i2c(client, data->fan_target);
361         }
362
363         /* invalidate data to force re-read from hardware */
364         data->valid = false;
365
366         mutex_unlock(&data->update_lock);
367         return count;
368 }
369
370 static ssize_t
371 show_fan_target(struct device *dev, struct device_attribute *da, char *buf)
372 {
373         struct emc2103_data *data = emc2103_update_device(dev);
374         int rpm = 0;
375
376         /* high byte of 0xff indicates disabled so return 0 */
377         if ((data->fan_target != 0) && ((data->fan_target & 0x1fe0) != 0x1fe0))
378                 rpm = (FAN_RPM_FACTOR * data->fan_multiplier)
379                         / data->fan_target;
380
381         return sprintf(buf, "%d\n", rpm);
382 }
383
384 static ssize_t set_fan_target(struct device *dev, struct device_attribute *da,
385                               const char *buf, size_t count)
386 {
387         struct emc2103_data *data = emc2103_update_device(dev);
388         struct i2c_client *client = to_i2c_client(dev);
389         long rpm_target;
390
391         int result = strict_strtol(buf, 10, &rpm_target);
392         if (result < 0)
393                 return -EINVAL;
394
395         /* Datasheet states 16384 as maximum RPM target (table 3.2) */
396         if ((rpm_target < 0) || (rpm_target > 16384))
397                 return -EINVAL;
398
399         mutex_lock(&data->update_lock);
400
401         if (rpm_target == 0)
402                 data->fan_target = 0x1fff;
403         else
404                 data->fan_target = SENSORS_LIMIT(
405                         (FAN_RPM_FACTOR * data->fan_multiplier) / rpm_target,
406                         0, 0x1fff);
407
408         write_fan_target_to_i2c(client, data->fan_target);
409
410         mutex_unlock(&data->update_lock);
411         return count;
412 }
413
414 static ssize_t
415 show_fan_fault(struct device *dev, struct device_attribute *da, char *buf)
416 {
417         struct emc2103_data *data = emc2103_update_device(dev);
418         bool fault = ((data->fan_tach & 0x1fe0) == 0x1fe0);
419         return sprintf(buf, "%d\n", fault ? 1 : 0);
420 }
421
422 static ssize_t
423 show_pwm_enable(struct device *dev, struct device_attribute *da, char *buf)
424 {
425         struct emc2103_data *data = emc2103_update_device(dev);
426         return sprintf(buf, "%d\n", data->fan_rpm_control ? 3 : 0);
427 }
428
429 static ssize_t set_pwm_enable(struct device *dev, struct device_attribute *da,
430                               const char *buf, size_t count)
431 {
432         struct i2c_client *client = to_i2c_client(dev);
433         struct emc2103_data *data = i2c_get_clientdata(client);
434         long new_value;
435         u8 conf_reg;
436
437         int result = strict_strtol(buf, 10, &new_value);
438         if (result < 0)
439                 return -EINVAL;
440
441         mutex_lock(&data->update_lock);
442         switch (new_value) {
443         case 0:
444                 data->fan_rpm_control = false;
445                 break;
446         case 3:
447                 data->fan_rpm_control = true;
448                 break;
449         default:
450                 mutex_unlock(&data->update_lock);
451                 return -EINVAL;
452         }
453
454         read_u8_from_i2c(client, REG_FAN_CONF1, &conf_reg);
455
456         if (data->fan_rpm_control)
457                 conf_reg |= 0x80;
458         else
459                 conf_reg &= ~0x80;
460
461         i2c_smbus_write_byte_data(client, REG_FAN_CONF1, conf_reg);
462
463         mutex_unlock(&data->update_lock);
464         return count;
465 }
466
467 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0);
468 static SENSOR_DEVICE_ATTR(temp1_min, S_IRUGO | S_IWUSR, show_temp_min,
469         set_temp_min, 0);
470 static SENSOR_DEVICE_ATTR(temp1_max, S_IRUGO | S_IWUSR, show_temp_max,
471         set_temp_max, 0);
472 static SENSOR_DEVICE_ATTR(temp1_fault, S_IRUGO, show_temp_fault, NULL, 0);
473 static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO, show_temp_min_alarm,
474         NULL, 0);
475 static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_temp_max_alarm,
476         NULL, 0);
477
478 static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp, NULL, 1);
479 static SENSOR_DEVICE_ATTR(temp2_min, S_IRUGO | S_IWUSR, show_temp_min,
480         set_temp_min, 1);
481 static SENSOR_DEVICE_ATTR(temp2_max, S_IRUGO | S_IWUSR, show_temp_max,
482         set_temp_max, 1);
483 static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_temp_fault, NULL, 1);
484 static SENSOR_DEVICE_ATTR(temp2_min_alarm, S_IRUGO, show_temp_min_alarm,
485         NULL, 1);
486 static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO, show_temp_max_alarm,
487         NULL, 1);
488
489 static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, show_temp, NULL, 2);
490 static SENSOR_DEVICE_ATTR(temp3_min, S_IRUGO | S_IWUSR, show_temp_min,
491         set_temp_min, 2);
492 static SENSOR_DEVICE_ATTR(temp3_max, S_IRUGO | S_IWUSR, show_temp_max,
493         set_temp_max, 2);
494 static SENSOR_DEVICE_ATTR(temp3_fault, S_IRUGO, show_temp_fault, NULL, 2);
495 static SENSOR_DEVICE_ATTR(temp3_min_alarm, S_IRUGO, show_temp_min_alarm,
496         NULL, 2);
497 static SENSOR_DEVICE_ATTR(temp3_max_alarm, S_IRUGO, show_temp_max_alarm,
498         NULL, 2);
499
500 static SENSOR_DEVICE_ATTR(temp4_input, S_IRUGO, show_temp, NULL, 3);
501 static SENSOR_DEVICE_ATTR(temp4_min, S_IRUGO | S_IWUSR, show_temp_min,
502         set_temp_min, 3);
503 static SENSOR_DEVICE_ATTR(temp4_max, S_IRUGO | S_IWUSR, show_temp_max,
504         set_temp_max, 3);
505 static SENSOR_DEVICE_ATTR(temp4_fault, S_IRUGO, show_temp_fault, NULL, 3);
506 static SENSOR_DEVICE_ATTR(temp4_min_alarm, S_IRUGO, show_temp_min_alarm,
507         NULL, 3);
508 static SENSOR_DEVICE_ATTR(temp4_max_alarm, S_IRUGO, show_temp_max_alarm,
509         NULL, 3);
510
511 static DEVICE_ATTR(fan1_input, S_IRUGO, show_fan, NULL);
512 static DEVICE_ATTR(fan1_div, S_IRUGO | S_IWUSR, show_fan_div, set_fan_div);
513 static DEVICE_ATTR(fan1_target, S_IRUGO | S_IWUSR, show_fan_target,
514         set_fan_target);
515 static DEVICE_ATTR(fan1_fault, S_IRUGO, show_fan_fault, NULL);
516
517 static DEVICE_ATTR(pwm1_enable, S_IRUGO | S_IWUSR, show_pwm_enable,
518         set_pwm_enable);
519
520 /* sensors present on all models */
521 static struct attribute *emc2103_attributes[] = {
522         &sensor_dev_attr_temp1_input.dev_attr.attr,
523         &sensor_dev_attr_temp1_min.dev_attr.attr,
524         &sensor_dev_attr_temp1_max.dev_attr.attr,
525         &sensor_dev_attr_temp1_fault.dev_attr.attr,
526         &sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
527         &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
528         &sensor_dev_attr_temp2_input.dev_attr.attr,
529         &sensor_dev_attr_temp2_min.dev_attr.attr,
530         &sensor_dev_attr_temp2_max.dev_attr.attr,
531         &sensor_dev_attr_temp2_fault.dev_attr.attr,
532         &sensor_dev_attr_temp2_min_alarm.dev_attr.attr,
533         &sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
534         &dev_attr_fan1_input.attr,
535         &dev_attr_fan1_div.attr,
536         &dev_attr_fan1_target.attr,
537         &dev_attr_fan1_fault.attr,
538         &dev_attr_pwm1_enable.attr,
539         NULL
540 };
541
542 /* extra temperature sensors only present on 2103-2 and 2103-4 */
543 static struct attribute *emc2103_attributes_temp3[] = {
544         &sensor_dev_attr_temp3_input.dev_attr.attr,
545         &sensor_dev_attr_temp3_min.dev_attr.attr,
546         &sensor_dev_attr_temp3_max.dev_attr.attr,
547         &sensor_dev_attr_temp3_fault.dev_attr.attr,
548         &sensor_dev_attr_temp3_min_alarm.dev_attr.attr,
549         &sensor_dev_attr_temp3_max_alarm.dev_attr.attr,
550         NULL
551 };
552
553 /* extra temperature sensors only present on 2103-2 and 2103-4 in APD mode */
554 static struct attribute *emc2103_attributes_temp4[] = {
555         &sensor_dev_attr_temp4_input.dev_attr.attr,
556         &sensor_dev_attr_temp4_min.dev_attr.attr,
557         &sensor_dev_attr_temp4_max.dev_attr.attr,
558         &sensor_dev_attr_temp4_fault.dev_attr.attr,
559         &sensor_dev_attr_temp4_min_alarm.dev_attr.attr,
560         &sensor_dev_attr_temp4_max_alarm.dev_attr.attr,
561         NULL
562 };
563
564 static const struct attribute_group emc2103_group = {
565         .attrs = emc2103_attributes,
566 };
567
568 static const struct attribute_group emc2103_temp3_group = {
569         .attrs = emc2103_attributes_temp3,
570 };
571
572 static const struct attribute_group emc2103_temp4_group = {
573         .attrs = emc2103_attributes_temp4,
574 };
575
576 static int
577 emc2103_probe(struct i2c_client *client, const struct i2c_device_id *id)
578 {
579         struct emc2103_data *data;
580         int status;
581
582         if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
583                 return -EIO;
584
585         data = kzalloc(sizeof(struct emc2103_data), GFP_KERNEL);
586         if (!data)
587                 return -ENOMEM;
588
589         i2c_set_clientdata(client, data);
590         mutex_init(&data->update_lock);
591
592         /* 2103-2 and 2103-4 have 3 external diodes, 2103-1 has 1 */
593         status = i2c_smbus_read_byte_data(client, REG_PRODUCT_ID);
594         if (status == 0x24) {
595                 /* 2103-1 only has 1 external diode */
596                 data->temp_count = 2;
597         } else {
598                 /* 2103-2 and 2103-4 have 3 or 4 external diodes */
599                 status = i2c_smbus_read_byte_data(client, REG_CONF1);
600                 if (status < 0) {
601                         dev_dbg(&client->dev, "reg 0x%02x, err %d\n", REG_CONF1,
602                                 status);
603                         goto exit_free;
604                 }
605
606                 /* detect current state of hardware */
607                 data->temp_count = (status & 0x01) ? 4 : 3;
608
609                 /* force APD state if module parameter is set */
610                 if (apd == 0) {
611                         /* force APD mode off */
612                         data->temp_count = 3;
613                         status &= ~(0x01);
614                         i2c_smbus_write_byte_data(client, REG_CONF1, status);
615                 } else if (apd == 1) {
616                         /* force APD mode on */
617                         data->temp_count = 4;
618                         status |= 0x01;
619                         i2c_smbus_write_byte_data(client, REG_CONF1, status);
620                 }
621         }
622
623         /* Register sysfs hooks */
624         status = sysfs_create_group(&client->dev.kobj, &emc2103_group);
625         if (status)
626                 goto exit_free;
627
628         if (data->temp_count >= 3) {
629                 status = sysfs_create_group(&client->dev.kobj,
630                         &emc2103_temp3_group);
631                 if (status)
632                         goto exit_remove;
633         }
634
635         if (data->temp_count == 4) {
636                 status = sysfs_create_group(&client->dev.kobj,
637                         &emc2103_temp4_group);
638                 if (status)
639                         goto exit_remove_temp3;
640         }
641
642         data->hwmon_dev = hwmon_device_register(&client->dev);
643         if (IS_ERR(data->hwmon_dev)) {
644                 status = PTR_ERR(data->hwmon_dev);
645                 goto exit_remove_temp4;
646         }
647
648         dev_info(&client->dev, "%s: sensor '%s'\n",
649                  dev_name(data->hwmon_dev), client->name);
650
651         return 0;
652
653 exit_remove_temp4:
654         if (data->temp_count == 4)
655                 sysfs_remove_group(&client->dev.kobj, &emc2103_temp4_group);
656 exit_remove_temp3:
657         if (data->temp_count >= 3)
658                 sysfs_remove_group(&client->dev.kobj, &emc2103_temp3_group);
659 exit_remove:
660         sysfs_remove_group(&client->dev.kobj, &emc2103_group);
661 exit_free:
662         kfree(data);
663         return status;
664 }
665
666 static int emc2103_remove(struct i2c_client *client)
667 {
668         struct emc2103_data *data = i2c_get_clientdata(client);
669
670         hwmon_device_unregister(data->hwmon_dev);
671
672         if (data->temp_count == 4)
673                 sysfs_remove_group(&client->dev.kobj, &emc2103_temp4_group);
674
675         if (data->temp_count >= 3)
676                 sysfs_remove_group(&client->dev.kobj, &emc2103_temp3_group);
677
678         sysfs_remove_group(&client->dev.kobj, &emc2103_group);
679
680         kfree(data);
681         return 0;
682 }
683
684 static const struct i2c_device_id emc2103_ids[] = {
685         { "emc2103", 0, },
686         { /* LIST END */ }
687 };
688 MODULE_DEVICE_TABLE(i2c, emc2103_ids);
689
690 /* Return 0 if detection is successful, -ENODEV otherwise */
691 static int
692 emc2103_detect(struct i2c_client *new_client, struct i2c_board_info *info)
693 {
694         struct i2c_adapter *adapter = new_client->adapter;
695         int manufacturer, product;
696
697         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
698                 return -ENODEV;
699
700         manufacturer = i2c_smbus_read_byte_data(new_client, REG_MFG_ID);
701         if (manufacturer != 0x5D)
702                 return -ENODEV;
703
704         product = i2c_smbus_read_byte_data(new_client, REG_PRODUCT_ID);
705         if ((product != 0x24) && (product != 0x26))
706                 return -ENODEV;
707
708         strlcpy(info->type, "emc2103", I2C_NAME_SIZE);
709
710         return 0;
711 }
712
713 static struct i2c_driver emc2103_driver = {
714         .class          = I2C_CLASS_HWMON,
715         .driver = {
716                 .name   = "emc2103",
717         },
718         .probe          = emc2103_probe,
719         .remove         = emc2103_remove,
720         .id_table       = emc2103_ids,
721         .detect         = emc2103_detect,
722         .address_list   = normal_i2c,
723 };
724
725 static int __init sensors_emc2103_init(void)
726 {
727         return i2c_add_driver(&emc2103_driver);
728 }
729
730 static void __exit sensors_emc2103_exit(void)
731 {
732         i2c_del_driver(&emc2103_driver);
733 }
734
735 MODULE_AUTHOR("Steve Glendinning <steve.glendinning@smsc.com>");
736 MODULE_DESCRIPTION("SMSC EMC2103 hwmon driver");
737 MODULE_LICENSE("GPL");
738
739 module_init(sensors_emc2103_init);
740 module_exit(sensors_emc2103_exit);