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