1 /* 2 smsc47m1.c - Part of lm_sensors, Linux kernel modules 3 for hardware monitoring 4 5 Supports the SMSC LPC47B27x, LPC47M10x, LPC47M112, LPC47M13x, 6 LPC47M14x, LPC47M15x, LPC47M192, LPC47M292 and LPC47M997 7 Super-I/O chips. 8 9 Copyright (C) 2002 Mark D. Studebaker <mdsxyz123@yahoo.com> 10 Copyright (C) 2004-2007 Jean Delvare <khali@linux-fr.org> 11 Ported to Linux 2.6 by Gabriele Gorla <gorlik@yahoo.com> 12 and Jean Delvare 13 14 This program is free software; you can redistribute it and/or modify 15 it under the terms of the GNU General Public License as published by 16 the Free Software Foundation; either version 2 of the License, or 17 (at your option) any later version. 18 19 This program is distributed in the hope that it will be useful, 20 but WITHOUT ANY WARRANTY; without even the implied warranty of 21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 22 GNU General Public License for more details. 23 24 You should have received a copy of the GNU General Public License 25 along with this program; if not, write to the Free Software 26 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 27 */ 28 29 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 30 31 #include <linux/module.h> 32 #include <linux/slab.h> 33 #include <linux/ioport.h> 34 #include <linux/jiffies.h> 35 #include <linux/platform_device.h> 36 #include <linux/hwmon.h> 37 #include <linux/hwmon-sysfs.h> 38 #include <linux/err.h> 39 #include <linux/init.h> 40 #include <linux/mutex.h> 41 #include <linux/sysfs.h> 42 #include <linux/acpi.h> 43 #include <linux/io.h> 44 45 static unsigned short force_id; 46 module_param(force_id, ushort, 0); 47 MODULE_PARM_DESC(force_id, "Override the detected device ID"); 48 49 static struct platform_device *pdev; 50 51 #define DRVNAME "smsc47m1" 52 enum chips { smsc47m1, smsc47m2 }; 53 54 /* Super-I/0 registers and commands */ 55 56 #define REG 0x2e /* The register to read/write */ 57 #define VAL 0x2f /* The value to read/write */ 58 59 static inline void 60 superio_outb(int reg, int val) 61 { 62 outb(reg, REG); 63 outb(val, VAL); 64 } 65 66 static inline int 67 superio_inb(int reg) 68 { 69 outb(reg, REG); 70 return inb(VAL); 71 } 72 73 /* logical device for fans is 0x0A */ 74 #define superio_select() superio_outb(0x07, 0x0A) 75 76 static inline void 77 superio_enter(void) 78 { 79 outb(0x55, REG); 80 } 81 82 static inline void 83 superio_exit(void) 84 { 85 outb(0xAA, REG); 86 } 87 88 #define SUPERIO_REG_ACT 0x30 89 #define SUPERIO_REG_BASE 0x60 90 #define SUPERIO_REG_DEVID 0x20 91 #define SUPERIO_REG_DEVREV 0x21 92 93 /* Logical device registers */ 94 95 #define SMSC_EXTENT 0x80 96 97 /* nr is 0 or 1 in the macros below */ 98 #define SMSC47M1_REG_ALARM 0x04 99 #define SMSC47M1_REG_TPIN(nr) (0x34 - (nr)) 100 #define SMSC47M1_REG_PPIN(nr) (0x36 - (nr)) 101 #define SMSC47M1_REG_FANDIV 0x58 102 103 static const u8 SMSC47M1_REG_FAN[3] = { 0x59, 0x5a, 0x6b }; 104 static const u8 SMSC47M1_REG_FAN_PRELOAD[3] = { 0x5b, 0x5c, 0x6c }; 105 static const u8 SMSC47M1_REG_PWM[3] = { 0x56, 0x57, 0x69 }; 106 107 #define SMSC47M2_REG_ALARM6 0x09 108 #define SMSC47M2_REG_TPIN1 0x38 109 #define SMSC47M2_REG_TPIN2 0x37 110 #define SMSC47M2_REG_TPIN3 0x2d 111 #define SMSC47M2_REG_PPIN3 0x2c 112 #define SMSC47M2_REG_FANDIV3 0x6a 113 114 #define MIN_FROM_REG(reg,div) ((reg)>=192 ? 0 : \ 115 983040/((192-(reg))*(div))) 116 #define FAN_FROM_REG(reg,div,preload) ((reg)<=(preload) || (reg)==255 ? 0 : \ 117 983040/(((reg)-(preload))*(div))) 118 #define DIV_FROM_REG(reg) (1 << (reg)) 119 #define PWM_FROM_REG(reg) (((reg) & 0x7E) << 1) 120 #define PWM_EN_FROM_REG(reg) ((~(reg)) & 0x01) 121 #define PWM_TO_REG(reg) (((reg) >> 1) & 0x7E) 122 123 struct smsc47m1_data { 124 unsigned short addr; 125 const char *name; 126 enum chips type; 127 struct device *hwmon_dev; 128 129 struct mutex update_lock; 130 unsigned long last_updated; /* In jiffies */ 131 132 u8 fan[3]; /* Register value */ 133 u8 fan_preload[3]; /* Register value */ 134 u8 fan_div[3]; /* Register encoding, shifted right */ 135 u8 alarms; /* Register encoding */ 136 u8 pwm[3]; /* Register value (bit 0 is disable) */ 137 }; 138 139 struct smsc47m1_sio_data { 140 enum chips type; 141 u8 activate; /* Remember initial device state */ 142 }; 143 144 145 static int __exit smsc47m1_remove(struct platform_device *pdev); 146 static struct smsc47m1_data *smsc47m1_update_device(struct device *dev, 147 int init); 148 149 static inline int smsc47m1_read_value(struct smsc47m1_data *data, u8 reg) 150 { 151 return inb_p(data->addr + reg); 152 } 153 154 static inline void smsc47m1_write_value(struct smsc47m1_data *data, u8 reg, 155 u8 value) 156 { 157 outb_p(value, data->addr + reg); 158 } 159 160 static struct platform_driver smsc47m1_driver = { 161 .driver = { 162 .owner = THIS_MODULE, 163 .name = DRVNAME, 164 }, 165 .remove = __exit_p(smsc47m1_remove), 166 }; 167 168 static ssize_t get_fan(struct device *dev, struct device_attribute 169 *devattr, char *buf) 170 { 171 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 172 struct smsc47m1_data *data = smsc47m1_update_device(dev, 0); 173 int nr = attr->index; 174 /* This chip (stupidly) stops monitoring fan speed if PWM is 175 enabled and duty cycle is 0%. This is fine if the monitoring 176 and control concern the same fan, but troublesome if they are 177 not (which could as well happen). */ 178 int rpm = (data->pwm[nr] & 0x7F) == 0x00 ? 0 : 179 FAN_FROM_REG(data->fan[nr], 180 DIV_FROM_REG(data->fan_div[nr]), 181 data->fan_preload[nr]); 182 return sprintf(buf, "%d\n", rpm); 183 } 184 185 static ssize_t get_fan_min(struct device *dev, struct device_attribute 186 *devattr, char *buf) 187 { 188 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 189 struct smsc47m1_data *data = smsc47m1_update_device(dev, 0); 190 int nr = attr->index; 191 int rpm = MIN_FROM_REG(data->fan_preload[nr], 192 DIV_FROM_REG(data->fan_div[nr])); 193 return sprintf(buf, "%d\n", rpm); 194 } 195 196 static ssize_t get_fan_div(struct device *dev, struct device_attribute 197 *devattr, char *buf) 198 { 199 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 200 struct smsc47m1_data *data = smsc47m1_update_device(dev, 0); 201 return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[attr->index])); 202 } 203 204 static ssize_t get_fan_alarm(struct device *dev, struct device_attribute 205 *devattr, char *buf) 206 { 207 int bitnr = to_sensor_dev_attr(devattr)->index; 208 struct smsc47m1_data *data = smsc47m1_update_device(dev, 0); 209 return sprintf(buf, "%u\n", (data->alarms >> bitnr) & 1); 210 } 211 212 static ssize_t get_pwm(struct device *dev, struct device_attribute 213 *devattr, char *buf) 214 { 215 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 216 struct smsc47m1_data *data = smsc47m1_update_device(dev, 0); 217 return sprintf(buf, "%d\n", PWM_FROM_REG(data->pwm[attr->index])); 218 } 219 220 static ssize_t get_pwm_en(struct device *dev, struct device_attribute 221 *devattr, char *buf) 222 { 223 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 224 struct smsc47m1_data *data = smsc47m1_update_device(dev, 0); 225 return sprintf(buf, "%d\n", PWM_EN_FROM_REG(data->pwm[attr->index])); 226 } 227 228 static ssize_t get_alarms(struct device *dev, struct device_attribute 229 *devattr, char *buf) 230 { 231 struct smsc47m1_data *data = smsc47m1_update_device(dev, 0); 232 return sprintf(buf, "%d\n", data->alarms); 233 } 234 235 static ssize_t set_fan_min(struct device *dev, struct device_attribute 236 *devattr, const char *buf, size_t count) 237 { 238 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 239 struct smsc47m1_data *data = dev_get_drvdata(dev); 240 int nr = attr->index; 241 long rpmdiv, val = simple_strtol(buf, NULL, 10); 242 243 mutex_lock(&data->update_lock); 244 rpmdiv = val * DIV_FROM_REG(data->fan_div[nr]); 245 246 if (983040 > 192 * rpmdiv || 2 * rpmdiv > 983040) { 247 mutex_unlock(&data->update_lock); 248 return -EINVAL; 249 } 250 251 data->fan_preload[nr] = 192 - ((983040 + rpmdiv / 2) / rpmdiv); 252 smsc47m1_write_value(data, SMSC47M1_REG_FAN_PRELOAD[nr], 253 data->fan_preload[nr]); 254 mutex_unlock(&data->update_lock); 255 256 return count; 257 } 258 259 /* Note: we save and restore the fan minimum here, because its value is 260 determined in part by the fan clock divider. This follows the principle 261 of least surprise; the user doesn't expect the fan minimum to change just 262 because the divider changed. */ 263 static ssize_t set_fan_div(struct device *dev, struct device_attribute 264 *devattr, const char *buf, size_t count) 265 { 266 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 267 struct smsc47m1_data *data = dev_get_drvdata(dev); 268 int nr = attr->index; 269 long new_div = simple_strtol(buf, NULL, 10), tmp; 270 u8 old_div = DIV_FROM_REG(data->fan_div[nr]); 271 272 if (new_div == old_div) /* No change */ 273 return count; 274 275 mutex_lock(&data->update_lock); 276 switch (new_div) { 277 case 1: data->fan_div[nr] = 0; break; 278 case 2: data->fan_div[nr] = 1; break; 279 case 4: data->fan_div[nr] = 2; break; 280 case 8: data->fan_div[nr] = 3; break; 281 default: 282 mutex_unlock(&data->update_lock); 283 return -EINVAL; 284 } 285 286 switch (nr) { 287 case 0: 288 case 1: 289 tmp = smsc47m1_read_value(data, SMSC47M1_REG_FANDIV) 290 & ~(0x03 << (4 + 2 * nr)); 291 tmp |= data->fan_div[nr] << (4 + 2 * nr); 292 smsc47m1_write_value(data, SMSC47M1_REG_FANDIV, tmp); 293 break; 294 case 2: 295 tmp = smsc47m1_read_value(data, SMSC47M2_REG_FANDIV3) & 0xCF; 296 tmp |= data->fan_div[2] << 4; 297 smsc47m1_write_value(data, SMSC47M2_REG_FANDIV3, tmp); 298 break; 299 } 300 301 /* Preserve fan min */ 302 tmp = 192 - (old_div * (192 - data->fan_preload[nr]) 303 + new_div / 2) / new_div; 304 data->fan_preload[nr] = SENSORS_LIMIT(tmp, 0, 191); 305 smsc47m1_write_value(data, SMSC47M1_REG_FAN_PRELOAD[nr], 306 data->fan_preload[nr]); 307 mutex_unlock(&data->update_lock); 308 309 return count; 310 } 311 312 static ssize_t set_pwm(struct device *dev, struct device_attribute 313 *devattr, const char *buf, size_t count) 314 { 315 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 316 struct smsc47m1_data *data = dev_get_drvdata(dev); 317 int nr = attr->index; 318 long val = simple_strtol(buf, NULL, 10); 319 320 if (val < 0 || val > 255) 321 return -EINVAL; 322 323 mutex_lock(&data->update_lock); 324 data->pwm[nr] &= 0x81; /* Preserve additional bits */ 325 data->pwm[nr] |= PWM_TO_REG(val); 326 smsc47m1_write_value(data, SMSC47M1_REG_PWM[nr], 327 data->pwm[nr]); 328 mutex_unlock(&data->update_lock); 329 330 return count; 331 } 332 333 static ssize_t set_pwm_en(struct device *dev, struct device_attribute 334 *devattr, const char *buf, size_t count) 335 { 336 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 337 struct smsc47m1_data *data = dev_get_drvdata(dev); 338 int nr = attr->index; 339 long val = simple_strtol(buf, NULL, 10); 340 341 if (val != 0 && val != 1) 342 return -EINVAL; 343 344 mutex_lock(&data->update_lock); 345 data->pwm[nr] &= 0xFE; /* preserve the other bits */ 346 data->pwm[nr] |= !val; 347 smsc47m1_write_value(data, SMSC47M1_REG_PWM[nr], 348 data->pwm[nr]); 349 mutex_unlock(&data->update_lock); 350 351 return count; 352 } 353 354 #define fan_present(offset) \ 355 static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO, get_fan, \ 356 NULL, offset - 1); \ 357 static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \ 358 get_fan_min, set_fan_min, offset - 1); \ 359 static SENSOR_DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR, \ 360 get_fan_div, set_fan_div, offset - 1); \ 361 static SENSOR_DEVICE_ATTR(fan##offset##_alarm, S_IRUGO, get_fan_alarm, \ 362 NULL, offset - 1); \ 363 static SENSOR_DEVICE_ATTR(pwm##offset, S_IRUGO | S_IWUSR, \ 364 get_pwm, set_pwm, offset - 1); \ 365 static SENSOR_DEVICE_ATTR(pwm##offset##_enable, S_IRUGO | S_IWUSR, \ 366 get_pwm_en, set_pwm_en, offset - 1) 367 368 fan_present(1); 369 fan_present(2); 370 fan_present(3); 371 372 static DEVICE_ATTR(alarms, S_IRUGO, get_alarms, NULL); 373 374 static ssize_t show_name(struct device *dev, struct device_attribute 375 *devattr, char *buf) 376 { 377 struct smsc47m1_data *data = dev_get_drvdata(dev); 378 379 return sprintf(buf, "%s\n", data->name); 380 } 381 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL); 382 383 /* Almost all sysfs files may or may not be created depending on the chip 384 setup so we create them individually. It is still convenient to define a 385 group to remove them all at once. */ 386 static struct attribute *smsc47m1_attributes[] = { 387 &sensor_dev_attr_fan1_input.dev_attr.attr, 388 &sensor_dev_attr_fan1_min.dev_attr.attr, 389 &sensor_dev_attr_fan1_div.dev_attr.attr, 390 &sensor_dev_attr_fan1_alarm.dev_attr.attr, 391 &sensor_dev_attr_fan2_input.dev_attr.attr, 392 &sensor_dev_attr_fan2_min.dev_attr.attr, 393 &sensor_dev_attr_fan2_div.dev_attr.attr, 394 &sensor_dev_attr_fan2_alarm.dev_attr.attr, 395 &sensor_dev_attr_fan3_input.dev_attr.attr, 396 &sensor_dev_attr_fan3_min.dev_attr.attr, 397 &sensor_dev_attr_fan3_div.dev_attr.attr, 398 &sensor_dev_attr_fan3_alarm.dev_attr.attr, 399 400 &sensor_dev_attr_pwm1.dev_attr.attr, 401 &sensor_dev_attr_pwm1_enable.dev_attr.attr, 402 &sensor_dev_attr_pwm2.dev_attr.attr, 403 &sensor_dev_attr_pwm2_enable.dev_attr.attr, 404 &sensor_dev_attr_pwm3.dev_attr.attr, 405 &sensor_dev_attr_pwm3_enable.dev_attr.attr, 406 407 &dev_attr_alarms.attr, 408 &dev_attr_name.attr, 409 NULL 410 }; 411 412 static const struct attribute_group smsc47m1_group = { 413 .attrs = smsc47m1_attributes, 414 }; 415 416 static int __init smsc47m1_find(unsigned short *addr, 417 struct smsc47m1_sio_data *sio_data) 418 { 419 u8 val; 420 421 superio_enter(); 422 val = force_id ? force_id : superio_inb(SUPERIO_REG_DEVID); 423 424 /* 425 * SMSC LPC47M10x/LPC47M112/LPC47M13x (device id 0x59), LPC47M14x 426 * (device id 0x5F) and LPC47B27x (device id 0x51) have fan control. 427 * The LPC47M15x and LPC47M192 chips "with hardware monitoring block" 428 * can do much more besides (device id 0x60). 429 * The LPC47M997 is undocumented, but seems to be compatible with 430 * the LPC47M192, and has the same device id. 431 * The LPC47M292 (device id 0x6B) is somewhat compatible, but it 432 * supports a 3rd fan, and the pin configuration registers are 433 * unfortunately different. 434 * The LPC47M233 has the same device id (0x6B) but is not compatible. 435 * We check the high bit of the device revision register to 436 * differentiate them. 437 */ 438 switch (val) { 439 case 0x51: 440 pr_info("Found SMSC LPC47B27x\n"); 441 sio_data->type = smsc47m1; 442 break; 443 case 0x59: 444 pr_info("Found SMSC LPC47M10x/LPC47M112/LPC47M13x\n"); 445 sio_data->type = smsc47m1; 446 break; 447 case 0x5F: 448 pr_info("Found SMSC LPC47M14x\n"); 449 sio_data->type = smsc47m1; 450 break; 451 case 0x60: 452 pr_info("Found SMSC LPC47M15x/LPC47M192/LPC47M997\n"); 453 sio_data->type = smsc47m1; 454 break; 455 case 0x6B: 456 if (superio_inb(SUPERIO_REG_DEVREV) & 0x80) { 457 pr_debug("Found SMSC LPC47M233, unsupported\n"); 458 superio_exit(); 459 return -ENODEV; 460 } 461 462 pr_info("Found SMSC LPC47M292\n"); 463 sio_data->type = smsc47m2; 464 break; 465 default: 466 superio_exit(); 467 return -ENODEV; 468 } 469 470 superio_select(); 471 *addr = (superio_inb(SUPERIO_REG_BASE) << 8) 472 | superio_inb(SUPERIO_REG_BASE + 1); 473 if (*addr == 0) { 474 pr_info("Device address not set, will not use\n"); 475 superio_exit(); 476 return -ENODEV; 477 } 478 479 /* Enable only if address is set (needed at least on the 480 * Compaq Presario S4000NX) */ 481 sio_data->activate = superio_inb(SUPERIO_REG_ACT); 482 if ((sio_data->activate & 0x01) == 0) { 483 pr_info("Enabling device\n"); 484 superio_outb(SUPERIO_REG_ACT, sio_data->activate | 0x01); 485 } 486 487 superio_exit(); 488 return 0; 489 } 490 491 /* Restore device to its initial state */ 492 static void smsc47m1_restore(const struct smsc47m1_sio_data *sio_data) 493 { 494 if ((sio_data->activate & 0x01) == 0) { 495 superio_enter(); 496 superio_select(); 497 498 pr_info("Disabling device\n"); 499 superio_outb(SUPERIO_REG_ACT, sio_data->activate); 500 501 superio_exit(); 502 } 503 } 504 505 #define CHECK 1 506 #define REQUEST 2 507 #define RELEASE 3 508 509 /* 510 * This function can be used to: 511 * - test for resource conflicts with ACPI 512 * - request the resources 513 * - release the resources 514 * We only allocate the I/O ports we really need, to minimize the risk of 515 * conflicts with ACPI or with other drivers. 516 */ 517 static int smsc47m1_handle_resources(unsigned short address, enum chips type, 518 int action, struct device *dev) 519 { 520 static const u8 ports_m1[] = { 521 /* register, region length */ 522 0x04, 1, 523 0x33, 4, 524 0x56, 7, 525 }; 526 527 static const u8 ports_m2[] = { 528 /* register, region length */ 529 0x04, 1, 530 0x09, 1, 531 0x2c, 2, 532 0x35, 4, 533 0x56, 7, 534 0x69, 4, 535 }; 536 537 int i, ports_size, err; 538 const u8 *ports; 539 540 switch (type) { 541 case smsc47m1: 542 default: 543 ports = ports_m1; 544 ports_size = ARRAY_SIZE(ports_m1); 545 break; 546 case smsc47m2: 547 ports = ports_m2; 548 ports_size = ARRAY_SIZE(ports_m2); 549 break; 550 } 551 552 for (i = 0; i + 1 < ports_size; i += 2) { 553 unsigned short start = address + ports[i]; 554 unsigned short len = ports[i + 1]; 555 556 switch (action) { 557 case CHECK: 558 /* Only check for conflicts */ 559 err = acpi_check_region(start, len, DRVNAME); 560 if (err) 561 return err; 562 break; 563 case REQUEST: 564 /* Request the resources */ 565 if (!request_region(start, len, DRVNAME)) { 566 dev_err(dev, "Region 0x%hx-0x%hx already in " 567 "use!\n", start, start + len); 568 569 /* Undo all requests */ 570 for (i -= 2; i >= 0; i -= 2) 571 release_region(address + ports[i], 572 ports[i + 1]); 573 return -EBUSY; 574 } 575 break; 576 case RELEASE: 577 /* Release the resources */ 578 release_region(start, len); 579 break; 580 } 581 } 582 583 return 0; 584 } 585 586 static int __init smsc47m1_probe(struct platform_device *pdev) 587 { 588 struct device *dev = &pdev->dev; 589 struct smsc47m1_sio_data *sio_data = dev->platform_data; 590 struct smsc47m1_data *data; 591 struct resource *res; 592 int err; 593 int fan1, fan2, fan3, pwm1, pwm2, pwm3; 594 595 static const char *names[] = { 596 "smsc47m1", 597 "smsc47m2", 598 }; 599 600 res = platform_get_resource(pdev, IORESOURCE_IO, 0); 601 err = smsc47m1_handle_resources(res->start, sio_data->type, 602 REQUEST, dev); 603 if (err < 0) 604 return err; 605 606 if (!(data = kzalloc(sizeof(struct smsc47m1_data), GFP_KERNEL))) { 607 err = -ENOMEM; 608 goto error_release; 609 } 610 611 data->addr = res->start; 612 data->type = sio_data->type; 613 data->name = names[sio_data->type]; 614 mutex_init(&data->update_lock); 615 platform_set_drvdata(pdev, data); 616 617 /* If no function is properly configured, there's no point in 618 actually registering the chip. */ 619 pwm1 = (smsc47m1_read_value(data, SMSC47M1_REG_PPIN(0)) & 0x05) 620 == 0x04; 621 pwm2 = (smsc47m1_read_value(data, SMSC47M1_REG_PPIN(1)) & 0x05) 622 == 0x04; 623 if (data->type == smsc47m2) { 624 fan1 = (smsc47m1_read_value(data, SMSC47M2_REG_TPIN1) 625 & 0x0d) == 0x09; 626 fan2 = (smsc47m1_read_value(data, SMSC47M2_REG_TPIN2) 627 & 0x0d) == 0x09; 628 fan3 = (smsc47m1_read_value(data, SMSC47M2_REG_TPIN3) 629 & 0x0d) == 0x0d; 630 pwm3 = (smsc47m1_read_value(data, SMSC47M2_REG_PPIN3) 631 & 0x0d) == 0x08; 632 } else { 633 fan1 = (smsc47m1_read_value(data, SMSC47M1_REG_TPIN(0)) 634 & 0x05) == 0x05; 635 fan2 = (smsc47m1_read_value(data, SMSC47M1_REG_TPIN(1)) 636 & 0x05) == 0x05; 637 fan3 = 0; 638 pwm3 = 0; 639 } 640 if (!(fan1 || fan2 || fan3 || pwm1 || pwm2 || pwm3)) { 641 dev_warn(dev, "Device not configured, will not use\n"); 642 err = -ENODEV; 643 goto error_free; 644 } 645 646 /* Some values (fan min, clock dividers, pwm registers) may be 647 needed before any update is triggered, so we better read them 648 at least once here. We don't usually do it that way, but in 649 this particular case, manually reading 5 registers out of 8 650 doesn't make much sense and we're better using the existing 651 function. */ 652 smsc47m1_update_device(dev, 1); 653 654 /* Register sysfs hooks */ 655 if (fan1) { 656 if ((err = device_create_file(dev, 657 &sensor_dev_attr_fan1_input.dev_attr)) 658 || (err = device_create_file(dev, 659 &sensor_dev_attr_fan1_min.dev_attr)) 660 || (err = device_create_file(dev, 661 &sensor_dev_attr_fan1_div.dev_attr)) 662 || (err = device_create_file(dev, 663 &sensor_dev_attr_fan1_alarm.dev_attr))) 664 goto error_remove_files; 665 } else 666 dev_dbg(dev, "Fan 1 not enabled by hardware, skipping\n"); 667 668 if (fan2) { 669 if ((err = device_create_file(dev, 670 &sensor_dev_attr_fan2_input.dev_attr)) 671 || (err = device_create_file(dev, 672 &sensor_dev_attr_fan2_min.dev_attr)) 673 || (err = device_create_file(dev, 674 &sensor_dev_attr_fan2_div.dev_attr)) 675 || (err = device_create_file(dev, 676 &sensor_dev_attr_fan2_alarm.dev_attr))) 677 goto error_remove_files; 678 } else 679 dev_dbg(dev, "Fan 2 not enabled by hardware, skipping\n"); 680 681 if (fan3) { 682 if ((err = device_create_file(dev, 683 &sensor_dev_attr_fan3_input.dev_attr)) 684 || (err = device_create_file(dev, 685 &sensor_dev_attr_fan3_min.dev_attr)) 686 || (err = device_create_file(dev, 687 &sensor_dev_attr_fan3_div.dev_attr)) 688 || (err = device_create_file(dev, 689 &sensor_dev_attr_fan3_alarm.dev_attr))) 690 goto error_remove_files; 691 } else if (data->type == smsc47m2) 692 dev_dbg(dev, "Fan 3 not enabled by hardware, skipping\n"); 693 694 if (pwm1) { 695 if ((err = device_create_file(dev, 696 &sensor_dev_attr_pwm1.dev_attr)) 697 || (err = device_create_file(dev, 698 &sensor_dev_attr_pwm1_enable.dev_attr))) 699 goto error_remove_files; 700 } else 701 dev_dbg(dev, "PWM 1 not enabled by hardware, skipping\n"); 702 703 if (pwm2) { 704 if ((err = device_create_file(dev, 705 &sensor_dev_attr_pwm2.dev_attr)) 706 || (err = device_create_file(dev, 707 &sensor_dev_attr_pwm2_enable.dev_attr))) 708 goto error_remove_files; 709 } else 710 dev_dbg(dev, "PWM 2 not enabled by hardware, skipping\n"); 711 712 if (pwm3) { 713 if ((err = device_create_file(dev, 714 &sensor_dev_attr_pwm3.dev_attr)) 715 || (err = device_create_file(dev, 716 &sensor_dev_attr_pwm3_enable.dev_attr))) 717 goto error_remove_files; 718 } else if (data->type == smsc47m2) 719 dev_dbg(dev, "PWM 3 not enabled by hardware, skipping\n"); 720 721 if ((err = device_create_file(dev, &dev_attr_alarms))) 722 goto error_remove_files; 723 if ((err = device_create_file(dev, &dev_attr_name))) 724 goto error_remove_files; 725 726 data->hwmon_dev = hwmon_device_register(dev); 727 if (IS_ERR(data->hwmon_dev)) { 728 err = PTR_ERR(data->hwmon_dev); 729 goto error_remove_files; 730 } 731 732 return 0; 733 734 error_remove_files: 735 sysfs_remove_group(&dev->kobj, &smsc47m1_group); 736 error_free: 737 platform_set_drvdata(pdev, NULL); 738 kfree(data); 739 error_release: 740 smsc47m1_handle_resources(res->start, sio_data->type, RELEASE, dev); 741 return err; 742 } 743 744 static int __exit smsc47m1_remove(struct platform_device *pdev) 745 { 746 struct smsc47m1_data *data = platform_get_drvdata(pdev); 747 struct resource *res; 748 749 hwmon_device_unregister(data->hwmon_dev); 750 sysfs_remove_group(&pdev->dev.kobj, &smsc47m1_group); 751 752 res = platform_get_resource(pdev, IORESOURCE_IO, 0); 753 smsc47m1_handle_resources(res->start, data->type, RELEASE, &pdev->dev); 754 platform_set_drvdata(pdev, NULL); 755 kfree(data); 756 757 return 0; 758 } 759 760 static struct smsc47m1_data *smsc47m1_update_device(struct device *dev, 761 int init) 762 { 763 struct smsc47m1_data *data = dev_get_drvdata(dev); 764 765 mutex_lock(&data->update_lock); 766 767 if (time_after(jiffies, data->last_updated + HZ + HZ / 2) || init) { 768 int i, fan_nr; 769 fan_nr = data->type == smsc47m2 ? 3 : 2; 770 771 for (i = 0; i < fan_nr; i++) { 772 data->fan[i] = smsc47m1_read_value(data, 773 SMSC47M1_REG_FAN[i]); 774 data->fan_preload[i] = smsc47m1_read_value(data, 775 SMSC47M1_REG_FAN_PRELOAD[i]); 776 data->pwm[i] = smsc47m1_read_value(data, 777 SMSC47M1_REG_PWM[i]); 778 } 779 780 i = smsc47m1_read_value(data, SMSC47M1_REG_FANDIV); 781 data->fan_div[0] = (i >> 4) & 0x03; 782 data->fan_div[1] = i >> 6; 783 784 data->alarms = smsc47m1_read_value(data, 785 SMSC47M1_REG_ALARM) >> 6; 786 /* Clear alarms if needed */ 787 if (data->alarms) 788 smsc47m1_write_value(data, SMSC47M1_REG_ALARM, 0xC0); 789 790 if (fan_nr >= 3) { 791 data->fan_div[2] = (smsc47m1_read_value(data, 792 SMSC47M2_REG_FANDIV3) >> 4) & 0x03; 793 data->alarms |= (smsc47m1_read_value(data, 794 SMSC47M2_REG_ALARM6) & 0x40) >> 4; 795 /* Clear alarm if needed */ 796 if (data->alarms & 0x04) 797 smsc47m1_write_value(data, 798 SMSC47M2_REG_ALARM6, 799 0x40); 800 } 801 802 data->last_updated = jiffies; 803 } 804 805 mutex_unlock(&data->update_lock); 806 return data; 807 } 808 809 static int __init smsc47m1_device_add(unsigned short address, 810 const struct smsc47m1_sio_data *sio_data) 811 { 812 struct resource res = { 813 .start = address, 814 .end = address + SMSC_EXTENT - 1, 815 .name = DRVNAME, 816 .flags = IORESOURCE_IO, 817 }; 818 int err; 819 820 err = smsc47m1_handle_resources(address, sio_data->type, CHECK, NULL); 821 if (err) 822 goto exit; 823 824 pdev = platform_device_alloc(DRVNAME, address); 825 if (!pdev) { 826 err = -ENOMEM; 827 pr_err("Device allocation failed\n"); 828 goto exit; 829 } 830 831 err = platform_device_add_resources(pdev, &res, 1); 832 if (err) { 833 pr_err("Device resource addition failed (%d)\n", err); 834 goto exit_device_put; 835 } 836 837 err = platform_device_add_data(pdev, sio_data, 838 sizeof(struct smsc47m1_sio_data)); 839 if (err) { 840 pr_err("Platform data allocation failed\n"); 841 goto exit_device_put; 842 } 843 844 err = platform_device_add(pdev); 845 if (err) { 846 pr_err("Device addition failed (%d)\n", err); 847 goto exit_device_put; 848 } 849 850 return 0; 851 852 exit_device_put: 853 platform_device_put(pdev); 854 exit: 855 return err; 856 } 857 858 static int __init sm_smsc47m1_init(void) 859 { 860 int err; 861 unsigned short address; 862 struct smsc47m1_sio_data sio_data; 863 864 if (smsc47m1_find(&address, &sio_data)) 865 return -ENODEV; 866 867 /* Sets global pdev as a side effect */ 868 err = smsc47m1_device_add(address, &sio_data); 869 if (err) 870 goto exit; 871 872 err = platform_driver_probe(&smsc47m1_driver, smsc47m1_probe); 873 if (err) 874 goto exit_device; 875 876 return 0; 877 878 exit_device: 879 platform_device_unregister(pdev); 880 smsc47m1_restore(&sio_data); 881 exit: 882 return err; 883 } 884 885 static void __exit sm_smsc47m1_exit(void) 886 { 887 platform_driver_unregister(&smsc47m1_driver); 888 smsc47m1_restore(pdev->dev.platform_data); 889 platform_device_unregister(pdev); 890 } 891 892 MODULE_AUTHOR("Mark D. Studebaker <mdsxyz123@yahoo.com>"); 893 MODULE_DESCRIPTION("SMSC LPC47M1xx fan sensors driver"); 894 MODULE_LICENSE("GPL"); 895 896 module_init(sm_smsc47m1_init); 897 module_exit(sm_smsc47m1_exit); 898