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