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