1032 lines · c
1// SPDX-License-Identifier: GPL-2.0-or-later2/*3 * lm78.c - Part of lm_sensors, Linux kernel modules for hardware4 * monitoring5 * Copyright (c) 1998, 1999 Frodo Looijaard <frodol@dds.nl>6 * Copyright (c) 2007, 2011 Jean Delvare <jdelvare@suse.de>7 */8 9#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt10 11#include <linux/module.h>12#include <linux/init.h>13#include <linux/slab.h>14#include <linux/jiffies.h>15#include <linux/i2c.h>16#include <linux/hwmon.h>17#include <linux/hwmon-vid.h>18#include <linux/hwmon-sysfs.h>19#include <linux/err.h>20#include <linux/mutex.h>21 22#ifdef CONFIG_ISA23#include <linux/platform_device.h>24#include <linux/ioport.h>25#include <linux/io.h>26#endif27 28/* Addresses to scan */29static const unsigned short normal_i2c[] = { 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d,30 0x2e, 0x2f, I2C_CLIENT_END };31enum chips { lm78, lm79 };32 33/* Many LM78 constants specified below */34 35/* Length of ISA address segment */36#define LM78_EXTENT 837 38/* Where are the ISA address/data registers relative to the base address */39#define LM78_ADDR_REG_OFFSET 540#define LM78_DATA_REG_OFFSET 641 42/* The LM78 registers */43#define LM78_REG_IN_MAX(nr) (0x2b + (nr) * 2)44#define LM78_REG_IN_MIN(nr) (0x2c + (nr) * 2)45#define LM78_REG_IN(nr) (0x20 + (nr))46 47#define LM78_REG_FAN_MIN(nr) (0x3b + (nr))48#define LM78_REG_FAN(nr) (0x28 + (nr))49 50#define LM78_REG_TEMP 0x2751#define LM78_REG_TEMP_OVER 0x3952#define LM78_REG_TEMP_HYST 0x3a53 54#define LM78_REG_ALARM1 0x4155#define LM78_REG_ALARM2 0x4256 57#define LM78_REG_VID_FANDIV 0x4758 59#define LM78_REG_CONFIG 0x4060#define LM78_REG_CHIPID 0x4961#define LM78_REG_I2C_ADDR 0x4862 63/*64 * Conversions. Rounding and limit checking is only done on the TO_REG65 * variants.66 */67 68/*69 * IN: mV (0V to 4.08V)70 * REG: 16mV/bit71 */72static inline u8 IN_TO_REG(unsigned long val)73{74 unsigned long nval = clamp_val(val, 0, 4080);75 return (nval + 8) / 16;76}77#define IN_FROM_REG(val) ((val) * 16)78 79static inline u8 FAN_TO_REG(long rpm, int div)80{81 if (rpm <= 0)82 return 255;83 if (rpm > 1350000)84 return 1;85 return clamp_val((1350000 + rpm * div / 2) / (rpm * div), 1, 254);86}87 88static inline int FAN_FROM_REG(u8 val, int div)89{90 return val == 0 ? -1 : val == 255 ? 0 : 1350000 / (val * div);91}92 93/*94 * TEMP: mC (-128C to +127C)95 * REG: 1C/bit, two's complement96 */97static inline s8 TEMP_TO_REG(long val)98{99 int nval = clamp_val(val, -128000, 127000) ;100 return nval < 0 ? (nval - 500) / 1000 : (nval + 500) / 1000;101}102 103static inline int TEMP_FROM_REG(s8 val)104{105 return val * 1000;106}107 108#define DIV_FROM_REG(val) (1 << (val))109 110struct lm78_data {111 struct i2c_client *client;112 struct mutex lock;113 enum chips type;114 115 /* For ISA device only */116 const char *name;117 int isa_addr;118 119 struct mutex update_lock;120 bool valid; /* true if following fields are valid */121 unsigned long last_updated; /* In jiffies */122 123 u8 in[7]; /* Register value */124 u8 in_max[7]; /* Register value */125 u8 in_min[7]; /* Register value */126 u8 fan[3]; /* Register value */127 u8 fan_min[3]; /* Register value */128 s8 temp; /* Register value */129 s8 temp_over; /* Register value */130 s8 temp_hyst; /* Register value */131 u8 fan_div[3]; /* Register encoding, shifted right */132 u8 vid; /* Register encoding, combined */133 u16 alarms; /* Register encoding, combined */134};135 136static int lm78_read_value(struct lm78_data *data, u8 reg);137static int lm78_write_value(struct lm78_data *data, u8 reg, u8 value);138static struct lm78_data *lm78_update_device(struct device *dev);139static void lm78_init_device(struct lm78_data *data);140 141/* 7 Voltages */142static ssize_t in_show(struct device *dev, struct device_attribute *da,143 char *buf)144{145 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);146 struct lm78_data *data = lm78_update_device(dev);147 return sprintf(buf, "%d\n", IN_FROM_REG(data->in[attr->index]));148}149 150static ssize_t in_min_show(struct device *dev, struct device_attribute *da,151 char *buf)152{153 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);154 struct lm78_data *data = lm78_update_device(dev);155 return sprintf(buf, "%d\n", IN_FROM_REG(data->in_min[attr->index]));156}157 158static ssize_t in_max_show(struct device *dev, struct device_attribute *da,159 char *buf)160{161 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);162 struct lm78_data *data = lm78_update_device(dev);163 return sprintf(buf, "%d\n", IN_FROM_REG(data->in_max[attr->index]));164}165 166static ssize_t in_min_store(struct device *dev, struct device_attribute *da,167 const char *buf, size_t count)168{169 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);170 struct lm78_data *data = dev_get_drvdata(dev);171 int nr = attr->index;172 unsigned long val;173 int err;174 175 err = kstrtoul(buf, 10, &val);176 if (err)177 return err;178 179 mutex_lock(&data->update_lock);180 data->in_min[nr] = IN_TO_REG(val);181 lm78_write_value(data, LM78_REG_IN_MIN(nr), data->in_min[nr]);182 mutex_unlock(&data->update_lock);183 return count;184}185 186static ssize_t in_max_store(struct device *dev, struct device_attribute *da,187 const char *buf, size_t count)188{189 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);190 struct lm78_data *data = dev_get_drvdata(dev);191 int nr = attr->index;192 unsigned long val;193 int err;194 195 err = kstrtoul(buf, 10, &val);196 if (err)197 return err;198 199 mutex_lock(&data->update_lock);200 data->in_max[nr] = IN_TO_REG(val);201 lm78_write_value(data, LM78_REG_IN_MAX(nr), data->in_max[nr]);202 mutex_unlock(&data->update_lock);203 return count;204}205 206static SENSOR_DEVICE_ATTR_RO(in0_input, in, 0);207static SENSOR_DEVICE_ATTR_RW(in0_min, in_min, 0);208static SENSOR_DEVICE_ATTR_RW(in0_max, in_max, 0);209static SENSOR_DEVICE_ATTR_RO(in1_input, in, 1);210static SENSOR_DEVICE_ATTR_RW(in1_min, in_min, 1);211static SENSOR_DEVICE_ATTR_RW(in1_max, in_max, 1);212static SENSOR_DEVICE_ATTR_RO(in2_input, in, 2);213static SENSOR_DEVICE_ATTR_RW(in2_min, in_min, 2);214static SENSOR_DEVICE_ATTR_RW(in2_max, in_max, 2);215static SENSOR_DEVICE_ATTR_RO(in3_input, in, 3);216static SENSOR_DEVICE_ATTR_RW(in3_min, in_min, 3);217static SENSOR_DEVICE_ATTR_RW(in3_max, in_max, 3);218static SENSOR_DEVICE_ATTR_RO(in4_input, in, 4);219static SENSOR_DEVICE_ATTR_RW(in4_min, in_min, 4);220static SENSOR_DEVICE_ATTR_RW(in4_max, in_max, 4);221static SENSOR_DEVICE_ATTR_RO(in5_input, in, 5);222static SENSOR_DEVICE_ATTR_RW(in5_min, in_min, 5);223static SENSOR_DEVICE_ATTR_RW(in5_max, in_max, 5);224static SENSOR_DEVICE_ATTR_RO(in6_input, in, 6);225static SENSOR_DEVICE_ATTR_RW(in6_min, in_min, 6);226static SENSOR_DEVICE_ATTR_RW(in6_max, in_max, 6);227 228/* Temperature */229static ssize_t temp1_input_show(struct device *dev,230 struct device_attribute *da, char *buf)231{232 struct lm78_data *data = lm78_update_device(dev);233 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp));234}235 236static ssize_t temp1_max_show(struct device *dev, struct device_attribute *da,237 char *buf)238{239 struct lm78_data *data = lm78_update_device(dev);240 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_over));241}242 243static ssize_t temp1_max_store(struct device *dev,244 struct device_attribute *da, const char *buf,245 size_t count)246{247 struct lm78_data *data = dev_get_drvdata(dev);248 long val;249 int err;250 251 err = kstrtol(buf, 10, &val);252 if (err)253 return err;254 255 mutex_lock(&data->update_lock);256 data->temp_over = TEMP_TO_REG(val);257 lm78_write_value(data, LM78_REG_TEMP_OVER, data->temp_over);258 mutex_unlock(&data->update_lock);259 return count;260}261 262static ssize_t temp1_max_hyst_show(struct device *dev,263 struct device_attribute *da, char *buf)264{265 struct lm78_data *data = lm78_update_device(dev);266 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_hyst));267}268 269static ssize_t temp1_max_hyst_store(struct device *dev,270 struct device_attribute *da,271 const char *buf, size_t count)272{273 struct lm78_data *data = dev_get_drvdata(dev);274 long val;275 int err;276 277 err = kstrtol(buf, 10, &val);278 if (err)279 return err;280 281 mutex_lock(&data->update_lock);282 data->temp_hyst = TEMP_TO_REG(val);283 lm78_write_value(data, LM78_REG_TEMP_HYST, data->temp_hyst);284 mutex_unlock(&data->update_lock);285 return count;286}287 288static DEVICE_ATTR_RO(temp1_input);289static DEVICE_ATTR_RW(temp1_max);290static DEVICE_ATTR_RW(temp1_max_hyst);291 292/* 3 Fans */293static ssize_t fan_show(struct device *dev, struct device_attribute *da,294 char *buf)295{296 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);297 struct lm78_data *data = lm78_update_device(dev);298 int nr = attr->index;299 return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[nr],300 DIV_FROM_REG(data->fan_div[nr])));301}302 303static ssize_t fan_min_show(struct device *dev, struct device_attribute *da,304 char *buf)305{306 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);307 struct lm78_data *data = lm78_update_device(dev);308 int nr = attr->index;309 return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan_min[nr],310 DIV_FROM_REG(data->fan_div[nr])));311}312 313static ssize_t fan_min_store(struct device *dev, struct device_attribute *da,314 const char *buf, size_t count)315{316 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);317 struct lm78_data *data = dev_get_drvdata(dev);318 int nr = attr->index;319 unsigned long val;320 int err;321 322 err = kstrtoul(buf, 10, &val);323 if (err)324 return err;325 326 mutex_lock(&data->update_lock);327 data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));328 lm78_write_value(data, LM78_REG_FAN_MIN(nr), data->fan_min[nr]);329 mutex_unlock(&data->update_lock);330 return count;331}332 333static ssize_t fan_div_show(struct device *dev, struct device_attribute *da,334 char *buf)335{336 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);337 struct lm78_data *data = lm78_update_device(dev);338 return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[attr->index]));339}340 341/*342 * Note: we save and restore the fan minimum here, because its value is343 * determined in part by the fan divisor. This follows the principle of344 * least surprise; the user doesn't expect the fan minimum to change just345 * because the divisor changed.346 */347static ssize_t fan_div_store(struct device *dev, struct device_attribute *da,348 const char *buf, size_t count)349{350 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);351 struct lm78_data *data = dev_get_drvdata(dev);352 int nr = attr->index;353 unsigned long min;354 u8 reg;355 unsigned long val;356 int err;357 358 err = kstrtoul(buf, 10, &val);359 if (err)360 return err;361 362 mutex_lock(&data->update_lock);363 min = FAN_FROM_REG(data->fan_min[nr],364 DIV_FROM_REG(data->fan_div[nr]));365 366 switch (val) {367 case 1:368 data->fan_div[nr] = 0;369 break;370 case 2:371 data->fan_div[nr] = 1;372 break;373 case 4:374 data->fan_div[nr] = 2;375 break;376 case 8:377 data->fan_div[nr] = 3;378 break;379 default:380 dev_err(dev,381 "fan_div value %ld not supported. Choose one of 1, 2, 4 or 8!\n",382 val);383 mutex_unlock(&data->update_lock);384 return -EINVAL;385 }386 387 reg = lm78_read_value(data, LM78_REG_VID_FANDIV);388 switch (nr) {389 case 0:390 reg = (reg & 0xcf) | (data->fan_div[nr] << 4);391 break;392 case 1:393 reg = (reg & 0x3f) | (data->fan_div[nr] << 6);394 break;395 }396 lm78_write_value(data, LM78_REG_VID_FANDIV, reg);397 398 data->fan_min[nr] =399 FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));400 lm78_write_value(data, LM78_REG_FAN_MIN(nr), data->fan_min[nr]);401 mutex_unlock(&data->update_lock);402 403 return count;404}405 406static SENSOR_DEVICE_ATTR_RO(fan1_input, fan, 0);407static SENSOR_DEVICE_ATTR_RW(fan1_min, fan_min, 0);408static SENSOR_DEVICE_ATTR_RO(fan2_input, fan, 1);409static SENSOR_DEVICE_ATTR_RW(fan2_min, fan_min, 1);410static SENSOR_DEVICE_ATTR_RO(fan3_input, fan, 2);411static SENSOR_DEVICE_ATTR_RW(fan3_min, fan_min, 2);412 413/* Fan 3 divisor is locked in H/W */414static SENSOR_DEVICE_ATTR_RW(fan1_div, fan_div, 0);415static SENSOR_DEVICE_ATTR_RW(fan2_div, fan_div, 1);416static SENSOR_DEVICE_ATTR_RO(fan3_div, fan_div, 2);417 418/* VID */419static ssize_t cpu0_vid_show(struct device *dev, struct device_attribute *da,420 char *buf)421{422 struct lm78_data *data = lm78_update_device(dev);423 return sprintf(buf, "%d\n", vid_from_reg(data->vid, 82));424}425static DEVICE_ATTR_RO(cpu0_vid);426 427/* Alarms */428static ssize_t alarms_show(struct device *dev, struct device_attribute *da,429 char *buf)430{431 struct lm78_data *data = lm78_update_device(dev);432 return sprintf(buf, "%u\n", data->alarms);433}434static DEVICE_ATTR_RO(alarms);435 436static ssize_t alarm_show(struct device *dev, struct device_attribute *da,437 char *buf)438{439 struct lm78_data *data = lm78_update_device(dev);440 int nr = to_sensor_dev_attr(da)->index;441 return sprintf(buf, "%u\n", (data->alarms >> nr) & 1);442}443static SENSOR_DEVICE_ATTR_RO(in0_alarm, alarm, 0);444static SENSOR_DEVICE_ATTR_RO(in1_alarm, alarm, 1);445static SENSOR_DEVICE_ATTR_RO(in2_alarm, alarm, 2);446static SENSOR_DEVICE_ATTR_RO(in3_alarm, alarm, 3);447static SENSOR_DEVICE_ATTR_RO(in4_alarm, alarm, 8);448static SENSOR_DEVICE_ATTR_RO(in5_alarm, alarm, 9);449static SENSOR_DEVICE_ATTR_RO(in6_alarm, alarm, 10);450static SENSOR_DEVICE_ATTR_RO(fan1_alarm, alarm, 6);451static SENSOR_DEVICE_ATTR_RO(fan2_alarm, alarm, 7);452static SENSOR_DEVICE_ATTR_RO(fan3_alarm, alarm, 11);453static SENSOR_DEVICE_ATTR_RO(temp1_alarm, alarm, 4);454 455static struct attribute *lm78_attrs[] = {456 &sensor_dev_attr_in0_input.dev_attr.attr,457 &sensor_dev_attr_in0_min.dev_attr.attr,458 &sensor_dev_attr_in0_max.dev_attr.attr,459 &sensor_dev_attr_in0_alarm.dev_attr.attr,460 &sensor_dev_attr_in1_input.dev_attr.attr,461 &sensor_dev_attr_in1_min.dev_attr.attr,462 &sensor_dev_attr_in1_max.dev_attr.attr,463 &sensor_dev_attr_in1_alarm.dev_attr.attr,464 &sensor_dev_attr_in2_input.dev_attr.attr,465 &sensor_dev_attr_in2_min.dev_attr.attr,466 &sensor_dev_attr_in2_max.dev_attr.attr,467 &sensor_dev_attr_in2_alarm.dev_attr.attr,468 &sensor_dev_attr_in3_input.dev_attr.attr,469 &sensor_dev_attr_in3_min.dev_attr.attr,470 &sensor_dev_attr_in3_max.dev_attr.attr,471 &sensor_dev_attr_in3_alarm.dev_attr.attr,472 &sensor_dev_attr_in4_input.dev_attr.attr,473 &sensor_dev_attr_in4_min.dev_attr.attr,474 &sensor_dev_attr_in4_max.dev_attr.attr,475 &sensor_dev_attr_in4_alarm.dev_attr.attr,476 &sensor_dev_attr_in5_input.dev_attr.attr,477 &sensor_dev_attr_in5_min.dev_attr.attr,478 &sensor_dev_attr_in5_max.dev_attr.attr,479 &sensor_dev_attr_in5_alarm.dev_attr.attr,480 &sensor_dev_attr_in6_input.dev_attr.attr,481 &sensor_dev_attr_in6_min.dev_attr.attr,482 &sensor_dev_attr_in6_max.dev_attr.attr,483 &sensor_dev_attr_in6_alarm.dev_attr.attr,484 &dev_attr_temp1_input.attr,485 &dev_attr_temp1_max.attr,486 &dev_attr_temp1_max_hyst.attr,487 &sensor_dev_attr_temp1_alarm.dev_attr.attr,488 &sensor_dev_attr_fan1_input.dev_attr.attr,489 &sensor_dev_attr_fan1_min.dev_attr.attr,490 &sensor_dev_attr_fan1_div.dev_attr.attr,491 &sensor_dev_attr_fan1_alarm.dev_attr.attr,492 &sensor_dev_attr_fan2_input.dev_attr.attr,493 &sensor_dev_attr_fan2_min.dev_attr.attr,494 &sensor_dev_attr_fan2_div.dev_attr.attr,495 &sensor_dev_attr_fan2_alarm.dev_attr.attr,496 &sensor_dev_attr_fan3_input.dev_attr.attr,497 &sensor_dev_attr_fan3_min.dev_attr.attr,498 &sensor_dev_attr_fan3_div.dev_attr.attr,499 &sensor_dev_attr_fan3_alarm.dev_attr.attr,500 &dev_attr_alarms.attr,501 &dev_attr_cpu0_vid.attr,502 503 NULL504};505 506ATTRIBUTE_GROUPS(lm78);507 508/*509 * ISA related code510 */511#ifdef CONFIG_ISA512 513/* ISA device, if found */514static struct platform_device *pdev;515 516static unsigned short isa_address = 0x290;517 518static struct lm78_data *lm78_data_if_isa(void)519{520 return pdev ? platform_get_drvdata(pdev) : NULL;521}522 523/* Returns 1 if the I2C chip appears to be an alias of the ISA chip */524static int lm78_alias_detect(struct i2c_client *client, u8 chipid)525{526 struct lm78_data *isa;527 int i;528 529 if (!pdev) /* No ISA chip */530 return 0;531 isa = platform_get_drvdata(pdev);532 533 if (lm78_read_value(isa, LM78_REG_I2C_ADDR) != client->addr)534 return 0; /* Address doesn't match */535 if ((lm78_read_value(isa, LM78_REG_CHIPID) & 0xfe) != (chipid & 0xfe))536 return 0; /* Chip type doesn't match */537 538 /*539 * We compare all the limit registers, the config register and the540 * interrupt mask registers541 */542 for (i = 0x2b; i <= 0x3d; i++) {543 if (lm78_read_value(isa, i) !=544 i2c_smbus_read_byte_data(client, i))545 return 0;546 }547 if (lm78_read_value(isa, LM78_REG_CONFIG) !=548 i2c_smbus_read_byte_data(client, LM78_REG_CONFIG))549 return 0;550 for (i = 0x43; i <= 0x46; i++) {551 if (lm78_read_value(isa, i) !=552 i2c_smbus_read_byte_data(client, i))553 return 0;554 }555 556 return 1;557}558#else /* !CONFIG_ISA */559 560static int lm78_alias_detect(struct i2c_client *client, u8 chipid)561{562 return 0;563}564 565static struct lm78_data *lm78_data_if_isa(void)566{567 return NULL;568}569#endif /* CONFIG_ISA */570 571static int lm78_i2c_detect(struct i2c_client *client,572 struct i2c_board_info *info)573{574 int i;575 struct lm78_data *isa = lm78_data_if_isa();576 const char *client_name;577 struct i2c_adapter *adapter = client->adapter;578 int address = client->addr;579 580 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))581 return -ENODEV;582 583 /*584 * We block updates of the ISA device to minimize the risk of585 * concurrent access to the same LM78 chip through different586 * interfaces.587 */588 if (isa)589 mutex_lock(&isa->update_lock);590 591 if ((i2c_smbus_read_byte_data(client, LM78_REG_CONFIG) & 0x80)592 || i2c_smbus_read_byte_data(client, LM78_REG_I2C_ADDR) != address)593 goto err_nodev;594 595 /* Explicitly prevent the misdetection of Winbond chips */596 i = i2c_smbus_read_byte_data(client, 0x4f);597 if (i == 0xa3 || i == 0x5c)598 goto err_nodev;599 600 /* Determine the chip type. */601 i = i2c_smbus_read_byte_data(client, LM78_REG_CHIPID);602 if (i == 0x00 || i == 0x20 /* LM78 */603 || i == 0x40) /* LM78-J */604 client_name = "lm78";605 else if ((i & 0xfe) == 0xc0)606 client_name = "lm79";607 else608 goto err_nodev;609 610 if (lm78_alias_detect(client, i)) {611 dev_dbg(&adapter->dev,612 "Device at 0x%02x appears to be the same as ISA device\n",613 address);614 goto err_nodev;615 }616 617 if (isa)618 mutex_unlock(&isa->update_lock);619 620 strscpy(info->type, client_name, I2C_NAME_SIZE);621 622 return 0;623 624 err_nodev:625 if (isa)626 mutex_unlock(&isa->update_lock);627 return -ENODEV;628}629 630static int lm78_i2c_probe(struct i2c_client *client)631{632 struct device *dev = &client->dev;633 struct device *hwmon_dev;634 struct lm78_data *data;635 636 data = devm_kzalloc(dev, sizeof(struct lm78_data), GFP_KERNEL);637 if (!data)638 return -ENOMEM;639 640 data->client = client;641 data->type = (uintptr_t)i2c_get_match_data(client);642 643 /* Initialize the LM78 chip */644 lm78_init_device(data);645 646 hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,647 data, lm78_groups);648 return PTR_ERR_OR_ZERO(hwmon_dev);649}650 651static const struct i2c_device_id lm78_i2c_id[] = {652 { "lm78", lm78 },653 { "lm79", lm79 },654 { }655};656MODULE_DEVICE_TABLE(i2c, lm78_i2c_id);657 658static struct i2c_driver lm78_driver = {659 .class = I2C_CLASS_HWMON,660 .driver = {661 .name = "lm78",662 },663 .probe = lm78_i2c_probe,664 .id_table = lm78_i2c_id,665 .detect = lm78_i2c_detect,666 .address_list = normal_i2c,667};668 669/*670 * The SMBus locks itself, but ISA access must be locked explicitly!671 * We don't want to lock the whole ISA bus, so we lock each client672 * separately.673 * We ignore the LM78 BUSY flag at this moment - it could lead to deadlocks,674 * would slow down the LM78 access and should not be necessary.675 */676static int lm78_read_value(struct lm78_data *data, u8 reg)677{678 struct i2c_client *client = data->client;679 680#ifdef CONFIG_ISA681 if (!client) { /* ISA device */682 int res;683 mutex_lock(&data->lock);684 outb_p(reg, data->isa_addr + LM78_ADDR_REG_OFFSET);685 res = inb_p(data->isa_addr + LM78_DATA_REG_OFFSET);686 mutex_unlock(&data->lock);687 return res;688 } else689#endif690 return i2c_smbus_read_byte_data(client, reg);691}692 693static int lm78_write_value(struct lm78_data *data, u8 reg, u8 value)694{695 struct i2c_client *client = data->client;696 697#ifdef CONFIG_ISA698 if (!client) { /* ISA device */699 mutex_lock(&data->lock);700 outb_p(reg, data->isa_addr + LM78_ADDR_REG_OFFSET);701 outb_p(value, data->isa_addr + LM78_DATA_REG_OFFSET);702 mutex_unlock(&data->lock);703 return 0;704 } else705#endif706 return i2c_smbus_write_byte_data(client, reg, value);707}708 709static void lm78_init_device(struct lm78_data *data)710{711 u8 config;712 int i;713 714 /* Start monitoring */715 config = lm78_read_value(data, LM78_REG_CONFIG);716 if ((config & 0x09) != 0x01)717 lm78_write_value(data, LM78_REG_CONFIG,718 (config & 0xf7) | 0x01);719 720 /* A few vars need to be filled upon startup */721 for (i = 0; i < 3; i++) {722 data->fan_min[i] = lm78_read_value(data,723 LM78_REG_FAN_MIN(i));724 }725 726 mutex_init(&data->update_lock);727}728 729static struct lm78_data *lm78_update_device(struct device *dev)730{731 struct lm78_data *data = dev_get_drvdata(dev);732 int i;733 734 mutex_lock(&data->update_lock);735 736 if (time_after(jiffies, data->last_updated + HZ + HZ / 2)737 || !data->valid) {738 739 dev_dbg(dev, "Starting lm78 update\n");740 741 for (i = 0; i <= 6; i++) {742 data->in[i] =743 lm78_read_value(data, LM78_REG_IN(i));744 data->in_min[i] =745 lm78_read_value(data, LM78_REG_IN_MIN(i));746 data->in_max[i] =747 lm78_read_value(data, LM78_REG_IN_MAX(i));748 }749 for (i = 0; i < 3; i++) {750 data->fan[i] =751 lm78_read_value(data, LM78_REG_FAN(i));752 data->fan_min[i] =753 lm78_read_value(data, LM78_REG_FAN_MIN(i));754 }755 data->temp = lm78_read_value(data, LM78_REG_TEMP);756 data->temp_over =757 lm78_read_value(data, LM78_REG_TEMP_OVER);758 data->temp_hyst =759 lm78_read_value(data, LM78_REG_TEMP_HYST);760 i = lm78_read_value(data, LM78_REG_VID_FANDIV);761 data->vid = i & 0x0f;762 if (data->type == lm79)763 data->vid |=764 (lm78_read_value(data, LM78_REG_CHIPID) &765 0x01) << 4;766 else767 data->vid |= 0x10;768 data->fan_div[0] = (i >> 4) & 0x03;769 data->fan_div[1] = i >> 6;770 data->alarms = lm78_read_value(data, LM78_REG_ALARM1) +771 (lm78_read_value(data, LM78_REG_ALARM2) << 8);772 data->last_updated = jiffies;773 data->valid = true;774 775 data->fan_div[2] = 1;776 }777 778 mutex_unlock(&data->update_lock);779 780 return data;781}782 783#ifdef CONFIG_ISA784static int lm78_isa_probe(struct platform_device *pdev)785{786 struct device *dev = &pdev->dev;787 struct device *hwmon_dev;788 struct lm78_data *data;789 struct resource *res;790 791 /* Reserve the ISA region */792 res = platform_get_resource(pdev, IORESOURCE_IO, 0);793 if (!devm_request_region(dev, res->start + LM78_ADDR_REG_OFFSET,794 2, "lm78"))795 return -EBUSY;796 797 data = devm_kzalloc(dev, sizeof(struct lm78_data), GFP_KERNEL);798 if (!data)799 return -ENOMEM;800 801 mutex_init(&data->lock);802 data->isa_addr = res->start;803 platform_set_drvdata(pdev, data);804 805 if (lm78_read_value(data, LM78_REG_CHIPID) & 0x80) {806 data->type = lm79;807 data->name = "lm79";808 } else {809 data->type = lm78;810 data->name = "lm78";811 }812 813 /* Initialize the LM78 chip */814 lm78_init_device(data);815 816 hwmon_dev = devm_hwmon_device_register_with_groups(dev, data->name,817 data, lm78_groups);818 return PTR_ERR_OR_ZERO(hwmon_dev);819}820 821static struct platform_driver lm78_isa_driver = {822 .driver = {823 .name = "lm78",824 },825 .probe = lm78_isa_probe,826};827 828/* return 1 if a supported chip is found, 0 otherwise */829static int __init lm78_isa_found(unsigned short address)830{831 int val, save, found = 0;832 int port;833 834 /*835 * Some boards declare base+0 to base+7 as a PNP device, some base+4836 * to base+7 and some base+5 to base+6. So we better request each port837 * individually for the probing phase.838 */839 for (port = address; port < address + LM78_EXTENT; port++) {840 if (!request_region(port, 1, "lm78")) {841 pr_debug("Failed to request port 0x%x\n", port);842 goto release;843 }844 }845 846#define REALLY_SLOW_IO847 /*848 * We need the timeouts for at least some LM78-like849 * chips. But only if we read 'undefined' registers.850 */851 val = inb_p(address + 1);852 if (inb_p(address + 2) != val853 || inb_p(address + 3) != val854 || inb_p(address + 7) != val)855 goto release;856#undef REALLY_SLOW_IO857 858 /*859 * We should be able to change the 7 LSB of the address port. The860 * MSB (busy flag) should be clear initially, set after the write.861 */862 save = inb_p(address + LM78_ADDR_REG_OFFSET);863 if (save & 0x80)864 goto release;865 val = ~save & 0x7f;866 outb_p(val, address + LM78_ADDR_REG_OFFSET);867 if (inb_p(address + LM78_ADDR_REG_OFFSET) != (val | 0x80)) {868 outb_p(save, address + LM78_ADDR_REG_OFFSET);869 goto release;870 }871 872 /* We found a device, now see if it could be an LM78 */873 outb_p(LM78_REG_CONFIG, address + LM78_ADDR_REG_OFFSET);874 val = inb_p(address + LM78_DATA_REG_OFFSET);875 if (val & 0x80)876 goto release;877 outb_p(LM78_REG_I2C_ADDR, address + LM78_ADDR_REG_OFFSET);878 val = inb_p(address + LM78_DATA_REG_OFFSET);879 if (val < 0x03 || val > 0x77) /* Not a valid I2C address */880 goto release;881 882 /* The busy flag should be clear again */883 if (inb_p(address + LM78_ADDR_REG_OFFSET) & 0x80)884 goto release;885 886 /* Explicitly prevent the misdetection of Winbond chips */887 outb_p(0x4f, address + LM78_ADDR_REG_OFFSET);888 val = inb_p(address + LM78_DATA_REG_OFFSET);889 if (val == 0xa3 || val == 0x5c)890 goto release;891 892 /* Explicitly prevent the misdetection of ITE chips */893 outb_p(0x58, address + LM78_ADDR_REG_OFFSET);894 val = inb_p(address + LM78_DATA_REG_OFFSET);895 if (val == 0x90)896 goto release;897 898 /* Determine the chip type */899 outb_p(LM78_REG_CHIPID, address + LM78_ADDR_REG_OFFSET);900 val = inb_p(address + LM78_DATA_REG_OFFSET);901 if (val == 0x00 || val == 0x20 /* LM78 */902 || val == 0x40 /* LM78-J */903 || (val & 0xfe) == 0xc0) /* LM79 */904 found = 1;905 906 if (found)907 pr_info("Found an %s chip at %#x\n",908 val & 0x80 ? "LM79" : "LM78", (int)address);909 910 release:911 for (port--; port >= address; port--)912 release_region(port, 1);913 return found;914}915 916static int __init lm78_isa_device_add(unsigned short address)917{918 struct resource res = {919 .start = address,920 .end = address + LM78_EXTENT - 1,921 .name = "lm78",922 .flags = IORESOURCE_IO,923 };924 int err;925 926 pdev = platform_device_alloc("lm78", address);927 if (!pdev) {928 err = -ENOMEM;929 pr_err("Device allocation failed\n");930 goto exit;931 }932 933 err = platform_device_add_resources(pdev, &res, 1);934 if (err) {935 pr_err("Device resource addition failed (%d)\n", err);936 goto exit_device_put;937 }938 939 err = platform_device_add(pdev);940 if (err) {941 pr_err("Device addition failed (%d)\n", err);942 goto exit_device_put;943 }944 945 return 0;946 947 exit_device_put:948 platform_device_put(pdev);949 exit:950 pdev = NULL;951 return err;952}953 954static int __init lm78_isa_register(void)955{956 int res;957 958 if (lm78_isa_found(isa_address)) {959 res = platform_driver_register(&lm78_isa_driver);960 if (res)961 goto exit;962 963 /* Sets global pdev as a side effect */964 res = lm78_isa_device_add(isa_address);965 if (res)966 goto exit_unreg_isa_driver;967 }968 969 return 0;970 971 exit_unreg_isa_driver:972 platform_driver_unregister(&lm78_isa_driver);973 exit:974 return res;975}976 977static void lm78_isa_unregister(void)978{979 if (pdev) {980 platform_device_unregister(pdev);981 platform_driver_unregister(&lm78_isa_driver);982 }983}984#else /* !CONFIG_ISA */985 986static int __init lm78_isa_register(void)987{988 return 0;989}990 991static void lm78_isa_unregister(void)992{993}994#endif /* CONFIG_ISA */995 996static int __init sm_lm78_init(void)997{998 int res;999 1000 /*1001 * We register the ISA device first, so that we can skip the1002 * registration of an I2C interface to the same device.1003 */1004 res = lm78_isa_register();1005 if (res)1006 goto exit;1007 1008 res = i2c_add_driver(&lm78_driver);1009 if (res)1010 goto exit_unreg_isa_device;1011 1012 return 0;1013 1014 exit_unreg_isa_device:1015 lm78_isa_unregister();1016 exit:1017 return res;1018}1019 1020static void __exit sm_lm78_exit(void)1021{1022 lm78_isa_unregister();1023 i2c_del_driver(&lm78_driver);1024}1025 1026MODULE_AUTHOR("Frodo Looijaard, Jean Delvare <jdelvare@suse.de>");1027MODULE_DESCRIPTION("LM78/LM79 driver");1028MODULE_LICENSE("GPL");1029 1030module_init(sm_lm78_init);1031module_exit(sm_lm78_exit);1032