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