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