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 unsigned short normal_i2c[] = { 0x20, 0x21, 0x22, 0x23, 0x24, 41 0x25, 0x26, 0x27, 0x28, 0x29, 42 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 43 0x2f, I2C_CLIENT_END }; 44 static unsigned short isa_address = 0x290; 45 46 /* Insmod parameters */ 47 I2C_CLIENT_INSMOD_2(lm78, lm79); 48 49 /* Many LM78 constants specified below */ 50 51 /* Length of ISA address segment */ 52 #define LM78_EXTENT 8 53 54 /* Where are the ISA address/data registers relative to the base address */ 55 #define LM78_ADDR_REG_OFFSET 5 56 #define LM78_DATA_REG_OFFSET 6 57 58 /* The LM78 registers */ 59 #define LM78_REG_IN_MAX(nr) (0x2b + (nr) * 2) 60 #define LM78_REG_IN_MIN(nr) (0x2c + (nr) * 2) 61 #define LM78_REG_IN(nr) (0x20 + (nr)) 62 63 #define LM78_REG_FAN_MIN(nr) (0x3b + (nr)) 64 #define LM78_REG_FAN(nr) (0x28 + (nr)) 65 66 #define LM78_REG_TEMP 0x27 67 #define LM78_REG_TEMP_OVER 0x39 68 #define LM78_REG_TEMP_HYST 0x3a 69 70 #define LM78_REG_ALARM1 0x41 71 #define LM78_REG_ALARM2 0x42 72 73 #define LM78_REG_VID_FANDIV 0x47 74 75 #define LM78_REG_CONFIG 0x40 76 #define LM78_REG_CHIPID 0x49 77 #define LM78_REG_I2C_ADDR 0x48 78 79 80 /* Conversions. Rounding and limit checking is only done on the TO_REG 81 variants. */ 82 83 /* IN: mV, (0V to 4.08V) 84 REG: 16mV/bit */ 85 static inline u8 IN_TO_REG(unsigned long val) 86 { 87 unsigned long nval = SENSORS_LIMIT(val, 0, 4080); 88 return (nval + 8) / 16; 89 } 90 #define IN_FROM_REG(val) ((val) * 16) 91 92 static inline u8 FAN_TO_REG(long rpm, int div) 93 { 94 if (rpm <= 0) 95 return 255; 96 return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1, 254); 97 } 98 99 static inline int FAN_FROM_REG(u8 val, int div) 100 { 101 return val==0 ? -1 : val==255 ? 0 : 1350000/(val*div); 102 } 103 104 /* TEMP: mC (-128C to +127C) 105 REG: 1C/bit, two's complement */ 106 static inline s8 TEMP_TO_REG(int val) 107 { 108 int nval = SENSORS_LIMIT(val, -128000, 127000) ; 109 return nval<0 ? (nval-500)/1000 : (nval+500)/1000; 110 } 111 112 static inline int TEMP_FROM_REG(s8 val) 113 { 114 return val * 1000; 115 } 116 117 #define DIV_FROM_REG(val) (1 << (val)) 118 119 /* There are some complications in a module like this. First off, LM78 chips 120 may be both present on the SMBus and the ISA bus, and we have to handle 121 those cases separately at some places. Second, there might be several 122 LM78 chips available (well, actually, that is probably never done; but 123 it is a clean illustration of how to handle a case like that). Finally, 124 a specific chip may be attached to *both* ISA and SMBus, and we would 125 not like to detect it double. Fortunately, in the case of the LM78 at 126 least, a register tells us what SMBus address we are on, so that helps 127 a bit - except if there could be more than one SMBus. Groan. No solution 128 for this yet. */ 129 130 /* For ISA chips, we abuse the i2c_client addr and name fields. We also use 131 the driver field to differentiate between I2C and ISA chips. */ 132 struct lm78_data { 133 struct i2c_client client; 134 struct device *hwmon_dev; 135 struct mutex lock; 136 enum chips type; 137 138 struct mutex update_lock; 139 char valid; /* !=0 if following fields are valid */ 140 unsigned long last_updated; /* In jiffies */ 141 142 u8 in[7]; /* Register value */ 143 u8 in_max[7]; /* Register value */ 144 u8 in_min[7]; /* Register value */ 145 u8 fan[3]; /* Register value */ 146 u8 fan_min[3]; /* Register value */ 147 s8 temp; /* Register value */ 148 s8 temp_over; /* Register value */ 149 s8 temp_hyst; /* Register value */ 150 u8 fan_div[3]; /* Register encoding, shifted right */ 151 u8 vid; /* Register encoding, combined */ 152 u16 alarms; /* Register encoding, combined */ 153 }; 154 155 156 static int lm78_attach_adapter(struct i2c_adapter *adapter); 157 static int lm78_detect(struct i2c_adapter *adapter, int address, int kind); 158 static int lm78_detach_client(struct i2c_client *client); 159 160 static int __devinit lm78_isa_probe(struct platform_device *pdev); 161 static int __devexit lm78_isa_remove(struct platform_device *pdev); 162 163 static int lm78_read_value(struct lm78_data *data, u8 reg); 164 static int lm78_write_value(struct lm78_data *data, u8 reg, u8 value); 165 static struct lm78_data *lm78_update_device(struct device *dev); 166 static void lm78_init_device(struct lm78_data *data); 167 168 169 static struct i2c_driver lm78_driver = { 170 .driver = { 171 .name = "lm78", 172 }, 173 .id = I2C_DRIVERID_LM78, 174 .attach_adapter = lm78_attach_adapter, 175 .detach_client = lm78_detach_client, 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 = 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 /* This function is called when: 461 * lm78_driver is inserted (when this module is loaded), for each 462 available adapter 463 * when a new adapter is inserted (and lm78_driver is still present) */ 464 static int lm78_attach_adapter(struct i2c_adapter *adapter) 465 { 466 if (!(adapter->class & I2C_CLASS_HWMON)) 467 return 0; 468 return i2c_probe(adapter, &addr_data, lm78_detect); 469 } 470 471 static struct attribute *lm78_attributes[] = { 472 &sensor_dev_attr_in0_input.dev_attr.attr, 473 &sensor_dev_attr_in0_min.dev_attr.attr, 474 &sensor_dev_attr_in0_max.dev_attr.attr, 475 &sensor_dev_attr_in0_alarm.dev_attr.attr, 476 &sensor_dev_attr_in1_input.dev_attr.attr, 477 &sensor_dev_attr_in1_min.dev_attr.attr, 478 &sensor_dev_attr_in1_max.dev_attr.attr, 479 &sensor_dev_attr_in1_alarm.dev_attr.attr, 480 &sensor_dev_attr_in2_input.dev_attr.attr, 481 &sensor_dev_attr_in2_min.dev_attr.attr, 482 &sensor_dev_attr_in2_max.dev_attr.attr, 483 &sensor_dev_attr_in2_alarm.dev_attr.attr, 484 &sensor_dev_attr_in3_input.dev_attr.attr, 485 &sensor_dev_attr_in3_min.dev_attr.attr, 486 &sensor_dev_attr_in3_max.dev_attr.attr, 487 &sensor_dev_attr_in3_alarm.dev_attr.attr, 488 &sensor_dev_attr_in4_input.dev_attr.attr, 489 &sensor_dev_attr_in4_min.dev_attr.attr, 490 &sensor_dev_attr_in4_max.dev_attr.attr, 491 &sensor_dev_attr_in4_alarm.dev_attr.attr, 492 &sensor_dev_attr_in5_input.dev_attr.attr, 493 &sensor_dev_attr_in5_min.dev_attr.attr, 494 &sensor_dev_attr_in5_max.dev_attr.attr, 495 &sensor_dev_attr_in5_alarm.dev_attr.attr, 496 &sensor_dev_attr_in6_input.dev_attr.attr, 497 &sensor_dev_attr_in6_min.dev_attr.attr, 498 &sensor_dev_attr_in6_max.dev_attr.attr, 499 &sensor_dev_attr_in6_alarm.dev_attr.attr, 500 &dev_attr_temp1_input.attr, 501 &dev_attr_temp1_max.attr, 502 &dev_attr_temp1_max_hyst.attr, 503 &sensor_dev_attr_temp1_alarm.dev_attr.attr, 504 &sensor_dev_attr_fan1_input.dev_attr.attr, 505 &sensor_dev_attr_fan1_min.dev_attr.attr, 506 &sensor_dev_attr_fan1_div.dev_attr.attr, 507 &sensor_dev_attr_fan1_alarm.dev_attr.attr, 508 &sensor_dev_attr_fan2_input.dev_attr.attr, 509 &sensor_dev_attr_fan2_min.dev_attr.attr, 510 &sensor_dev_attr_fan2_div.dev_attr.attr, 511 &sensor_dev_attr_fan2_alarm.dev_attr.attr, 512 &sensor_dev_attr_fan3_input.dev_attr.attr, 513 &sensor_dev_attr_fan3_min.dev_attr.attr, 514 &sensor_dev_attr_fan3_div.dev_attr.attr, 515 &sensor_dev_attr_fan3_alarm.dev_attr.attr, 516 &dev_attr_alarms.attr, 517 &dev_attr_cpu0_vid.attr, 518 519 NULL 520 }; 521 522 static const struct attribute_group lm78_group = { 523 .attrs = lm78_attributes, 524 }; 525 526 /* I2C devices get this name attribute automatically, but for ISA devices 527 we must create it by ourselves. */ 528 static ssize_t show_name(struct device *dev, struct device_attribute 529 *devattr, char *buf) 530 { 531 struct lm78_data *data = dev_get_drvdata(dev); 532 533 return sprintf(buf, "%s\n", data->client.name); 534 } 535 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL); 536 537 /* This function is called by i2c_probe */ 538 static int lm78_detect(struct i2c_adapter *adapter, int address, int kind) 539 { 540 int i, err; 541 struct i2c_client *new_client; 542 struct lm78_data *data; 543 const char *client_name = ""; 544 545 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) { 546 err = -ENODEV; 547 goto ERROR1; 548 } 549 550 /* OK. For now, we presume we have a valid client. We now create the 551 client structure, even though we cannot fill it completely yet. 552 But it allows us to access lm78_{read,write}_value. */ 553 554 if (!(data = kzalloc(sizeof(struct lm78_data), GFP_KERNEL))) { 555 err = -ENOMEM; 556 goto ERROR1; 557 } 558 559 new_client = &data->client; 560 i2c_set_clientdata(new_client, data); 561 new_client->addr = address; 562 new_client->adapter = adapter; 563 new_client->driver = &lm78_driver; 564 565 /* Now, we do the remaining detection. */ 566 if (kind < 0) { 567 if (lm78_read_value(data, LM78_REG_CONFIG) & 0x80) { 568 err = -ENODEV; 569 goto ERROR2; 570 } 571 if (lm78_read_value(data, LM78_REG_I2C_ADDR) != 572 address) { 573 err = -ENODEV; 574 goto ERROR2; 575 } 576 } 577 578 /* Determine the chip type. */ 579 if (kind <= 0) { 580 i = lm78_read_value(data, LM78_REG_CHIPID); 581 if (i == 0x00 || i == 0x20 /* LM78 */ 582 || i == 0x40) /* LM78-J */ 583 kind = lm78; 584 else if ((i & 0xfe) == 0xc0) 585 kind = lm79; 586 else { 587 if (kind == 0) 588 dev_warn(&adapter->dev, "Ignoring 'force' " 589 "parameter for unknown chip at " 590 "adapter %d, address 0x%02x\n", 591 i2c_adapter_id(adapter), address); 592 err = -ENODEV; 593 goto ERROR2; 594 } 595 } 596 597 if (kind == lm78) { 598 client_name = "lm78"; 599 } else if (kind == lm79) { 600 client_name = "lm79"; 601 } 602 603 /* Fill in the remaining client fields and put into the global list */ 604 strlcpy(new_client->name, client_name, I2C_NAME_SIZE); 605 data->type = kind; 606 607 /* Tell the I2C layer a new client has arrived */ 608 if ((err = i2c_attach_client(new_client))) 609 goto ERROR2; 610 611 /* Initialize the LM78 chip */ 612 lm78_init_device(data); 613 614 /* Register sysfs hooks */ 615 if ((err = sysfs_create_group(&new_client->dev.kobj, &lm78_group))) 616 goto ERROR3; 617 618 data->hwmon_dev = hwmon_device_register(&new_client->dev); 619 if (IS_ERR(data->hwmon_dev)) { 620 err = PTR_ERR(data->hwmon_dev); 621 goto ERROR4; 622 } 623 624 return 0; 625 626 ERROR4: 627 sysfs_remove_group(&new_client->dev.kobj, &lm78_group); 628 ERROR3: 629 i2c_detach_client(new_client); 630 ERROR2: 631 kfree(data); 632 ERROR1: 633 return err; 634 } 635 636 static int lm78_detach_client(struct i2c_client *client) 637 { 638 struct lm78_data *data = i2c_get_clientdata(client); 639 int err; 640 641 hwmon_device_unregister(data->hwmon_dev); 642 sysfs_remove_group(&client->dev.kobj, &lm78_group); 643 644 if ((err = i2c_detach_client(client))) 645 return err; 646 647 kfree(data); 648 649 return 0; 650 } 651 652 static int __devinit lm78_isa_probe(struct platform_device *pdev) 653 { 654 int err; 655 struct lm78_data *data; 656 struct resource *res; 657 const char *name; 658 659 /* Reserve the ISA region */ 660 res = platform_get_resource(pdev, IORESOURCE_IO, 0); 661 if (!request_region(res->start, LM78_EXTENT, "lm78")) { 662 err = -EBUSY; 663 goto exit; 664 } 665 666 if (!(data = kzalloc(sizeof(struct lm78_data), GFP_KERNEL))) { 667 err = -ENOMEM; 668 goto exit_release_region; 669 } 670 mutex_init(&data->lock); 671 data->client.addr = res->start; 672 i2c_set_clientdata(&data->client, data); 673 platform_set_drvdata(pdev, data); 674 675 if (lm78_read_value(data, LM78_REG_CHIPID) & 0x80) { 676 data->type = lm79; 677 name = "lm79"; 678 } else { 679 data->type = lm78; 680 name = "lm78"; 681 } 682 strlcpy(data->client.name, name, I2C_NAME_SIZE); 683 684 /* Initialize the LM78 chip */ 685 lm78_init_device(data); 686 687 /* Register sysfs hooks */ 688 if ((err = sysfs_create_group(&pdev->dev.kobj, &lm78_group)) 689 || (err = device_create_file(&pdev->dev, &dev_attr_name))) 690 goto exit_remove_files; 691 692 data->hwmon_dev = hwmon_device_register(&pdev->dev); 693 if (IS_ERR(data->hwmon_dev)) { 694 err = PTR_ERR(data->hwmon_dev); 695 goto exit_remove_files; 696 } 697 698 return 0; 699 700 exit_remove_files: 701 sysfs_remove_group(&pdev->dev.kobj, &lm78_group); 702 device_remove_file(&pdev->dev, &dev_attr_name); 703 kfree(data); 704 exit_release_region: 705 release_region(res->start, LM78_EXTENT); 706 exit: 707 return err; 708 } 709 710 static int __devexit lm78_isa_remove(struct platform_device *pdev) 711 { 712 struct lm78_data *data = platform_get_drvdata(pdev); 713 714 hwmon_device_unregister(data->hwmon_dev); 715 sysfs_remove_group(&pdev->dev.kobj, &lm78_group); 716 device_remove_file(&pdev->dev, &dev_attr_name); 717 release_region(data->client.addr, LM78_EXTENT); 718 kfree(data); 719 720 return 0; 721 } 722 723 /* The SMBus locks itself, but ISA access must be locked explicitly! 724 We don't want to lock the whole ISA bus, so we lock each client 725 separately. 726 We ignore the LM78 BUSY flag at this moment - it could lead to deadlocks, 727 would slow down the LM78 access and should not be necessary. */ 728 static int lm78_read_value(struct lm78_data *data, u8 reg) 729 { 730 struct i2c_client *client = &data->client; 731 732 if (!client->driver) { /* ISA device */ 733 int res; 734 mutex_lock(&data->lock); 735 outb_p(reg, client->addr + LM78_ADDR_REG_OFFSET); 736 res = inb_p(client->addr + LM78_DATA_REG_OFFSET); 737 mutex_unlock(&data->lock); 738 return res; 739 } else 740 return i2c_smbus_read_byte_data(client, reg); 741 } 742 743 /* The SMBus locks itself, but ISA access muse be locked explicitly! 744 We don't want to lock the whole ISA bus, so we lock each client 745 separately. 746 We ignore the LM78 BUSY flag at this moment - it could lead to deadlocks, 747 would slow down the LM78 access and should not be necessary. 748 There are some ugly typecasts here, but the good new is - they should 749 nowhere else be necessary! */ 750 static int lm78_write_value(struct lm78_data *data, u8 reg, u8 value) 751 { 752 struct i2c_client *client = &data->client; 753 754 if (!client->driver) { /* ISA device */ 755 mutex_lock(&data->lock); 756 outb_p(reg, client->addr + LM78_ADDR_REG_OFFSET); 757 outb_p(value, client->addr + LM78_DATA_REG_OFFSET); 758 mutex_unlock(&data->lock); 759 return 0; 760 } else 761 return i2c_smbus_write_byte_data(client, reg, value); 762 } 763 764 static void lm78_init_device(struct lm78_data *data) 765 { 766 u8 config; 767 int i; 768 769 /* Start monitoring */ 770 config = lm78_read_value(data, LM78_REG_CONFIG); 771 if ((config & 0x09) != 0x01) 772 lm78_write_value(data, LM78_REG_CONFIG, 773 (config & 0xf7) | 0x01); 774 775 /* A few vars need to be filled upon startup */ 776 for (i = 0; i < 3; i++) { 777 data->fan_min[i] = lm78_read_value(data, 778 LM78_REG_FAN_MIN(i)); 779 } 780 781 mutex_init(&data->update_lock); 782 } 783 784 static struct lm78_data *lm78_update_device(struct device *dev) 785 { 786 struct lm78_data *data = dev_get_drvdata(dev); 787 int i; 788 789 mutex_lock(&data->update_lock); 790 791 if (time_after(jiffies, data->last_updated + HZ + HZ / 2) 792 || !data->valid) { 793 794 dev_dbg(dev, "Starting lm78 update\n"); 795 796 for (i = 0; i <= 6; i++) { 797 data->in[i] = 798 lm78_read_value(data, LM78_REG_IN(i)); 799 data->in_min[i] = 800 lm78_read_value(data, LM78_REG_IN_MIN(i)); 801 data->in_max[i] = 802 lm78_read_value(data, LM78_REG_IN_MAX(i)); 803 } 804 for (i = 0; i < 3; i++) { 805 data->fan[i] = 806 lm78_read_value(data, LM78_REG_FAN(i)); 807 data->fan_min[i] = 808 lm78_read_value(data, LM78_REG_FAN_MIN(i)); 809 } 810 data->temp = lm78_read_value(data, LM78_REG_TEMP); 811 data->temp_over = 812 lm78_read_value(data, LM78_REG_TEMP_OVER); 813 data->temp_hyst = 814 lm78_read_value(data, LM78_REG_TEMP_HYST); 815 i = lm78_read_value(data, LM78_REG_VID_FANDIV); 816 data->vid = i & 0x0f; 817 if (data->type == lm79) 818 data->vid |= 819 (lm78_read_value(data, LM78_REG_CHIPID) & 820 0x01) << 4; 821 else 822 data->vid |= 0x10; 823 data->fan_div[0] = (i >> 4) & 0x03; 824 data->fan_div[1] = i >> 6; 825 data->alarms = lm78_read_value(data, LM78_REG_ALARM1) + 826 (lm78_read_value(data, LM78_REG_ALARM2) << 8); 827 data->last_updated = jiffies; 828 data->valid = 1; 829 830 data->fan_div[2] = 1; 831 } 832 833 mutex_unlock(&data->update_lock); 834 835 return data; 836 } 837 838 /* return 1 if a supported chip is found, 0 otherwise */ 839 static int __init lm78_isa_found(unsigned short address) 840 { 841 int val, save, found = 0; 842 843 if (!request_region(address, LM78_EXTENT, "lm78")) 844 return 0; 845 846 #define REALLY_SLOW_IO 847 /* We need the timeouts for at least some LM78-like 848 chips. But only if we read 'undefined' registers. */ 849 val = inb_p(address + 1); 850 if (inb_p(address + 2) != val 851 || inb_p(address + 3) != val 852 || inb_p(address + 7) != val) 853 goto release; 854 #undef REALLY_SLOW_IO 855 856 /* We should be able to change the 7 LSB of the address port. The 857 MSB (busy flag) should be clear initially, set after the write. */ 858 save = inb_p(address + LM78_ADDR_REG_OFFSET); 859 if (save & 0x80) 860 goto release; 861 val = ~save & 0x7f; 862 outb_p(val, address + LM78_ADDR_REG_OFFSET); 863 if (inb_p(address + LM78_ADDR_REG_OFFSET) != (val | 0x80)) { 864 outb_p(save, address + LM78_ADDR_REG_OFFSET); 865 goto release; 866 } 867 868 /* We found a device, now see if it could be an LM78 */ 869 outb_p(LM78_REG_CONFIG, address + LM78_ADDR_REG_OFFSET); 870 val = inb_p(address + LM78_DATA_REG_OFFSET); 871 if (val & 0x80) 872 goto release; 873 outb_p(LM78_REG_I2C_ADDR, address + LM78_ADDR_REG_OFFSET); 874 val = inb_p(address + LM78_DATA_REG_OFFSET); 875 if (val < 0x03 || val > 0x77) /* Not a valid I2C address */ 876 goto release; 877 878 /* The busy flag should be clear again */ 879 if (inb_p(address + LM78_ADDR_REG_OFFSET) & 0x80) 880 goto release; 881 882 /* Explicitly prevent the misdetection of Winbond chips */ 883 outb_p(0x4f, address + LM78_ADDR_REG_OFFSET); 884 val = inb_p(address + LM78_DATA_REG_OFFSET); 885 if (val == 0xa3 || val == 0x5c) 886 goto release; 887 888 /* Explicitly prevent the misdetection of ITE chips */ 889 outb_p(0x58, address + LM78_ADDR_REG_OFFSET); 890 val = inb_p(address + LM78_DATA_REG_OFFSET); 891 if (val == 0x90) 892 goto release; 893 894 /* Determine the chip type */ 895 outb_p(LM78_REG_CHIPID, address + LM78_ADDR_REG_OFFSET); 896 val = inb_p(address + LM78_DATA_REG_OFFSET); 897 if (val == 0x00 || val == 0x20 /* LM78 */ 898 || val == 0x40 /* LM78-J */ 899 || (val & 0xfe) == 0xc0) /* LM79 */ 900 found = 1; 901 902 if (found) 903 pr_info("lm78: Found an %s chip at %#x\n", 904 val & 0x80 ? "LM79" : "LM78", (int)address); 905 906 release: 907 release_region(address, LM78_EXTENT); 908 return found; 909 } 910 911 static int __init lm78_isa_device_add(unsigned short address) 912 { 913 struct resource res = { 914 .start = address, 915 .end = address + LM78_EXTENT - 1, 916 .name = "lm78", 917 .flags = IORESOURCE_IO, 918 }; 919 int err; 920 921 pdev = platform_device_alloc("lm78", address); 922 if (!pdev) { 923 err = -ENOMEM; 924 printk(KERN_ERR "lm78: Device allocation failed\n"); 925 goto exit; 926 } 927 928 err = platform_device_add_resources(pdev, &res, 1); 929 if (err) { 930 printk(KERN_ERR "lm78: Device resource addition failed " 931 "(%d)\n", err); 932 goto exit_device_put; 933 } 934 935 err = platform_device_add(pdev); 936 if (err) { 937 printk(KERN_ERR "lm78: Device addition failed (%d)\n", 938 err); 939 goto exit_device_put; 940 } 941 942 return 0; 943 944 exit_device_put: 945 platform_device_put(pdev); 946 exit: 947 pdev = NULL; 948 return err; 949 } 950 951 static int __init sm_lm78_init(void) 952 { 953 int res; 954 955 res = i2c_add_driver(&lm78_driver); 956 if (res) 957 goto exit; 958 959 if (lm78_isa_found(isa_address)) { 960 res = platform_driver_register(&lm78_isa_driver); 961 if (res) 962 goto exit_unreg_i2c_driver; 963 964 /* Sets global pdev as a side effect */ 965 res = lm78_isa_device_add(isa_address); 966 if (res) 967 goto exit_unreg_isa_driver; 968 } 969 970 return 0; 971 972 exit_unreg_isa_driver: 973 platform_driver_unregister(&lm78_isa_driver); 974 exit_unreg_i2c_driver: 975 i2c_del_driver(&lm78_driver); 976 exit: 977 return res; 978 } 979 980 static void __exit sm_lm78_exit(void) 981 { 982 if (pdev) { 983 platform_device_unregister(pdev); 984 platform_driver_unregister(&lm78_isa_driver); 985 } 986 i2c_del_driver(&lm78_driver); 987 } 988 989 990 991 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>"); 992 MODULE_DESCRIPTION("LM78/LM79 driver"); 993 MODULE_LICENSE("GPL"); 994 995 module_init(sm_lm78_init); 996 module_exit(sm_lm78_exit); 997