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