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