aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/hwmon/lm85.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/hwmon/lm85.c')
-rw-r--r--drivers/hwmon/lm85.c660
1 files changed, 304 insertions, 356 deletions
diff --git a/drivers/hwmon/lm85.c b/drivers/hwmon/lm85.c
index b0129a54e1a6..2b4b419273fe 100644
--- a/drivers/hwmon/lm85.c
+++ b/drivers/hwmon/lm85.c
@@ -121,7 +121,6 @@ enum chips {
121#define EMC6D102_REG_EXTEND_ADC3 0x87 121#define EMC6D102_REG_EXTEND_ADC3 0x87
122#define EMC6D102_REG_EXTEND_ADC4 0x88 122#define EMC6D102_REG_EXTEND_ADC4 0x88
123 123
124
125/* 124/*
126 * Conversions. Rounding and limit checking is only done on the TO_REG 125 * Conversions. Rounding and limit checking is only done on the TO_REG
127 * variants. Note that you should be a bit careful with which arguments 126 * variants. Note that you should be a bit careful with which arguments
@@ -155,7 +154,7 @@ static inline u16 FAN_TO_REG(unsigned long val)
155 154
156/* Temperature is reported in .001 degC increments */ 155/* Temperature is reported in .001 degC increments */
157#define TEMP_TO_REG(val) \ 156#define TEMP_TO_REG(val) \
158 clamp_val(SCALE(val, 1000, 1), -127, 127) 157 DIV_ROUND_CLOSEST(clamp_val((val), -127000, 127000), 1000)
159#define TEMPEXT_FROM_REG(val, ext) \ 158#define TEMPEXT_FROM_REG(val, ext) \
160 SCALE(((val) << 4) + (ext), 16, 1000) 159 SCALE(((val) << 4) + (ext), 16, 1000)
161#define TEMP_FROM_REG(val) ((val) * 1000) 160#define TEMP_FROM_REG(val) ((val) * 1000)
@@ -189,7 +188,7 @@ static const int lm85_range_map[] = {
189 13300, 16000, 20000, 26600, 32000, 40000, 53300, 80000 188 13300, 16000, 20000, 26600, 32000, 40000, 53300, 80000
190}; 189};
191 190
192static int RANGE_TO_REG(int range) 191static int RANGE_TO_REG(long range)
193{ 192{
194 int i; 193 int i;
195 194
@@ -211,7 +210,7 @@ static const int adm1027_freq_map[8] = { /* 1 Hz */
211 11, 15, 22, 29, 35, 44, 59, 88 210 11, 15, 22, 29, 35, 44, 59, 88
212}; 211};
213 212
214static int FREQ_TO_REG(const int *map, int freq) 213static int FREQ_TO_REG(const int *map, unsigned long freq)
215{ 214{
216 int i; 215 int i;
217 216
@@ -303,7 +302,8 @@ struct lm85_autofan {
303 * The structure is dynamically allocated. 302 * The structure is dynamically allocated.
304 */ 303 */
305struct lm85_data { 304struct lm85_data {
306 struct device *hwmon_dev; 305 struct i2c_client *client;
306 const struct attribute_group *groups[6];
307 const int *freq_map; 307 const int *freq_map;
308 enum chips type; 308 enum chips type;
309 309
@@ -334,44 +334,235 @@ struct lm85_data {
334 struct lm85_zone zone[3]; 334 struct lm85_zone zone[3];
335}; 335};
336 336
337static int lm85_detect(struct i2c_client *client, struct i2c_board_info *info); 337static int lm85_read_value(struct i2c_client *client, u8 reg)
338static int lm85_probe(struct i2c_client *client, 338{
339 const struct i2c_device_id *id); 339 int res;
340static int lm85_remove(struct i2c_client *client);
341 340
342static int lm85_read_value(struct i2c_client *client, u8 reg); 341 /* What size location is it? */
343static void lm85_write_value(struct i2c_client *client, u8 reg, int value); 342 switch (reg) {
344static struct lm85_data *lm85_update_device(struct device *dev); 343 case LM85_REG_FAN(0): /* Read WORD data */
344 case LM85_REG_FAN(1):
345 case LM85_REG_FAN(2):
346 case LM85_REG_FAN(3):
347 case LM85_REG_FAN_MIN(0):
348 case LM85_REG_FAN_MIN(1):
349 case LM85_REG_FAN_MIN(2):
350 case LM85_REG_FAN_MIN(3):
351 case LM85_REG_ALARM1: /* Read both bytes at once */
352 res = i2c_smbus_read_byte_data(client, reg) & 0xff;
353 res |= i2c_smbus_read_byte_data(client, reg + 1) << 8;
354 break;
355 default: /* Read BYTE data */
356 res = i2c_smbus_read_byte_data(client, reg);
357 break;
358 }
345 359
360 return res;
361}
346 362
347static const struct i2c_device_id lm85_id[] = { 363static void lm85_write_value(struct i2c_client *client, u8 reg, int value)
348 { "adm1027", adm1027 }, 364{
349 { "adt7463", adt7463 }, 365 switch (reg) {
350 { "adt7468", adt7468 }, 366 case LM85_REG_FAN(0): /* Write WORD data */
351 { "lm85", lm85 }, 367 case LM85_REG_FAN(1):
352 { "lm85b", lm85 }, 368 case LM85_REG_FAN(2):
353 { "lm85c", lm85 }, 369 case LM85_REG_FAN(3):
354 { "emc6d100", emc6d100 }, 370 case LM85_REG_FAN_MIN(0):
355 { "emc6d101", emc6d100 }, 371 case LM85_REG_FAN_MIN(1):
356 { "emc6d102", emc6d102 }, 372 case LM85_REG_FAN_MIN(2):
357 { "emc6d103", emc6d103 }, 373 case LM85_REG_FAN_MIN(3):
358 { "emc6d103s", emc6d103s }, 374 /* NOTE: ALARM is read only, so not included here */
359 { } 375 i2c_smbus_write_byte_data(client, reg, value & 0xff);
360}; 376 i2c_smbus_write_byte_data(client, reg + 1, value >> 8);
361MODULE_DEVICE_TABLE(i2c, lm85_id); 377 break;
378 default: /* Write BYTE data */
379 i2c_smbus_write_byte_data(client, reg, value);
380 break;
381 }
382}
362 383
363static struct i2c_driver lm85_driver = { 384static struct lm85_data *lm85_update_device(struct device *dev)
364 .class = I2C_CLASS_HWMON, 385{
365 .driver = { 386 struct lm85_data *data = dev_get_drvdata(dev);
366 .name = "lm85", 387 struct i2c_client *client = data->client;
367 }, 388 int i;
368 .probe = lm85_probe, 389
369 .remove = lm85_remove, 390 mutex_lock(&data->update_lock);
370 .id_table = lm85_id, 391
371 .detect = lm85_detect, 392 if (!data->valid ||
372 .address_list = normal_i2c, 393 time_after(jiffies, data->last_reading + LM85_DATA_INTERVAL)) {
373}; 394 /* Things that change quickly */
395 dev_dbg(&client->dev, "Reading sensor values\n");
396
397 /*
398 * Have to read extended bits first to "freeze" the
399 * more significant bits that are read later.
400 * There are 2 additional resolution bits per channel and we
401 * have room for 4, so we shift them to the left.
402 */
403 if (data->type == adm1027 || data->type == adt7463 ||
404 data->type == adt7468) {
405 int ext1 = lm85_read_value(client,
406 ADM1027_REG_EXTEND_ADC1);
407 int ext2 = lm85_read_value(client,
408 ADM1027_REG_EXTEND_ADC2);
409 int val = (ext1 << 8) + ext2;
410
411 for (i = 0; i <= 4; i++)
412 data->in_ext[i] =
413 ((val >> (i * 2)) & 0x03) << 2;
414
415 for (i = 0; i <= 2; i++)
416 data->temp_ext[i] =
417 (val >> ((i + 4) * 2)) & 0x0c;
418 }
419
420 data->vid = lm85_read_value(client, LM85_REG_VID);
421
422 for (i = 0; i <= 3; ++i) {
423 data->in[i] =
424 lm85_read_value(client, LM85_REG_IN(i));
425 data->fan[i] =
426 lm85_read_value(client, LM85_REG_FAN(i));
427 }
428
429 if (!data->has_vid5)
430 data->in[4] = lm85_read_value(client, LM85_REG_IN(4));
431
432 if (data->type == adt7468)
433 data->cfg5 = lm85_read_value(client, ADT7468_REG_CFG5);
374 434
435 for (i = 0; i <= 2; ++i) {
436 data->temp[i] =
437 lm85_read_value(client, LM85_REG_TEMP(i));
438 data->pwm[i] =
439 lm85_read_value(client, LM85_REG_PWM(i));
440
441 if (IS_ADT7468_OFF64(data))
442 data->temp[i] -= 64;
443 }
444
445 data->alarms = lm85_read_value(client, LM85_REG_ALARM1);
446
447 if (data->type == emc6d100) {
448 /* Three more voltage sensors */
449 for (i = 5; i <= 7; ++i) {
450 data->in[i] = lm85_read_value(client,
451 EMC6D100_REG_IN(i));
452 }
453 /* More alarm bits */
454 data->alarms |= lm85_read_value(client,
455 EMC6D100_REG_ALARM3) << 16;
456 } else if (data->type == emc6d102 || data->type == emc6d103 ||
457 data->type == emc6d103s) {
458 /*
459 * Have to read LSB bits after the MSB ones because
460 * the reading of the MSB bits has frozen the
461 * LSBs (backward from the ADM1027).
462 */
463 int ext1 = lm85_read_value(client,
464 EMC6D102_REG_EXTEND_ADC1);
465 int ext2 = lm85_read_value(client,
466 EMC6D102_REG_EXTEND_ADC2);
467 int ext3 = lm85_read_value(client,
468 EMC6D102_REG_EXTEND_ADC3);
469 int ext4 = lm85_read_value(client,
470 EMC6D102_REG_EXTEND_ADC4);
471 data->in_ext[0] = ext3 & 0x0f;
472 data->in_ext[1] = ext4 & 0x0f;
473 data->in_ext[2] = ext4 >> 4;
474 data->in_ext[3] = ext3 >> 4;
475 data->in_ext[4] = ext2 >> 4;
476
477 data->temp_ext[0] = ext1 & 0x0f;
478 data->temp_ext[1] = ext2 & 0x0f;
479 data->temp_ext[2] = ext1 >> 4;
480 }
481
482 data->last_reading = jiffies;
483 } /* last_reading */
484
485 if (!data->valid ||
486 time_after(jiffies, data->last_config + LM85_CONFIG_INTERVAL)) {
487 /* Things that don't change often */
488 dev_dbg(&client->dev, "Reading config values\n");
489
490 for (i = 0; i <= 3; ++i) {
491 data->in_min[i] =
492 lm85_read_value(client, LM85_REG_IN_MIN(i));
493 data->in_max[i] =
494 lm85_read_value(client, LM85_REG_IN_MAX(i));
495 data->fan_min[i] =
496 lm85_read_value(client, LM85_REG_FAN_MIN(i));
497 }
498
499 if (!data->has_vid5) {
500 data->in_min[4] = lm85_read_value(client,
501 LM85_REG_IN_MIN(4));
502 data->in_max[4] = lm85_read_value(client,
503 LM85_REG_IN_MAX(4));
504 }
505
506 if (data->type == emc6d100) {
507 for (i = 5; i <= 7; ++i) {
508 data->in_min[i] = lm85_read_value(client,
509 EMC6D100_REG_IN_MIN(i));
510 data->in_max[i] = lm85_read_value(client,
511 EMC6D100_REG_IN_MAX(i));
512 }
513 }
514
515 for (i = 0; i <= 2; ++i) {
516 int val;
517
518 data->temp_min[i] =
519 lm85_read_value(client, LM85_REG_TEMP_MIN(i));
520 data->temp_max[i] =
521 lm85_read_value(client, LM85_REG_TEMP_MAX(i));
522
523 data->autofan[i].config =
524 lm85_read_value(client, LM85_REG_AFAN_CONFIG(i));
525 val = lm85_read_value(client, LM85_REG_AFAN_RANGE(i));
526 data->pwm_freq[i] = val & 0x07;
527 data->zone[i].range = val >> 4;
528 data->autofan[i].min_pwm =
529 lm85_read_value(client, LM85_REG_AFAN_MINPWM(i));
530 data->zone[i].limit =
531 lm85_read_value(client, LM85_REG_AFAN_LIMIT(i));
532 data->zone[i].critical =
533 lm85_read_value(client, LM85_REG_AFAN_CRITICAL(i));
534
535 if (IS_ADT7468_OFF64(data)) {
536 data->temp_min[i] -= 64;
537 data->temp_max[i] -= 64;
538 data->zone[i].limit -= 64;
539 data->zone[i].critical -= 64;
540 }
541 }
542
543 if (data->type != emc6d103s) {
544 i = lm85_read_value(client, LM85_REG_AFAN_SPIKE1);
545 data->autofan[0].min_off = (i & 0x20) != 0;
546 data->autofan[1].min_off = (i & 0x40) != 0;
547 data->autofan[2].min_off = (i & 0x80) != 0;
548
549 i = lm85_read_value(client, LM85_REG_AFAN_HYST1);
550 data->zone[0].hyst = i >> 4;
551 data->zone[1].hyst = i & 0x0f;
552
553 i = lm85_read_value(client, LM85_REG_AFAN_HYST2);
554 data->zone[2].hyst = i >> 4;
555 }
556
557 data->last_config = jiffies;
558 } /* last_config */
559
560 data->valid = 1;
561
562 mutex_unlock(&data->update_lock);
563
564 return data;
565}
375 566
376/* 4 Fans */ 567/* 4 Fans */
377static ssize_t show_fan(struct device *dev, struct device_attribute *attr, 568static ssize_t show_fan(struct device *dev, struct device_attribute *attr,
@@ -394,8 +585,8 @@ static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr,
394 const char *buf, size_t count) 585 const char *buf, size_t count)
395{ 586{
396 int nr = to_sensor_dev_attr(attr)->index; 587 int nr = to_sensor_dev_attr(attr)->index;
397 struct i2c_client *client = to_i2c_client(dev); 588 struct lm85_data *data = dev_get_drvdata(dev);
398 struct lm85_data *data = i2c_get_clientdata(client); 589 struct i2c_client *client = data->client;
399 unsigned long val; 590 unsigned long val;
400 int err; 591 int err;
401 592
@@ -460,6 +651,9 @@ static ssize_t store_vrm_reg(struct device *dev, struct device_attribute *attr,
460 if (err) 651 if (err)
461 return err; 652 return err;
462 653
654 if (val > 255)
655 return -EINVAL;
656
463 data->vrm = val; 657 data->vrm = val;
464 return count; 658 return count;
465} 659}
@@ -515,8 +709,8 @@ static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
515 const char *buf, size_t count) 709 const char *buf, size_t count)
516{ 710{
517 int nr = to_sensor_dev_attr(attr)->index; 711 int nr = to_sensor_dev_attr(attr)->index;
518 struct i2c_client *client = to_i2c_client(dev); 712 struct lm85_data *data = dev_get_drvdata(dev);
519 struct lm85_data *data = i2c_get_clientdata(client); 713 struct i2c_client *client = data->client;
520 unsigned long val; 714 unsigned long val;
521 int err; 715 int err;
522 716
@@ -557,8 +751,8 @@ static ssize_t set_pwm_enable(struct device *dev, struct device_attribute
557 *attr, const char *buf, size_t count) 751 *attr, const char *buf, size_t count)
558{ 752{
559 int nr = to_sensor_dev_attr(attr)->index; 753 int nr = to_sensor_dev_attr(attr)->index;
560 struct i2c_client *client = to_i2c_client(dev); 754 struct lm85_data *data = dev_get_drvdata(dev);
561 struct lm85_data *data = i2c_get_clientdata(client); 755 struct i2c_client *client = data->client;
562 u8 config; 756 u8 config;
563 unsigned long val; 757 unsigned long val;
564 int err; 758 int err;
@@ -615,8 +809,8 @@ static ssize_t set_pwm_freq(struct device *dev,
615 struct device_attribute *attr, const char *buf, size_t count) 809 struct device_attribute *attr, const char *buf, size_t count)
616{ 810{
617 int nr = to_sensor_dev_attr(attr)->index; 811 int nr = to_sensor_dev_attr(attr)->index;
618 struct i2c_client *client = to_i2c_client(dev); 812 struct lm85_data *data = dev_get_drvdata(dev);
619 struct lm85_data *data = i2c_get_clientdata(client); 813 struct i2c_client *client = data->client;
620 unsigned long val; 814 unsigned long val;
621 int err; 815 int err;
622 816
@@ -682,8 +876,8 @@ static ssize_t set_in_min(struct device *dev, struct device_attribute *attr,
682 const char *buf, size_t count) 876 const char *buf, size_t count)
683{ 877{
684 int nr = to_sensor_dev_attr(attr)->index; 878 int nr = to_sensor_dev_attr(attr)->index;
685 struct i2c_client *client = to_i2c_client(dev); 879 struct lm85_data *data = dev_get_drvdata(dev);
686 struct lm85_data *data = i2c_get_clientdata(client); 880 struct i2c_client *client = data->client;
687 long val; 881 long val;
688 int err; 882 int err;
689 883
@@ -710,8 +904,8 @@ static ssize_t set_in_max(struct device *dev, struct device_attribute *attr,
710 const char *buf, size_t count) 904 const char *buf, size_t count)
711{ 905{
712 int nr = to_sensor_dev_attr(attr)->index; 906 int nr = to_sensor_dev_attr(attr)->index;
713 struct i2c_client *client = to_i2c_client(dev); 907 struct lm85_data *data = dev_get_drvdata(dev);
714 struct lm85_data *data = i2c_get_clientdata(client); 908 struct i2c_client *client = data->client;
715 long val; 909 long val;
716 int err; 910 int err;
717 911
@@ -766,8 +960,8 @@ static ssize_t set_temp_min(struct device *dev, struct device_attribute *attr,
766 const char *buf, size_t count) 960 const char *buf, size_t count)
767{ 961{
768 int nr = to_sensor_dev_attr(attr)->index; 962 int nr = to_sensor_dev_attr(attr)->index;
769 struct i2c_client *client = to_i2c_client(dev); 963 struct lm85_data *data = dev_get_drvdata(dev);
770 struct lm85_data *data = i2c_get_clientdata(client); 964 struct i2c_client *client = data->client;
771 long val; 965 long val;
772 int err; 966 int err;
773 967
@@ -797,8 +991,8 @@ static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr,
797 const char *buf, size_t count) 991 const char *buf, size_t count)
798{ 992{
799 int nr = to_sensor_dev_attr(attr)->index; 993 int nr = to_sensor_dev_attr(attr)->index;
800 struct i2c_client *client = to_i2c_client(dev); 994 struct lm85_data *data = dev_get_drvdata(dev);
801 struct lm85_data *data = i2c_get_clientdata(client); 995 struct i2c_client *client = data->client;
802 long val; 996 long val;
803 int err; 997 int err;
804 998
@@ -843,8 +1037,8 @@ static ssize_t set_pwm_auto_channels(struct device *dev,
843 struct device_attribute *attr, const char *buf, size_t count) 1037 struct device_attribute *attr, const char *buf, size_t count)
844{ 1038{
845 int nr = to_sensor_dev_attr(attr)->index; 1039 int nr = to_sensor_dev_attr(attr)->index;
846 struct i2c_client *client = to_i2c_client(dev); 1040 struct lm85_data *data = dev_get_drvdata(dev);
847 struct lm85_data *data = i2c_get_clientdata(client); 1041 struct i2c_client *client = data->client;
848 long val; 1042 long val;
849 int err; 1043 int err;
850 1044
@@ -873,8 +1067,8 @@ static ssize_t set_pwm_auto_pwm_min(struct device *dev,
873 struct device_attribute *attr, const char *buf, size_t count) 1067 struct device_attribute *attr, const char *buf, size_t count)
874{ 1068{
875 int nr = to_sensor_dev_attr(attr)->index; 1069 int nr = to_sensor_dev_attr(attr)->index;
876 struct i2c_client *client = to_i2c_client(dev); 1070 struct lm85_data *data = dev_get_drvdata(dev);
877 struct lm85_data *data = i2c_get_clientdata(client); 1071 struct i2c_client *client = data->client;
878 unsigned long val; 1072 unsigned long val;
879 int err; 1073 int err;
880 1074
@@ -902,8 +1096,8 @@ static ssize_t set_pwm_auto_pwm_minctl(struct device *dev,
902 struct device_attribute *attr, const char *buf, size_t count) 1096 struct device_attribute *attr, const char *buf, size_t count)
903{ 1097{
904 int nr = to_sensor_dev_attr(attr)->index; 1098 int nr = to_sensor_dev_attr(attr)->index;
905 struct i2c_client *client = to_i2c_client(dev); 1099 struct lm85_data *data = dev_get_drvdata(dev);
906 struct lm85_data *data = i2c_get_clientdata(client); 1100 struct i2c_client *client = data->client;
907 u8 tmp; 1101 u8 tmp;
908 long val; 1102 long val;
909 int err; 1103 int err;
@@ -953,8 +1147,8 @@ static ssize_t set_temp_auto_temp_off(struct device *dev,
953 struct device_attribute *attr, const char *buf, size_t count) 1147 struct device_attribute *attr, const char *buf, size_t count)
954{ 1148{
955 int nr = to_sensor_dev_attr(attr)->index; 1149 int nr = to_sensor_dev_attr(attr)->index;
956 struct i2c_client *client = to_i2c_client(dev); 1150 struct lm85_data *data = dev_get_drvdata(dev);
957 struct lm85_data *data = i2c_get_clientdata(client); 1151 struct i2c_client *client = data->client;
958 int min; 1152 int min;
959 long val; 1153 long val;
960 int err; 1154 int err;
@@ -990,8 +1184,8 @@ static ssize_t set_temp_auto_temp_min(struct device *dev,
990 struct device_attribute *attr, const char *buf, size_t count) 1184 struct device_attribute *attr, const char *buf, size_t count)
991{ 1185{
992 int nr = to_sensor_dev_attr(attr)->index; 1186 int nr = to_sensor_dev_attr(attr)->index;
993 struct i2c_client *client = to_i2c_client(dev); 1187 struct lm85_data *data = dev_get_drvdata(dev);
994 struct lm85_data *data = i2c_get_clientdata(client); 1188 struct i2c_client *client = data->client;
995 long val; 1189 long val;
996 int err; 1190 int err;
997 1191
@@ -1029,8 +1223,8 @@ static ssize_t set_temp_auto_temp_max(struct device *dev,
1029 struct device_attribute *attr, const char *buf, size_t count) 1223 struct device_attribute *attr, const char *buf, size_t count)
1030{ 1224{
1031 int nr = to_sensor_dev_attr(attr)->index; 1225 int nr = to_sensor_dev_attr(attr)->index;
1032 struct i2c_client *client = to_i2c_client(dev); 1226 struct lm85_data *data = dev_get_drvdata(dev);
1033 struct lm85_data *data = i2c_get_clientdata(client); 1227 struct i2c_client *client = data->client;
1034 int min; 1228 int min;
1035 long val; 1229 long val;
1036 int err; 1230 int err;
@@ -1063,8 +1257,8 @@ static ssize_t set_temp_auto_temp_crit(struct device *dev,
1063 struct device_attribute *attr, const char *buf, size_t count) 1257 struct device_attribute *attr, const char *buf, size_t count)
1064{ 1258{
1065 int nr = to_sensor_dev_attr(attr)->index; 1259 int nr = to_sensor_dev_attr(attr)->index;
1066 struct i2c_client *client = to_i2c_client(dev); 1260 struct lm85_data *data = dev_get_drvdata(dev);
1067 struct lm85_data *data = i2c_get_clientdata(client); 1261 struct i2c_client *client = data->client;
1068 long val; 1262 long val;
1069 int err; 1263 int err;
1070 1264
@@ -1355,30 +1549,18 @@ static int lm85_detect(struct i2c_client *client, struct i2c_board_info *info)
1355 return 0; 1549 return 0;
1356} 1550}
1357 1551
1358static void lm85_remove_files(struct i2c_client *client, struct lm85_data *data) 1552static int lm85_probe(struct i2c_client *client, const struct i2c_device_id *id)
1359{
1360 sysfs_remove_group(&client->dev.kobj, &lm85_group);
1361 if (data->type != emc6d103s) {
1362 sysfs_remove_group(&client->dev.kobj, &lm85_group_minctl);
1363 sysfs_remove_group(&client->dev.kobj, &lm85_group_temp_off);
1364 }
1365 if (!data->has_vid5)
1366 sysfs_remove_group(&client->dev.kobj, &lm85_group_in4);
1367 if (data->type == emc6d100)
1368 sysfs_remove_group(&client->dev.kobj, &lm85_group_in567);
1369}
1370
1371static int lm85_probe(struct i2c_client *client,
1372 const struct i2c_device_id *id)
1373{ 1553{
1554 struct device *dev = &client->dev;
1555 struct device *hwmon_dev;
1374 struct lm85_data *data; 1556 struct lm85_data *data;
1375 int err; 1557 int idx = 0;
1376 1558
1377 data = devm_kzalloc(&client->dev, sizeof(struct lm85_data), GFP_KERNEL); 1559 data = devm_kzalloc(dev, sizeof(struct lm85_data), GFP_KERNEL);
1378 if (!data) 1560 if (!data)
1379 return -ENOMEM; 1561 return -ENOMEM;
1380 1562
1381 i2c_set_clientdata(client, data); 1563 data->client = client;
1382 data->type = id->driver_data; 1564 data->type = id->driver_data;
1383 mutex_init(&data->update_lock); 1565 mutex_init(&data->update_lock);
1384 1566
@@ -1403,20 +1585,13 @@ static int lm85_probe(struct i2c_client *client,
1403 /* Initialize the LM85 chip */ 1585 /* Initialize the LM85 chip */
1404 lm85_init_client(client); 1586 lm85_init_client(client);
1405 1587
1406 /* Register sysfs hooks */ 1588 /* sysfs hooks */
1407 err = sysfs_create_group(&client->dev.kobj, &lm85_group); 1589 data->groups[idx++] = &lm85_group;
1408 if (err)
1409 return err;
1410 1590
1411 /* minctl and temp_off exist on all chips except emc6d103s */ 1591 /* minctl and temp_off exist on all chips except emc6d103s */
1412 if (data->type != emc6d103s) { 1592 if (data->type != emc6d103s) {
1413 err = sysfs_create_group(&client->dev.kobj, &lm85_group_minctl); 1593 data->groups[idx++] = &lm85_group_minctl;
1414 if (err) 1594 data->groups[idx++] = &lm85_group_temp_off;
1415 goto err_remove_files;
1416 err = sysfs_create_group(&client->dev.kobj,
1417 &lm85_group_temp_off);
1418 if (err)
1419 goto err_remove_files;
1420 } 1595 }
1421 1596
1422 /* 1597 /*
@@ -1429,271 +1604,44 @@ static int lm85_probe(struct i2c_client *client,
1429 data->has_vid5 = true; 1604 data->has_vid5 = true;
1430 } 1605 }
1431 1606
1432 if (!data->has_vid5) { 1607 if (!data->has_vid5)
1433 err = sysfs_create_group(&client->dev.kobj, &lm85_group_in4); 1608 data->groups[idx++] = &lm85_group_in4;
1434 if (err)
1435 goto err_remove_files;
1436 }
1437 1609
1438 /* The EMC6D100 has 3 additional voltage inputs */ 1610 /* The EMC6D100 has 3 additional voltage inputs */
1439 if (data->type == emc6d100) { 1611 if (data->type == emc6d100)
1440 err = sysfs_create_group(&client->dev.kobj, &lm85_group_in567); 1612 data->groups[idx++] = &lm85_group_in567;
1441 if (err)
1442 goto err_remove_files;
1443 }
1444
1445 data->hwmon_dev = hwmon_device_register(&client->dev);
1446 if (IS_ERR(data->hwmon_dev)) {
1447 err = PTR_ERR(data->hwmon_dev);
1448 goto err_remove_files;
1449 }
1450
1451 return 0;
1452
1453 /* Error out and cleanup code */
1454 err_remove_files:
1455 lm85_remove_files(client, data);
1456 return err;
1457}
1458
1459static int lm85_remove(struct i2c_client *client)
1460{
1461 struct lm85_data *data = i2c_get_clientdata(client);
1462 hwmon_device_unregister(data->hwmon_dev);
1463 lm85_remove_files(client, data);
1464 return 0;
1465}
1466
1467
1468static int lm85_read_value(struct i2c_client *client, u8 reg)
1469{
1470 int res;
1471
1472 /* What size location is it? */
1473 switch (reg) {
1474 case LM85_REG_FAN(0): /* Read WORD data */
1475 case LM85_REG_FAN(1):
1476 case LM85_REG_FAN(2):
1477 case LM85_REG_FAN(3):
1478 case LM85_REG_FAN_MIN(0):
1479 case LM85_REG_FAN_MIN(1):
1480 case LM85_REG_FAN_MIN(2):
1481 case LM85_REG_FAN_MIN(3):
1482 case LM85_REG_ALARM1: /* Read both bytes at once */
1483 res = i2c_smbus_read_byte_data(client, reg) & 0xff;
1484 res |= i2c_smbus_read_byte_data(client, reg + 1) << 8;
1485 break;
1486 default: /* Read BYTE data */
1487 res = i2c_smbus_read_byte_data(client, reg);
1488 break;
1489 }
1490
1491 return res;
1492}
1493 1613
1494static void lm85_write_value(struct i2c_client *client, u8 reg, int value) 1614 hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
1495{ 1615 data, data->groups);
1496 switch (reg) { 1616 return PTR_ERR_OR_ZERO(hwmon_dev);
1497 case LM85_REG_FAN(0): /* Write WORD data */
1498 case LM85_REG_FAN(1):
1499 case LM85_REG_FAN(2):
1500 case LM85_REG_FAN(3):
1501 case LM85_REG_FAN_MIN(0):
1502 case LM85_REG_FAN_MIN(1):
1503 case LM85_REG_FAN_MIN(2):
1504 case LM85_REG_FAN_MIN(3):
1505 /* NOTE: ALARM is read only, so not included here */
1506 i2c_smbus_write_byte_data(client, reg, value & 0xff);
1507 i2c_smbus_write_byte_data(client, reg + 1, value >> 8);
1508 break;
1509 default: /* Write BYTE data */
1510 i2c_smbus_write_byte_data(client, reg, value);
1511 break;
1512 }
1513} 1617}
1514 1618
1515static struct lm85_data *lm85_update_device(struct device *dev) 1619static const struct i2c_device_id lm85_id[] = {
1516{ 1620 { "adm1027", adm1027 },
1517 struct i2c_client *client = to_i2c_client(dev); 1621 { "adt7463", adt7463 },
1518 struct lm85_data *data = i2c_get_clientdata(client); 1622 { "adt7468", adt7468 },
1519 int i; 1623 { "lm85", lm85 },
1520 1624 { "lm85b", lm85 },
1521 mutex_lock(&data->update_lock); 1625 { "lm85c", lm85 },
1522 1626 { "emc6d100", emc6d100 },
1523 if (!data->valid || 1627 { "emc6d101", emc6d100 },
1524 time_after(jiffies, data->last_reading + LM85_DATA_INTERVAL)) { 1628 { "emc6d102", emc6d102 },
1525 /* Things that change quickly */ 1629 { "emc6d103", emc6d103 },
1526 dev_dbg(&client->dev, "Reading sensor values\n"); 1630 { "emc6d103s", emc6d103s },
1527 1631 { }
1528 /* 1632};
1529 * Have to read extended bits first to "freeze" the 1633MODULE_DEVICE_TABLE(i2c, lm85_id);
1530 * more significant bits that are read later.
1531 * There are 2 additional resolution bits per channel and we
1532 * have room for 4, so we shift them to the left.
1533 */
1534 if (data->type == adm1027 || data->type == adt7463 ||
1535 data->type == adt7468) {
1536 int ext1 = lm85_read_value(client,
1537 ADM1027_REG_EXTEND_ADC1);
1538 int ext2 = lm85_read_value(client,
1539 ADM1027_REG_EXTEND_ADC2);
1540 int val = (ext1 << 8) + ext2;
1541
1542 for (i = 0; i <= 4; i++)
1543 data->in_ext[i] =
1544 ((val >> (i * 2)) & 0x03) << 2;
1545
1546 for (i = 0; i <= 2; i++)
1547 data->temp_ext[i] =
1548 (val >> ((i + 4) * 2)) & 0x0c;
1549 }
1550
1551 data->vid = lm85_read_value(client, LM85_REG_VID);
1552
1553 for (i = 0; i <= 3; ++i) {
1554 data->in[i] =
1555 lm85_read_value(client, LM85_REG_IN(i));
1556 data->fan[i] =
1557 lm85_read_value(client, LM85_REG_FAN(i));
1558 }
1559
1560 if (!data->has_vid5)
1561 data->in[4] = lm85_read_value(client, LM85_REG_IN(4));
1562
1563 if (data->type == adt7468)
1564 data->cfg5 = lm85_read_value(client, ADT7468_REG_CFG5);
1565
1566 for (i = 0; i <= 2; ++i) {
1567 data->temp[i] =
1568 lm85_read_value(client, LM85_REG_TEMP(i));
1569 data->pwm[i] =
1570 lm85_read_value(client, LM85_REG_PWM(i));
1571
1572 if (IS_ADT7468_OFF64(data))
1573 data->temp[i] -= 64;
1574 }
1575
1576 data->alarms = lm85_read_value(client, LM85_REG_ALARM1);
1577
1578 if (data->type == emc6d100) {
1579 /* Three more voltage sensors */
1580 for (i = 5; i <= 7; ++i) {
1581 data->in[i] = lm85_read_value(client,
1582 EMC6D100_REG_IN(i));
1583 }
1584 /* More alarm bits */
1585 data->alarms |= lm85_read_value(client,
1586 EMC6D100_REG_ALARM3) << 16;
1587 } else if (data->type == emc6d102 || data->type == emc6d103 ||
1588 data->type == emc6d103s) {
1589 /*
1590 * Have to read LSB bits after the MSB ones because
1591 * the reading of the MSB bits has frozen the
1592 * LSBs (backward from the ADM1027).
1593 */
1594 int ext1 = lm85_read_value(client,
1595 EMC6D102_REG_EXTEND_ADC1);
1596 int ext2 = lm85_read_value(client,
1597 EMC6D102_REG_EXTEND_ADC2);
1598 int ext3 = lm85_read_value(client,
1599 EMC6D102_REG_EXTEND_ADC3);
1600 int ext4 = lm85_read_value(client,
1601 EMC6D102_REG_EXTEND_ADC4);
1602 data->in_ext[0] = ext3 & 0x0f;
1603 data->in_ext[1] = ext4 & 0x0f;
1604 data->in_ext[2] = ext4 >> 4;
1605 data->in_ext[3] = ext3 >> 4;
1606 data->in_ext[4] = ext2 >> 4;
1607
1608 data->temp_ext[0] = ext1 & 0x0f;
1609 data->temp_ext[1] = ext2 & 0x0f;
1610 data->temp_ext[2] = ext1 >> 4;
1611 }
1612
1613 data->last_reading = jiffies;
1614 } /* last_reading */
1615
1616 if (!data->valid ||
1617 time_after(jiffies, data->last_config + LM85_CONFIG_INTERVAL)) {
1618 /* Things that don't change often */
1619 dev_dbg(&client->dev, "Reading config values\n");
1620
1621 for (i = 0; i <= 3; ++i) {
1622 data->in_min[i] =
1623 lm85_read_value(client, LM85_REG_IN_MIN(i));
1624 data->in_max[i] =
1625 lm85_read_value(client, LM85_REG_IN_MAX(i));
1626 data->fan_min[i] =
1627 lm85_read_value(client, LM85_REG_FAN_MIN(i));
1628 }
1629
1630 if (!data->has_vid5) {
1631 data->in_min[4] = lm85_read_value(client,
1632 LM85_REG_IN_MIN(4));
1633 data->in_max[4] = lm85_read_value(client,
1634 LM85_REG_IN_MAX(4));
1635 }
1636
1637 if (data->type == emc6d100) {
1638 for (i = 5; i <= 7; ++i) {
1639 data->in_min[i] = lm85_read_value(client,
1640 EMC6D100_REG_IN_MIN(i));
1641 data->in_max[i] = lm85_read_value(client,
1642 EMC6D100_REG_IN_MAX(i));
1643 }
1644 }
1645
1646 for (i = 0; i <= 2; ++i) {
1647 int val;
1648
1649 data->temp_min[i] =
1650 lm85_read_value(client, LM85_REG_TEMP_MIN(i));
1651 data->temp_max[i] =
1652 lm85_read_value(client, LM85_REG_TEMP_MAX(i));
1653
1654 data->autofan[i].config =
1655 lm85_read_value(client, LM85_REG_AFAN_CONFIG(i));
1656 val = lm85_read_value(client, LM85_REG_AFAN_RANGE(i));
1657 data->pwm_freq[i] = val & 0x07;
1658 data->zone[i].range = val >> 4;
1659 data->autofan[i].min_pwm =
1660 lm85_read_value(client, LM85_REG_AFAN_MINPWM(i));
1661 data->zone[i].limit =
1662 lm85_read_value(client, LM85_REG_AFAN_LIMIT(i));
1663 data->zone[i].critical =
1664 lm85_read_value(client, LM85_REG_AFAN_CRITICAL(i));
1665
1666 if (IS_ADT7468_OFF64(data)) {
1667 data->temp_min[i] -= 64;
1668 data->temp_max[i] -= 64;
1669 data->zone[i].limit -= 64;
1670 data->zone[i].critical -= 64;
1671 }
1672 }
1673
1674 if (data->type != emc6d103s) {
1675 i = lm85_read_value(client, LM85_REG_AFAN_SPIKE1);
1676 data->autofan[0].min_off = (i & 0x20) != 0;
1677 data->autofan[1].min_off = (i & 0x40) != 0;
1678 data->autofan[2].min_off = (i & 0x80) != 0;
1679
1680 i = lm85_read_value(client, LM85_REG_AFAN_HYST1);
1681 data->zone[0].hyst = i >> 4;
1682 data->zone[1].hyst = i & 0x0f;
1683
1684 i = lm85_read_value(client, LM85_REG_AFAN_HYST2);
1685 data->zone[2].hyst = i >> 4;
1686 }
1687
1688 data->last_config = jiffies;
1689 } /* last_config */
1690
1691 data->valid = 1;
1692
1693 mutex_unlock(&data->update_lock);
1694 1634
1695 return data; 1635static struct i2c_driver lm85_driver = {
1696} 1636 .class = I2C_CLASS_HWMON,
1637 .driver = {
1638 .name = "lm85",
1639 },
1640 .probe = lm85_probe,
1641 .id_table = lm85_id,
1642 .detect = lm85_detect,
1643 .address_list = normal_i2c,
1644};
1697 1645
1698module_i2c_driver(lm85_driver); 1646module_i2c_driver(lm85_driver);
1699 1647
generated by cgit v1.2.2 (git 2.25.0) at 2026-01-07 21:40:20 -0500