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