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