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 */ 29static const unsigned short normal_i2c[] = { 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 30 0x2e, 0x2f, I2C_CLIENT_END }; 31enum 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 */ 72static 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 79static 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 88static 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 */ 97static 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 103static inline int TEMP_FROM_REG(s8 val) 104{ 105 return val * 1000; 106} 107 108#define DIV_FROM_REG(val) (1 << (val)) 109 110struct 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 136static int lm78_read_value(struct lm78_data *data, u8 reg); 137static int lm78_write_value(struct lm78_data *data, u8 reg, u8 value); 138static struct lm78_data *lm78_update_device(struct device *dev); 139static void lm78_init_device(struct lm78_data *data); 140 141/* 7 Voltages */ 142static 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 150static 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 158static 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 166static 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 186static 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 206static SENSOR_DEVICE_ATTR_RO(in0_input, in, 0); 207static SENSOR_DEVICE_ATTR_RW(in0_min, in_min, 0); 208static SENSOR_DEVICE_ATTR_RW(in0_max, in_max, 0); 209static SENSOR_DEVICE_ATTR_RO(in1_input, in, 1); 210static SENSOR_DEVICE_ATTR_RW(in1_min, in_min, 1); 211static SENSOR_DEVICE_ATTR_RW(in1_max, in_max, 1); 212static SENSOR_DEVICE_ATTR_RO(in2_input, in, 2); 213static SENSOR_DEVICE_ATTR_RW(in2_min, in_min, 2); 214static SENSOR_DEVICE_ATTR_RW(in2_max, in_max, 2); 215static SENSOR_DEVICE_ATTR_RO(in3_input, in, 3); 216static SENSOR_DEVICE_ATTR_RW(in3_min, in_min, 3); 217static SENSOR_DEVICE_ATTR_RW(in3_max, in_max, 3); 218static SENSOR_DEVICE_ATTR_RO(in4_input, in, 4); 219static SENSOR_DEVICE_ATTR_RW(in4_min, in_min, 4); 220static SENSOR_DEVICE_ATTR_RW(in4_max, in_max, 4); 221static SENSOR_DEVICE_ATTR_RO(in5_input, in, 5); 222static SENSOR_DEVICE_ATTR_RW(in5_min, in_min, 5); 223static SENSOR_DEVICE_ATTR_RW(in5_max, in_max, 5); 224static SENSOR_DEVICE_ATTR_RO(in6_input, in, 6); 225static SENSOR_DEVICE_ATTR_RW(in6_min, in_min, 6); 226static SENSOR_DEVICE_ATTR_RW(in6_max, in_max, 6); 227 228/* Temperature */ 229static 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 236static 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 243static 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 262static 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 269static 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 288static DEVICE_ATTR_RO(temp1_input); 289static DEVICE_ATTR_RW(temp1_max); 290static DEVICE_ATTR_RW(temp1_max_hyst); 291 292/* 3 Fans */ 293static 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 303static 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 313static 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 333static 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 */ 347static 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 406static SENSOR_DEVICE_ATTR_RO(fan1_input, fan, 0); 407static SENSOR_DEVICE_ATTR_RW(fan1_min, fan_min, 0); 408static SENSOR_DEVICE_ATTR_RO(fan2_input, fan, 1); 409static SENSOR_DEVICE_ATTR_RW(fan2_min, fan_min, 1); 410static SENSOR_DEVICE_ATTR_RO(fan3_input, fan, 2); 411static SENSOR_DEVICE_ATTR_RW(fan3_min, fan_min, 2); 412 413/* Fan 3 divisor is locked in H/W */ 414static SENSOR_DEVICE_ATTR_RW(fan1_div, fan_div, 0); 415static SENSOR_DEVICE_ATTR_RW(fan2_div, fan_div, 1); 416static SENSOR_DEVICE_ATTR_RO(fan3_div, fan_div, 2); 417 418/* VID */ 419static 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} 425static DEVICE_ATTR_RO(cpu0_vid); 426 427/* Alarms */ 428static 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} 434static DEVICE_ATTR_RO(alarms); 435 436static 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} 443static SENSOR_DEVICE_ATTR_RO(in0_alarm, alarm, 0); 444static SENSOR_DEVICE_ATTR_RO(in1_alarm, alarm, 1); 445static SENSOR_DEVICE_ATTR_RO(in2_alarm, alarm, 2); 446static SENSOR_DEVICE_ATTR_RO(in3_alarm, alarm, 3); 447static SENSOR_DEVICE_ATTR_RO(in4_alarm, alarm, 8); 448static SENSOR_DEVICE_ATTR_RO(in5_alarm, alarm, 9); 449static SENSOR_DEVICE_ATTR_RO(in6_alarm, alarm, 10); 450static SENSOR_DEVICE_ATTR_RO(fan1_alarm, alarm, 6); 451static SENSOR_DEVICE_ATTR_RO(fan2_alarm, alarm, 7); 452static SENSOR_DEVICE_ATTR_RO(fan3_alarm, alarm, 11); 453static SENSOR_DEVICE_ATTR_RO(temp1_alarm, alarm, 4); 454 455static 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 506ATTRIBUTE_GROUPS(lm78); 507 508/* 509 * ISA related code 510 */ 511#ifdef CONFIG_ISA 512 513/* ISA device, if found */ 514static struct platform_device *pdev; 515 516static unsigned short isa_address = 0x290; 517 518static 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 */ 524static 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 560static int lm78_alias_detect(struct i2c_client *client, u8 chipid) 561{ 562 return 0; 563} 564 565static struct lm78_data *lm78_data_if_isa(void) 566{ 567 return NULL; 568} 569#endif /* CONFIG_ISA */ 570 571static 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 630static const struct i2c_device_id lm78_i2c_id[]; 631 632static 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 653static const struct i2c_device_id lm78_i2c_id[] = { 654 { "lm78", lm78 }, 655 { "lm79", lm79 }, 656 { } 657}; 658MODULE_DEVICE_TABLE(i2c, lm78_i2c_id); 659 660static 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 */ 678static 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 695static 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 711static 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 731static 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 786static 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 823static 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 */ 831static 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 918static 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 956static 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 979static 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 988static int __init lm78_isa_register(void) 989{ 990 return 0; 991} 992 993static void lm78_isa_unregister(void) 994{ 995} 996#endif /* CONFIG_ISA */ 997 998static 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 1022static void __exit sm_lm78_exit(void) 1023{ 1024 lm78_isa_unregister(); 1025 i2c_del_driver(&lm78_driver); 1026} 1027 1028MODULE_AUTHOR("Frodo Looijaard, Jean Delvare <jdelvare@suse.de>"); 1029MODULE_DESCRIPTION("LM78/LM79 driver"); 1030MODULE_LICENSE("GPL"); 1031 1032module_init(sm_lm78_init); 1033module_exit(sm_lm78_exit); 1034