1 /* 2 sis5595.c - Part of lm_sensors, Linux kernel modules 3 for hardware monitoring 4 5 Copyright (C) 1998 - 2001 Frodo Looijaard <frodol@dds.nl>, 6 Ky�sti M�lkki <kmalkki@cc.hut.fi>, and 7 Mark D. Studebaker <mdsxyz123@yahoo.com> 8 Ported to Linux 2.6 by Aurelien Jarno <aurelien@aurel32.net> with 9 the help of Jean Delvare <khali@linux-fr.org> 10 11 This program is free software; you can redistribute it and/or modify 12 it under the terms of the GNU General Public License as published by 13 the Free Software Foundation; either version 2 of the License, or 14 (at your option) any later version. 15 16 This program is distributed in the hope that it will be useful, 17 but WITHOUT ANY WARRANTY; without even the implied warranty of 18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 19 GNU General Public License for more details. 20 21 You should have received a copy of the GNU General Public License 22 along with this program; if not, write to the Free Software 23 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 24 */ 25 26 /* 27 SiS southbridge has a LM78-like chip integrated on the same IC. 28 This driver is a customized copy of lm78.c 29 30 Supports following revisions: 31 Version PCI ID PCI Revision 32 1 1039/0008 AF or less 33 2 1039/0008 B0 or greater 34 35 Note: these chips contain a 0008 device which is incompatible with the 36 5595. We recognize these by the presence of the listed 37 "blacklist" PCI ID and refuse to load. 38 39 NOT SUPPORTED PCI ID BLACKLIST PCI ID 40 540 0008 0540 41 550 0008 0550 42 5513 0008 5511 43 5581 0008 5597 44 5582 0008 5597 45 5597 0008 5597 46 5598 0008 5597/5598 47 630 0008 0630 48 645 0008 0645 49 730 0008 0730 50 735 0008 0735 51 */ 52 53 #include <linux/module.h> 54 #include <linux/slab.h> 55 #include <linux/ioport.h> 56 #include <linux/pci.h> 57 #include <linux/platform_device.h> 58 #include <linux/hwmon.h> 59 #include <linux/hwmon-sysfs.h> 60 #include <linux/err.h> 61 #include <linux/init.h> 62 #include <linux/jiffies.h> 63 #include <linux/mutex.h> 64 #include <linux/sysfs.h> 65 #include <asm/io.h> 66 67 68 /* If force_addr is set to anything different from 0, we forcibly enable 69 the device at the given address. */ 70 static u16 force_addr; 71 module_param(force_addr, ushort, 0); 72 MODULE_PARM_DESC(force_addr, 73 "Initialize the base address of the sensors"); 74 75 static struct platform_device *pdev; 76 77 /* Many SIS5595 constants specified below */ 78 79 /* Length of ISA address segment */ 80 #define SIS5595_EXTENT 8 81 /* PCI Config Registers */ 82 #define SIS5595_BASE_REG 0x68 83 #define SIS5595_PIN_REG 0x7A 84 #define SIS5595_ENABLE_REG 0x7B 85 86 /* Where are the ISA address/data registers relative to the base address */ 87 #define SIS5595_ADDR_REG_OFFSET 5 88 #define SIS5595_DATA_REG_OFFSET 6 89 90 /* The SIS5595 registers */ 91 #define SIS5595_REG_IN_MAX(nr) (0x2b + (nr) * 2) 92 #define SIS5595_REG_IN_MIN(nr) (0x2c + (nr) * 2) 93 #define SIS5595_REG_IN(nr) (0x20 + (nr)) 94 95 #define SIS5595_REG_FAN_MIN(nr) (0x3b + (nr)) 96 #define SIS5595_REG_FAN(nr) (0x28 + (nr)) 97 98 /* On the first version of the chip, the temp registers are separate. 99 On the second version, 100 TEMP pin is shared with IN4, configured in PCI register 0x7A. 101 The registers are the same as well. 102 OVER and HYST are really MAX and MIN. */ 103 104 #define REV2MIN 0xb0 105 #define SIS5595_REG_TEMP (( data->revision) >= REV2MIN) ? \ 106 SIS5595_REG_IN(4) : 0x27 107 #define SIS5595_REG_TEMP_OVER (( data->revision) >= REV2MIN) ? \ 108 SIS5595_REG_IN_MAX(4) : 0x39 109 #define SIS5595_REG_TEMP_HYST (( data->revision) >= REV2MIN) ? \ 110 SIS5595_REG_IN_MIN(4) : 0x3a 111 112 #define SIS5595_REG_CONFIG 0x40 113 #define SIS5595_REG_ALARM1 0x41 114 #define SIS5595_REG_ALARM2 0x42 115 #define SIS5595_REG_FANDIV 0x47 116 117 /* Conversions. Limit checking is only done on the TO_REG 118 variants. */ 119 120 /* IN: mV, (0V to 4.08V) 121 REG: 16mV/bit */ 122 static inline u8 IN_TO_REG(unsigned long val) 123 { 124 unsigned long nval = SENSORS_LIMIT(val, 0, 4080); 125 return (nval + 8) / 16; 126 } 127 #define IN_FROM_REG(val) ((val) * 16) 128 129 static inline u8 FAN_TO_REG(long rpm, int div) 130 { 131 if (rpm <= 0) 132 return 255; 133 return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1, 254); 134 } 135 136 static inline int FAN_FROM_REG(u8 val, int div) 137 { 138 return val==0 ? -1 : val==255 ? 0 : 1350000/(val*div); 139 } 140 141 /* TEMP: mC (-54.12C to +157.53C) 142 REG: 0.83C/bit + 52.12, two's complement */ 143 static inline int TEMP_FROM_REG(s8 val) 144 { 145 return val * 830 + 52120; 146 } 147 static inline s8 TEMP_TO_REG(int val) 148 { 149 int nval = SENSORS_LIMIT(val, -54120, 157530) ; 150 return nval<0 ? (nval-5212-415)/830 : (nval-5212+415)/830; 151 } 152 153 /* FAN DIV: 1, 2, 4, or 8 (defaults to 2) 154 REG: 0, 1, 2, or 3 (respectively) (defaults to 1) */ 155 static inline u8 DIV_TO_REG(int val) 156 { 157 return val==8 ? 3 : val==4 ? 2 : val==1 ? 0 : 1; 158 } 159 #define DIV_FROM_REG(val) (1 << (val)) 160 161 /* For each registered chip, we need to keep some data in memory. 162 The structure is dynamically allocated. */ 163 struct sis5595_data { 164 unsigned short addr; 165 const char *name; 166 struct device *hwmon_dev; 167 struct mutex lock; 168 169 struct mutex update_lock; 170 char valid; /* !=0 if following fields are valid */ 171 unsigned long last_updated; /* In jiffies */ 172 char maxins; /* == 3 if temp enabled, otherwise == 4 */ 173 u8 revision; /* Reg. value */ 174 175 u8 in[5]; /* Register value */ 176 u8 in_max[5]; /* Register value */ 177 u8 in_min[5]; /* Register value */ 178 u8 fan[2]; /* Register value */ 179 u8 fan_min[2]; /* Register value */ 180 s8 temp; /* Register value */ 181 s8 temp_over; /* Register value */ 182 s8 temp_hyst; /* Register value */ 183 u8 fan_div[2]; /* Register encoding, shifted right */ 184 u16 alarms; /* Register encoding, combined */ 185 }; 186 187 static struct pci_dev *s_bridge; /* pointer to the (only) sis5595 */ 188 189 static int sis5595_probe(struct platform_device *pdev); 190 static int __devexit sis5595_remove(struct platform_device *pdev); 191 192 static int sis5595_read_value(struct sis5595_data *data, u8 reg); 193 static void sis5595_write_value(struct sis5595_data *data, u8 reg, u8 value); 194 static struct sis5595_data *sis5595_update_device(struct device *dev); 195 static void sis5595_init_device(struct sis5595_data *data); 196 197 static struct platform_driver sis5595_driver = { 198 .driver = { 199 .owner = THIS_MODULE, 200 .name = "sis5595", 201 }, 202 .probe = sis5595_probe, 203 .remove = __devexit_p(sis5595_remove), 204 }; 205 206 /* 4 Voltages */ 207 static ssize_t show_in(struct device *dev, struct device_attribute *da, 208 char *buf) 209 { 210 struct sis5595_data *data = sis5595_update_device(dev); 211 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); 212 int nr = attr->index; 213 return sprintf(buf, "%d\n", IN_FROM_REG(data->in[nr])); 214 } 215 216 static ssize_t show_in_min(struct device *dev, struct device_attribute *da, 217 char *buf) 218 { 219 struct sis5595_data *data = sis5595_update_device(dev); 220 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); 221 int nr = attr->index; 222 return sprintf(buf, "%d\n", IN_FROM_REG(data->in_min[nr])); 223 } 224 225 static ssize_t show_in_max(struct device *dev, struct device_attribute *da, 226 char *buf) 227 { 228 struct sis5595_data *data = sis5595_update_device(dev); 229 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); 230 int nr = attr->index; 231 return sprintf(buf, "%d\n", IN_FROM_REG(data->in_max[nr])); 232 } 233 234 static ssize_t set_in_min(struct device *dev, struct device_attribute *da, 235 const char *buf, size_t count) 236 { 237 struct sis5595_data *data = dev_get_drvdata(dev); 238 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); 239 int nr = attr->index; 240 unsigned long val = simple_strtoul(buf, NULL, 10); 241 242 mutex_lock(&data->update_lock); 243 data->in_min[nr] = IN_TO_REG(val); 244 sis5595_write_value(data, SIS5595_REG_IN_MIN(nr), data->in_min[nr]); 245 mutex_unlock(&data->update_lock); 246 return count; 247 } 248 249 static ssize_t set_in_max(struct device *dev, struct device_attribute *da, 250 const char *buf, size_t count) 251 { 252 struct sis5595_data *data = dev_get_drvdata(dev); 253 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); 254 int nr = attr->index; 255 unsigned long val = simple_strtoul(buf, NULL, 10); 256 257 mutex_lock(&data->update_lock); 258 data->in_max[nr] = IN_TO_REG(val); 259 sis5595_write_value(data, SIS5595_REG_IN_MAX(nr), data->in_max[nr]); 260 mutex_unlock(&data->update_lock); 261 return count; 262 } 263 264 #define show_in_offset(offset) \ 265 static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO, \ 266 show_in, NULL, offset); \ 267 static SENSOR_DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR, \ 268 show_in_min, set_in_min, offset); \ 269 static SENSOR_DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR, \ 270 show_in_max, set_in_max, offset); 271 272 show_in_offset(0); 273 show_in_offset(1); 274 show_in_offset(2); 275 show_in_offset(3); 276 show_in_offset(4); 277 278 /* Temperature */ 279 static ssize_t show_temp(struct device *dev, struct device_attribute *attr, char *buf) 280 { 281 struct sis5595_data *data = sis5595_update_device(dev); 282 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp)); 283 } 284 285 static ssize_t show_temp_over(struct device *dev, struct device_attribute *attr, char *buf) 286 { 287 struct sis5595_data *data = sis5595_update_device(dev); 288 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_over)); 289 } 290 291 static ssize_t set_temp_over(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) 292 { 293 struct sis5595_data *data = dev_get_drvdata(dev); 294 long val = simple_strtol(buf, NULL, 10); 295 296 mutex_lock(&data->update_lock); 297 data->temp_over = TEMP_TO_REG(val); 298 sis5595_write_value(data, SIS5595_REG_TEMP_OVER, data->temp_over); 299 mutex_unlock(&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 sis5595_data *data = sis5595_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 sis5595_data *data = dev_get_drvdata(dev); 312 long val = simple_strtol(buf, NULL, 10); 313 314 mutex_lock(&data->update_lock); 315 data->temp_hyst = TEMP_TO_REG(val); 316 sis5595_write_value(data, SIS5595_REG_TEMP_HYST, data->temp_hyst); 317 mutex_unlock(&data->update_lock); 318 return count; 319 } 320 321 static DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL); 322 static DEVICE_ATTR(temp1_max, S_IRUGO | S_IWUSR, 323 show_temp_over, set_temp_over); 324 static DEVICE_ATTR(temp1_max_hyst, S_IRUGO | S_IWUSR, 325 show_temp_hyst, set_temp_hyst); 326 327 /* 2 Fans */ 328 static ssize_t show_fan(struct device *dev, struct device_attribute *da, 329 char *buf) 330 { 331 struct sis5595_data *data = sis5595_update_device(dev); 332 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); 333 int nr = attr->index; 334 return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[nr], 335 DIV_FROM_REG(data->fan_div[nr])) ); 336 } 337 338 static ssize_t show_fan_min(struct device *dev, struct device_attribute *da, 339 char *buf) 340 { 341 struct sis5595_data *data = sis5595_update_device(dev); 342 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); 343 int nr = attr->index; 344 return sprintf(buf,"%d\n", FAN_FROM_REG(data->fan_min[nr], 345 DIV_FROM_REG(data->fan_div[nr])) ); 346 } 347 348 static ssize_t set_fan_min(struct device *dev, struct device_attribute *da, 349 const char *buf, size_t count) 350 { 351 struct sis5595_data *data = dev_get_drvdata(dev); 352 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); 353 int nr = attr->index; 354 unsigned long val = simple_strtoul(buf, NULL, 10); 355 356 mutex_lock(&data->update_lock); 357 data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr])); 358 sis5595_write_value(data, SIS5595_REG_FAN_MIN(nr), data->fan_min[nr]); 359 mutex_unlock(&data->update_lock); 360 return count; 361 } 362 363 static ssize_t show_fan_div(struct device *dev, struct device_attribute *da, 364 char *buf) 365 { 366 struct sis5595_data *data = sis5595_update_device(dev); 367 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); 368 int nr = attr->index; 369 return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[nr]) ); 370 } 371 372 /* Note: we save and restore the fan minimum here, because its value is 373 determined in part by the fan divisor. This follows the principle of 374 least surprise; the user doesn't expect the fan minimum to change just 375 because the divisor changed. */ 376 static ssize_t set_fan_div(struct device *dev, struct device_attribute *da, 377 const char *buf, size_t count) 378 { 379 struct sis5595_data *data = dev_get_drvdata(dev); 380 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); 381 int nr = attr->index; 382 unsigned long min; 383 unsigned long val = simple_strtoul(buf, NULL, 10); 384 int reg; 385 386 mutex_lock(&data->update_lock); 387 min = FAN_FROM_REG(data->fan_min[nr], 388 DIV_FROM_REG(data->fan_div[nr])); 389 reg = sis5595_read_value(data, SIS5595_REG_FANDIV); 390 391 switch (val) { 392 case 1: data->fan_div[nr] = 0; break; 393 case 2: data->fan_div[nr] = 1; break; 394 case 4: data->fan_div[nr] = 2; break; 395 case 8: data->fan_div[nr] = 3; break; 396 default: 397 dev_err(dev, "fan_div value %ld not " 398 "supported. Choose one of 1, 2, 4 or 8!\n", val); 399 mutex_unlock(&data->update_lock); 400 return -EINVAL; 401 } 402 403 switch (nr) { 404 case 0: 405 reg = (reg & 0xcf) | (data->fan_div[nr] << 4); 406 break; 407 case 1: 408 reg = (reg & 0x3f) | (data->fan_div[nr] << 6); 409 break; 410 } 411 sis5595_write_value(data, SIS5595_REG_FANDIV, reg); 412 data->fan_min[nr] = 413 FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr])); 414 sis5595_write_value(data, SIS5595_REG_FAN_MIN(nr), data->fan_min[nr]); 415 mutex_unlock(&data->update_lock); 416 return count; 417 } 418 419 #define show_fan_offset(offset) \ 420 static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO, \ 421 show_fan, NULL, offset - 1); \ 422 static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \ 423 show_fan_min, set_fan_min, offset - 1); \ 424 static SENSOR_DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR, \ 425 show_fan_div, set_fan_div, offset - 1); 426 427 show_fan_offset(1); 428 show_fan_offset(2); 429 430 /* Alarms */ 431 static ssize_t show_alarms(struct device *dev, struct device_attribute *attr, char *buf) 432 { 433 struct sis5595_data *data = sis5595_update_device(dev); 434 return sprintf(buf, "%d\n", data->alarms); 435 } 436 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL); 437 438 static ssize_t show_name(struct device *dev, struct device_attribute *attr, 439 char *buf) 440 { 441 struct sis5595_data *data = dev_get_drvdata(dev); 442 return sprintf(buf, "%s\n", data->name); 443 } 444 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL); 445 446 static struct attribute *sis5595_attributes[] = { 447 &sensor_dev_attr_in0_input.dev_attr.attr, 448 &sensor_dev_attr_in0_min.dev_attr.attr, 449 &sensor_dev_attr_in0_max.dev_attr.attr, 450 &sensor_dev_attr_in1_input.dev_attr.attr, 451 &sensor_dev_attr_in1_min.dev_attr.attr, 452 &sensor_dev_attr_in1_max.dev_attr.attr, 453 &sensor_dev_attr_in2_input.dev_attr.attr, 454 &sensor_dev_attr_in2_min.dev_attr.attr, 455 &sensor_dev_attr_in2_max.dev_attr.attr, 456 &sensor_dev_attr_in3_input.dev_attr.attr, 457 &sensor_dev_attr_in3_min.dev_attr.attr, 458 &sensor_dev_attr_in3_max.dev_attr.attr, 459 460 &sensor_dev_attr_fan1_input.dev_attr.attr, 461 &sensor_dev_attr_fan1_min.dev_attr.attr, 462 &sensor_dev_attr_fan1_div.dev_attr.attr, 463 &sensor_dev_attr_fan2_input.dev_attr.attr, 464 &sensor_dev_attr_fan2_min.dev_attr.attr, 465 &sensor_dev_attr_fan2_div.dev_attr.attr, 466 467 &dev_attr_alarms.attr, 468 &dev_attr_name.attr, 469 NULL 470 }; 471 472 static const struct attribute_group sis5595_group = { 473 .attrs = sis5595_attributes, 474 }; 475 476 static struct attribute *sis5595_attributes_opt[] = { 477 &sensor_dev_attr_in4_input.dev_attr.attr, 478 &sensor_dev_attr_in4_min.dev_attr.attr, 479 &sensor_dev_attr_in4_max.dev_attr.attr, 480 481 &dev_attr_temp1_input.attr, 482 &dev_attr_temp1_max.attr, 483 &dev_attr_temp1_max_hyst.attr, 484 NULL 485 }; 486 487 static const struct attribute_group sis5595_group_opt = { 488 .attrs = sis5595_attributes_opt, 489 }; 490 491 /* This is called when the module is loaded */ 492 static int __devinit sis5595_probe(struct platform_device *pdev) 493 { 494 int err = 0; 495 int i; 496 struct sis5595_data *data; 497 struct resource *res; 498 char val; 499 500 /* Reserve the ISA region */ 501 res = platform_get_resource(pdev, IORESOURCE_IO, 0); 502 if (!request_region(res->start, SIS5595_EXTENT, 503 sis5595_driver.driver.name)) { 504 err = -EBUSY; 505 goto exit; 506 } 507 508 if (!(data = kzalloc(sizeof(struct sis5595_data), GFP_KERNEL))) { 509 err = -ENOMEM; 510 goto exit_release; 511 } 512 513 mutex_init(&data->lock); 514 mutex_init(&data->update_lock); 515 data->addr = res->start; 516 data->name = "sis5595"; 517 platform_set_drvdata(pdev, data); 518 519 /* Check revision and pin registers to determine whether 4 or 5 voltages */ 520 data->revision = s_bridge->revision; 521 /* 4 voltages, 1 temp */ 522 data->maxins = 3; 523 if (data->revision >= REV2MIN) { 524 pci_read_config_byte(s_bridge, SIS5595_PIN_REG, &val); 525 if (!(val & 0x80)) 526 /* 5 voltages, no temps */ 527 data->maxins = 4; 528 } 529 530 /* Initialize the SIS5595 chip */ 531 sis5595_init_device(data); 532 533 /* A few vars need to be filled upon startup */ 534 for (i = 0; i < 2; i++) { 535 data->fan_min[i] = sis5595_read_value(data, 536 SIS5595_REG_FAN_MIN(i)); 537 } 538 539 /* Register sysfs hooks */ 540 if ((err = sysfs_create_group(&pdev->dev.kobj, &sis5595_group))) 541 goto exit_free; 542 if (data->maxins == 4) { 543 if ((err = device_create_file(&pdev->dev, 544 &sensor_dev_attr_in4_input.dev_attr)) 545 || (err = device_create_file(&pdev->dev, 546 &sensor_dev_attr_in4_min.dev_attr)) 547 || (err = device_create_file(&pdev->dev, 548 &sensor_dev_attr_in4_max.dev_attr))) 549 goto exit_remove_files; 550 } else { 551 if ((err = device_create_file(&pdev->dev, 552 &dev_attr_temp1_input)) 553 || (err = device_create_file(&pdev->dev, 554 &dev_attr_temp1_max)) 555 || (err = device_create_file(&pdev->dev, 556 &dev_attr_temp1_max_hyst))) 557 goto exit_remove_files; 558 } 559 560 data->hwmon_dev = hwmon_device_register(&pdev->dev); 561 if (IS_ERR(data->hwmon_dev)) { 562 err = PTR_ERR(data->hwmon_dev); 563 goto exit_remove_files; 564 } 565 566 return 0; 567 568 exit_remove_files: 569 sysfs_remove_group(&pdev->dev.kobj, &sis5595_group); 570 sysfs_remove_group(&pdev->dev.kobj, &sis5595_group_opt); 571 exit_free: 572 kfree(data); 573 exit_release: 574 release_region(res->start, SIS5595_EXTENT); 575 exit: 576 return err; 577 } 578 579 static int __devexit sis5595_remove(struct platform_device *pdev) 580 { 581 struct sis5595_data *data = platform_get_drvdata(pdev); 582 583 hwmon_device_unregister(data->hwmon_dev); 584 sysfs_remove_group(&pdev->dev.kobj, &sis5595_group); 585 sysfs_remove_group(&pdev->dev.kobj, &sis5595_group_opt); 586 587 release_region(data->addr, SIS5595_EXTENT); 588 platform_set_drvdata(pdev, NULL); 589 kfree(data); 590 591 return 0; 592 } 593 594 595 /* ISA access must be locked explicitly. */ 596 static int sis5595_read_value(struct sis5595_data *data, u8 reg) 597 { 598 int res; 599 600 mutex_lock(&data->lock); 601 outb_p(reg, data->addr + SIS5595_ADDR_REG_OFFSET); 602 res = inb_p(data->addr + SIS5595_DATA_REG_OFFSET); 603 mutex_unlock(&data->lock); 604 return res; 605 } 606 607 static void sis5595_write_value(struct sis5595_data *data, u8 reg, u8 value) 608 { 609 mutex_lock(&data->lock); 610 outb_p(reg, data->addr + SIS5595_ADDR_REG_OFFSET); 611 outb_p(value, data->addr + SIS5595_DATA_REG_OFFSET); 612 mutex_unlock(&data->lock); 613 } 614 615 /* Called when we have found a new SIS5595. */ 616 static void __devinit sis5595_init_device(struct sis5595_data *data) 617 { 618 u8 config = sis5595_read_value(data, SIS5595_REG_CONFIG); 619 if (!(config & 0x01)) 620 sis5595_write_value(data, SIS5595_REG_CONFIG, 621 (config & 0xf7) | 0x01); 622 } 623 624 static struct sis5595_data *sis5595_update_device(struct device *dev) 625 { 626 struct sis5595_data *data = dev_get_drvdata(dev); 627 int i; 628 629 mutex_lock(&data->update_lock); 630 631 if (time_after(jiffies, data->last_updated + HZ + HZ / 2) 632 || !data->valid) { 633 634 for (i = 0; i <= data->maxins; i++) { 635 data->in[i] = 636 sis5595_read_value(data, SIS5595_REG_IN(i)); 637 data->in_min[i] = 638 sis5595_read_value(data, 639 SIS5595_REG_IN_MIN(i)); 640 data->in_max[i] = 641 sis5595_read_value(data, 642 SIS5595_REG_IN_MAX(i)); 643 } 644 for (i = 0; i < 2; i++) { 645 data->fan[i] = 646 sis5595_read_value(data, SIS5595_REG_FAN(i)); 647 data->fan_min[i] = 648 sis5595_read_value(data, 649 SIS5595_REG_FAN_MIN(i)); 650 } 651 if (data->maxins == 3) { 652 data->temp = 653 sis5595_read_value(data, SIS5595_REG_TEMP); 654 data->temp_over = 655 sis5595_read_value(data, SIS5595_REG_TEMP_OVER); 656 data->temp_hyst = 657 sis5595_read_value(data, SIS5595_REG_TEMP_HYST); 658 } 659 i = sis5595_read_value(data, SIS5595_REG_FANDIV); 660 data->fan_div[0] = (i >> 4) & 0x03; 661 data->fan_div[1] = i >> 6; 662 data->alarms = 663 sis5595_read_value(data, SIS5595_REG_ALARM1) | 664 (sis5595_read_value(data, SIS5595_REG_ALARM2) << 8); 665 data->last_updated = jiffies; 666 data->valid = 1; 667 } 668 669 mutex_unlock(&data->update_lock); 670 671 return data; 672 } 673 674 static struct pci_device_id sis5595_pci_ids[] = { 675 { PCI_DEVICE(PCI_VENDOR_ID_SI, PCI_DEVICE_ID_SI_503) }, 676 { 0, } 677 }; 678 679 MODULE_DEVICE_TABLE(pci, sis5595_pci_ids); 680 681 static int blacklist[] __devinitdata = { 682 PCI_DEVICE_ID_SI_540, 683 PCI_DEVICE_ID_SI_550, 684 PCI_DEVICE_ID_SI_630, 685 PCI_DEVICE_ID_SI_645, 686 PCI_DEVICE_ID_SI_730, 687 PCI_DEVICE_ID_SI_735, 688 PCI_DEVICE_ID_SI_5511, /* 5513 chip has the 0008 device but 689 that ID shows up in other chips so we 690 use the 5511 ID for recognition */ 691 PCI_DEVICE_ID_SI_5597, 692 PCI_DEVICE_ID_SI_5598, 693 0 }; 694 695 static int __devinit sis5595_device_add(unsigned short address) 696 { 697 struct resource res = { 698 .start = address, 699 .end = address + SIS5595_EXTENT - 1, 700 .name = "sis5595", 701 .flags = IORESOURCE_IO, 702 }; 703 int err; 704 705 pdev = platform_device_alloc("sis5595", address); 706 if (!pdev) { 707 err = -ENOMEM; 708 printk(KERN_ERR "sis5595: Device allocation failed\n"); 709 goto exit; 710 } 711 712 err = platform_device_add_resources(pdev, &res, 1); 713 if (err) { 714 printk(KERN_ERR "sis5595: Device resource addition failed " 715 "(%d)\n", err); 716 goto exit_device_put; 717 } 718 719 err = platform_device_add(pdev); 720 if (err) { 721 printk(KERN_ERR "sis5595: Device addition failed (%d)\n", 722 err); 723 goto exit_device_put; 724 } 725 726 return 0; 727 728 exit_device_put: 729 platform_device_put(pdev); 730 exit: 731 return err; 732 } 733 734 static int __devinit sis5595_pci_probe(struct pci_dev *dev, 735 const struct pci_device_id *id) 736 { 737 u16 address; 738 u8 enable; 739 int *i; 740 741 for (i = blacklist; *i != 0; i++) { 742 struct pci_dev *d; 743 if ((d = pci_get_device(PCI_VENDOR_ID_SI, *i, NULL))) { 744 dev_err(&d->dev, "Looked for SIS5595 but found unsupported device %.4x\n", *i); 745 pci_dev_put(d); 746 return -ENODEV; 747 } 748 } 749 750 force_addr &= ~(SIS5595_EXTENT - 1); 751 if (force_addr) { 752 dev_warn(&dev->dev, "Forcing ISA address 0x%x\n", force_addr); 753 pci_write_config_word(dev, SIS5595_BASE_REG, force_addr); 754 } 755 756 if (PCIBIOS_SUCCESSFUL != 757 pci_read_config_word(dev, SIS5595_BASE_REG, &address)) { 758 dev_err(&dev->dev, "Failed to read ISA address\n"); 759 return -ENODEV; 760 } 761 762 address &= ~(SIS5595_EXTENT - 1); 763 if (!address) { 764 dev_err(&dev->dev, "Base address not set - upgrade BIOS or use force_addr=0xaddr\n"); 765 return -ENODEV; 766 } 767 if (force_addr && address != force_addr) { 768 /* doesn't work for some chips? */ 769 dev_err(&dev->dev, "Failed to force ISA address\n"); 770 return -ENODEV; 771 } 772 773 if (PCIBIOS_SUCCESSFUL != 774 pci_read_config_byte(dev, SIS5595_ENABLE_REG, &enable)) { 775 dev_err(&dev->dev, "Failed to read enable register\n"); 776 return -ENODEV; 777 } 778 if (!(enable & 0x80)) { 779 if ((PCIBIOS_SUCCESSFUL != 780 pci_write_config_byte(dev, SIS5595_ENABLE_REG, 781 enable | 0x80)) 782 || (PCIBIOS_SUCCESSFUL != 783 pci_read_config_byte(dev, SIS5595_ENABLE_REG, &enable)) 784 || (!(enable & 0x80))) { 785 /* doesn't work for some chips! */ 786 dev_err(&dev->dev, "Failed to enable HWM device\n"); 787 return -ENODEV; 788 } 789 } 790 791 if (platform_driver_register(&sis5595_driver)) { 792 dev_dbg(&dev->dev, "Failed to register sis5595 driver\n"); 793 goto exit; 794 } 795 796 s_bridge = pci_dev_get(dev); 797 /* Sets global pdev as a side effect */ 798 if (sis5595_device_add(address)) 799 goto exit_unregister; 800 801 /* Always return failure here. This is to allow other drivers to bind 802 * to this pci device. We don't really want to have control over the 803 * pci device, we only wanted to read as few register values from it. 804 */ 805 return -ENODEV; 806 807 exit_unregister: 808 pci_dev_put(dev); 809 platform_driver_unregister(&sis5595_driver); 810 exit: 811 return -ENODEV; 812 } 813 814 static struct pci_driver sis5595_pci_driver = { 815 .name = "sis5595", 816 .id_table = sis5595_pci_ids, 817 .probe = sis5595_pci_probe, 818 }; 819 820 static int __init sm_sis5595_init(void) 821 { 822 return pci_register_driver(&sis5595_pci_driver); 823 } 824 825 static void __exit sm_sis5595_exit(void) 826 { 827 pci_unregister_driver(&sis5595_pci_driver); 828 if (s_bridge != NULL) { 829 platform_device_unregister(pdev); 830 platform_driver_unregister(&sis5595_driver); 831 pci_dev_put(s_bridge); 832 s_bridge = NULL; 833 } 834 } 835 836 MODULE_AUTHOR("Aurelien Jarno <aurelien@aurel32.net>"); 837 MODULE_DESCRIPTION("SiS 5595 Sensor device"); 838 MODULE_LICENSE("GPL"); 839 840 module_init(sm_sis5595_init); 841 module_exit(sm_sis5595_exit); 842