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 chip, we need to keep some data in memory. 129 The structure is dynamically allocated. */ 130 struct lm78_data { 131 struct i2c_client client; 132 struct class_device *class_dev; 133 struct mutex lock; 134 enum chips type; 135 136 struct mutex update_lock; 137 char valid; /* !=0 if following fields are valid */ 138 unsigned long last_updated; /* In jiffies */ 139 140 u8 in[7]; /* Register value */ 141 u8 in_max[7]; /* Register value */ 142 u8 in_min[7]; /* Register value */ 143 u8 fan[3]; /* Register value */ 144 u8 fan_min[3]; /* Register value */ 145 s8 temp; /* Register value */ 146 s8 temp_over; /* Register value */ 147 s8 temp_hyst; /* Register value */ 148 u8 fan_div[3]; /* Register encoding, shifted right */ 149 u8 vid; /* Register encoding, combined */ 150 u16 alarms; /* Register encoding, combined */ 151 }; 152 153 154 static int lm78_attach_adapter(struct i2c_adapter *adapter); 155 static int lm78_isa_attach_adapter(struct i2c_adapter *adapter); 156 static int lm78_detect(struct i2c_adapter *adapter, int address, int kind); 157 static int lm78_detach_client(struct i2c_client *client); 158 159 static int lm78_read_value(struct i2c_client *client, u8 reg); 160 static int lm78_write_value(struct i2c_client *client, u8 reg, u8 value); 161 static struct lm78_data *lm78_update_device(struct device *dev); 162 static void lm78_init_client(struct i2c_client *client); 163 164 165 static struct i2c_driver lm78_driver = { 166 .driver = { 167 .name = "lm78", 168 }, 169 .id = I2C_DRIVERID_LM78, 170 .attach_adapter = lm78_attach_adapter, 171 .detach_client = lm78_detach_client, 172 }; 173 174 static struct i2c_driver lm78_isa_driver = { 175 .driver = { 176 .owner = THIS_MODULE, 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 mutex_lock(&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 mutex_unlock(&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 mutex_lock(&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 mutex_unlock(&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 mutex_lock(&data->update_lock); 292 data->temp_over = TEMP_TO_REG(val); 293 lm78_write_value(client, LM78_REG_TEMP_OVER, data->temp_over); 294 mutex_unlock(&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 mutex_lock(&data->update_lock); 311 data->temp_hyst = TEMP_TO_REG(val); 312 lm78_write_value(client, LM78_REG_TEMP_HYST, data->temp_hyst); 313 mutex_unlock(&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 mutex_lock(&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 mutex_unlock(&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 surprise; the user doesn't expect the fan minimum to change just 361 because the divisor changed. */ 362 static ssize_t set_fan_div(struct device *dev, 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 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(&client->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(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 mutex_unlock(&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 static struct attribute *lm78_attributes[] = { 484 &dev_attr_in0_input.attr, 485 &dev_attr_in0_min.attr, 486 &dev_attr_in0_max.attr, 487 &dev_attr_in1_input.attr, 488 &dev_attr_in1_min.attr, 489 &dev_attr_in1_max.attr, 490 &dev_attr_in2_input.attr, 491 &dev_attr_in2_min.attr, 492 &dev_attr_in2_max.attr, 493 &dev_attr_in3_input.attr, 494 &dev_attr_in3_min.attr, 495 &dev_attr_in3_max.attr, 496 &dev_attr_in4_input.attr, 497 &dev_attr_in4_min.attr, 498 &dev_attr_in4_max.attr, 499 &dev_attr_in5_input.attr, 500 &dev_attr_in5_min.attr, 501 &dev_attr_in5_max.attr, 502 &dev_attr_in6_input.attr, 503 &dev_attr_in6_min.attr, 504 &dev_attr_in6_max.attr, 505 &dev_attr_temp1_input.attr, 506 &dev_attr_temp1_max.attr, 507 &dev_attr_temp1_max_hyst.attr, 508 &dev_attr_fan1_input.attr, 509 &dev_attr_fan1_min.attr, 510 &dev_attr_fan1_div.attr, 511 &dev_attr_fan2_input.attr, 512 &dev_attr_fan2_min.attr, 513 &dev_attr_fan2_div.attr, 514 &dev_attr_fan3_input.attr, 515 &dev_attr_fan3_min.attr, 516 &dev_attr_fan3_div.attr, 517 &dev_attr_alarms.attr, 518 &dev_attr_cpu0_vid.attr, 519 520 NULL 521 }; 522 523 static const struct attribute_group lm78_group = { 524 .attrs = lm78_attributes, 525 }; 526 527 /* This function is called by i2c_probe */ 528 static int lm78_detect(struct i2c_adapter *adapter, int address, int kind) 529 { 530 int i, err; 531 struct i2c_client *new_client; 532 struct lm78_data *data; 533 const char *client_name = ""; 534 int is_isa = i2c_is_isa_adapter(adapter); 535 536 if (!is_isa && 537 !i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) { 538 err = -ENODEV; 539 goto ERROR0; 540 } 541 542 /* Reserve the ISA region */ 543 if (is_isa) 544 if (!request_region(address, LM78_EXTENT, 545 lm78_isa_driver.driver.name)) { 546 err = -EBUSY; 547 goto ERROR0; 548 } 549 550 /* Probe whether there is anything available on this address. Already 551 done for SMBus clients */ 552 if (kind < 0) { 553 if (is_isa) { 554 555 #define REALLY_SLOW_IO 556 /* We need the timeouts for at least some LM78-like 557 chips. But only if we read 'undefined' registers. */ 558 i = inb_p(address + 1); 559 if (inb_p(address + 2) != i) { 560 err = -ENODEV; 561 goto ERROR1; 562 } 563 if (inb_p(address + 3) != i) { 564 err = -ENODEV; 565 goto ERROR1; 566 } 567 if (inb_p(address + 7) != i) { 568 err = -ENODEV; 569 goto ERROR1; 570 } 571 #undef REALLY_SLOW_IO 572 573 /* Let's just hope nothing breaks here */ 574 i = inb_p(address + 5) & 0x7f; 575 outb_p(~i & 0x7f, address + 5); 576 if ((inb_p(address + 5) & 0x7f) != (~i & 0x7f)) { 577 outb_p(i, address + 5); 578 err = -ENODEV; 579 goto ERROR1; 580 } 581 } 582 } 583 584 /* OK. For now, we presume we have a valid client. We now create the 585 client structure, even though we cannot fill it completely yet. 586 But it allows us to access lm78_{read,write}_value. */ 587 588 if (!(data = kzalloc(sizeof(struct lm78_data), GFP_KERNEL))) { 589 err = -ENOMEM; 590 goto ERROR1; 591 } 592 593 new_client = &data->client; 594 if (is_isa) 595 mutex_init(&data->lock); 596 i2c_set_clientdata(new_client, data); 597 new_client->addr = address; 598 new_client->adapter = adapter; 599 new_client->driver = is_isa ? &lm78_isa_driver : &lm78_driver; 600 new_client->flags = 0; 601 602 /* Now, we do the remaining detection. */ 603 if (kind < 0) { 604 if (lm78_read_value(new_client, LM78_REG_CONFIG) & 0x80) { 605 err = -ENODEV; 606 goto ERROR2; 607 } 608 if (!is_isa && (lm78_read_value( 609 new_client, LM78_REG_I2C_ADDR) != address)) { 610 err = -ENODEV; 611 goto ERROR2; 612 } 613 } 614 615 /* Determine the chip type. */ 616 if (kind <= 0) { 617 i = lm78_read_value(new_client, LM78_REG_CHIPID); 618 if (i == 0x00 || i == 0x20 /* LM78 */ 619 || i == 0x40) /* LM78-J */ 620 kind = lm78; 621 else if ((i & 0xfe) == 0xc0) 622 kind = lm79; 623 else { 624 if (kind == 0) 625 dev_warn(&adapter->dev, "Ignoring 'force' " 626 "parameter for unknown chip at " 627 "adapter %d, address 0x%02x\n", 628 i2c_adapter_id(adapter), address); 629 err = -ENODEV; 630 goto ERROR2; 631 } 632 } 633 634 if (kind == lm78) { 635 client_name = "lm78"; 636 } else if (kind == lm79) { 637 client_name = "lm79"; 638 } 639 640 /* Fill in the remaining client fields and put into the global list */ 641 strlcpy(new_client->name, client_name, I2C_NAME_SIZE); 642 data->type = kind; 643 644 data->valid = 0; 645 mutex_init(&data->update_lock); 646 647 /* Tell the I2C layer a new client has arrived */ 648 if ((err = i2c_attach_client(new_client))) 649 goto ERROR2; 650 651 /* Initialize the LM78 chip */ 652 lm78_init_client(new_client); 653 654 /* A few vars need to be filled upon startup */ 655 for (i = 0; i < 3; i++) { 656 data->fan_min[i] = lm78_read_value(new_client, 657 LM78_REG_FAN_MIN(i)); 658 } 659 660 /* Register sysfs hooks */ 661 if ((err = sysfs_create_group(&new_client->dev.kobj, &lm78_group))) 662 goto ERROR3; 663 664 data->class_dev = hwmon_device_register(&new_client->dev); 665 if (IS_ERR(data->class_dev)) { 666 err = PTR_ERR(data->class_dev); 667 goto ERROR4; 668 } 669 670 return 0; 671 672 ERROR4: 673 sysfs_remove_group(&new_client->dev.kobj, &lm78_group); 674 ERROR3: 675 i2c_detach_client(new_client); 676 ERROR2: 677 kfree(data); 678 ERROR1: 679 if (is_isa) 680 release_region(address, LM78_EXTENT); 681 ERROR0: 682 return err; 683 } 684 685 static int lm78_detach_client(struct i2c_client *client) 686 { 687 struct lm78_data *data = i2c_get_clientdata(client); 688 int err; 689 690 hwmon_device_unregister(data->class_dev); 691 sysfs_remove_group(&client->dev.kobj, &lm78_group); 692 693 if ((err = i2c_detach_client(client))) 694 return err; 695 696 if(i2c_is_isa_client(client)) 697 release_region(client->addr, LM78_EXTENT); 698 699 kfree(data); 700 701 return 0; 702 } 703 704 /* The SMBus locks itself, but ISA access must be locked explicitly! 705 We don't want to lock the whole ISA bus, so we lock each client 706 separately. 707 We ignore the LM78 BUSY flag at this moment - it could lead to deadlocks, 708 would slow down the LM78 access and should not be necessary. */ 709 static int lm78_read_value(struct i2c_client *client, u8 reg) 710 { 711 int res; 712 if (i2c_is_isa_client(client)) { 713 struct lm78_data *data = i2c_get_clientdata(client); 714 mutex_lock(&data->lock); 715 outb_p(reg, client->addr + LM78_ADDR_REG_OFFSET); 716 res = inb_p(client->addr + LM78_DATA_REG_OFFSET); 717 mutex_unlock(&data->lock); 718 return res; 719 } else 720 return i2c_smbus_read_byte_data(client, reg); 721 } 722 723 /* The SMBus locks itself, but ISA access muse 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 There are some ugly typecasts here, but the good new is - they should 729 nowhere else be necessary! */ 730 static int lm78_write_value(struct i2c_client *client, u8 reg, u8 value) 731 { 732 if (i2c_is_isa_client(client)) { 733 struct lm78_data *data = i2c_get_clientdata(client); 734 mutex_lock(&data->lock); 735 outb_p(reg, client->addr + LM78_ADDR_REG_OFFSET); 736 outb_p(value, client->addr + LM78_DATA_REG_OFFSET); 737 mutex_unlock(&data->lock); 738 return 0; 739 } else 740 return i2c_smbus_write_byte_data(client, reg, value); 741 } 742 743 static void lm78_init_client(struct i2c_client *client) 744 { 745 u8 config = lm78_read_value(client, LM78_REG_CONFIG); 746 747 /* Start monitoring */ 748 if (!(config & 0x01)) 749 lm78_write_value(client, LM78_REG_CONFIG, 750 (config & 0xf7) | 0x01); 751 } 752 753 static struct lm78_data *lm78_update_device(struct device *dev) 754 { 755 struct i2c_client *client = to_i2c_client(dev); 756 struct lm78_data *data = i2c_get_clientdata(client); 757 int i; 758 759 mutex_lock(&data->update_lock); 760 761 if (time_after(jiffies, data->last_updated + HZ + HZ / 2) 762 || !data->valid) { 763 764 dev_dbg(&client->dev, "Starting lm78 update\n"); 765 766 for (i = 0; i <= 6; i++) { 767 data->in[i] = 768 lm78_read_value(client, LM78_REG_IN(i)); 769 data->in_min[i] = 770 lm78_read_value(client, LM78_REG_IN_MIN(i)); 771 data->in_max[i] = 772 lm78_read_value(client, LM78_REG_IN_MAX(i)); 773 } 774 for (i = 0; i < 3; i++) { 775 data->fan[i] = 776 lm78_read_value(client, LM78_REG_FAN(i)); 777 data->fan_min[i] = 778 lm78_read_value(client, LM78_REG_FAN_MIN(i)); 779 } 780 data->temp = lm78_read_value(client, LM78_REG_TEMP); 781 data->temp_over = 782 lm78_read_value(client, LM78_REG_TEMP_OVER); 783 data->temp_hyst = 784 lm78_read_value(client, LM78_REG_TEMP_HYST); 785 i = lm78_read_value(client, LM78_REG_VID_FANDIV); 786 data->vid = i & 0x0f; 787 if (data->type == lm79) 788 data->vid |= 789 (lm78_read_value(client, LM78_REG_CHIPID) & 790 0x01) << 4; 791 else 792 data->vid |= 0x10; 793 data->fan_div[0] = (i >> 4) & 0x03; 794 data->fan_div[1] = i >> 6; 795 data->alarms = lm78_read_value(client, LM78_REG_ALARM1) + 796 (lm78_read_value(client, LM78_REG_ALARM2) << 8); 797 data->last_updated = jiffies; 798 data->valid = 1; 799 800 data->fan_div[2] = 1; 801 } 802 803 mutex_unlock(&data->update_lock); 804 805 return data; 806 } 807 808 static int __init sm_lm78_init(void) 809 { 810 int res; 811 812 res = i2c_add_driver(&lm78_driver); 813 if (res) 814 return res; 815 816 /* Don't exit if this one fails, we still want the I2C variants 817 to work! */ 818 if (i2c_isa_add_driver(&lm78_isa_driver)) 819 isa_address = 0; 820 821 return 0; 822 } 823 824 static void __exit sm_lm78_exit(void) 825 { 826 if (isa_address) 827 i2c_isa_del_driver(&lm78_isa_driver); 828 i2c_del_driver(&lm78_driver); 829 } 830 831 832 833 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>"); 834 MODULE_DESCRIPTION("LM78/LM79 driver"); 835 MODULE_LICENSE("GPL"); 836 837 module_init(sm_lm78_init); 838 module_exit(sm_lm78_exit); 839