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 <linux/mutex.h> 31 #include <asm/io.h> 32 33 /* Addresses to scan */ 34 static unsigned short normal_i2c[] = { 0x20, 0x21, 0x22, 0x23, 0x24, 35 0x25, 0x26, 0x27, 0x28, 0x29, 36 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 37 0x2f, I2C_CLIENT_END }; 38 static unsigned short isa_address = 0x290; 39 40 /* Insmod parameters */ 41 I2C_CLIENT_INSMOD_2(lm78, lm79); 42 43 /* Many LM78 constants specified below */ 44 45 /* Length of ISA address segment */ 46 #define LM78_EXTENT 8 47 48 /* Where are the ISA address/data registers relative to the base address */ 49 #define LM78_ADDR_REG_OFFSET 5 50 #define LM78_DATA_REG_OFFSET 6 51 52 /* The LM78 registers */ 53 #define LM78_REG_IN_MAX(nr) (0x2b + (nr) * 2) 54 #define LM78_REG_IN_MIN(nr) (0x2c + (nr) * 2) 55 #define LM78_REG_IN(nr) (0x20 + (nr)) 56 57 #define LM78_REG_FAN_MIN(nr) (0x3b + (nr)) 58 #define LM78_REG_FAN(nr) (0x28 + (nr)) 59 60 #define LM78_REG_TEMP 0x27 61 #define LM78_REG_TEMP_OVER 0x39 62 #define LM78_REG_TEMP_HYST 0x3a 63 64 #define LM78_REG_ALARM1 0x41 65 #define LM78_REG_ALARM2 0x42 66 67 #define LM78_REG_VID_FANDIV 0x47 68 69 #define LM78_REG_CONFIG 0x40 70 #define LM78_REG_CHIPID 0x49 71 #define LM78_REG_I2C_ADDR 0x48 72 73 74 /* Conversions. Rounding and limit checking is only done on the TO_REG 75 variants. */ 76 77 /* IN: mV, (0V to 4.08V) 78 REG: 16mV/bit */ 79 static inline u8 IN_TO_REG(unsigned long val) 80 { 81 unsigned long nval = SENSORS_LIMIT(val, 0, 4080); 82 return (nval + 8) / 16; 83 } 84 #define IN_FROM_REG(val) ((val) * 16) 85 86 static inline u8 FAN_TO_REG(long rpm, int div) 87 { 88 if (rpm <= 0) 89 return 255; 90 return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1, 254); 91 } 92 93 static inline int FAN_FROM_REG(u8 val, int div) 94 { 95 return val==0 ? -1 : val==255 ? 0 : 1350000/(val*div); 96 } 97 98 /* TEMP: mC (-128C to +127C) 99 REG: 1C/bit, two's complement */ 100 static inline s8 TEMP_TO_REG(int val) 101 { 102 int nval = SENSORS_LIMIT(val, -128000, 127000) ; 103 return nval<0 ? (nval-500)/1000 : (nval+500)/1000; 104 } 105 106 static inline int TEMP_FROM_REG(s8 val) 107 { 108 return val * 1000; 109 } 110 111 #define DIV_FROM_REG(val) (1 << (val)) 112 113 /* There are some complications in a module like this. First off, LM78 chips 114 may be both present on the SMBus and the ISA bus, and we have to handle 115 those cases separately at some places. Second, there might be several 116 LM78 chips available (well, actually, that is probably never done; but 117 it is a clean illustration of how to handle a case like that). Finally, 118 a specific chip may be attached to *both* ISA and SMBus, and we would 119 not like to detect it double. Fortunately, in the case of the LM78 at 120 least, a register tells us what SMBus address we are on, so that helps 121 a bit - except if there could be more than one SMBus. Groan. No solution 122 for this yet. */ 123 124 /* This module may seem overly long and complicated. In fact, it is not so 125 bad. Quite a lot of bookkeeping is done. A real driver can often cut 126 some corners. */ 127 128 /* For each registered LM78, we need to keep some data in memory. That 129 data is pointed to by lm78_list[NR]->data. The structure itself is 130 dynamically allocated, at the same time when a new lm78 client is 131 allocated. */ 132 struct lm78_data { 133 struct i2c_client client; 134 struct class_device *class_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_isa_attach_adapter(struct i2c_adapter *adapter); 158 static int lm78_detect(struct i2c_adapter *adapter, int address, int kind); 159 static int lm78_detach_client(struct i2c_client *client); 160 161 static int lm78_read_value(struct i2c_client *client, u8 reg); 162 static int lm78_write_value(struct i2c_client *client, u8 reg, u8 value); 163 static struct lm78_data *lm78_update_device(struct device *dev); 164 static void lm78_init_client(struct i2c_client *client); 165 166 167 static struct i2c_driver lm78_driver = { 168 .driver = { 169 .name = "lm78", 170 }, 171 .id = I2C_DRIVERID_LM78, 172 .attach_adapter = lm78_attach_adapter, 173 .detach_client = lm78_detach_client, 174 }; 175 176 static struct i2c_driver lm78_isa_driver = { 177 .driver = { 178 .name = "lm78-isa", 179 }, 180 .attach_adapter = lm78_isa_attach_adapter, 181 .detach_client = lm78_detach_client, 182 }; 183 184 185 /* 7 Voltages */ 186 static ssize_t show_in(struct device *dev, char *buf, int nr) 187 { 188 struct lm78_data *data = lm78_update_device(dev); 189 return sprintf(buf, "%d\n", IN_FROM_REG(data->in[nr])); 190 } 191 192 static ssize_t show_in_min(struct device *dev, char *buf, int nr) 193 { 194 struct lm78_data *data = lm78_update_device(dev); 195 return sprintf(buf, "%d\n", IN_FROM_REG(data->in_min[nr])); 196 } 197 198 static ssize_t show_in_max(struct device *dev, char *buf, int nr) 199 { 200 struct lm78_data *data = lm78_update_device(dev); 201 return sprintf(buf, "%d\n", IN_FROM_REG(data->in_max[nr])); 202 } 203 204 static ssize_t set_in_min(struct device *dev, const char *buf, 205 size_t count, int nr) 206 { 207 struct i2c_client *client = to_i2c_client(dev); 208 struct lm78_data *data = i2c_get_clientdata(client); 209 unsigned long val = simple_strtoul(buf, NULL, 10); 210 211 mutex_lock(&data->update_lock); 212 data->in_min[nr] = IN_TO_REG(val); 213 lm78_write_value(client, LM78_REG_IN_MIN(nr), data->in_min[nr]); 214 mutex_unlock(&data->update_lock); 215 return count; 216 } 217 218 static ssize_t set_in_max(struct device *dev, const char *buf, 219 size_t count, int nr) 220 { 221 struct i2c_client *client = to_i2c_client(dev); 222 struct lm78_data *data = i2c_get_clientdata(client); 223 unsigned long val = simple_strtoul(buf, NULL, 10); 224 225 mutex_lock(&data->update_lock); 226 data->in_max[nr] = IN_TO_REG(val); 227 lm78_write_value(client, LM78_REG_IN_MAX(nr), data->in_max[nr]); 228 mutex_unlock(&data->update_lock); 229 return count; 230 } 231 232 #define show_in_offset(offset) \ 233 static ssize_t \ 234 show_in##offset (struct device *dev, struct device_attribute *attr, char *buf) \ 235 { \ 236 return show_in(dev, buf, offset); \ 237 } \ 238 static DEVICE_ATTR(in##offset##_input, S_IRUGO, \ 239 show_in##offset, NULL); \ 240 static ssize_t \ 241 show_in##offset##_min (struct device *dev, struct device_attribute *attr, char *buf) \ 242 { \ 243 return show_in_min(dev, buf, offset); \ 244 } \ 245 static ssize_t \ 246 show_in##offset##_max (struct device *dev, struct device_attribute *attr, char *buf) \ 247 { \ 248 return show_in_max(dev, buf, offset); \ 249 } \ 250 static ssize_t set_in##offset##_min (struct device *dev, struct device_attribute *attr, \ 251 const char *buf, size_t count) \ 252 { \ 253 return set_in_min(dev, buf, count, offset); \ 254 } \ 255 static ssize_t set_in##offset##_max (struct device *dev, struct device_attribute *attr, \ 256 const char *buf, size_t count) \ 257 { \ 258 return set_in_max(dev, buf, count, offset); \ 259 } \ 260 static DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR, \ 261 show_in##offset##_min, set_in##offset##_min); \ 262 static DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR, \ 263 show_in##offset##_max, set_in##offset##_max); 264 265 show_in_offset(0); 266 show_in_offset(1); 267 show_in_offset(2); 268 show_in_offset(3); 269 show_in_offset(4); 270 show_in_offset(5); 271 show_in_offset(6); 272 273 /* Temperature */ 274 static ssize_t show_temp(struct device *dev, struct device_attribute *attr, char *buf) 275 { 276 struct lm78_data *data = lm78_update_device(dev); 277 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp)); 278 } 279 280 static ssize_t show_temp_over(struct device *dev, struct device_attribute *attr, char *buf) 281 { 282 struct lm78_data *data = lm78_update_device(dev); 283 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_over)); 284 } 285 286 static ssize_t set_temp_over(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) 287 { 288 struct i2c_client *client = to_i2c_client(dev); 289 struct lm78_data *data = i2c_get_clientdata(client); 290 long val = simple_strtol(buf, NULL, 10); 291 292 mutex_lock(&data->update_lock); 293 data->temp_over = TEMP_TO_REG(val); 294 lm78_write_value(client, LM78_REG_TEMP_OVER, data->temp_over); 295 mutex_unlock(&data->update_lock); 296 return count; 297 } 298 299 static ssize_t show_temp_hyst(struct device *dev, struct device_attribute *attr, char *buf) 300 { 301 struct lm78_data *data = lm78_update_device(dev); 302 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_hyst)); 303 } 304 305 static ssize_t set_temp_hyst(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) 306 { 307 struct i2c_client *client = to_i2c_client(dev); 308 struct lm78_data *data = i2c_get_clientdata(client); 309 long val = simple_strtol(buf, NULL, 10); 310 311 mutex_lock(&data->update_lock); 312 data->temp_hyst = TEMP_TO_REG(val); 313 lm78_write_value(client, LM78_REG_TEMP_HYST, data->temp_hyst); 314 mutex_unlock(&data->update_lock); 315 return count; 316 } 317 318 static DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL); 319 static DEVICE_ATTR(temp1_max, S_IRUGO | S_IWUSR, 320 show_temp_over, set_temp_over); 321 static DEVICE_ATTR(temp1_max_hyst, S_IRUGO | S_IWUSR, 322 show_temp_hyst, set_temp_hyst); 323 324 /* 3 Fans */ 325 static ssize_t show_fan(struct device *dev, char *buf, int nr) 326 { 327 struct lm78_data *data = lm78_update_device(dev); 328 return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[nr], 329 DIV_FROM_REG(data->fan_div[nr])) ); 330 } 331 332 static ssize_t show_fan_min(struct device *dev, char *buf, int nr) 333 { 334 struct lm78_data *data = lm78_update_device(dev); 335 return sprintf(buf,"%d\n", FAN_FROM_REG(data->fan_min[nr], 336 DIV_FROM_REG(data->fan_div[nr])) ); 337 } 338 339 static ssize_t set_fan_min(struct device *dev, const char *buf, 340 size_t count, int nr) 341 { 342 struct i2c_client *client = to_i2c_client(dev); 343 struct lm78_data *data = i2c_get_clientdata(client); 344 unsigned long val = simple_strtoul(buf, NULL, 10); 345 346 mutex_lock(&data->update_lock); 347 data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr])); 348 lm78_write_value(client, LM78_REG_FAN_MIN(nr), data->fan_min[nr]); 349 mutex_unlock(&data->update_lock); 350 return count; 351 } 352 353 static ssize_t show_fan_div(struct device *dev, char *buf, int nr) 354 { 355 struct lm78_data *data = lm78_update_device(dev); 356 return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[nr]) ); 357 } 358 359 /* Note: we save and restore the fan minimum here, because its value is 360 determined in part by the fan divisor. This follows the principle of 361 least surprise; the user doesn't expect the fan minimum to change just 362 because the divisor changed. */ 363 static ssize_t set_fan_div(struct device *dev, const char *buf, 364 size_t count, int nr) 365 { 366 struct i2c_client *client = to_i2c_client(dev); 367 struct lm78_data *data = i2c_get_clientdata(client); 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(&client->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(client, 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(client, 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(client, 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 ssize_t show_fan_##offset (struct device *dev, struct device_attribute *attr, char *buf) \ 409 { \ 410 return show_fan(dev, buf, offset - 1); \ 411 } \ 412 static ssize_t show_fan_##offset##_min (struct device *dev, struct device_attribute *attr, char *buf) \ 413 { \ 414 return show_fan_min(dev, buf, offset - 1); \ 415 } \ 416 static ssize_t show_fan_##offset##_div (struct device *dev, struct device_attribute *attr, char *buf) \ 417 { \ 418 return show_fan_div(dev, buf, offset - 1); \ 419 } \ 420 static ssize_t set_fan_##offset##_min (struct device *dev, struct device_attribute *attr, \ 421 const char *buf, size_t count) \ 422 { \ 423 return set_fan_min(dev, buf, count, offset - 1); \ 424 } \ 425 static DEVICE_ATTR(fan##offset##_input, S_IRUGO, show_fan_##offset, NULL);\ 426 static DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \ 427 show_fan_##offset##_min, set_fan_##offset##_min); 428 429 static ssize_t set_fan_1_div(struct device *dev, struct device_attribute *attr, const char *buf, 430 size_t count) 431 { 432 return set_fan_div(dev, buf, count, 0) ; 433 } 434 435 static ssize_t set_fan_2_div(struct device *dev, struct device_attribute *attr, const char *buf, 436 size_t count) 437 { 438 return set_fan_div(dev, buf, count, 1) ; 439 } 440 441 show_fan_offset(1); 442 show_fan_offset(2); 443 show_fan_offset(3); 444 445 /* Fan 3 divisor is locked in H/W */ 446 static DEVICE_ATTR(fan1_div, S_IRUGO | S_IWUSR, 447 show_fan_1_div, set_fan_1_div); 448 static DEVICE_ATTR(fan2_div, S_IRUGO | S_IWUSR, 449 show_fan_2_div, set_fan_2_div); 450 static DEVICE_ATTR(fan3_div, S_IRUGO, show_fan_3_div, NULL); 451 452 /* VID */ 453 static ssize_t show_vid(struct device *dev, struct device_attribute *attr, char *buf) 454 { 455 struct lm78_data *data = lm78_update_device(dev); 456 return sprintf(buf, "%d\n", vid_from_reg(data->vid, 82)); 457 } 458 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid, NULL); 459 460 /* Alarms */ 461 static ssize_t show_alarms(struct device *dev, struct device_attribute *attr, char *buf) 462 { 463 struct lm78_data *data = lm78_update_device(dev); 464 return sprintf(buf, "%u\n", data->alarms); 465 } 466 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL); 467 468 /* This function is called when: 469 * lm78_driver is inserted (when this module is loaded), for each 470 available adapter 471 * when a new adapter is inserted (and lm78_driver is still present) */ 472 static int lm78_attach_adapter(struct i2c_adapter *adapter) 473 { 474 if (!(adapter->class & I2C_CLASS_HWMON)) 475 return 0; 476 return i2c_probe(adapter, &addr_data, lm78_detect); 477 } 478 479 static int lm78_isa_attach_adapter(struct i2c_adapter *adapter) 480 { 481 return lm78_detect(adapter, isa_address, -1); 482 } 483 484 /* This function is called by i2c_probe */ 485 static int lm78_detect(struct i2c_adapter *adapter, int address, int kind) 486 { 487 int i, err; 488 struct i2c_client *new_client; 489 struct lm78_data *data; 490 const char *client_name = ""; 491 int is_isa = i2c_is_isa_adapter(adapter); 492 493 if (!is_isa && 494 !i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) { 495 err = -ENODEV; 496 goto ERROR0; 497 } 498 499 /* Reserve the ISA region */ 500 if (is_isa) 501 if (!request_region(address, LM78_EXTENT, 502 lm78_isa_driver.driver.name)) { 503 err = -EBUSY; 504 goto ERROR0; 505 } 506 507 /* Probe whether there is anything available on this address. Already 508 done for SMBus clients */ 509 if (kind < 0) { 510 if (is_isa) { 511 512 #define REALLY_SLOW_IO 513 /* We need the timeouts for at least some LM78-like 514 chips. But only if we read 'undefined' registers. */ 515 i = inb_p(address + 1); 516 if (inb_p(address + 2) != i) { 517 err = -ENODEV; 518 goto ERROR1; 519 } 520 if (inb_p(address + 3) != i) { 521 err = -ENODEV; 522 goto ERROR1; 523 } 524 if (inb_p(address + 7) != i) { 525 err = -ENODEV; 526 goto ERROR1; 527 } 528 #undef REALLY_SLOW_IO 529 530 /* Let's just hope nothing breaks here */ 531 i = inb_p(address + 5) & 0x7f; 532 outb_p(~i & 0x7f, address + 5); 533 if ((inb_p(address + 5) & 0x7f) != (~i & 0x7f)) { 534 outb_p(i, address + 5); 535 err = -ENODEV; 536 goto ERROR1; 537 } 538 } 539 } 540 541 /* OK. For now, we presume we have a valid client. We now create the 542 client structure, even though we cannot fill it completely yet. 543 But it allows us to access lm78_{read,write}_value. */ 544 545 if (!(data = kzalloc(sizeof(struct lm78_data), GFP_KERNEL))) { 546 err = -ENOMEM; 547 goto ERROR1; 548 } 549 550 new_client = &data->client; 551 if (is_isa) 552 mutex_init(&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 mutex_init(&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 return err; 682 683 if(i2c_is_isa_client(client)) 684 release_region(client->addr, LM78_EXTENT); 685 686 kfree(data); 687 688 return 0; 689 } 690 691 /* The SMBus locks itself, but ISA access must be locked explicitly! 692 We don't want to lock the whole ISA bus, so we lock each client 693 separately. 694 We ignore the LM78 BUSY flag at this moment - it could lead to deadlocks, 695 would slow down the LM78 access and should not be necessary. */ 696 static int lm78_read_value(struct i2c_client *client, u8 reg) 697 { 698 int res; 699 if (i2c_is_isa_client(client)) { 700 struct lm78_data *data = i2c_get_clientdata(client); 701 mutex_lock(&data->lock); 702 outb_p(reg, client->addr + LM78_ADDR_REG_OFFSET); 703 res = inb_p(client->addr + LM78_DATA_REG_OFFSET); 704 mutex_unlock(&data->lock); 705 return res; 706 } else 707 return i2c_smbus_read_byte_data(client, reg); 708 } 709 710 /* The SMBus locks itself, but ISA access muse be locked explicitly! 711 We don't want to lock the whole ISA bus, so we lock each client 712 separately. 713 We ignore the LM78 BUSY flag at this moment - it could lead to deadlocks, 714 would slow down the LM78 access and should not be necessary. 715 There are some ugly typecasts here, but the good new is - they should 716 nowhere else be necessary! */ 717 static int lm78_write_value(struct i2c_client *client, u8 reg, u8 value) 718 { 719 if (i2c_is_isa_client(client)) { 720 struct lm78_data *data = i2c_get_clientdata(client); 721 mutex_lock(&data->lock); 722 outb_p(reg, client->addr + LM78_ADDR_REG_OFFSET); 723 outb_p(value, client->addr + LM78_DATA_REG_OFFSET); 724 mutex_unlock(&data->lock); 725 return 0; 726 } else 727 return i2c_smbus_write_byte_data(client, reg, value); 728 } 729 730 static void lm78_init_client(struct i2c_client *client) 731 { 732 u8 config = lm78_read_value(client, LM78_REG_CONFIG); 733 734 /* Start monitoring */ 735 if (!(config & 0x01)) 736 lm78_write_value(client, LM78_REG_CONFIG, 737 (config & 0xf7) | 0x01); 738 } 739 740 static struct lm78_data *lm78_update_device(struct device *dev) 741 { 742 struct i2c_client *client = to_i2c_client(dev); 743 struct lm78_data *data = i2c_get_clientdata(client); 744 int i; 745 746 mutex_lock(&data->update_lock); 747 748 if (time_after(jiffies, data->last_updated + HZ + HZ / 2) 749 || !data->valid) { 750 751 dev_dbg(&client->dev, "Starting lm78 update\n"); 752 753 for (i = 0; i <= 6; i++) { 754 data->in[i] = 755 lm78_read_value(client, LM78_REG_IN(i)); 756 data->in_min[i] = 757 lm78_read_value(client, LM78_REG_IN_MIN(i)); 758 data->in_max[i] = 759 lm78_read_value(client, LM78_REG_IN_MAX(i)); 760 } 761 for (i = 0; i < 3; i++) { 762 data->fan[i] = 763 lm78_read_value(client, LM78_REG_FAN(i)); 764 data->fan_min[i] = 765 lm78_read_value(client, LM78_REG_FAN_MIN(i)); 766 } 767 data->temp = lm78_read_value(client, LM78_REG_TEMP); 768 data->temp_over = 769 lm78_read_value(client, LM78_REG_TEMP_OVER); 770 data->temp_hyst = 771 lm78_read_value(client, LM78_REG_TEMP_HYST); 772 i = lm78_read_value(client, LM78_REG_VID_FANDIV); 773 data->vid = i & 0x0f; 774 if (data->type == lm79) 775 data->vid |= 776 (lm78_read_value(client, LM78_REG_CHIPID) & 777 0x01) << 4; 778 else 779 data->vid |= 0x10; 780 data->fan_div[0] = (i >> 4) & 0x03; 781 data->fan_div[1] = i >> 6; 782 data->alarms = lm78_read_value(client, LM78_REG_ALARM1) + 783 (lm78_read_value(client, LM78_REG_ALARM2) << 8); 784 data->last_updated = jiffies; 785 data->valid = 1; 786 787 data->fan_div[2] = 1; 788 } 789 790 mutex_unlock(&data->update_lock); 791 792 return data; 793 } 794 795 static int __init sm_lm78_init(void) 796 { 797 int res; 798 799 res = i2c_add_driver(&lm78_driver); 800 if (res) 801 return res; 802 803 res = i2c_isa_add_driver(&lm78_isa_driver); 804 if (res) { 805 i2c_del_driver(&lm78_driver); 806 return res; 807 } 808 809 return 0; 810 } 811 812 static void __exit sm_lm78_exit(void) 813 { 814 i2c_isa_del_driver(&lm78_isa_driver); 815 i2c_del_driver(&lm78_driver); 816 } 817 818 819 820 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>"); 821 MODULE_DESCRIPTION("LM78/LM79 driver"); 822 MODULE_LICENSE("GPL"); 823 824 module_init(sm_lm78_init); 825 module_exit(sm_lm78_exit); 826