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/hwmon.h> 28 #include <linux/hwmon-vid.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 short isa_address = 0x290; 38 39 /* Insmod parameters */ 40 I2C_CLIENT_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 #define DIV_FROM_REG(val) (1 << (val)) 111 112 /* There are some complications in a module like this. First off, LM78 chips 113 may be both present on the SMBus and the ISA bus, and we have to handle 114 those cases separately at some places. Second, there might be several 115 LM78 chips available (well, actually, that is probably never done; but 116 it is a clean illustration of how to handle a case like that). Finally, 117 a specific chip may be attached to *both* ISA and SMBus, and we would 118 not like to detect it double. Fortunately, in the case of the LM78 at 119 least, a register tells us what SMBus address we are on, so that helps 120 a bit - except if there could be more than one SMBus. Groan. No solution 121 for this yet. */ 122 123 /* This module may seem overly long and complicated. In fact, it is not so 124 bad. Quite a lot of bookkeeping is done. A real driver can often cut 125 some corners. */ 126 127 /* For each registered LM78, we need to keep some data in memory. That 128 data is pointed to by lm78_list[NR]->data. The structure itself is 129 dynamically allocated, at the same time when a new lm78 client is 130 allocated. */ 131 struct lm78_data { 132 struct i2c_client client; 133 struct class_device *class_dev; 134 struct semaphore lock; 135 enum chips type; 136 137 struct semaphore update_lock; 138 char valid; /* !=0 if following fields are valid */ 139 unsigned long last_updated; /* In jiffies */ 140 141 u8 in[7]; /* Register value */ 142 u8 in_max[7]; /* Register value */ 143 u8 in_min[7]; /* Register value */ 144 u8 fan[3]; /* Register value */ 145 u8 fan_min[3]; /* Register value */ 146 s8 temp; /* Register value */ 147 s8 temp_over; /* Register value */ 148 s8 temp_hyst; /* Register value */ 149 u8 fan_div[3]; /* Register encoding, shifted right */ 150 u8 vid; /* Register encoding, combined */ 151 u16 alarms; /* Register encoding, combined */ 152 }; 153 154 155 static int lm78_attach_adapter(struct i2c_adapter *adapter); 156 static int lm78_isa_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 lm78_read_value(struct i2c_client *client, u8 register); 161 static int lm78_write_value(struct i2c_client *client, u8 register, u8 value); 162 static struct lm78_data *lm78_update_device(struct device *dev); 163 static void lm78_init_client(struct i2c_client *client); 164 165 166 static struct i2c_driver lm78_driver = { 167 .driver = { 168 .name = "lm78", 169 }, 170 .id = I2C_DRIVERID_LM78, 171 .attach_adapter = lm78_attach_adapter, 172 .detach_client = lm78_detach_client, 173 }; 174 175 static struct i2c_driver lm78_isa_driver = { 176 .driver = { 177 .name = "lm78-isa", 178 }, 179 .attach_adapter = lm78_isa_attach_adapter, 180 .detach_client = lm78_detach_client, 181 }; 182 183 184 /* 7 Voltages */ 185 static ssize_t show_in(struct device *dev, char *buf, int nr) 186 { 187 struct lm78_data *data = lm78_update_device(dev); 188 return sprintf(buf, "%d\n", IN_FROM_REG(data->in[nr])); 189 } 190 191 static ssize_t show_in_min(struct device *dev, char *buf, int nr) 192 { 193 struct lm78_data *data = lm78_update_device(dev); 194 return sprintf(buf, "%d\n", IN_FROM_REG(data->in_min[nr])); 195 } 196 197 static ssize_t show_in_max(struct device *dev, char *buf, int nr) 198 { 199 struct lm78_data *data = lm78_update_device(dev); 200 return sprintf(buf, "%d\n", IN_FROM_REG(data->in_max[nr])); 201 } 202 203 static ssize_t set_in_min(struct device *dev, const char *buf, 204 size_t count, int nr) 205 { 206 struct i2c_client *client = to_i2c_client(dev); 207 struct lm78_data *data = i2c_get_clientdata(client); 208 unsigned long val = simple_strtoul(buf, NULL, 10); 209 210 down(&data->update_lock); 211 data->in_min[nr] = IN_TO_REG(val); 212 lm78_write_value(client, LM78_REG_IN_MIN(nr), data->in_min[nr]); 213 up(&data->update_lock); 214 return count; 215 } 216 217 static ssize_t set_in_max(struct device *dev, const char *buf, 218 size_t count, int nr) 219 { 220 struct i2c_client *client = to_i2c_client(dev); 221 struct lm78_data *data = i2c_get_clientdata(client); 222 unsigned long val = simple_strtoul(buf, NULL, 10); 223 224 down(&data->update_lock); 225 data->in_max[nr] = IN_TO_REG(val); 226 lm78_write_value(client, LM78_REG_IN_MAX(nr), data->in_max[nr]); 227 up(&data->update_lock); 228 return count; 229 } 230 231 #define show_in_offset(offset) \ 232 static ssize_t \ 233 show_in##offset (struct device *dev, struct device_attribute *attr, char *buf) \ 234 { \ 235 return show_in(dev, buf, offset); \ 236 } \ 237 static DEVICE_ATTR(in##offset##_input, S_IRUGO, \ 238 show_in##offset, NULL); \ 239 static ssize_t \ 240 show_in##offset##_min (struct device *dev, struct device_attribute *attr, char *buf) \ 241 { \ 242 return show_in_min(dev, buf, offset); \ 243 } \ 244 static ssize_t \ 245 show_in##offset##_max (struct device *dev, struct device_attribute *attr, char *buf) \ 246 { \ 247 return show_in_max(dev, buf, offset); \ 248 } \ 249 static ssize_t set_in##offset##_min (struct device *dev, struct device_attribute *attr, \ 250 const char *buf, size_t count) \ 251 { \ 252 return set_in_min(dev, buf, count, offset); \ 253 } \ 254 static ssize_t set_in##offset##_max (struct device *dev, struct device_attribute *attr, \ 255 const char *buf, size_t count) \ 256 { \ 257 return set_in_max(dev, buf, count, offset); \ 258 } \ 259 static DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR, \ 260 show_in##offset##_min, set_in##offset##_min); \ 261 static DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR, \ 262 show_in##offset##_max, set_in##offset##_max); 263 264 show_in_offset(0); 265 show_in_offset(1); 266 show_in_offset(2); 267 show_in_offset(3); 268 show_in_offset(4); 269 show_in_offset(5); 270 show_in_offset(6); 271 272 /* Temperature */ 273 static ssize_t show_temp(struct device *dev, struct device_attribute *attr, char *buf) 274 { 275 struct lm78_data *data = lm78_update_device(dev); 276 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp)); 277 } 278 279 static ssize_t show_temp_over(struct device *dev, struct device_attribute *attr, char *buf) 280 { 281 struct lm78_data *data = lm78_update_device(dev); 282 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_over)); 283 } 284 285 static ssize_t set_temp_over(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) 286 { 287 struct i2c_client *client = to_i2c_client(dev); 288 struct lm78_data *data = i2c_get_clientdata(client); 289 long val = simple_strtol(buf, NULL, 10); 290 291 down(&data->update_lock); 292 data->temp_over = TEMP_TO_REG(val); 293 lm78_write_value(client, LM78_REG_TEMP_OVER, data->temp_over); 294 up(&data->update_lock); 295 return count; 296 } 297 298 static ssize_t show_temp_hyst(struct device *dev, struct device_attribute *attr, char *buf) 299 { 300 struct lm78_data *data = lm78_update_device(dev); 301 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_hyst)); 302 } 303 304 static ssize_t set_temp_hyst(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) 305 { 306 struct i2c_client *client = to_i2c_client(dev); 307 struct lm78_data *data = i2c_get_clientdata(client); 308 long val = simple_strtol(buf, NULL, 10); 309 310 down(&data->update_lock); 311 data->temp_hyst = TEMP_TO_REG(val); 312 lm78_write_value(client, LM78_REG_TEMP_HYST, data->temp_hyst); 313 up(&data->update_lock); 314 return count; 315 } 316 317 static DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL); 318 static DEVICE_ATTR(temp1_max, S_IRUGO | S_IWUSR, 319 show_temp_over, set_temp_over); 320 static DEVICE_ATTR(temp1_max_hyst, S_IRUGO | S_IWUSR, 321 show_temp_hyst, set_temp_hyst); 322 323 /* 3 Fans */ 324 static ssize_t show_fan(struct device *dev, char *buf, int nr) 325 { 326 struct lm78_data *data = lm78_update_device(dev); 327 return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[nr], 328 DIV_FROM_REG(data->fan_div[nr])) ); 329 } 330 331 static ssize_t show_fan_min(struct device *dev, char *buf, int nr) 332 { 333 struct lm78_data *data = lm78_update_device(dev); 334 return sprintf(buf,"%d\n", FAN_FROM_REG(data->fan_min[nr], 335 DIV_FROM_REG(data->fan_div[nr])) ); 336 } 337 338 static ssize_t set_fan_min(struct device *dev, const char *buf, 339 size_t count, int nr) 340 { 341 struct i2c_client *client = to_i2c_client(dev); 342 struct lm78_data *data = i2c_get_clientdata(client); 343 unsigned long val = simple_strtoul(buf, NULL, 10); 344 345 down(&data->update_lock); 346 data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr])); 347 lm78_write_value(client, LM78_REG_FAN_MIN(nr), data->fan_min[nr]); 348 up(&data->update_lock); 349 return count; 350 } 351 352 static ssize_t show_fan_div(struct device *dev, char *buf, int nr) 353 { 354 struct lm78_data *data = lm78_update_device(dev); 355 return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[nr]) ); 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 suprise; 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, const char *buf, 363 size_t count, int nr) 364 { 365 struct i2c_client *client = to_i2c_client(dev); 366 struct lm78_data *data = i2c_get_clientdata(client); 367 unsigned long val = simple_strtoul(buf, NULL, 10); 368 unsigned long min; 369 u8 reg; 370 371 down(&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(&client->dev, "fan_div value %ld not " 382 "supported. Choose one of 1, 2, 4 or 8!\n", val); 383 up(&data->update_lock); 384 return -EINVAL; 385 } 386 387 reg = lm78_read_value(client, 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(client, 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(client, LM78_REG_FAN_MIN(nr), data->fan_min[nr]); 401 up(&data->update_lock); 402 403 return count; 404 } 405 406 #define show_fan_offset(offset) \ 407 static ssize_t show_fan_##offset (struct device *dev, struct device_attribute *attr, char *buf) \ 408 { \ 409 return show_fan(dev, buf, offset - 1); \ 410 } \ 411 static ssize_t show_fan_##offset##_min (struct device *dev, struct device_attribute *attr, char *buf) \ 412 { \ 413 return show_fan_min(dev, buf, offset - 1); \ 414 } \ 415 static ssize_t show_fan_##offset##_div (struct device *dev, struct device_attribute *attr, char *buf) \ 416 { \ 417 return show_fan_div(dev, buf, offset - 1); \ 418 } \ 419 static ssize_t set_fan_##offset##_min (struct device *dev, struct device_attribute *attr, \ 420 const char *buf, size_t count) \ 421 { \ 422 return set_fan_min(dev, buf, count, offset - 1); \ 423 } \ 424 static DEVICE_ATTR(fan##offset##_input, S_IRUGO, show_fan_##offset, NULL);\ 425 static DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \ 426 show_fan_##offset##_min, set_fan_##offset##_min); 427 428 static ssize_t set_fan_1_div(struct device *dev, struct device_attribute *attr, const char *buf, 429 size_t count) 430 { 431 return set_fan_div(dev, buf, count, 0) ; 432 } 433 434 static ssize_t set_fan_2_div(struct device *dev, struct device_attribute *attr, const char *buf, 435 size_t count) 436 { 437 return set_fan_div(dev, buf, count, 1) ; 438 } 439 440 show_fan_offset(1); 441 show_fan_offset(2); 442 show_fan_offset(3); 443 444 /* Fan 3 divisor is locked in H/W */ 445 static DEVICE_ATTR(fan1_div, S_IRUGO | S_IWUSR, 446 show_fan_1_div, set_fan_1_div); 447 static DEVICE_ATTR(fan2_div, S_IRUGO | S_IWUSR, 448 show_fan_2_div, set_fan_2_div); 449 static DEVICE_ATTR(fan3_div, S_IRUGO, show_fan_3_div, NULL); 450 451 /* VID */ 452 static ssize_t show_vid(struct device *dev, struct device_attribute *attr, char *buf) 453 { 454 struct lm78_data *data = lm78_update_device(dev); 455 return sprintf(buf, "%d\n", vid_from_reg(data->vid, 82)); 456 } 457 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid, NULL); 458 459 /* Alarms */ 460 static ssize_t show_alarms(struct device *dev, struct device_attribute *attr, char *buf) 461 { 462 struct lm78_data *data = lm78_update_device(dev); 463 return sprintf(buf, "%u\n", data->alarms); 464 } 465 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL); 466 467 /* This function is called when: 468 * lm78_driver is inserted (when this module is loaded), for each 469 available adapter 470 * when a new adapter is inserted (and lm78_driver is still present) */ 471 static int lm78_attach_adapter(struct i2c_adapter *adapter) 472 { 473 if (!(adapter->class & I2C_CLASS_HWMON)) 474 return 0; 475 return i2c_probe(adapter, &addr_data, lm78_detect); 476 } 477 478 static int lm78_isa_attach_adapter(struct i2c_adapter *adapter) 479 { 480 return lm78_detect(adapter, isa_address, -1); 481 } 482 483 /* This function is called by i2c_probe */ 484 static 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.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 = kzalloc(sizeof(struct lm78_data), GFP_KERNEL))) { 545 err = -ENOMEM; 546 goto ERROR1; 547 } 548 549 new_client = &data->client; 550 if (is_isa) 551 init_MUTEX(&data->lock); 552 i2c_set_clientdata(new_client, data); 553 new_client->addr = address; 554 new_client->adapter = adapter; 555 new_client->driver = is_isa ? &lm78_isa_driver : &lm78_driver; 556 new_client->flags = 0; 557 558 /* Now, we do the remaining detection. */ 559 if (kind < 0) { 560 if (lm78_read_value(new_client, LM78_REG_CONFIG) & 0x80) { 561 err = -ENODEV; 562 goto ERROR2; 563 } 564 if (!is_isa && (lm78_read_value( 565 new_client, LM78_REG_I2C_ADDR) != address)) { 566 err = -ENODEV; 567 goto ERROR2; 568 } 569 } 570 571 /* Determine the chip type. */ 572 if (kind <= 0) { 573 i = lm78_read_value(new_client, LM78_REG_CHIPID); 574 if (i == 0x00 || i == 0x20 /* LM78 */ 575 || i == 0x40) /* LM78-J */ 576 kind = lm78; 577 else if ((i & 0xfe) == 0xc0) 578 kind = lm79; 579 else { 580 if (kind == 0) 581 dev_warn(&adapter->dev, "Ignoring 'force' " 582 "parameter for unknown chip at " 583 "adapter %d, address 0x%02x\n", 584 i2c_adapter_id(adapter), address); 585 err = -ENODEV; 586 goto ERROR2; 587 } 588 } 589 590 if (kind == lm78) { 591 client_name = "lm78"; 592 } else if (kind == lm79) { 593 client_name = "lm79"; 594 } 595 596 /* Fill in the remaining client fields and put into the global list */ 597 strlcpy(new_client->name, client_name, I2C_NAME_SIZE); 598 data->type = kind; 599 600 data->valid = 0; 601 init_MUTEX(&data->update_lock); 602 603 /* Tell the I2C layer a new client has arrived */ 604 if ((err = i2c_attach_client(new_client))) 605 goto ERROR2; 606 607 /* Initialize the LM78 chip */ 608 lm78_init_client(new_client); 609 610 /* A few vars need to be filled upon startup */ 611 for (i = 0; i < 3; i++) { 612 data->fan_min[i] = lm78_read_value(new_client, 613 LM78_REG_FAN_MIN(i)); 614 } 615 616 /* Register sysfs hooks */ 617 data->class_dev = hwmon_device_register(&new_client->dev); 618 if (IS_ERR(data->class_dev)) { 619 err = PTR_ERR(data->class_dev); 620 goto ERROR3; 621 } 622 623 device_create_file(&new_client->dev, &dev_attr_in0_input); 624 device_create_file(&new_client->dev, &dev_attr_in0_min); 625 device_create_file(&new_client->dev, &dev_attr_in0_max); 626 device_create_file(&new_client->dev, &dev_attr_in1_input); 627 device_create_file(&new_client->dev, &dev_attr_in1_min); 628 device_create_file(&new_client->dev, &dev_attr_in1_max); 629 device_create_file(&new_client->dev, &dev_attr_in2_input); 630 device_create_file(&new_client->dev, &dev_attr_in2_min); 631 device_create_file(&new_client->dev, &dev_attr_in2_max); 632 device_create_file(&new_client->dev, &dev_attr_in3_input); 633 device_create_file(&new_client->dev, &dev_attr_in3_min); 634 device_create_file(&new_client->dev, &dev_attr_in3_max); 635 device_create_file(&new_client->dev, &dev_attr_in4_input); 636 device_create_file(&new_client->dev, &dev_attr_in4_min); 637 device_create_file(&new_client->dev, &dev_attr_in4_max); 638 device_create_file(&new_client->dev, &dev_attr_in5_input); 639 device_create_file(&new_client->dev, &dev_attr_in5_min); 640 device_create_file(&new_client->dev, &dev_attr_in5_max); 641 device_create_file(&new_client->dev, &dev_attr_in6_input); 642 device_create_file(&new_client->dev, &dev_attr_in6_min); 643 device_create_file(&new_client->dev, &dev_attr_in6_max); 644 device_create_file(&new_client->dev, &dev_attr_temp1_input); 645 device_create_file(&new_client->dev, &dev_attr_temp1_max); 646 device_create_file(&new_client->dev, &dev_attr_temp1_max_hyst); 647 device_create_file(&new_client->dev, &dev_attr_fan1_input); 648 device_create_file(&new_client->dev, &dev_attr_fan1_min); 649 device_create_file(&new_client->dev, &dev_attr_fan1_div); 650 device_create_file(&new_client->dev, &dev_attr_fan2_input); 651 device_create_file(&new_client->dev, &dev_attr_fan2_min); 652 device_create_file(&new_client->dev, &dev_attr_fan2_div); 653 device_create_file(&new_client->dev, &dev_attr_fan3_input); 654 device_create_file(&new_client->dev, &dev_attr_fan3_min); 655 device_create_file(&new_client->dev, &dev_attr_fan3_div); 656 device_create_file(&new_client->dev, &dev_attr_alarms); 657 device_create_file(&new_client->dev, &dev_attr_cpu0_vid); 658 659 return 0; 660 661 ERROR3: 662 i2c_detach_client(new_client); 663 ERROR2: 664 kfree(data); 665 ERROR1: 666 if (is_isa) 667 release_region(address, LM78_EXTENT); 668 ERROR0: 669 return err; 670 } 671 672 static int lm78_detach_client(struct i2c_client *client) 673 { 674 struct lm78_data *data = i2c_get_clientdata(client); 675 int err; 676 677 hwmon_device_unregister(data->class_dev); 678 679 if ((err = i2c_detach_client(client))) 680 return err; 681 682 if(i2c_is_isa_client(client)) 683 release_region(client->addr, LM78_EXTENT); 684 685 kfree(data); 686 687 return 0; 688 } 689 690 /* The SMBus locks itself, but ISA access must be locked explicitly! 691 We don't want to lock the whole ISA bus, so we lock each client 692 separately. 693 We ignore the LM78 BUSY flag at this moment - it could lead to deadlocks, 694 would slow down the LM78 access and should not be necessary. */ 695 static int lm78_read_value(struct i2c_client *client, u8 reg) 696 { 697 int res; 698 if (i2c_is_isa_client(client)) { 699 struct lm78_data *data = i2c_get_clientdata(client); 700 down(&data->lock); 701 outb_p(reg, client->addr + LM78_ADDR_REG_OFFSET); 702 res = inb_p(client->addr + LM78_DATA_REG_OFFSET); 703 up(&data->lock); 704 return res; 705 } else 706 return i2c_smbus_read_byte_data(client, reg); 707 } 708 709 /* The SMBus locks itself, but ISA access muse be locked explicitly! 710 We don't want to lock the whole ISA bus, so we lock each client 711 separately. 712 We ignore the LM78 BUSY flag at this moment - it could lead to deadlocks, 713 would slow down the LM78 access and should not be necessary. 714 There are some ugly typecasts here, but the good new is - they should 715 nowhere else be necessary! */ 716 static int lm78_write_value(struct i2c_client *client, u8 reg, u8 value) 717 { 718 if (i2c_is_isa_client(client)) { 719 struct lm78_data *data = i2c_get_clientdata(client); 720 down(&data->lock); 721 outb_p(reg, client->addr + LM78_ADDR_REG_OFFSET); 722 outb_p(value, client->addr + LM78_DATA_REG_OFFSET); 723 up(&data->lock); 724 return 0; 725 } else 726 return i2c_smbus_write_byte_data(client, reg, value); 727 } 728 729 static void lm78_init_client(struct i2c_client *client) 730 { 731 u8 config = lm78_read_value(client, LM78_REG_CONFIG); 732 733 /* Start monitoring */ 734 if (!(config & 0x01)) 735 lm78_write_value(client, LM78_REG_CONFIG, 736 (config & 0xf7) | 0x01); 737 } 738 739 static struct lm78_data *lm78_update_device(struct device *dev) 740 { 741 struct i2c_client *client = to_i2c_client(dev); 742 struct lm78_data *data = i2c_get_clientdata(client); 743 int i; 744 745 down(&data->update_lock); 746 747 if (time_after(jiffies, data->last_updated + HZ + HZ / 2) 748 || !data->valid) { 749 750 dev_dbg(&client->dev, "Starting lm78 update\n"); 751 752 for (i = 0; i <= 6; i++) { 753 data->in[i] = 754 lm78_read_value(client, LM78_REG_IN(i)); 755 data->in_min[i] = 756 lm78_read_value(client, LM78_REG_IN_MIN(i)); 757 data->in_max[i] = 758 lm78_read_value(client, LM78_REG_IN_MAX(i)); 759 } 760 for (i = 0; i < 3; i++) { 761 data->fan[i] = 762 lm78_read_value(client, LM78_REG_FAN(i)); 763 data->fan_min[i] = 764 lm78_read_value(client, LM78_REG_FAN_MIN(i)); 765 } 766 data->temp = lm78_read_value(client, LM78_REG_TEMP); 767 data->temp_over = 768 lm78_read_value(client, LM78_REG_TEMP_OVER); 769 data->temp_hyst = 770 lm78_read_value(client, LM78_REG_TEMP_HYST); 771 i = lm78_read_value(client, LM78_REG_VID_FANDIV); 772 data->vid = i & 0x0f; 773 if (data->type == lm79) 774 data->vid |= 775 (lm78_read_value(client, LM78_REG_CHIPID) & 776 0x01) << 4; 777 else 778 data->vid |= 0x10; 779 data->fan_div[0] = (i >> 4) & 0x03; 780 data->fan_div[1] = i >> 6; 781 data->alarms = lm78_read_value(client, LM78_REG_ALARM1) + 782 (lm78_read_value(client, LM78_REG_ALARM2) << 8); 783 data->last_updated = jiffies; 784 data->valid = 1; 785 786 data->fan_div[2] = 1; 787 } 788 789 up(&data->update_lock); 790 791 return data; 792 } 793 794 static int __init sm_lm78_init(void) 795 { 796 int res; 797 798 res = i2c_add_driver(&lm78_driver); 799 if (res) 800 return res; 801 802 res = i2c_isa_add_driver(&lm78_isa_driver); 803 if (res) { 804 i2c_del_driver(&lm78_driver); 805 return res; 806 } 807 808 return 0; 809 } 810 811 static void __exit sm_lm78_exit(void) 812 { 813 i2c_isa_del_driver(&lm78_isa_driver); 814 i2c_del_driver(&lm78_driver); 815 } 816 817 818 819 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>"); 820 MODULE_DESCRIPTION("LM78/LM79 driver"); 821 MODULE_LICENSE("GPL"); 822 823 module_init(sm_lm78_init); 824 module_exit(sm_lm78_exit); 825