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