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 <jdelvare@suse.de> 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 int 77 superio_enter(void) 78 { 79 if (!request_muxed_region(REG, 2, DRVNAME)) 80 return -EBUSY; 81 82 outb(0x55, REG); 83 return 0; 84 } 85 86 static inline void 87 superio_exit(void) 88 { 89 outb(0xAA, REG); 90 release_region(REG, 2); 91 } 92 93 #define SUPERIO_REG_ACT 0x30 94 #define SUPERIO_REG_BASE 0x60 95 #define SUPERIO_REG_DEVID 0x20 96 #define SUPERIO_REG_DEVREV 0x21 97 98 /* Logical device registers */ 99 100 #define SMSC_EXTENT 0x80 101 102 /* nr is 0 or 1 in the macros below */ 103 #define SMSC47M1_REG_ALARM 0x04 104 #define SMSC47M1_REG_TPIN(nr) (0x34 - (nr)) 105 #define SMSC47M1_REG_PPIN(nr) (0x36 - (nr)) 106 #define SMSC47M1_REG_FANDIV 0x58 107 108 static const u8 SMSC47M1_REG_FAN[3] = { 0x59, 0x5a, 0x6b }; 109 static const u8 SMSC47M1_REG_FAN_PRELOAD[3] = { 0x5b, 0x5c, 0x6c }; 110 static const u8 SMSC47M1_REG_PWM[3] = { 0x56, 0x57, 0x69 }; 111 112 #define SMSC47M2_REG_ALARM6 0x09 113 #define SMSC47M2_REG_TPIN1 0x38 114 #define SMSC47M2_REG_TPIN2 0x37 115 #define SMSC47M2_REG_TPIN3 0x2d 116 #define SMSC47M2_REG_PPIN3 0x2c 117 #define SMSC47M2_REG_FANDIV3 0x6a 118 119 #define MIN_FROM_REG(reg, div) ((reg) >= 192 ? 0 : \ 120 983040 / ((192 - (reg)) * (div))) 121 #define FAN_FROM_REG(reg, div, preload) ((reg) <= (preload) || (reg) == 255 ? \ 122 0 : \ 123 983040 / (((reg) - (preload)) * (div))) 124 #define DIV_FROM_REG(reg) (1 << (reg)) 125 #define PWM_FROM_REG(reg) (((reg) & 0x7E) << 1) 126 #define PWM_EN_FROM_REG(reg) ((~(reg)) & 0x01) 127 #define PWM_TO_REG(reg) (((reg) >> 1) & 0x7E) 128 129 struct smsc47m1_data { 130 unsigned short addr; 131 const char *name; 132 enum chips type; 133 struct device *hwmon_dev; 134 135 struct mutex update_lock; 136 unsigned long last_updated; /* In jiffies */ 137 138 u8 fan[3]; /* Register value */ 139 u8 fan_preload[3]; /* Register value */ 140 u8 fan_div[3]; /* Register encoding, shifted right */ 141 u8 alarms; /* Register encoding */ 142 u8 pwm[3]; /* Register value (bit 0 is disable) */ 143 }; 144 145 struct smsc47m1_sio_data { 146 enum chips type; 147 u8 activate; /* Remember initial device state */ 148 }; 149 150 static inline int smsc47m1_read_value(struct smsc47m1_data *data, u8 reg) 151 { 152 return inb_p(data->addr + reg); 153 } 154 155 static inline void smsc47m1_write_value(struct smsc47m1_data *data, u8 reg, 156 u8 value) 157 { 158 outb_p(value, data->addr + reg); 159 } 160 161 static struct smsc47m1_data *smsc47m1_update_device(struct device *dev, 162 int init) 163 { 164 struct smsc47m1_data *data = dev_get_drvdata(dev); 165 166 mutex_lock(&data->update_lock); 167 168 if (time_after(jiffies, data->last_updated + HZ + HZ / 2) || init) { 169 int i, fan_nr; 170 fan_nr = data->type == smsc47m2 ? 3 : 2; 171 172 for (i = 0; i < fan_nr; i++) { 173 data->fan[i] = smsc47m1_read_value(data, 174 SMSC47M1_REG_FAN[i]); 175 data->fan_preload[i] = smsc47m1_read_value(data, 176 SMSC47M1_REG_FAN_PRELOAD[i]); 177 data->pwm[i] = smsc47m1_read_value(data, 178 SMSC47M1_REG_PWM[i]); 179 } 180 181 i = smsc47m1_read_value(data, SMSC47M1_REG_FANDIV); 182 data->fan_div[0] = (i >> 4) & 0x03; 183 data->fan_div[1] = i >> 6; 184 185 data->alarms = smsc47m1_read_value(data, 186 SMSC47M1_REG_ALARM) >> 6; 187 /* Clear alarms if needed */ 188 if (data->alarms) 189 smsc47m1_write_value(data, SMSC47M1_REG_ALARM, 0xC0); 190 191 if (fan_nr >= 3) { 192 data->fan_div[2] = (smsc47m1_read_value(data, 193 SMSC47M2_REG_FANDIV3) >> 4) & 0x03; 194 data->alarms |= (smsc47m1_read_value(data, 195 SMSC47M2_REG_ALARM6) & 0x40) >> 4; 196 /* Clear alarm if needed */ 197 if (data->alarms & 0x04) 198 smsc47m1_write_value(data, 199 SMSC47M2_REG_ALARM6, 200 0x40); 201 } 202 203 data->last_updated = jiffies; 204 } 205 206 mutex_unlock(&data->update_lock); 207 return data; 208 } 209 210 static ssize_t fan_show(struct device *dev, struct device_attribute *devattr, 211 char *buf) 212 { 213 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 214 struct smsc47m1_data *data = smsc47m1_update_device(dev, 0); 215 int nr = attr->index; 216 /* 217 * This chip (stupidly) stops monitoring fan speed if PWM is 218 * enabled and duty cycle is 0%. This is fine if the monitoring 219 * and control concern the same fan, but troublesome if they are 220 * not (which could as well happen). 221 */ 222 int rpm = (data->pwm[nr] & 0x7F) == 0x00 ? 0 : 223 FAN_FROM_REG(data->fan[nr], 224 DIV_FROM_REG(data->fan_div[nr]), 225 data->fan_preload[nr]); 226 return sprintf(buf, "%d\n", rpm); 227 } 228 229 static ssize_t fan_min_show(struct device *dev, 230 struct device_attribute *devattr, char *buf) 231 { 232 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 233 struct smsc47m1_data *data = smsc47m1_update_device(dev, 0); 234 int nr = attr->index; 235 int rpm = MIN_FROM_REG(data->fan_preload[nr], 236 DIV_FROM_REG(data->fan_div[nr])); 237 return sprintf(buf, "%d\n", rpm); 238 } 239 240 static ssize_t fan_div_show(struct device *dev, 241 struct device_attribute *devattr, char *buf) 242 { 243 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 244 struct smsc47m1_data *data = smsc47m1_update_device(dev, 0); 245 return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[attr->index])); 246 } 247 248 static ssize_t fan_alarm_show(struct device *dev, 249 struct device_attribute *devattr, char *buf) 250 { 251 int bitnr = to_sensor_dev_attr(devattr)->index; 252 struct smsc47m1_data *data = smsc47m1_update_device(dev, 0); 253 return sprintf(buf, "%u\n", (data->alarms >> bitnr) & 1); 254 } 255 256 static ssize_t pwm_show(struct device *dev, struct device_attribute *devattr, 257 char *buf) 258 { 259 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 260 struct smsc47m1_data *data = smsc47m1_update_device(dev, 0); 261 return sprintf(buf, "%d\n", PWM_FROM_REG(data->pwm[attr->index])); 262 } 263 264 static ssize_t pwm_en_show(struct device *dev, 265 struct device_attribute *devattr, char *buf) 266 { 267 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 268 struct smsc47m1_data *data = smsc47m1_update_device(dev, 0); 269 return sprintf(buf, "%d\n", PWM_EN_FROM_REG(data->pwm[attr->index])); 270 } 271 272 static ssize_t alarms_show(struct device *dev, 273 struct device_attribute *devattr, char *buf) 274 { 275 struct smsc47m1_data *data = smsc47m1_update_device(dev, 0); 276 return sprintf(buf, "%d\n", data->alarms); 277 } 278 279 static ssize_t fan_min_store(struct device *dev, 280 struct device_attribute *devattr, 281 const char *buf, size_t count) 282 { 283 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 284 struct smsc47m1_data *data = dev_get_drvdata(dev); 285 int nr = attr->index; 286 long rpmdiv; 287 long val; 288 int err; 289 290 err = kstrtol(buf, 10, &val); 291 if (err) 292 return err; 293 294 mutex_lock(&data->update_lock); 295 rpmdiv = val * DIV_FROM_REG(data->fan_div[nr]); 296 297 if (983040 > 192 * rpmdiv || 2 * rpmdiv > 983040) { 298 mutex_unlock(&data->update_lock); 299 return -EINVAL; 300 } 301 302 data->fan_preload[nr] = 192 - ((983040 + rpmdiv / 2) / rpmdiv); 303 smsc47m1_write_value(data, SMSC47M1_REG_FAN_PRELOAD[nr], 304 data->fan_preload[nr]); 305 mutex_unlock(&data->update_lock); 306 307 return count; 308 } 309 310 /* 311 * Note: we save and restore the fan minimum here, because its value is 312 * determined in part by the fan clock divider. This follows the principle 313 * of least surprise; the user doesn't expect the fan minimum to change just 314 * because the divider changed. 315 */ 316 static ssize_t fan_div_store(struct device *dev, 317 struct device_attribute *devattr, 318 const char *buf, size_t count) 319 { 320 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 321 struct smsc47m1_data *data = dev_get_drvdata(dev); 322 int nr = attr->index; 323 long new_div; 324 int err; 325 long tmp; 326 u8 old_div = DIV_FROM_REG(data->fan_div[nr]); 327 328 err = kstrtol(buf, 10, &new_div); 329 if (err) 330 return err; 331 332 if (new_div == old_div) /* No change */ 333 return count; 334 335 mutex_lock(&data->update_lock); 336 switch (new_div) { 337 case 1: 338 data->fan_div[nr] = 0; 339 break; 340 case 2: 341 data->fan_div[nr] = 1; 342 break; 343 case 4: 344 data->fan_div[nr] = 2; 345 break; 346 case 8: 347 data->fan_div[nr] = 3; 348 break; 349 default: 350 mutex_unlock(&data->update_lock); 351 return -EINVAL; 352 } 353 354 switch (nr) { 355 case 0: 356 case 1: 357 tmp = smsc47m1_read_value(data, SMSC47M1_REG_FANDIV) 358 & ~(0x03 << (4 + 2 * nr)); 359 tmp |= data->fan_div[nr] << (4 + 2 * nr); 360 smsc47m1_write_value(data, SMSC47M1_REG_FANDIV, tmp); 361 break; 362 case 2: 363 tmp = smsc47m1_read_value(data, SMSC47M2_REG_FANDIV3) & 0xCF; 364 tmp |= data->fan_div[2] << 4; 365 smsc47m1_write_value(data, SMSC47M2_REG_FANDIV3, tmp); 366 break; 367 } 368 369 /* Preserve fan min */ 370 tmp = 192 - (old_div * (192 - data->fan_preload[nr]) 371 + new_div / 2) / new_div; 372 data->fan_preload[nr] = clamp_val(tmp, 0, 191); 373 smsc47m1_write_value(data, SMSC47M1_REG_FAN_PRELOAD[nr], 374 data->fan_preload[nr]); 375 mutex_unlock(&data->update_lock); 376 377 return count; 378 } 379 380 static ssize_t pwm_store(struct device *dev, struct device_attribute *devattr, 381 const char *buf, size_t count) 382 { 383 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 384 struct smsc47m1_data *data = dev_get_drvdata(dev); 385 int nr = attr->index; 386 long val; 387 int err; 388 389 err = kstrtol(buf, 10, &val); 390 if (err) 391 return err; 392 393 if (val < 0 || val > 255) 394 return -EINVAL; 395 396 mutex_lock(&data->update_lock); 397 data->pwm[nr] &= 0x81; /* Preserve additional bits */ 398 data->pwm[nr] |= PWM_TO_REG(val); 399 smsc47m1_write_value(data, SMSC47M1_REG_PWM[nr], 400 data->pwm[nr]); 401 mutex_unlock(&data->update_lock); 402 403 return count; 404 } 405 406 static ssize_t pwm_en_store(struct device *dev, 407 struct device_attribute *devattr, const char *buf, 408 size_t count) 409 { 410 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 411 struct smsc47m1_data *data = dev_get_drvdata(dev); 412 int nr = attr->index; 413 unsigned long val; 414 int err; 415 416 err = kstrtoul(buf, 10, &val); 417 if (err) 418 return err; 419 420 if (val > 1) 421 return -EINVAL; 422 423 mutex_lock(&data->update_lock); 424 data->pwm[nr] &= 0xFE; /* preserve the other bits */ 425 data->pwm[nr] |= !val; 426 smsc47m1_write_value(data, SMSC47M1_REG_PWM[nr], 427 data->pwm[nr]); 428 mutex_unlock(&data->update_lock); 429 430 return count; 431 } 432 433 static SENSOR_DEVICE_ATTR_RO(fan1_input, fan, 0); 434 static SENSOR_DEVICE_ATTR_RW(fan1_min, fan_min, 0); 435 static SENSOR_DEVICE_ATTR_RW(fan1_div, fan_div, 0); 436 static SENSOR_DEVICE_ATTR_RO(fan1_alarm, fan_alarm, 0); 437 static SENSOR_DEVICE_ATTR_RW(pwm1, pwm, 0); 438 static SENSOR_DEVICE_ATTR_RW(pwm1_enable, pwm_en, 0); 439 static SENSOR_DEVICE_ATTR_RO(fan2_input, fan, 1); 440 static SENSOR_DEVICE_ATTR_RW(fan2_min, fan_min, 1); 441 static SENSOR_DEVICE_ATTR_RW(fan2_div, fan_div, 1); 442 static SENSOR_DEVICE_ATTR_RO(fan2_alarm, fan_alarm, 1); 443 static SENSOR_DEVICE_ATTR_RW(pwm2, pwm, 1); 444 static SENSOR_DEVICE_ATTR_RW(pwm2_enable, pwm_en, 1); 445 static SENSOR_DEVICE_ATTR_RO(fan3_input, fan, 2); 446 static SENSOR_DEVICE_ATTR_RW(fan3_min, fan_min, 2); 447 static SENSOR_DEVICE_ATTR_RW(fan3_div, fan_div, 2); 448 static SENSOR_DEVICE_ATTR_RO(fan3_alarm, fan_alarm, 2); 449 static SENSOR_DEVICE_ATTR_RW(pwm3, pwm, 2); 450 static SENSOR_DEVICE_ATTR_RW(pwm3_enable, pwm_en, 2); 451 452 static DEVICE_ATTR_RO(alarms); 453 454 static ssize_t name_show(struct device *dev, struct device_attribute 455 *devattr, char *buf) 456 { 457 struct smsc47m1_data *data = dev_get_drvdata(dev); 458 459 return sprintf(buf, "%s\n", data->name); 460 } 461 static DEVICE_ATTR_RO(name); 462 463 static struct attribute *smsc47m1_attributes_fan1[] = { 464 &sensor_dev_attr_fan1_input.dev_attr.attr, 465 &sensor_dev_attr_fan1_min.dev_attr.attr, 466 &sensor_dev_attr_fan1_div.dev_attr.attr, 467 &sensor_dev_attr_fan1_alarm.dev_attr.attr, 468 NULL 469 }; 470 471 static const struct attribute_group smsc47m1_group_fan1 = { 472 .attrs = smsc47m1_attributes_fan1, 473 }; 474 475 static struct attribute *smsc47m1_attributes_fan2[] = { 476 &sensor_dev_attr_fan2_input.dev_attr.attr, 477 &sensor_dev_attr_fan2_min.dev_attr.attr, 478 &sensor_dev_attr_fan2_div.dev_attr.attr, 479 &sensor_dev_attr_fan2_alarm.dev_attr.attr, 480 NULL 481 }; 482 483 static const struct attribute_group smsc47m1_group_fan2 = { 484 .attrs = smsc47m1_attributes_fan2, 485 }; 486 487 static struct attribute *smsc47m1_attributes_fan3[] = { 488 &sensor_dev_attr_fan3_input.dev_attr.attr, 489 &sensor_dev_attr_fan3_min.dev_attr.attr, 490 &sensor_dev_attr_fan3_div.dev_attr.attr, 491 &sensor_dev_attr_fan3_alarm.dev_attr.attr, 492 NULL 493 }; 494 495 static const struct attribute_group smsc47m1_group_fan3 = { 496 .attrs = smsc47m1_attributes_fan3, 497 }; 498 499 static struct attribute *smsc47m1_attributes_pwm1[] = { 500 &sensor_dev_attr_pwm1.dev_attr.attr, 501 &sensor_dev_attr_pwm1_enable.dev_attr.attr, 502 NULL 503 }; 504 505 static const struct attribute_group smsc47m1_group_pwm1 = { 506 .attrs = smsc47m1_attributes_pwm1, 507 }; 508 509 static struct attribute *smsc47m1_attributes_pwm2[] = { 510 &sensor_dev_attr_pwm2.dev_attr.attr, 511 &sensor_dev_attr_pwm2_enable.dev_attr.attr, 512 NULL 513 }; 514 515 static const struct attribute_group smsc47m1_group_pwm2 = { 516 .attrs = smsc47m1_attributes_pwm2, 517 }; 518 519 static struct attribute *smsc47m1_attributes_pwm3[] = { 520 &sensor_dev_attr_pwm3.dev_attr.attr, 521 &sensor_dev_attr_pwm3_enable.dev_attr.attr, 522 NULL 523 }; 524 525 static const struct attribute_group smsc47m1_group_pwm3 = { 526 .attrs = smsc47m1_attributes_pwm3, 527 }; 528 529 static struct attribute *smsc47m1_attributes[] = { 530 &dev_attr_alarms.attr, 531 &dev_attr_name.attr, 532 NULL 533 }; 534 535 static const struct attribute_group smsc47m1_group = { 536 .attrs = smsc47m1_attributes, 537 }; 538 539 static int __init smsc47m1_find(struct smsc47m1_sio_data *sio_data) 540 { 541 u8 val; 542 unsigned short addr; 543 int err; 544 545 err = superio_enter(); 546 if (err) 547 return err; 548 549 val = force_id ? force_id : superio_inb(SUPERIO_REG_DEVID); 550 551 /* 552 * SMSC LPC47M10x/LPC47M112/LPC47M13x (device id 0x59), LPC47M14x 553 * (device id 0x5F) and LPC47B27x (device id 0x51) have fan control. 554 * The LPC47M15x and LPC47M192 chips "with hardware monitoring block" 555 * can do much more besides (device id 0x60). 556 * The LPC47M997 is undocumented, but seems to be compatible with 557 * the LPC47M192, and has the same device id. 558 * The LPC47M292 (device id 0x6B) is somewhat compatible, but it 559 * supports a 3rd fan, and the pin configuration registers are 560 * unfortunately different. 561 * The LPC47M233 has the same device id (0x6B) but is not compatible. 562 * We check the high bit of the device revision register to 563 * differentiate them. 564 */ 565 switch (val) { 566 case 0x51: 567 pr_info("Found SMSC LPC47B27x\n"); 568 sio_data->type = smsc47m1; 569 break; 570 case 0x59: 571 pr_info("Found SMSC LPC47M10x/LPC47M112/LPC47M13x\n"); 572 sio_data->type = smsc47m1; 573 break; 574 case 0x5F: 575 pr_info("Found SMSC LPC47M14x\n"); 576 sio_data->type = smsc47m1; 577 break; 578 case 0x60: 579 pr_info("Found SMSC LPC47M15x/LPC47M192/LPC47M997\n"); 580 sio_data->type = smsc47m1; 581 break; 582 case 0x6B: 583 if (superio_inb(SUPERIO_REG_DEVREV) & 0x80) { 584 pr_debug("Found SMSC LPC47M233, unsupported\n"); 585 superio_exit(); 586 return -ENODEV; 587 } 588 589 pr_info("Found SMSC LPC47M292\n"); 590 sio_data->type = smsc47m2; 591 break; 592 default: 593 superio_exit(); 594 return -ENODEV; 595 } 596 597 superio_select(); 598 addr = (superio_inb(SUPERIO_REG_BASE) << 8) 599 | superio_inb(SUPERIO_REG_BASE + 1); 600 if (addr == 0) { 601 pr_info("Device address not set, will not use\n"); 602 superio_exit(); 603 return -ENODEV; 604 } 605 606 /* 607 * Enable only if address is set (needed at least on the 608 * Compaq Presario S4000NX) 609 */ 610 sio_data->activate = superio_inb(SUPERIO_REG_ACT); 611 if ((sio_data->activate & 0x01) == 0) { 612 pr_info("Enabling device\n"); 613 superio_outb(SUPERIO_REG_ACT, sio_data->activate | 0x01); 614 } 615 616 superio_exit(); 617 return addr; 618 } 619 620 /* Restore device to its initial state */ 621 static void smsc47m1_restore(const struct smsc47m1_sio_data *sio_data) 622 { 623 if ((sio_data->activate & 0x01) == 0) { 624 if (!superio_enter()) { 625 superio_select(); 626 pr_info("Disabling device\n"); 627 superio_outb(SUPERIO_REG_ACT, sio_data->activate); 628 superio_exit(); 629 } else { 630 pr_warn("Failed to disable device\n"); 631 } 632 } 633 } 634 635 #define CHECK 1 636 #define REQUEST 2 637 638 /* 639 * This function can be used to: 640 * - test for resource conflicts with ACPI 641 * - request the resources 642 * We only allocate the I/O ports we really need, to minimize the risk of 643 * conflicts with ACPI or with other drivers. 644 */ 645 static int __init smsc47m1_handle_resources(unsigned short address, 646 enum chips type, int action, 647 struct device *dev) 648 { 649 static const u8 ports_m1[] = { 650 /* register, region length */ 651 0x04, 1, 652 0x33, 4, 653 0x56, 7, 654 }; 655 656 static const u8 ports_m2[] = { 657 /* register, region length */ 658 0x04, 1, 659 0x09, 1, 660 0x2c, 2, 661 0x35, 4, 662 0x56, 7, 663 0x69, 4, 664 }; 665 666 int i, ports_size, err; 667 const u8 *ports; 668 669 switch (type) { 670 case smsc47m1: 671 default: 672 ports = ports_m1; 673 ports_size = ARRAY_SIZE(ports_m1); 674 break; 675 case smsc47m2: 676 ports = ports_m2; 677 ports_size = ARRAY_SIZE(ports_m2); 678 break; 679 } 680 681 for (i = 0; i + 1 < ports_size; i += 2) { 682 unsigned short start = address + ports[i]; 683 unsigned short len = ports[i + 1]; 684 685 switch (action) { 686 case CHECK: 687 /* Only check for conflicts */ 688 err = acpi_check_region(start, len, DRVNAME); 689 if (err) 690 return err; 691 break; 692 case REQUEST: 693 /* Request the resources */ 694 if (!devm_request_region(dev, start, len, DRVNAME)) { 695 dev_err(dev, 696 "Region 0x%hx-0x%hx already in use!\n", 697 start, start + len); 698 return -EBUSY; 699 } 700 break; 701 } 702 } 703 704 return 0; 705 } 706 707 static void smsc47m1_remove_files(struct device *dev) 708 { 709 sysfs_remove_group(&dev->kobj, &smsc47m1_group); 710 sysfs_remove_group(&dev->kobj, &smsc47m1_group_fan1); 711 sysfs_remove_group(&dev->kobj, &smsc47m1_group_fan2); 712 sysfs_remove_group(&dev->kobj, &smsc47m1_group_fan3); 713 sysfs_remove_group(&dev->kobj, &smsc47m1_group_pwm1); 714 sysfs_remove_group(&dev->kobj, &smsc47m1_group_pwm2); 715 sysfs_remove_group(&dev->kobj, &smsc47m1_group_pwm3); 716 } 717 718 static int __init smsc47m1_probe(struct platform_device *pdev) 719 { 720 struct device *dev = &pdev->dev; 721 struct smsc47m1_sio_data *sio_data = dev_get_platdata(dev); 722 struct smsc47m1_data *data; 723 struct resource *res; 724 int err; 725 int fan1, fan2, fan3, pwm1, pwm2, pwm3; 726 727 static const char * const names[] = { 728 "smsc47m1", 729 "smsc47m2", 730 }; 731 732 res = platform_get_resource(pdev, IORESOURCE_IO, 0); 733 err = smsc47m1_handle_resources(res->start, sio_data->type, 734 REQUEST, dev); 735 if (err < 0) 736 return err; 737 738 data = devm_kzalloc(dev, sizeof(struct smsc47m1_data), GFP_KERNEL); 739 if (!data) 740 return -ENOMEM; 741 742 data->addr = res->start; 743 data->type = sio_data->type; 744 data->name = names[sio_data->type]; 745 mutex_init(&data->update_lock); 746 platform_set_drvdata(pdev, data); 747 748 /* 749 * If no function is properly configured, there's no point in 750 * actually registering the chip. 751 */ 752 pwm1 = (smsc47m1_read_value(data, SMSC47M1_REG_PPIN(0)) & 0x05) 753 == 0x04; 754 pwm2 = (smsc47m1_read_value(data, SMSC47M1_REG_PPIN(1)) & 0x05) 755 == 0x04; 756 if (data->type == smsc47m2) { 757 fan1 = (smsc47m1_read_value(data, SMSC47M2_REG_TPIN1) 758 & 0x0d) == 0x09; 759 fan2 = (smsc47m1_read_value(data, SMSC47M2_REG_TPIN2) 760 & 0x0d) == 0x09; 761 fan3 = (smsc47m1_read_value(data, SMSC47M2_REG_TPIN3) 762 & 0x0d) == 0x0d; 763 pwm3 = (smsc47m1_read_value(data, SMSC47M2_REG_PPIN3) 764 & 0x0d) == 0x08; 765 } else { 766 fan1 = (smsc47m1_read_value(data, SMSC47M1_REG_TPIN(0)) 767 & 0x05) == 0x05; 768 fan2 = (smsc47m1_read_value(data, SMSC47M1_REG_TPIN(1)) 769 & 0x05) == 0x05; 770 fan3 = 0; 771 pwm3 = 0; 772 } 773 if (!(fan1 || fan2 || fan3 || pwm1 || pwm2 || pwm3)) { 774 dev_warn(dev, "Device not configured, will not use\n"); 775 return -ENODEV; 776 } 777 778 /* 779 * Some values (fan min, clock dividers, pwm registers) may be 780 * needed before any update is triggered, so we better read them 781 * at least once here. We don't usually do it that way, but in 782 * this particular case, manually reading 5 registers out of 8 783 * doesn't make much sense and we're better using the existing 784 * function. 785 */ 786 smsc47m1_update_device(dev, 1); 787 788 /* Register sysfs hooks */ 789 if (fan1) { 790 err = sysfs_create_group(&dev->kobj, 791 &smsc47m1_group_fan1); 792 if (err) 793 goto error_remove_files; 794 } else 795 dev_dbg(dev, "Fan 1 not enabled by hardware, skipping\n"); 796 797 if (fan2) { 798 err = sysfs_create_group(&dev->kobj, 799 &smsc47m1_group_fan2); 800 if (err) 801 goto error_remove_files; 802 } else 803 dev_dbg(dev, "Fan 2 not enabled by hardware, skipping\n"); 804 805 if (fan3) { 806 err = sysfs_create_group(&dev->kobj, 807 &smsc47m1_group_fan3); 808 if (err) 809 goto error_remove_files; 810 } else if (data->type == smsc47m2) 811 dev_dbg(dev, "Fan 3 not enabled by hardware, skipping\n"); 812 813 if (pwm1) { 814 err = sysfs_create_group(&dev->kobj, 815 &smsc47m1_group_pwm1); 816 if (err) 817 goto error_remove_files; 818 } else 819 dev_dbg(dev, "PWM 1 not enabled by hardware, skipping\n"); 820 821 if (pwm2) { 822 err = sysfs_create_group(&dev->kobj, 823 &smsc47m1_group_pwm2); 824 if (err) 825 goto error_remove_files; 826 } else 827 dev_dbg(dev, "PWM 2 not enabled by hardware, skipping\n"); 828 829 if (pwm3) { 830 err = sysfs_create_group(&dev->kobj, 831 &smsc47m1_group_pwm3); 832 if (err) 833 goto error_remove_files; 834 } else if (data->type == smsc47m2) 835 dev_dbg(dev, "PWM 3 not enabled by hardware, skipping\n"); 836 837 err = sysfs_create_group(&dev->kobj, &smsc47m1_group); 838 if (err) 839 goto error_remove_files; 840 841 data->hwmon_dev = hwmon_device_register(dev); 842 if (IS_ERR(data->hwmon_dev)) { 843 err = PTR_ERR(data->hwmon_dev); 844 goto error_remove_files; 845 } 846 847 return 0; 848 849 error_remove_files: 850 smsc47m1_remove_files(dev); 851 return err; 852 } 853 854 static int __exit smsc47m1_remove(struct platform_device *pdev) 855 { 856 struct smsc47m1_data *data = platform_get_drvdata(pdev); 857 858 hwmon_device_unregister(data->hwmon_dev); 859 smsc47m1_remove_files(&pdev->dev); 860 861 return 0; 862 } 863 864 static struct platform_driver smsc47m1_driver = { 865 .driver = { 866 .name = DRVNAME, 867 }, 868 .remove = __exit_p(smsc47m1_remove), 869 }; 870 871 static int __init smsc47m1_device_add(unsigned short address, 872 const struct smsc47m1_sio_data *sio_data) 873 { 874 struct resource res = { 875 .start = address, 876 .end = address + SMSC_EXTENT - 1, 877 .name = DRVNAME, 878 .flags = IORESOURCE_IO, 879 }; 880 int err; 881 882 err = smsc47m1_handle_resources(address, sio_data->type, CHECK, NULL); 883 if (err) 884 goto exit; 885 886 pdev = platform_device_alloc(DRVNAME, address); 887 if (!pdev) { 888 err = -ENOMEM; 889 pr_err("Device allocation failed\n"); 890 goto exit; 891 } 892 893 err = platform_device_add_resources(pdev, &res, 1); 894 if (err) { 895 pr_err("Device resource addition failed (%d)\n", err); 896 goto exit_device_put; 897 } 898 899 err = platform_device_add_data(pdev, sio_data, 900 sizeof(struct smsc47m1_sio_data)); 901 if (err) { 902 pr_err("Platform data allocation failed\n"); 903 goto exit_device_put; 904 } 905 906 err = platform_device_add(pdev); 907 if (err) { 908 pr_err("Device addition failed (%d)\n", err); 909 goto exit_device_put; 910 } 911 912 return 0; 913 914 exit_device_put: 915 platform_device_put(pdev); 916 exit: 917 return err; 918 } 919 920 static int __init sm_smsc47m1_init(void) 921 { 922 int err; 923 unsigned short address; 924 struct smsc47m1_sio_data sio_data; 925 926 err = smsc47m1_find(&sio_data); 927 if (err < 0) 928 return err; 929 address = err; 930 931 /* Sets global pdev as a side effect */ 932 err = smsc47m1_device_add(address, &sio_data); 933 if (err) 934 return err; 935 936 err = platform_driver_probe(&smsc47m1_driver, smsc47m1_probe); 937 if (err) 938 goto exit_device; 939 940 return 0; 941 942 exit_device: 943 platform_device_unregister(pdev); 944 smsc47m1_restore(&sio_data); 945 return err; 946 } 947 948 static void __exit sm_smsc47m1_exit(void) 949 { 950 platform_driver_unregister(&smsc47m1_driver); 951 smsc47m1_restore(dev_get_platdata(&pdev->dev)); 952 platform_device_unregister(pdev); 953 } 954 955 MODULE_AUTHOR("Mark D. Studebaker <mdsxyz123@yahoo.com>"); 956 MODULE_DESCRIPTION("SMSC LPC47M1xx fan sensors driver"); 957 MODULE_LICENSE("GPL"); 958 959 module_init(sm_smsc47m1_init); 960 module_exit(sm_smsc47m1_exit); 961