1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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
31static const unsigned short normal_i2c[] = { 0x2E, I2C_CLIENT_END };
32
33static const u8 REG_TEMP[4] = { 0x00, 0x02, 0x04, 0x06 };
34static const u8 REG_TEMP_MIN[4] = { 0x3c, 0x38, 0x39, 0x3a };
35static 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
49#define FAN_RPM_FACTOR 3932160
50
51
52
53
54
55
56
57
58
59static int apd = -1;
60module_param(apd, bint, 0);
61MODULE_PARM_DESC(init, "Set to zero to disable anti-parallel diode mode");
62
63struct temperature {
64 s8 degrees;
65 u8 fraction;
66};
67
68struct emc2103_data {
69 struct device *hwmon_dev;
70 struct mutex update_lock;
71 bool valid;
72 bool fan_rpm_control;
73 int temp_count;
74 unsigned long last_updated;
75 struct temperature temp[4];
76 s8 temp_min[4];
77 s8 temp_max[4];
78 u8 temp_min_alarm;
79 u8 temp_max_alarm;
80 u8 fan_multiplier;
81 u16 fan_tach;
82 u16 fan_target;
83};
84
85static int read_u8_from_i2c(struct i2c_client *client, u8 i2c_reg, u8 *output)
86{
87 int status = i2c_smbus_read_byte_data(client, i2c_reg);
88 if (status < 0) {
89 dev_warn(&client->dev, "reg 0x%02x, err %d\n",
90 i2c_reg, status);
91 } else {
92 *output = status;
93 }
94 return status;
95}
96
97static void read_temp_from_i2c(struct i2c_client *client, u8 i2c_reg,
98 struct temperature *temp)
99{
100 u8 degrees, fractional;
101
102 if (read_u8_from_i2c(client, i2c_reg, °rees) < 0)
103 return;
104
105 if (read_u8_from_i2c(client, i2c_reg + 1, &fractional) < 0)
106 return;
107
108 temp->degrees = degrees;
109 temp->fraction = (fractional & 0xe0) >> 5;
110}
111
112static void read_fan_from_i2c(struct i2c_client *client, u16 *output,
113 u8 hi_addr, u8 lo_addr)
114{
115 u8 high_byte, lo_byte;
116
117 if (read_u8_from_i2c(client, hi_addr, &high_byte) < 0)
118 return;
119
120 if (read_u8_from_i2c(client, lo_addr, &lo_byte) < 0)
121 return;
122
123 *output = ((u16)high_byte << 5) | (lo_byte >> 3);
124}
125
126static void write_fan_target_to_i2c(struct i2c_client *client, u16 new_target)
127{
128 u8 high_byte = (new_target & 0x1fe0) >> 5;
129 u8 low_byte = (new_target & 0x001f) << 3;
130 i2c_smbus_write_byte_data(client, REG_FAN_TARGET_LO, low_byte);
131 i2c_smbus_write_byte_data(client, REG_FAN_TARGET_HI, high_byte);
132}
133
134static void read_fan_config_from_i2c(struct i2c_client *client)
135
136{
137 struct emc2103_data *data = i2c_get_clientdata(client);
138 u8 conf1;
139
140 if (read_u8_from_i2c(client, REG_FAN_CONF1, &conf1) < 0)
141 return;
142
143 data->fan_multiplier = 1 << ((conf1 & 0x60) >> 5);
144 data->fan_rpm_control = (conf1 & 0x80) != 0;
145}
146
147static struct emc2103_data *emc2103_update_device(struct device *dev)
148{
149 struct i2c_client *client = to_i2c_client(dev);
150 struct emc2103_data *data = i2c_get_clientdata(client);
151
152 mutex_lock(&data->update_lock);
153
154 if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
155 || !data->valid) {
156 int i;
157
158 for (i = 0; i < data->temp_count; i++) {
159 read_temp_from_i2c(client, REG_TEMP[i], &data->temp[i]);
160 read_u8_from_i2c(client, REG_TEMP_MIN[i],
161 &data->temp_min[i]);
162 read_u8_from_i2c(client, REG_TEMP_MAX[i],
163 &data->temp_max[i]);
164 }
165
166 read_u8_from_i2c(client, REG_TEMP_MIN_ALARM,
167 &data->temp_min_alarm);
168 read_u8_from_i2c(client, REG_TEMP_MAX_ALARM,
169 &data->temp_max_alarm);
170
171 read_fan_from_i2c(client, &data->fan_tach,
172 REG_FAN_TACH_HI, REG_FAN_TACH_LO);
173 read_fan_from_i2c(client, &data->fan_target,
174 REG_FAN_TARGET_HI, REG_FAN_TARGET_LO);
175 read_fan_config_from_i2c(client);
176
177 data->last_updated = jiffies;
178 data->valid = true;
179 }
180
181 mutex_unlock(&data->update_lock);
182
183 return data;
184}
185
186static ssize_t
187show_temp(struct device *dev, struct device_attribute *da, char *buf)
188{
189 int nr = to_sensor_dev_attr(da)->index;
190 struct emc2103_data *data = emc2103_update_device(dev);
191 int millidegrees = data->temp[nr].degrees * 1000
192 + data->temp[nr].fraction * 125;
193 return sprintf(buf, "%d\n", millidegrees);
194}
195
196static ssize_t
197show_temp_min(struct device *dev, struct device_attribute *da, char *buf)
198{
199 int nr = to_sensor_dev_attr(da)->index;
200 struct emc2103_data *data = emc2103_update_device(dev);
201 int millidegrees = data->temp_min[nr] * 1000;
202 return sprintf(buf, "%d\n", millidegrees);
203}
204
205static ssize_t
206show_temp_max(struct device *dev, struct device_attribute *da, char *buf)
207{
208 int nr = to_sensor_dev_attr(da)->index;
209 struct emc2103_data *data = emc2103_update_device(dev);
210 int millidegrees = data->temp_max[nr] * 1000;
211 return sprintf(buf, "%d\n", millidegrees);
212}
213
214static ssize_t
215show_temp_fault(struct device *dev, struct device_attribute *da, char *buf)
216{
217 int nr = to_sensor_dev_attr(da)->index;
218 struct emc2103_data *data = emc2103_update_device(dev);
219 bool fault = (data->temp[nr].degrees == -128);
220 return sprintf(buf, "%d\n", fault ? 1 : 0);
221}
222
223static ssize_t
224show_temp_min_alarm(struct device *dev, struct device_attribute *da, char *buf)
225{
226 int nr = to_sensor_dev_attr(da)->index;
227 struct emc2103_data *data = emc2103_update_device(dev);
228 bool alarm = data->temp_min_alarm & (1 << nr);
229 return sprintf(buf, "%d\n", alarm ? 1 : 0);
230}
231
232static ssize_t
233show_temp_max_alarm(struct device *dev, struct device_attribute *da, char *buf)
234{
235 int nr = to_sensor_dev_attr(da)->index;
236 struct emc2103_data *data = emc2103_update_device(dev);
237 bool alarm = data->temp_max_alarm & (1 << nr);
238 return sprintf(buf, "%d\n", alarm ? 1 : 0);
239}
240
241static ssize_t set_temp_min(struct device *dev, struct device_attribute *da,
242 const char *buf, size_t count)
243{
244 int nr = to_sensor_dev_attr(da)->index;
245 struct i2c_client *client = to_i2c_client(dev);
246 struct emc2103_data *data = i2c_get_clientdata(client);
247 long val;
248
249 int result = kstrtol(buf, 10, &val);
250 if (result < 0)
251 return result;
252
253 val = clamp_val(DIV_ROUND_CLOSEST(val, 1000), -63, 127);
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
263static 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 = kstrtol(buf, 10, &val);
272 if (result < 0)
273 return result;
274
275 val = clamp_val(DIV_ROUND_CLOSEST(val, 1000), -63, 127);
276
277 mutex_lock(&data->update_lock);
278 data->temp_max[nr] = val;
279 i2c_smbus_write_byte_data(client, REG_TEMP_MAX[nr], val);
280 mutex_unlock(&data->update_lock);
281
282 return count;
283}
284
285static ssize_t
286show_fan(struct device *dev, struct device_attribute *da, char *buf)
287{
288 struct emc2103_data *data = emc2103_update_device(dev);
289 int rpm = 0;
290 if (data->fan_tach != 0)
291 rpm = (FAN_RPM_FACTOR * data->fan_multiplier) / data->fan_tach;
292 return sprintf(buf, "%d\n", rpm);
293}
294
295static ssize_t
296show_fan_div(struct device *dev, struct device_attribute *da, char *buf)
297{
298 struct emc2103_data *data = emc2103_update_device(dev);
299 int fan_div = 8 / data->fan_multiplier;
300 return sprintf(buf, "%d\n", fan_div);
301}
302
303
304
305
306
307
308
309static 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 = kstrtol(buf, 10, &new_div);
318 if (status < 0)
319 return status;
320
321 if (new_div == old_div)
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 status;
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
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
364 data->valid = false;
365
366 mutex_unlock(&data->update_lock);
367 return count;
368}
369
370static ssize_t
371show_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
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
384static 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 unsigned long rpm_target;
390
391 int result = kstrtoul(buf, 10, &rpm_target);
392 if (result < 0)
393 return result;
394
395
396 rpm_target = clamp_val(rpm_target, 0, 16384);
397
398 mutex_lock(&data->update_lock);
399
400 if (rpm_target == 0)
401 data->fan_target = 0x1fff;
402 else
403 data->fan_target = clamp_val(
404 (FAN_RPM_FACTOR * data->fan_multiplier) / rpm_target,
405 0, 0x1fff);
406
407 write_fan_target_to_i2c(client, data->fan_target);
408
409 mutex_unlock(&data->update_lock);
410 return count;
411}
412
413static ssize_t
414show_fan_fault(struct device *dev, struct device_attribute *da, char *buf)
415{
416 struct emc2103_data *data = emc2103_update_device(dev);
417 bool fault = ((data->fan_tach & 0x1fe0) == 0x1fe0);
418 return sprintf(buf, "%d\n", fault ? 1 : 0);
419}
420
421static ssize_t
422show_pwm_enable(struct device *dev, struct device_attribute *da, char *buf)
423{
424 struct emc2103_data *data = emc2103_update_device(dev);
425 return sprintf(buf, "%d\n", data->fan_rpm_control ? 3 : 0);
426}
427
428static ssize_t set_pwm_enable(struct device *dev, struct device_attribute *da,
429 const char *buf, size_t count)
430{
431 struct i2c_client *client = to_i2c_client(dev);
432 struct emc2103_data *data = i2c_get_clientdata(client);
433 long new_value;
434 u8 conf_reg;
435
436 int result = kstrtol(buf, 10, &new_value);
437 if (result < 0)
438 return result;
439
440 mutex_lock(&data->update_lock);
441 switch (new_value) {
442 case 0:
443 data->fan_rpm_control = false;
444 break;
445 case 3:
446 data->fan_rpm_control = true;
447 break;
448 default:
449 count = -EINVAL;
450 goto err;
451 }
452
453 result = read_u8_from_i2c(client, REG_FAN_CONF1, &conf_reg);
454 if (result) {
455 count = result;
456 goto err;
457 }
458
459 if (data->fan_rpm_control)
460 conf_reg |= 0x80;
461 else
462 conf_reg &= ~0x80;
463
464 i2c_smbus_write_byte_data(client, REG_FAN_CONF1, conf_reg);
465err:
466 mutex_unlock(&data->update_lock);
467 return count;
468}
469
470static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0);
471static SENSOR_DEVICE_ATTR(temp1_min, S_IRUGO | S_IWUSR, show_temp_min,
472 set_temp_min, 0);
473static SENSOR_DEVICE_ATTR(temp1_max, S_IRUGO | S_IWUSR, show_temp_max,
474 set_temp_max, 0);
475static SENSOR_DEVICE_ATTR(temp1_fault, S_IRUGO, show_temp_fault, NULL, 0);
476static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO, show_temp_min_alarm,
477 NULL, 0);
478static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_temp_max_alarm,
479 NULL, 0);
480
481static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp, NULL, 1);
482static SENSOR_DEVICE_ATTR(temp2_min, S_IRUGO | S_IWUSR, show_temp_min,
483 set_temp_min, 1);
484static SENSOR_DEVICE_ATTR(temp2_max, S_IRUGO | S_IWUSR, show_temp_max,
485 set_temp_max, 1);
486static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_temp_fault, NULL, 1);
487static SENSOR_DEVICE_ATTR(temp2_min_alarm, S_IRUGO, show_temp_min_alarm,
488 NULL, 1);
489static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO, show_temp_max_alarm,
490 NULL, 1);
491
492static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, show_temp, NULL, 2);
493static SENSOR_DEVICE_ATTR(temp3_min, S_IRUGO | S_IWUSR, show_temp_min,
494 set_temp_min, 2);
495static SENSOR_DEVICE_ATTR(temp3_max, S_IRUGO | S_IWUSR, show_temp_max,
496 set_temp_max, 2);
497static SENSOR_DEVICE_ATTR(temp3_fault, S_IRUGO, show_temp_fault, NULL, 2);
498static SENSOR_DEVICE_ATTR(temp3_min_alarm, S_IRUGO, show_temp_min_alarm,
499 NULL, 2);
500static SENSOR_DEVICE_ATTR(temp3_max_alarm, S_IRUGO, show_temp_max_alarm,
501 NULL, 2);
502
503static SENSOR_DEVICE_ATTR(temp4_input, S_IRUGO, show_temp, NULL, 3);
504static SENSOR_DEVICE_ATTR(temp4_min, S_IRUGO | S_IWUSR, show_temp_min,
505 set_temp_min, 3);
506static SENSOR_DEVICE_ATTR(temp4_max, S_IRUGO | S_IWUSR, show_temp_max,
507 set_temp_max, 3);
508static SENSOR_DEVICE_ATTR(temp4_fault, S_IRUGO, show_temp_fault, NULL, 3);
509static SENSOR_DEVICE_ATTR(temp4_min_alarm, S_IRUGO, show_temp_min_alarm,
510 NULL, 3);
511static SENSOR_DEVICE_ATTR(temp4_max_alarm, S_IRUGO, show_temp_max_alarm,
512 NULL, 3);
513
514static DEVICE_ATTR(fan1_input, S_IRUGO, show_fan, NULL);
515static DEVICE_ATTR(fan1_div, S_IRUGO | S_IWUSR, show_fan_div, set_fan_div);
516static DEVICE_ATTR(fan1_target, S_IRUGO | S_IWUSR, show_fan_target,
517 set_fan_target);
518static DEVICE_ATTR(fan1_fault, S_IRUGO, show_fan_fault, NULL);
519
520static DEVICE_ATTR(pwm1_enable, S_IRUGO | S_IWUSR, show_pwm_enable,
521 set_pwm_enable);
522
523
524static struct attribute *emc2103_attributes[] = {
525 &sensor_dev_attr_temp1_input.dev_attr.attr,
526 &sensor_dev_attr_temp1_min.dev_attr.attr,
527 &sensor_dev_attr_temp1_max.dev_attr.attr,
528 &sensor_dev_attr_temp1_fault.dev_attr.attr,
529 &sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
530 &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
531 &sensor_dev_attr_temp2_input.dev_attr.attr,
532 &sensor_dev_attr_temp2_min.dev_attr.attr,
533 &sensor_dev_attr_temp2_max.dev_attr.attr,
534 &sensor_dev_attr_temp2_fault.dev_attr.attr,
535 &sensor_dev_attr_temp2_min_alarm.dev_attr.attr,
536 &sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
537 &dev_attr_fan1_input.attr,
538 &dev_attr_fan1_div.attr,
539 &dev_attr_fan1_target.attr,
540 &dev_attr_fan1_fault.attr,
541 &dev_attr_pwm1_enable.attr,
542 NULL
543};
544
545
546static struct attribute *emc2103_attributes_temp3[] = {
547 &sensor_dev_attr_temp3_input.dev_attr.attr,
548 &sensor_dev_attr_temp3_min.dev_attr.attr,
549 &sensor_dev_attr_temp3_max.dev_attr.attr,
550 &sensor_dev_attr_temp3_fault.dev_attr.attr,
551 &sensor_dev_attr_temp3_min_alarm.dev_attr.attr,
552 &sensor_dev_attr_temp3_max_alarm.dev_attr.attr,
553 NULL
554};
555
556
557static struct attribute *emc2103_attributes_temp4[] = {
558 &sensor_dev_attr_temp4_input.dev_attr.attr,
559 &sensor_dev_attr_temp4_min.dev_attr.attr,
560 &sensor_dev_attr_temp4_max.dev_attr.attr,
561 &sensor_dev_attr_temp4_fault.dev_attr.attr,
562 &sensor_dev_attr_temp4_min_alarm.dev_attr.attr,
563 &sensor_dev_attr_temp4_max_alarm.dev_attr.attr,
564 NULL
565};
566
567static const struct attribute_group emc2103_group = {
568 .attrs = emc2103_attributes,
569};
570
571static const struct attribute_group emc2103_temp3_group = {
572 .attrs = emc2103_attributes_temp3,
573};
574
575static const struct attribute_group emc2103_temp4_group = {
576 .attrs = emc2103_attributes_temp4,
577};
578
579static int
580emc2103_probe(struct i2c_client *client, const struct i2c_device_id *id)
581{
582 struct emc2103_data *data;
583 int status;
584
585 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
586 return -EIO;
587
588 data = devm_kzalloc(&client->dev, sizeof(struct emc2103_data),
589 GFP_KERNEL);
590 if (!data)
591 return -ENOMEM;
592
593 i2c_set_clientdata(client, data);
594 mutex_init(&data->update_lock);
595
596
597 status = i2c_smbus_read_byte_data(client, REG_PRODUCT_ID);
598 if (status == 0x24) {
599
600 data->temp_count = 2;
601 } else {
602
603 status = i2c_smbus_read_byte_data(client, REG_CONF1);
604 if (status < 0) {
605 dev_dbg(&client->dev, "reg 0x%02x, err %d\n", REG_CONF1,
606 status);
607 return status;
608 }
609
610
611 data->temp_count = (status & 0x01) ? 4 : 3;
612
613
614 if (apd == 0) {
615
616 data->temp_count = 3;
617 status &= ~(0x01);
618 i2c_smbus_write_byte_data(client, REG_CONF1, status);
619 } else if (apd == 1) {
620
621 data->temp_count = 4;
622 status |= 0x01;
623 i2c_smbus_write_byte_data(client, REG_CONF1, status);
624 }
625 }
626
627
628 status = sysfs_create_group(&client->dev.kobj, &emc2103_group);
629 if (status)
630 return status;
631
632 if (data->temp_count >= 3) {
633 status = sysfs_create_group(&client->dev.kobj,
634 &emc2103_temp3_group);
635 if (status)
636 goto exit_remove;
637 }
638
639 if (data->temp_count == 4) {
640 status = sysfs_create_group(&client->dev.kobj,
641 &emc2103_temp4_group);
642 if (status)
643 goto exit_remove_temp3;
644 }
645
646 data->hwmon_dev = hwmon_device_register(&client->dev);
647 if (IS_ERR(data->hwmon_dev)) {
648 status = PTR_ERR(data->hwmon_dev);
649 goto exit_remove_temp4;
650 }
651
652 dev_info(&client->dev, "%s: sensor '%s'\n",
653 dev_name(data->hwmon_dev), client->name);
654
655 return 0;
656
657exit_remove_temp4:
658 if (data->temp_count == 4)
659 sysfs_remove_group(&client->dev.kobj, &emc2103_temp4_group);
660exit_remove_temp3:
661 if (data->temp_count >= 3)
662 sysfs_remove_group(&client->dev.kobj, &emc2103_temp3_group);
663exit_remove:
664 sysfs_remove_group(&client->dev.kobj, &emc2103_group);
665 return status;
666}
667
668static int emc2103_remove(struct i2c_client *client)
669{
670 struct emc2103_data *data = i2c_get_clientdata(client);
671
672 hwmon_device_unregister(data->hwmon_dev);
673
674 if (data->temp_count == 4)
675 sysfs_remove_group(&client->dev.kobj, &emc2103_temp4_group);
676
677 if (data->temp_count >= 3)
678 sysfs_remove_group(&client->dev.kobj, &emc2103_temp3_group);
679
680 sysfs_remove_group(&client->dev.kobj, &emc2103_group);
681
682 return 0;
683}
684
685static const struct i2c_device_id emc2103_ids[] = {
686 { "emc2103", 0, },
687 { }
688};
689MODULE_DEVICE_TABLE(i2c, emc2103_ids);
690
691
692static int
693emc2103_detect(struct i2c_client *new_client, struct i2c_board_info *info)
694{
695 struct i2c_adapter *adapter = new_client->adapter;
696 int manufacturer, product;
697
698 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
699 return -ENODEV;
700
701 manufacturer = i2c_smbus_read_byte_data(new_client, REG_MFG_ID);
702 if (manufacturer != 0x5D)
703 return -ENODEV;
704
705 product = i2c_smbus_read_byte_data(new_client, REG_PRODUCT_ID);
706 if ((product != 0x24) && (product != 0x26))
707 return -ENODEV;
708
709 strlcpy(info->type, "emc2103", I2C_NAME_SIZE);
710
711 return 0;
712}
713
714static struct i2c_driver emc2103_driver = {
715 .class = I2C_CLASS_HWMON,
716 .driver = {
717 .name = "emc2103",
718 },
719 .probe = emc2103_probe,
720 .remove = emc2103_remove,
721 .id_table = emc2103_ids,
722 .detect = emc2103_detect,
723 .address_list = normal_i2c,
724};
725
726module_i2c_driver(emc2103_driver);
727
728MODULE_AUTHOR("Steve Glendinning <steve.glendinning@shawell.net>");
729MODULE_DESCRIPTION("SMSC EMC2103 hwmon driver");
730MODULE_LICENSE("GPL");
731
