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