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 bool valid; /* true if following fields are valid */ 121 unsigned long last_updated; /* In jiffies */ 122 123 u8 in[7]; /* Register value */ 124 u8 in_max[7]; /* Register value */ 125 u8 in_min[7]; /* Register value */ 126 u8 fan[3]; /* Register value */ 127 u8 fan_min[3]; /* Register value */ 128 s8 temp; /* Register value */ 129 s8 temp_over; /* Register value */ 130 s8 temp_hyst; /* Register value */ 131 u8 fan_div[3]; /* Register encoding, shifted right */ 132 u8 vid; /* Register encoding, combined */ 133 u16 alarms; /* Register encoding, combined */ 134 }; 135 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 strscpy(info->type, client_name, I2C_NAME_SIZE); 621 622 return 0; 623 624 err_nodev: 625 if (isa) 626 mutex_unlock(&isa->update_lock); 627 return -ENODEV; 628 } 629 630 static int lm78_i2c_probe(struct i2c_client *client) 631 { 632 struct device *dev = &client->dev; 633 struct device *hwmon_dev; 634 struct lm78_data *data; 635 636 data = devm_kzalloc(dev, sizeof(struct lm78_data), GFP_KERNEL); 637 if (!data) 638 return -ENOMEM; 639 640 data->client = client; 641 data->type = (uintptr_t)i2c_get_match_data(client); 642 643 /* Initialize the LM78 chip */ 644 lm78_init_device(data); 645 646 hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name, 647 data, lm78_groups); 648 return PTR_ERR_OR_ZERO(hwmon_dev); 649 } 650 651 static const struct i2c_device_id lm78_i2c_id[] = { 652 { "lm78", lm78 }, 653 { "lm79", lm79 }, 654 { } 655 }; 656 MODULE_DEVICE_TABLE(i2c, lm78_i2c_id); 657 658 static struct i2c_driver lm78_driver = { 659 .class = I2C_CLASS_HWMON, 660 .driver = { 661 .name = "lm78", 662 }, 663 .probe = lm78_i2c_probe, 664 .id_table = lm78_i2c_id, 665 .detect = lm78_i2c_detect, 666 .address_list = normal_i2c, 667 }; 668 669 /* 670 * The SMBus locks itself, but ISA access must be locked explicitly! 671 * We don't want to lock the whole ISA bus, so we lock each client 672 * separately. 673 * We ignore the LM78 BUSY flag at this moment - it could lead to deadlocks, 674 * would slow down the LM78 access and should not be necessary. 675 */ 676 static int lm78_read_value(struct lm78_data *data, u8 reg) 677 { 678 struct i2c_client *client = data->client; 679 680 #ifdef CONFIG_ISA 681 if (!client) { /* ISA device */ 682 int res; 683 mutex_lock(&data->lock); 684 outb_p(reg, data->isa_addr + LM78_ADDR_REG_OFFSET); 685 res = inb_p(data->isa_addr + LM78_DATA_REG_OFFSET); 686 mutex_unlock(&data->lock); 687 return res; 688 } else 689 #endif 690 return i2c_smbus_read_byte_data(client, reg); 691 } 692 693 static int lm78_write_value(struct lm78_data *data, u8 reg, u8 value) 694 { 695 struct i2c_client *client = data->client; 696 697 #ifdef CONFIG_ISA 698 if (!client) { /* ISA device */ 699 mutex_lock(&data->lock); 700 outb_p(reg, data->isa_addr + LM78_ADDR_REG_OFFSET); 701 outb_p(value, data->isa_addr + LM78_DATA_REG_OFFSET); 702 mutex_unlock(&data->lock); 703 return 0; 704 } else 705 #endif 706 return i2c_smbus_write_byte_data(client, reg, value); 707 } 708 709 static void lm78_init_device(struct lm78_data *data) 710 { 711 u8 config; 712 int i; 713 714 /* Start monitoring */ 715 config = lm78_read_value(data, LM78_REG_CONFIG); 716 if ((config & 0x09) != 0x01) 717 lm78_write_value(data, LM78_REG_CONFIG, 718 (config & 0xf7) | 0x01); 719 720 /* A few vars need to be filled upon startup */ 721 for (i = 0; i < 3; i++) { 722 data->fan_min[i] = lm78_read_value(data, 723 LM78_REG_FAN_MIN(i)); 724 } 725 726 mutex_init(&data->update_lock); 727 } 728 729 static struct lm78_data *lm78_update_device(struct device *dev) 730 { 731 struct lm78_data *data = dev_get_drvdata(dev); 732 int i; 733 734 mutex_lock(&data->update_lock); 735 736 if (time_after(jiffies, data->last_updated + HZ + HZ / 2) 737 || !data->valid) { 738 739 dev_dbg(dev, "Starting lm78 update\n"); 740 741 for (i = 0; i <= 6; i++) { 742 data->in[i] = 743 lm78_read_value(data, LM78_REG_IN(i)); 744 data->in_min[i] = 745 lm78_read_value(data, LM78_REG_IN_MIN(i)); 746 data->in_max[i] = 747 lm78_read_value(data, LM78_REG_IN_MAX(i)); 748 } 749 for (i = 0; i < 3; i++) { 750 data->fan[i] = 751 lm78_read_value(data, LM78_REG_FAN(i)); 752 data->fan_min[i] = 753 lm78_read_value(data, LM78_REG_FAN_MIN(i)); 754 } 755 data->temp = lm78_read_value(data, LM78_REG_TEMP); 756 data->temp_over = 757 lm78_read_value(data, LM78_REG_TEMP_OVER); 758 data->temp_hyst = 759 lm78_read_value(data, LM78_REG_TEMP_HYST); 760 i = lm78_read_value(data, LM78_REG_VID_FANDIV); 761 data->vid = i & 0x0f; 762 if (data->type == lm79) 763 data->vid |= 764 (lm78_read_value(data, LM78_REG_CHIPID) & 765 0x01) << 4; 766 else 767 data->vid |= 0x10; 768 data->fan_div[0] = (i >> 4) & 0x03; 769 data->fan_div[1] = i >> 6; 770 data->alarms = lm78_read_value(data, LM78_REG_ALARM1) + 771 (lm78_read_value(data, LM78_REG_ALARM2) << 8); 772 data->last_updated = jiffies; 773 data->valid = true; 774 775 data->fan_div[2] = 1; 776 } 777 778 mutex_unlock(&data->update_lock); 779 780 return data; 781 } 782 783 #ifdef CONFIG_ISA 784 static int lm78_isa_probe(struct platform_device *pdev) 785 { 786 struct device *dev = &pdev->dev; 787 struct device *hwmon_dev; 788 struct lm78_data *data; 789 struct resource *res; 790 791 /* Reserve the ISA region */ 792 res = platform_get_resource(pdev, IORESOURCE_IO, 0); 793 if (!devm_request_region(dev, res->start + LM78_ADDR_REG_OFFSET, 794 2, "lm78")) 795 return -EBUSY; 796 797 data = devm_kzalloc(dev, sizeof(struct lm78_data), GFP_KERNEL); 798 if (!data) 799 return -ENOMEM; 800 801 mutex_init(&data->lock); 802 data->isa_addr = res->start; 803 platform_set_drvdata(pdev, data); 804 805 if (lm78_read_value(data, LM78_REG_CHIPID) & 0x80) { 806 data->type = lm79; 807 data->name = "lm79"; 808 } else { 809 data->type = lm78; 810 data->name = "lm78"; 811 } 812 813 /* Initialize the LM78 chip */ 814 lm78_init_device(data); 815 816 hwmon_dev = devm_hwmon_device_register_with_groups(dev, data->name, 817 data, lm78_groups); 818 return PTR_ERR_OR_ZERO(hwmon_dev); 819 } 820 821 static struct platform_driver lm78_isa_driver = { 822 .driver = { 823 .name = "lm78", 824 }, 825 .probe = lm78_isa_probe, 826 }; 827 828 /* return 1 if a supported chip is found, 0 otherwise */ 829 static int __init lm78_isa_found(unsigned short address) 830 { 831 int val, save, found = 0; 832 int port; 833 834 /* 835 * Some boards declare base+0 to base+7 as a PNP device, some base+4 836 * to base+7 and some base+5 to base+6. So we better request each port 837 * individually for the probing phase. 838 */ 839 for (port = address; port < address + LM78_EXTENT; port++) { 840 if (!request_region(port, 1, "lm78")) { 841 pr_debug("Failed to request port 0x%x\n", port); 842 goto release; 843 } 844 } 845 846 #define REALLY_SLOW_IO 847 /* 848 * We need the timeouts for at least some LM78-like 849 * chips. But only if we read 'undefined' registers. 850 */ 851 val = inb_p(address + 1); 852 if (inb_p(address + 2) != val 853 || inb_p(address + 3) != val 854 || inb_p(address + 7) != val) 855 goto release; 856 #undef REALLY_SLOW_IO 857 858 /* 859 * We should be able to change the 7 LSB of the address port. The 860 * MSB (busy flag) should be clear initially, set after the write. 861 */ 862 save = inb_p(address + LM78_ADDR_REG_OFFSET); 863 if (save & 0x80) 864 goto release; 865 val = ~save & 0x7f; 866 outb_p(val, address + LM78_ADDR_REG_OFFSET); 867 if (inb_p(address + LM78_ADDR_REG_OFFSET) != (val | 0x80)) { 868 outb_p(save, address + LM78_ADDR_REG_OFFSET); 869 goto release; 870 } 871 872 /* We found a device, now see if it could be an LM78 */ 873 outb_p(LM78_REG_CONFIG, address + LM78_ADDR_REG_OFFSET); 874 val = inb_p(address + LM78_DATA_REG_OFFSET); 875 if (val & 0x80) 876 goto release; 877 outb_p(LM78_REG_I2C_ADDR, address + LM78_ADDR_REG_OFFSET); 878 val = inb_p(address + LM78_DATA_REG_OFFSET); 879 if (val < 0x03 || val > 0x77) /* Not a valid I2C address */ 880 goto release; 881 882 /* The busy flag should be clear again */ 883 if (inb_p(address + LM78_ADDR_REG_OFFSET) & 0x80) 884 goto release; 885 886 /* Explicitly prevent the misdetection of Winbond chips */ 887 outb_p(0x4f, address + LM78_ADDR_REG_OFFSET); 888 val = inb_p(address + LM78_DATA_REG_OFFSET); 889 if (val == 0xa3 || val == 0x5c) 890 goto release; 891 892 /* Explicitly prevent the misdetection of ITE chips */ 893 outb_p(0x58, address + LM78_ADDR_REG_OFFSET); 894 val = inb_p(address + LM78_DATA_REG_OFFSET); 895 if (val == 0x90) 896 goto release; 897 898 /* Determine the chip type */ 899 outb_p(LM78_REG_CHIPID, address + LM78_ADDR_REG_OFFSET); 900 val = inb_p(address + LM78_DATA_REG_OFFSET); 901 if (val == 0x00 || val == 0x20 /* LM78 */ 902 || val == 0x40 /* LM78-J */ 903 || (val & 0xfe) == 0xc0) /* LM79 */ 904 found = 1; 905 906 if (found) 907 pr_info("Found an %s chip at %#x\n", 908 val & 0x80 ? "LM79" : "LM78", (int)address); 909 910 release: 911 for (port--; port >= address; port--) 912 release_region(port, 1); 913 return found; 914 } 915 916 static int __init lm78_isa_device_add(unsigned short address) 917 { 918 struct resource res = { 919 .start = address, 920 .end = address + LM78_EXTENT - 1, 921 .name = "lm78", 922 .flags = IORESOURCE_IO, 923 }; 924 int err; 925 926 pdev = platform_device_alloc("lm78", address); 927 if (!pdev) { 928 err = -ENOMEM; 929 pr_err("Device allocation failed\n"); 930 goto exit; 931 } 932 933 err = platform_device_add_resources(pdev, &res, 1); 934 if (err) { 935 pr_err("Device resource addition failed (%d)\n", err); 936 goto exit_device_put; 937 } 938 939 err = platform_device_add(pdev); 940 if (err) { 941 pr_err("Device addition failed (%d)\n", err); 942 goto exit_device_put; 943 } 944 945 return 0; 946 947 exit_device_put: 948 platform_device_put(pdev); 949 exit: 950 pdev = NULL; 951 return err; 952 } 953 954 static int __init lm78_isa_register(void) 955 { 956 int res; 957 958 if (lm78_isa_found(isa_address)) { 959 res = platform_driver_register(&lm78_isa_driver); 960 if (res) 961 goto exit; 962 963 /* Sets global pdev as a side effect */ 964 res = lm78_isa_device_add(isa_address); 965 if (res) 966 goto exit_unreg_isa_driver; 967 } 968 969 return 0; 970 971 exit_unreg_isa_driver: 972 platform_driver_unregister(&lm78_isa_driver); 973 exit: 974 return res; 975 } 976 977 static void lm78_isa_unregister(void) 978 { 979 if (pdev) { 980 platform_device_unregister(pdev); 981 platform_driver_unregister(&lm78_isa_driver); 982 } 983 } 984 #else /* !CONFIG_ISA */ 985 986 static int __init lm78_isa_register(void) 987 { 988 return 0; 989 } 990 991 static void lm78_isa_unregister(void) 992 { 993 } 994 #endif /* CONFIG_ISA */ 995 996 static int __init sm_lm78_init(void) 997 { 998 int res; 999 1000 /* 1001 * We register the ISA device first, so that we can skip the 1002 * registration of an I2C interface to the same device. 1003 */ 1004 res = lm78_isa_register(); 1005 if (res) 1006 goto exit; 1007 1008 res = i2c_add_driver(&lm78_driver); 1009 if (res) 1010 goto exit_unreg_isa_device; 1011 1012 return 0; 1013 1014 exit_unreg_isa_device: 1015 lm78_isa_unregister(); 1016 exit: 1017 return res; 1018 } 1019 1020 static void __exit sm_lm78_exit(void) 1021 { 1022 lm78_isa_unregister(); 1023 i2c_del_driver(&lm78_driver); 1024 } 1025 1026 MODULE_AUTHOR("Frodo Looijaard, Jean Delvare <jdelvare@suse.de>"); 1027 MODULE_DESCRIPTION("LM78/LM79 driver"); 1028 MODULE_LICENSE("GPL"); 1029 1030 module_init(sm_lm78_init); 1031 module_exit(sm_lm78_exit); 1032