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 6 This program is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 2 of the License, or 9 (at your option) any later version. 10 11 This program is distributed in the hope that it will be useful, 12 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program; if not, write to the Free Software 18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 19 */ 20 21 #include <linux/module.h> 22 #include <linux/init.h> 23 #include <linux/slab.h> 24 #include <linux/jiffies.h> 25 #include <linux/i2c.h> 26 #include <linux/i2c-isa.h> 27 #include <linux/i2c-sensor.h> 28 #include <linux/hwmon.h> 29 #include <linux/err.h> 30 #include <asm/io.h> 31 32 /* Addresses to scan */ 33 static unsigned short normal_i2c[] = { 0x20, 0x21, 0x22, 0x23, 0x24, 34 0x25, 0x26, 0x27, 0x28, 0x29, 35 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 36 0x2f, I2C_CLIENT_END }; 37 static unsigned int normal_isa[] = { 0x0290, I2C_CLIENT_ISA_END }; 38 39 /* Insmod parameters */ 40 SENSORS_INSMOD_2(lm78, lm79); 41 42 /* Many LM78 constants specified below */ 43 44 /* Length of ISA address segment */ 45 #define LM78_EXTENT 8 46 47 /* Where are the ISA address/data registers relative to the base address */ 48 #define LM78_ADDR_REG_OFFSET 5 49 #define LM78_DATA_REG_OFFSET 6 50 51 /* The LM78 registers */ 52 #define LM78_REG_IN_MAX(nr) (0x2b + (nr) * 2) 53 #define LM78_REG_IN_MIN(nr) (0x2c + (nr) * 2) 54 #define LM78_REG_IN(nr) (0x20 + (nr)) 55 56 #define LM78_REG_FAN_MIN(nr) (0x3b + (nr)) 57 #define LM78_REG_FAN(nr) (0x28 + (nr)) 58 59 #define LM78_REG_TEMP 0x27 60 #define LM78_REG_TEMP_OVER 0x39 61 #define LM78_REG_TEMP_HYST 0x3a 62 63 #define LM78_REG_ALARM1 0x41 64 #define LM78_REG_ALARM2 0x42 65 66 #define LM78_REG_VID_FANDIV 0x47 67 68 #define LM78_REG_CONFIG 0x40 69 #define LM78_REG_CHIPID 0x49 70 #define LM78_REG_I2C_ADDR 0x48 71 72 73 /* Conversions. Rounding and limit checking is only done on the TO_REG 74 variants. */ 75 76 /* IN: mV, (0V to 4.08V) 77 REG: 16mV/bit */ 78 static inline u8 IN_TO_REG(unsigned long val) 79 { 80 unsigned long nval = SENSORS_LIMIT(val, 0, 4080); 81 return (nval + 8) / 16; 82 } 83 #define IN_FROM_REG(val) ((val) * 16) 84 85 static inline u8 FAN_TO_REG(long rpm, int div) 86 { 87 if (rpm <= 0) 88 return 255; 89 return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1, 254); 90 } 91 92 static inline int FAN_FROM_REG(u8 val, int div) 93 { 94 return val==0 ? -1 : val==255 ? 0 : 1350000/(val*div); 95 } 96 97 /* TEMP: mC (-128C to +127C) 98 REG: 1C/bit, two's complement */ 99 static inline s8 TEMP_TO_REG(int val) 100 { 101 int nval = SENSORS_LIMIT(val, -128000, 127000) ; 102 return nval<0 ? (nval-500)/1000 : (nval+500)/1000; 103 } 104 105 static inline int TEMP_FROM_REG(s8 val) 106 { 107 return val * 1000; 108 } 109 110 /* VID: mV 111 REG: (see doc/vid) */ 112 static inline int VID_FROM_REG(u8 val) 113 { 114 return val==0x1f ? 0 : val>=0x10 ? 5100-val*100 : 2050-val*50; 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 /* This module may seem overly long and complicated. In fact, it is not so 131 bad. Quite a lot of bookkeeping is done. A real driver can often cut 132 some corners. */ 133 134 /* For each registered LM78, we need to keep some data in memory. That 135 data is pointed to by lm78_list[NR]->data. The structure itself is 136 dynamically allocated, at the same time when a new lm78 client is 137 allocated. */ 138 struct lm78_data { 139 struct i2c_client client; 140 struct class_device *class_dev; 141 struct semaphore lock; 142 enum chips type; 143 144 struct semaphore update_lock; 145 char valid; /* !=0 if following fields are valid */ 146 unsigned long last_updated; /* In jiffies */ 147 148 u8 in[7]; /* Register value */ 149 u8 in_max[7]; /* Register value */ 150 u8 in_min[7]; /* Register value */ 151 u8 fan[3]; /* Register value */ 152 u8 fan_min[3]; /* Register value */ 153 s8 temp; /* Register value */ 154 s8 temp_over; /* Register value */ 155 s8 temp_hyst; /* Register value */ 156 u8 fan_div[3]; /* Register encoding, shifted right */ 157 u8 vid; /* Register encoding, combined */ 158 u16 alarms; /* Register encoding, combined */ 159 }; 160 161 162 static int lm78_attach_adapter(struct i2c_adapter *adapter); 163 static int lm78_detect(struct i2c_adapter *adapter, int address, int kind); 164 static int lm78_detach_client(struct i2c_client *client); 165 166 static int lm78_read_value(struct i2c_client *client, u8 register); 167 static int lm78_write_value(struct i2c_client *client, u8 register, u8 value); 168 static struct lm78_data *lm78_update_device(struct device *dev); 169 static void lm78_init_client(struct i2c_client *client); 170 171 172 static struct i2c_driver lm78_driver = { 173 .owner = THIS_MODULE, 174 .name = "lm78", 175 .id = I2C_DRIVERID_LM78, 176 .flags = I2C_DF_NOTIFY, 177 .attach_adapter = lm78_attach_adapter, 178 .detach_client = lm78_detach_client, 179 }; 180 181 static struct i2c_driver lm78_isa_driver = { 182 .owner = THIS_MODULE, 183 .name = "lm78-isa", 184 .attach_adapter = lm78_attach_adapter, 185 .detach_client = lm78_detach_client, 186 }; 187 188 189 /* 7 Voltages */ 190 static ssize_t show_in(struct device *dev, char *buf, int nr) 191 { 192 struct lm78_data *data = lm78_update_device(dev); 193 return sprintf(buf, "%d\n", IN_FROM_REG(data->in[nr])); 194 } 195 196 static ssize_t show_in_min(struct device *dev, char *buf, int nr) 197 { 198 struct lm78_data *data = lm78_update_device(dev); 199 return sprintf(buf, "%d\n", IN_FROM_REG(data->in_min[nr])); 200 } 201 202 static ssize_t show_in_max(struct device *dev, char *buf, int nr) 203 { 204 struct lm78_data *data = lm78_update_device(dev); 205 return sprintf(buf, "%d\n", IN_FROM_REG(data->in_max[nr])); 206 } 207 208 static ssize_t set_in_min(struct device *dev, const char *buf, 209 size_t count, int nr) 210 { 211 struct i2c_client *client = to_i2c_client(dev); 212 struct lm78_data *data = i2c_get_clientdata(client); 213 unsigned long val = simple_strtoul(buf, NULL, 10); 214 215 down(&data->update_lock); 216 data->in_min[nr] = IN_TO_REG(val); 217 lm78_write_value(client, LM78_REG_IN_MIN(nr), data->in_min[nr]); 218 up(&data->update_lock); 219 return count; 220 } 221 222 static ssize_t set_in_max(struct device *dev, const char *buf, 223 size_t count, int nr) 224 { 225 struct i2c_client *client = to_i2c_client(dev); 226 struct lm78_data *data = i2c_get_clientdata(client); 227 unsigned long val = simple_strtoul(buf, NULL, 10); 228 229 down(&data->update_lock); 230 data->in_max[nr] = IN_TO_REG(val); 231 lm78_write_value(client, LM78_REG_IN_MAX(nr), data->in_max[nr]); 232 up(&data->update_lock); 233 return count; 234 } 235 236 #define show_in_offset(offset) \ 237 static ssize_t \ 238 show_in##offset (struct device *dev, struct device_attribute *attr, char *buf) \ 239 { \ 240 return show_in(dev, buf, offset); \ 241 } \ 242 static DEVICE_ATTR(in##offset##_input, S_IRUGO, \ 243 show_in##offset, NULL); \ 244 static ssize_t \ 245 show_in##offset##_min (struct device *dev, struct device_attribute *attr, char *buf) \ 246 { \ 247 return show_in_min(dev, buf, offset); \ 248 } \ 249 static ssize_t \ 250 show_in##offset##_max (struct device *dev, struct device_attribute *attr, char *buf) \ 251 { \ 252 return show_in_max(dev, buf, offset); \ 253 } \ 254 static ssize_t set_in##offset##_min (struct device *dev, struct device_attribute *attr, \ 255 const char *buf, size_t count) \ 256 { \ 257 return set_in_min(dev, buf, count, offset); \ 258 } \ 259 static ssize_t set_in##offset##_max (struct device *dev, struct device_attribute *attr, \ 260 const char *buf, size_t count) \ 261 { \ 262 return set_in_max(dev, buf, count, offset); \ 263 } \ 264 static DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR, \ 265 show_in##offset##_min, set_in##offset##_min); \ 266 static DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR, \ 267 show_in##offset##_max, set_in##offset##_max); 268 269 show_in_offset(0); 270 show_in_offset(1); 271 show_in_offset(2); 272 show_in_offset(3); 273 show_in_offset(4); 274 show_in_offset(5); 275 show_in_offset(6); 276 277 /* Temperature */ 278 static ssize_t show_temp(struct device *dev, struct device_attribute *attr, char *buf) 279 { 280 struct lm78_data *data = lm78_update_device(dev); 281 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp)); 282 } 283 284 static ssize_t show_temp_over(struct device *dev, struct device_attribute *attr, char *buf) 285 { 286 struct lm78_data *data = lm78_update_device(dev); 287 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_over)); 288 } 289 290 static ssize_t set_temp_over(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) 291 { 292 struct i2c_client *client = to_i2c_client(dev); 293 struct lm78_data *data = i2c_get_clientdata(client); 294 long val = simple_strtol(buf, NULL, 10); 295 296 down(&data->update_lock); 297 data->temp_over = TEMP_TO_REG(val); 298 lm78_write_value(client, LM78_REG_TEMP_OVER, data->temp_over); 299 up(&data->update_lock); 300 return count; 301 } 302 303 static ssize_t show_temp_hyst(struct device *dev, struct device_attribute *attr, char *buf) 304 { 305 struct lm78_data *data = lm78_update_device(dev); 306 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_hyst)); 307 } 308 309 static ssize_t set_temp_hyst(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) 310 { 311 struct i2c_client *client = to_i2c_client(dev); 312 struct lm78_data *data = i2c_get_clientdata(client); 313 long val = simple_strtol(buf, NULL, 10); 314 315 down(&data->update_lock); 316 data->temp_hyst = TEMP_TO_REG(val); 317 lm78_write_value(client, LM78_REG_TEMP_HYST, data->temp_hyst); 318 up(&data->update_lock); 319 return count; 320 } 321 322 static DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL); 323 static DEVICE_ATTR(temp1_max, S_IRUGO | S_IWUSR, 324 show_temp_over, set_temp_over); 325 static DEVICE_ATTR(temp1_max_hyst, S_IRUGO | S_IWUSR, 326 show_temp_hyst, set_temp_hyst); 327 328 /* 3 Fans */ 329 static ssize_t show_fan(struct device *dev, char *buf, int nr) 330 { 331 struct lm78_data *data = lm78_update_device(dev); 332 return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[nr], 333 DIV_FROM_REG(data->fan_div[nr])) ); 334 } 335 336 static ssize_t show_fan_min(struct device *dev, char *buf, int nr) 337 { 338 struct lm78_data *data = lm78_update_device(dev); 339 return sprintf(buf,"%d\n", FAN_FROM_REG(data->fan_min[nr], 340 DIV_FROM_REG(data->fan_div[nr])) ); 341 } 342 343 static ssize_t set_fan_min(struct device *dev, const char *buf, 344 size_t count, int nr) 345 { 346 struct i2c_client *client = to_i2c_client(dev); 347 struct lm78_data *data = i2c_get_clientdata(client); 348 unsigned long val = simple_strtoul(buf, NULL, 10); 349 350 down(&data->update_lock); 351 data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr])); 352 lm78_write_value(client, LM78_REG_FAN_MIN(nr), data->fan_min[nr]); 353 up(&data->update_lock); 354 return count; 355 } 356 357 static ssize_t show_fan_div(struct device *dev, char *buf, int nr) 358 { 359 struct lm78_data *data = lm78_update_device(dev); 360 return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[nr]) ); 361 } 362 363 /* Note: we save and restore the fan minimum here, because its value is 364 determined in part by the fan divisor. This follows the principle of 365 least suprise; the user doesn't expect the fan minimum to change just 366 because the divisor changed. */ 367 static ssize_t set_fan_div(struct device *dev, const char *buf, 368 size_t count, int nr) 369 { 370 struct i2c_client *client = to_i2c_client(dev); 371 struct lm78_data *data = i2c_get_clientdata(client); 372 unsigned long val = simple_strtoul(buf, NULL, 10); 373 unsigned long min; 374 u8 reg; 375 376 down(&data->update_lock); 377 min = FAN_FROM_REG(data->fan_min[nr], 378 DIV_FROM_REG(data->fan_div[nr])); 379 380 switch (val) { 381 case 1: data->fan_div[nr] = 0; break; 382 case 2: data->fan_div[nr] = 1; break; 383 case 4: data->fan_div[nr] = 2; break; 384 case 8: data->fan_div[nr] = 3; break; 385 default: 386 dev_err(&client->dev, "fan_div value %ld not " 387 "supported. Choose one of 1, 2, 4 or 8!\n", val); 388 up(&data->update_lock); 389 return -EINVAL; 390 } 391 392 reg = lm78_read_value(client, LM78_REG_VID_FANDIV); 393 switch (nr) { 394 case 0: 395 reg = (reg & 0xcf) | (data->fan_div[nr] << 4); 396 break; 397 case 1: 398 reg = (reg & 0x3f) | (data->fan_div[nr] << 6); 399 break; 400 } 401 lm78_write_value(client, LM78_REG_VID_FANDIV, reg); 402 403 data->fan_min[nr] = 404 FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr])); 405 lm78_write_value(client, LM78_REG_FAN_MIN(nr), data->fan_min[nr]); 406 up(&data->update_lock); 407 408 return count; 409 } 410 411 #define show_fan_offset(offset) \ 412 static ssize_t show_fan_##offset (struct device *dev, struct device_attribute *attr, char *buf) \ 413 { \ 414 return show_fan(dev, buf, offset - 1); \ 415 } \ 416 static ssize_t show_fan_##offset##_min (struct device *dev, struct device_attribute *attr, char *buf) \ 417 { \ 418 return show_fan_min(dev, buf, offset - 1); \ 419 } \ 420 static ssize_t show_fan_##offset##_div (struct device *dev, struct device_attribute *attr, char *buf) \ 421 { \ 422 return show_fan_div(dev, buf, offset - 1); \ 423 } \ 424 static ssize_t set_fan_##offset##_min (struct device *dev, struct device_attribute *attr, \ 425 const char *buf, size_t count) \ 426 { \ 427 return set_fan_min(dev, buf, count, offset - 1); \ 428 } \ 429 static DEVICE_ATTR(fan##offset##_input, S_IRUGO, show_fan_##offset, NULL);\ 430 static DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \ 431 show_fan_##offset##_min, set_fan_##offset##_min); 432 433 static ssize_t set_fan_1_div(struct device *dev, struct device_attribute *attr, const char *buf, 434 size_t count) 435 { 436 return set_fan_div(dev, buf, count, 0) ; 437 } 438 439 static ssize_t set_fan_2_div(struct device *dev, struct device_attribute *attr, const char *buf, 440 size_t count) 441 { 442 return set_fan_div(dev, buf, count, 1) ; 443 } 444 445 show_fan_offset(1); 446 show_fan_offset(2); 447 show_fan_offset(3); 448 449 /* Fan 3 divisor is locked in H/W */ 450 static DEVICE_ATTR(fan1_div, S_IRUGO | S_IWUSR, 451 show_fan_1_div, set_fan_1_div); 452 static DEVICE_ATTR(fan2_div, S_IRUGO | S_IWUSR, 453 show_fan_2_div, set_fan_2_div); 454 static DEVICE_ATTR(fan3_div, S_IRUGO, show_fan_3_div, NULL); 455 456 /* VID */ 457 static ssize_t show_vid(struct device *dev, struct device_attribute *attr, char *buf) 458 { 459 struct lm78_data *data = lm78_update_device(dev); 460 return sprintf(buf, "%d\n", VID_FROM_REG(data->vid)); 461 } 462 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid, NULL); 463 464 /* Alarms */ 465 static ssize_t show_alarms(struct device *dev, struct device_attribute *attr, char *buf) 466 { 467 struct lm78_data *data = lm78_update_device(dev); 468 return sprintf(buf, "%u\n", data->alarms); 469 } 470 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL); 471 472 /* This function is called when: 473 * lm78_driver is inserted (when this module is loaded), for each 474 available adapter 475 * when a new adapter is inserted (and lm78_driver is still present) */ 476 static int lm78_attach_adapter(struct i2c_adapter *adapter) 477 { 478 if (!(adapter->class & I2C_CLASS_HWMON)) 479 return 0; 480 return i2c_detect(adapter, &addr_data, lm78_detect); 481 } 482 483 /* This function is called by i2c_detect */ 484 int lm78_detect(struct i2c_adapter *adapter, int address, int kind) 485 { 486 int i, err; 487 struct i2c_client *new_client; 488 struct lm78_data *data; 489 const char *client_name = ""; 490 int is_isa = i2c_is_isa_adapter(adapter); 491 492 if (!is_isa && 493 !i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) { 494 err = -ENODEV; 495 goto ERROR0; 496 } 497 498 /* Reserve the ISA region */ 499 if (is_isa) 500 if (!request_region(address, LM78_EXTENT, 501 lm78_isa_driver.name)) { 502 err = -EBUSY; 503 goto ERROR0; 504 } 505 506 /* Probe whether there is anything available on this address. Already 507 done for SMBus clients */ 508 if (kind < 0) { 509 if (is_isa) { 510 511 #define REALLY_SLOW_IO 512 /* We need the timeouts for at least some LM78-like 513 chips. But only if we read 'undefined' registers. */ 514 i = inb_p(address + 1); 515 if (inb_p(address + 2) != i) { 516 err = -ENODEV; 517 goto ERROR1; 518 } 519 if (inb_p(address + 3) != i) { 520 err = -ENODEV; 521 goto ERROR1; 522 } 523 if (inb_p(address + 7) != i) { 524 err = -ENODEV; 525 goto ERROR1; 526 } 527 #undef REALLY_SLOW_IO 528 529 /* Let's just hope nothing breaks here */ 530 i = inb_p(address + 5) & 0x7f; 531 outb_p(~i & 0x7f, address + 5); 532 if ((inb_p(address + 5) & 0x7f) != (~i & 0x7f)) { 533 outb_p(i, address + 5); 534 err = -ENODEV; 535 goto ERROR1; 536 } 537 } 538 } 539 540 /* OK. For now, we presume we have a valid client. We now create the 541 client structure, even though we cannot fill it completely yet. 542 But it allows us to access lm78_{read,write}_value. */ 543 544 if (!(data = kmalloc(sizeof(struct lm78_data), GFP_KERNEL))) { 545 err = -ENOMEM; 546 goto ERROR1; 547 } 548 memset(data, 0, sizeof(struct lm78_data)); 549 550 new_client = &data->client; 551 if (is_isa) 552 init_MUTEX(&data->lock); 553 i2c_set_clientdata(new_client, data); 554 new_client->addr = address; 555 new_client->adapter = adapter; 556 new_client->driver = is_isa ? &lm78_isa_driver : &lm78_driver; 557 new_client->flags = 0; 558 559 /* Now, we do the remaining detection. */ 560 if (kind < 0) { 561 if (lm78_read_value(new_client, LM78_REG_CONFIG) & 0x80) { 562 err = -ENODEV; 563 goto ERROR2; 564 } 565 if (!is_isa && (lm78_read_value( 566 new_client, LM78_REG_I2C_ADDR) != address)) { 567 err = -ENODEV; 568 goto ERROR2; 569 } 570 } 571 572 /* Determine the chip type. */ 573 if (kind <= 0) { 574 i = lm78_read_value(new_client, LM78_REG_CHIPID); 575 if (i == 0x00 || i == 0x20 /* LM78 */ 576 || i == 0x40) /* LM78-J */ 577 kind = lm78; 578 else if ((i & 0xfe) == 0xc0) 579 kind = lm79; 580 else { 581 if (kind == 0) 582 dev_warn(&adapter->dev, "Ignoring 'force' " 583 "parameter for unknown chip at " 584 "adapter %d, address 0x%02x\n", 585 i2c_adapter_id(adapter), address); 586 err = -ENODEV; 587 goto ERROR2; 588 } 589 } 590 591 if (kind == lm78) { 592 client_name = "lm78"; 593 } else if (kind == lm79) { 594 client_name = "lm79"; 595 } 596 597 /* Fill in the remaining client fields and put into the global list */ 598 strlcpy(new_client->name, client_name, I2C_NAME_SIZE); 599 data->type = kind; 600 601 data->valid = 0; 602 init_MUTEX(&data->update_lock); 603 604 /* Tell the I2C layer a new client has arrived */ 605 if ((err = i2c_attach_client(new_client))) 606 goto ERROR2; 607 608 /* Initialize the LM78 chip */ 609 lm78_init_client(new_client); 610 611 /* A few vars need to be filled upon startup */ 612 for (i = 0; i < 3; i++) { 613 data->fan_min[i] = lm78_read_value(new_client, 614 LM78_REG_FAN_MIN(i)); 615 } 616 617 /* Register sysfs hooks */ 618 data->class_dev = hwmon_device_register(&new_client->dev); 619 if (IS_ERR(data->class_dev)) { 620 err = PTR_ERR(data->class_dev); 621 goto ERROR3; 622 } 623 624 device_create_file(&new_client->dev, &dev_attr_in0_input); 625 device_create_file(&new_client->dev, &dev_attr_in0_min); 626 device_create_file(&new_client->dev, &dev_attr_in0_max); 627 device_create_file(&new_client->dev, &dev_attr_in1_input); 628 device_create_file(&new_client->dev, &dev_attr_in1_min); 629 device_create_file(&new_client->dev, &dev_attr_in1_max); 630 device_create_file(&new_client->dev, &dev_attr_in2_input); 631 device_create_file(&new_client->dev, &dev_attr_in2_min); 632 device_create_file(&new_client->dev, &dev_attr_in2_max); 633 device_create_file(&new_client->dev, &dev_attr_in3_input); 634 device_create_file(&new_client->dev, &dev_attr_in3_min); 635 device_create_file(&new_client->dev, &dev_attr_in3_max); 636 device_create_file(&new_client->dev, &dev_attr_in4_input); 637 device_create_file(&new_client->dev, &dev_attr_in4_min); 638 device_create_file(&new_client->dev, &dev_attr_in4_max); 639 device_create_file(&new_client->dev, &dev_attr_in5_input); 640 device_create_file(&new_client->dev, &dev_attr_in5_min); 641 device_create_file(&new_client->dev, &dev_attr_in5_max); 642 device_create_file(&new_client->dev, &dev_attr_in6_input); 643 device_create_file(&new_client->dev, &dev_attr_in6_min); 644 device_create_file(&new_client->dev, &dev_attr_in6_max); 645 device_create_file(&new_client->dev, &dev_attr_temp1_input); 646 device_create_file(&new_client->dev, &dev_attr_temp1_max); 647 device_create_file(&new_client->dev, &dev_attr_temp1_max_hyst); 648 device_create_file(&new_client->dev, &dev_attr_fan1_input); 649 device_create_file(&new_client->dev, &dev_attr_fan1_min); 650 device_create_file(&new_client->dev, &dev_attr_fan1_div); 651 device_create_file(&new_client->dev, &dev_attr_fan2_input); 652 device_create_file(&new_client->dev, &dev_attr_fan2_min); 653 device_create_file(&new_client->dev, &dev_attr_fan2_div); 654 device_create_file(&new_client->dev, &dev_attr_fan3_input); 655 device_create_file(&new_client->dev, &dev_attr_fan3_min); 656 device_create_file(&new_client->dev, &dev_attr_fan3_div); 657 device_create_file(&new_client->dev, &dev_attr_alarms); 658 device_create_file(&new_client->dev, &dev_attr_cpu0_vid); 659 660 return 0; 661 662 ERROR3: 663 i2c_detach_client(new_client); 664 ERROR2: 665 kfree(data); 666 ERROR1: 667 if (is_isa) 668 release_region(address, LM78_EXTENT); 669 ERROR0: 670 return err; 671 } 672 673 static int lm78_detach_client(struct i2c_client *client) 674 { 675 struct lm78_data *data = i2c_get_clientdata(client); 676 int err; 677 678 hwmon_device_unregister(data->class_dev); 679 680 if ((err = i2c_detach_client(client))) { 681 dev_err(&client->dev, 682 "Client deregistration failed, client not detached.\n"); 683 return err; 684 } 685 686 if(i2c_is_isa_client(client)) 687 release_region(client->addr, LM78_EXTENT); 688 689 kfree(data); 690 691 return 0; 692 } 693 694 /* The SMBus locks itself, but ISA access must be locked explicitly! 695 We don't want to lock the whole ISA bus, so we lock each client 696 separately. 697 We ignore the LM78 BUSY flag at this moment - it could lead to deadlocks, 698 would slow down the LM78 access and should not be necessary. */ 699 static int lm78_read_value(struct i2c_client *client, u8 reg) 700 { 701 int res; 702 if (i2c_is_isa_client(client)) { 703 struct lm78_data *data = i2c_get_clientdata(client); 704 down(&data->lock); 705 outb_p(reg, client->addr + LM78_ADDR_REG_OFFSET); 706 res = inb_p(client->addr + LM78_DATA_REG_OFFSET); 707 up(&data->lock); 708 return res; 709 } else 710 return i2c_smbus_read_byte_data(client, reg); 711 } 712 713 /* The SMBus locks itself, but ISA access muse be locked explicitly! 714 We don't want to lock the whole ISA bus, so we lock each client 715 separately. 716 We ignore the LM78 BUSY flag at this moment - it could lead to deadlocks, 717 would slow down the LM78 access and should not be necessary. 718 There are some ugly typecasts here, but the good new is - they should 719 nowhere else be necessary! */ 720 static int lm78_write_value(struct i2c_client *client, u8 reg, u8 value) 721 { 722 if (i2c_is_isa_client(client)) { 723 struct lm78_data *data = i2c_get_clientdata(client); 724 down(&data->lock); 725 outb_p(reg, client->addr + LM78_ADDR_REG_OFFSET); 726 outb_p(value, client->addr + LM78_DATA_REG_OFFSET); 727 up(&data->lock); 728 return 0; 729 } else 730 return i2c_smbus_write_byte_data(client, reg, value); 731 } 732 733 /* Called when we have found a new LM78. It should set limits, etc. */ 734 static void lm78_init_client(struct i2c_client *client) 735 { 736 u8 config = lm78_read_value(client, LM78_REG_CONFIG); 737 738 /* Start monitoring */ 739 if (!(config & 0x01)) 740 lm78_write_value(client, LM78_REG_CONFIG, 741 (config & 0xf7) | 0x01); 742 } 743 744 static struct lm78_data *lm78_update_device(struct device *dev) 745 { 746 struct i2c_client *client = to_i2c_client(dev); 747 struct lm78_data *data = i2c_get_clientdata(client); 748 int i; 749 750 down(&data->update_lock); 751 752 if (time_after(jiffies, data->last_updated + HZ + HZ / 2) 753 || !data->valid) { 754 755 dev_dbg(&client->dev, "Starting lm78 update\n"); 756 757 for (i = 0; i <= 6; i++) { 758 data->in[i] = 759 lm78_read_value(client, LM78_REG_IN(i)); 760 data->in_min[i] = 761 lm78_read_value(client, LM78_REG_IN_MIN(i)); 762 data->in_max[i] = 763 lm78_read_value(client, LM78_REG_IN_MAX(i)); 764 } 765 for (i = 0; i < 3; i++) { 766 data->fan[i] = 767 lm78_read_value(client, LM78_REG_FAN(i)); 768 data->fan_min[i] = 769 lm78_read_value(client, LM78_REG_FAN_MIN(i)); 770 } 771 data->temp = lm78_read_value(client, LM78_REG_TEMP); 772 data->temp_over = 773 lm78_read_value(client, LM78_REG_TEMP_OVER); 774 data->temp_hyst = 775 lm78_read_value(client, LM78_REG_TEMP_HYST); 776 i = lm78_read_value(client, LM78_REG_VID_FANDIV); 777 data->vid = i & 0x0f; 778 if (data->type == lm79) 779 data->vid |= 780 (lm78_read_value(client, LM78_REG_CHIPID) & 781 0x01) << 4; 782 else 783 data->vid |= 0x10; 784 data->fan_div[0] = (i >> 4) & 0x03; 785 data->fan_div[1] = i >> 6; 786 data->alarms = lm78_read_value(client, LM78_REG_ALARM1) + 787 (lm78_read_value(client, LM78_REG_ALARM2) << 8); 788 data->last_updated = jiffies; 789 data->valid = 1; 790 791 data->fan_div[2] = 1; 792 } 793 794 up(&data->update_lock); 795 796 return data; 797 } 798 799 static int __init sm_lm78_init(void) 800 { 801 int res; 802 803 res = i2c_add_driver(&lm78_driver); 804 if (res) 805 return res; 806 807 res = i2c_isa_add_driver(&lm78_isa_driver); 808 if (res) { 809 i2c_del_driver(&lm78_driver); 810 return res; 811 } 812 813 return 0; 814 } 815 816 static void __exit sm_lm78_exit(void) 817 { 818 i2c_isa_del_driver(&lm78_isa_driver); 819 i2c_del_driver(&lm78_driver); 820 } 821 822 823 824 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>"); 825 MODULE_DESCRIPTION("LM78/LM79 driver"); 826 MODULE_LICENSE("GPL"); 827 828 module_init(sm_lm78_init); 829 module_exit(sm_lm78_exit); 830