1 /* 2 smsc47m1.c - Part of lm_sensors, Linux kernel modules 3 for hardware monitoring 4 5 Supports the SMSC LPC47B27x, LPC47M10x, LPC47M13x, LPC47M14x, 6 LPC47M15x, LPC47M192 and LPC47M997 Super-I/O chips. 7 8 Copyright (C) 2002 Mark D. Studebaker <mdsxyz123@yahoo.com> 9 Copyright (C) 2004 Jean Delvare <khali@linux-fr.org> 10 Ported to Linux 2.6 by Gabriele Gorla <gorlik@yahoo.com> 11 and Jean Delvare 12 13 This program is free software; you can redistribute it and/or modify 14 it under the terms of the GNU General Public License as published by 15 the Free Software Foundation; either version 2 of the License, or 16 (at your option) any later version. 17 18 This program is distributed in the hope that it will be useful, 19 but WITHOUT ANY WARRANTY; without even the implied warranty of 20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 21 GNU General Public License for more details. 22 23 You should have received a copy of the GNU General Public License 24 along with this program; if not, write to the Free Software 25 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 26 */ 27 28 #include <linux/module.h> 29 #include <linux/slab.h> 30 #include <linux/ioport.h> 31 #include <linux/jiffies.h> 32 #include <linux/i2c.h> 33 #include <linux/i2c-isa.h> 34 #include <linux/hwmon.h> 35 #include <linux/err.h> 36 #include <linux/init.h> 37 #include <asm/io.h> 38 39 /* Address is autodetected, there is no default value */ 40 static unsigned short address; 41 42 /* Super-I/0 registers and commands */ 43 44 #define REG 0x2e /* The register to read/write */ 45 #define VAL 0x2f /* The value to read/write */ 46 47 static inline void 48 superio_outb(int reg, int val) 49 { 50 outb(reg, REG); 51 outb(val, VAL); 52 } 53 54 static inline int 55 superio_inb(int reg) 56 { 57 outb(reg, REG); 58 return inb(VAL); 59 } 60 61 /* logical device for fans is 0x0A */ 62 #define superio_select() superio_outb(0x07, 0x0A) 63 64 static inline void 65 superio_enter(void) 66 { 67 outb(0x55, REG); 68 } 69 70 static inline void 71 superio_exit(void) 72 { 73 outb(0xAA, REG); 74 } 75 76 #define SUPERIO_REG_ACT 0x30 77 #define SUPERIO_REG_BASE 0x60 78 #define SUPERIO_REG_DEVID 0x20 79 80 /* Logical device registers */ 81 82 #define SMSC_EXTENT 0x80 83 84 /* nr is 0 or 1 in the macros below */ 85 #define SMSC47M1_REG_ALARM 0x04 86 #define SMSC47M1_REG_TPIN(nr) (0x34 - (nr)) 87 #define SMSC47M1_REG_PPIN(nr) (0x36 - (nr)) 88 #define SMSC47M1_REG_PWM(nr) (0x56 + (nr)) 89 #define SMSC47M1_REG_FANDIV 0x58 90 #define SMSC47M1_REG_FAN(nr) (0x59 + (nr)) 91 #define SMSC47M1_REG_FAN_PRELOAD(nr) (0x5B + (nr)) 92 93 #define MIN_FROM_REG(reg,div) ((reg)>=192 ? 0 : \ 94 983040/((192-(reg))*(div))) 95 #define FAN_FROM_REG(reg,div,preload) ((reg)<=(preload) || (reg)==255 ? 0 : \ 96 983040/(((reg)-(preload))*(div))) 97 #define DIV_FROM_REG(reg) (1 << (reg)) 98 #define PWM_FROM_REG(reg) (((reg) & 0x7E) << 1) 99 #define PWM_EN_FROM_REG(reg) ((~(reg)) & 0x01) 100 #define PWM_TO_REG(reg) (((reg) >> 1) & 0x7E) 101 102 struct smsc47m1_data { 103 struct i2c_client client; 104 struct class_device *class_dev; 105 struct semaphore lock; 106 107 struct semaphore update_lock; 108 unsigned long last_updated; /* In jiffies */ 109 110 u8 fan[2]; /* Register value */ 111 u8 fan_preload[2]; /* Register value */ 112 u8 fan_div[2]; /* Register encoding, shifted right */ 113 u8 alarms; /* Register encoding */ 114 u8 pwm[2]; /* Register value (bit 7 is enable) */ 115 }; 116 117 118 static int smsc47m1_detect(struct i2c_adapter *adapter); 119 static int smsc47m1_detach_client(struct i2c_client *client); 120 121 static int smsc47m1_read_value(struct i2c_client *client, u8 reg); 122 static void smsc47m1_write_value(struct i2c_client *client, u8 reg, u8 value); 123 124 static struct smsc47m1_data *smsc47m1_update_device(struct device *dev, 125 int init); 126 127 128 static struct i2c_driver smsc47m1_driver = { 129 .owner = THIS_MODULE, 130 .name = "smsc47m1", 131 .attach_adapter = smsc47m1_detect, 132 .detach_client = smsc47m1_detach_client, 133 }; 134 135 /* nr is 0 or 1 in the callback functions below */ 136 137 static ssize_t get_fan(struct device *dev, char *buf, int nr) 138 { 139 struct smsc47m1_data *data = smsc47m1_update_device(dev, 0); 140 /* This chip (stupidly) stops monitoring fan speed if PWM is 141 enabled and duty cycle is 0%. This is fine if the monitoring 142 and control concern the same fan, but troublesome if they are 143 not (which could as well happen). */ 144 int rpm = (data->pwm[nr] & 0x7F) == 0x00 ? 0 : 145 FAN_FROM_REG(data->fan[nr], 146 DIV_FROM_REG(data->fan_div[nr]), 147 data->fan_preload[nr]); 148 return sprintf(buf, "%d\n", rpm); 149 } 150 151 static ssize_t get_fan_min(struct device *dev, char *buf, int nr) 152 { 153 struct smsc47m1_data *data = smsc47m1_update_device(dev, 0); 154 int rpm = MIN_FROM_REG(data->fan_preload[nr], 155 DIV_FROM_REG(data->fan_div[nr])); 156 return sprintf(buf, "%d\n", rpm); 157 } 158 159 static ssize_t get_fan_div(struct device *dev, char *buf, int nr) 160 { 161 struct smsc47m1_data *data = smsc47m1_update_device(dev, 0); 162 return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[nr])); 163 } 164 165 static ssize_t get_pwm(struct device *dev, char *buf, int nr) 166 { 167 struct smsc47m1_data *data = smsc47m1_update_device(dev, 0); 168 return sprintf(buf, "%d\n", PWM_FROM_REG(data->pwm[nr])); 169 } 170 171 static ssize_t get_pwm_en(struct device *dev, char *buf, int nr) 172 { 173 struct smsc47m1_data *data = smsc47m1_update_device(dev, 0); 174 return sprintf(buf, "%d\n", PWM_EN_FROM_REG(data->pwm[nr])); 175 } 176 177 static ssize_t get_alarms(struct device *dev, struct device_attribute *attr, char *buf) 178 { 179 struct smsc47m1_data *data = smsc47m1_update_device(dev, 0); 180 return sprintf(buf, "%d\n", data->alarms); 181 } 182 183 static ssize_t set_fan_min(struct device *dev, const char *buf, 184 size_t count, int nr) 185 { 186 struct i2c_client *client = to_i2c_client(dev); 187 struct smsc47m1_data *data = i2c_get_clientdata(client); 188 long rpmdiv, val = simple_strtol(buf, NULL, 10); 189 190 down(&data->update_lock); 191 rpmdiv = val * DIV_FROM_REG(data->fan_div[nr]); 192 193 if (983040 > 192 * rpmdiv || 2 * rpmdiv > 983040) { 194 up(&data->update_lock); 195 return -EINVAL; 196 } 197 198 data->fan_preload[nr] = 192 - ((983040 + rpmdiv / 2) / rpmdiv); 199 smsc47m1_write_value(client, SMSC47M1_REG_FAN_PRELOAD(nr), 200 data->fan_preload[nr]); 201 up(&data->update_lock); 202 203 return count; 204 } 205 206 /* Note: we save and restore the fan minimum here, because its value is 207 determined in part by the fan clock divider. This follows the principle 208 of least suprise; the user doesn't expect the fan minimum to change just 209 because the divider changed. */ 210 static ssize_t set_fan_div(struct device *dev, const char *buf, 211 size_t count, int nr) 212 { 213 struct i2c_client *client = to_i2c_client(dev); 214 struct smsc47m1_data *data = i2c_get_clientdata(client); 215 216 long new_div = simple_strtol(buf, NULL, 10), tmp; 217 u8 old_div = DIV_FROM_REG(data->fan_div[nr]); 218 219 if (new_div == old_div) /* No change */ 220 return count; 221 222 down(&data->update_lock); 223 switch (new_div) { 224 case 1: data->fan_div[nr] = 0; break; 225 case 2: data->fan_div[nr] = 1; break; 226 case 4: data->fan_div[nr] = 2; break; 227 case 8: data->fan_div[nr] = 3; break; 228 default: 229 up(&data->update_lock); 230 return -EINVAL; 231 } 232 233 tmp = smsc47m1_read_value(client, SMSC47M1_REG_FANDIV) & 0x0F; 234 tmp |= (data->fan_div[0] << 4) | (data->fan_div[1] << 6); 235 smsc47m1_write_value(client, SMSC47M1_REG_FANDIV, tmp); 236 237 /* Preserve fan min */ 238 tmp = 192 - (old_div * (192 - data->fan_preload[nr]) 239 + new_div / 2) / new_div; 240 data->fan_preload[nr] = SENSORS_LIMIT(tmp, 0, 191); 241 smsc47m1_write_value(client, SMSC47M1_REG_FAN_PRELOAD(nr), 242 data->fan_preload[nr]); 243 up(&data->update_lock); 244 245 return count; 246 } 247 248 static ssize_t set_pwm(struct device *dev, const char *buf, 249 size_t count, int nr) 250 { 251 struct i2c_client *client = to_i2c_client(dev); 252 struct smsc47m1_data *data = i2c_get_clientdata(client); 253 254 long val = simple_strtol(buf, NULL, 10); 255 256 if (val < 0 || val > 255) 257 return -EINVAL; 258 259 down(&data->update_lock); 260 data->pwm[nr] &= 0x81; /* Preserve additional bits */ 261 data->pwm[nr] |= PWM_TO_REG(val); 262 smsc47m1_write_value(client, SMSC47M1_REG_PWM(nr), 263 data->pwm[nr]); 264 up(&data->update_lock); 265 266 return count; 267 } 268 269 static ssize_t set_pwm_en(struct device *dev, const char *buf, 270 size_t count, int nr) 271 { 272 struct i2c_client *client = to_i2c_client(dev); 273 struct smsc47m1_data *data = i2c_get_clientdata(client); 274 275 long val = simple_strtol(buf, NULL, 10); 276 277 if (val != 0 && val != 1) 278 return -EINVAL; 279 280 down(&data->update_lock); 281 data->pwm[nr] &= 0xFE; /* preserve the other bits */ 282 data->pwm[nr] |= !val; 283 smsc47m1_write_value(client, SMSC47M1_REG_PWM(nr), 284 data->pwm[nr]); 285 up(&data->update_lock); 286 287 return count; 288 } 289 290 #define fan_present(offset) \ 291 static ssize_t get_fan##offset (struct device *dev, struct device_attribute *attr, char *buf) \ 292 { \ 293 return get_fan(dev, buf, offset - 1); \ 294 } \ 295 static ssize_t get_fan##offset##_min (struct device *dev, struct device_attribute *attr, char *buf) \ 296 { \ 297 return get_fan_min(dev, buf, offset - 1); \ 298 } \ 299 static ssize_t set_fan##offset##_min (struct device *dev, struct device_attribute *attr, \ 300 const char *buf, size_t count) \ 301 { \ 302 return set_fan_min(dev, buf, count, offset - 1); \ 303 } \ 304 static ssize_t get_fan##offset##_div (struct device *dev, struct device_attribute *attr, char *buf) \ 305 { \ 306 return get_fan_div(dev, buf, offset - 1); \ 307 } \ 308 static ssize_t set_fan##offset##_div (struct device *dev, struct device_attribute *attr, \ 309 const char *buf, size_t count) \ 310 { \ 311 return set_fan_div(dev, buf, count, offset - 1); \ 312 } \ 313 static ssize_t get_pwm##offset (struct device *dev, struct device_attribute *attr, char *buf) \ 314 { \ 315 return get_pwm(dev, buf, offset - 1); \ 316 } \ 317 static ssize_t set_pwm##offset (struct device *dev, struct device_attribute *attr, \ 318 const char *buf, size_t count) \ 319 { \ 320 return set_pwm(dev, buf, count, offset - 1); \ 321 } \ 322 static ssize_t get_pwm##offset##_en (struct device *dev, struct device_attribute *attr, char *buf) \ 323 { \ 324 return get_pwm_en(dev, buf, offset - 1); \ 325 } \ 326 static ssize_t set_pwm##offset##_en (struct device *dev, struct device_attribute *attr, \ 327 const char *buf, size_t count) \ 328 { \ 329 return set_pwm_en(dev, buf, count, offset - 1); \ 330 } \ 331 static DEVICE_ATTR(fan##offset##_input, S_IRUGO, get_fan##offset, \ 332 NULL); \ 333 static DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \ 334 get_fan##offset##_min, set_fan##offset##_min); \ 335 static DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR, \ 336 get_fan##offset##_div, set_fan##offset##_div); \ 337 static DEVICE_ATTR(pwm##offset, S_IRUGO | S_IWUSR, \ 338 get_pwm##offset, set_pwm##offset); \ 339 static DEVICE_ATTR(pwm##offset##_enable, S_IRUGO | S_IWUSR, \ 340 get_pwm##offset##_en, set_pwm##offset##_en); 341 342 fan_present(1); 343 fan_present(2); 344 345 static DEVICE_ATTR(alarms, S_IRUGO, get_alarms, NULL); 346 347 static int __init smsc47m1_find(unsigned short *addr) 348 { 349 u8 val; 350 351 superio_enter(); 352 val = superio_inb(SUPERIO_REG_DEVID); 353 354 /* 355 * SMSC LPC47M10x/LPC47M13x (device id 0x59), LPC47M14x (device id 356 * 0x5F) and LPC47B27x (device id 0x51) have fan control. 357 * The LPC47M15x and LPC47M192 chips "with hardware monitoring block" 358 * can do much more besides (device id 0x60). 359 * The LPC47M997 is undocumented, but seems to be compatible with 360 * the LPC47M192, and has the same device id. 361 */ 362 if (val == 0x51) 363 printk(KERN_INFO "smsc47m1: Found SMSC LPC47B27x\n"); 364 else if (val == 0x59) 365 printk(KERN_INFO "smsc47m1: Found SMSC LPC47M10x/LPC47M13x\n"); 366 else if (val == 0x5F) 367 printk(KERN_INFO "smsc47m1: Found SMSC LPC47M14x\n"); 368 else if (val == 0x60) 369 printk(KERN_INFO "smsc47m1: Found SMSC " 370 "LPC47M15x/LPC47M192/LPC47M997\n"); 371 else { 372 superio_exit(); 373 return -ENODEV; 374 } 375 376 superio_select(); 377 *addr = (superio_inb(SUPERIO_REG_BASE) << 8) 378 | superio_inb(SUPERIO_REG_BASE + 1); 379 val = superio_inb(SUPERIO_REG_ACT); 380 if (*addr == 0 || (val & 0x01) == 0) { 381 printk(KERN_INFO "smsc47m1: Device is disabled, will not use\n"); 382 superio_exit(); 383 return -ENODEV; 384 } 385 386 superio_exit(); 387 return 0; 388 } 389 390 static int smsc47m1_detect(struct i2c_adapter *adapter) 391 { 392 struct i2c_client *new_client; 393 struct smsc47m1_data *data; 394 int err = 0; 395 int fan1, fan2, pwm1, pwm2; 396 397 if (!request_region(address, SMSC_EXTENT, smsc47m1_driver.name)) { 398 dev_err(&adapter->dev, "Region 0x%x already in use!\n", address); 399 return -EBUSY; 400 } 401 402 if (!(data = kzalloc(sizeof(struct smsc47m1_data), GFP_KERNEL))) { 403 err = -ENOMEM; 404 goto error_release; 405 } 406 407 new_client = &data->client; 408 i2c_set_clientdata(new_client, data); 409 new_client->addr = address; 410 init_MUTEX(&data->lock); 411 new_client->adapter = adapter; 412 new_client->driver = &smsc47m1_driver; 413 new_client->flags = 0; 414 415 strlcpy(new_client->name, "smsc47m1", I2C_NAME_SIZE); 416 init_MUTEX(&data->update_lock); 417 418 /* If no function is properly configured, there's no point in 419 actually registering the chip. */ 420 fan1 = (smsc47m1_read_value(new_client, SMSC47M1_REG_TPIN(0)) & 0x05) 421 == 0x05; 422 fan2 = (smsc47m1_read_value(new_client, SMSC47M1_REG_TPIN(1)) & 0x05) 423 == 0x05; 424 pwm1 = (smsc47m1_read_value(new_client, SMSC47M1_REG_PPIN(0)) & 0x05) 425 == 0x04; 426 pwm2 = (smsc47m1_read_value(new_client, SMSC47M1_REG_PPIN(1)) & 0x05) 427 == 0x04; 428 if (!(fan1 || fan2 || pwm1 || pwm2)) { 429 dev_warn(&new_client->dev, "Device is not configured, will not use\n"); 430 err = -ENODEV; 431 goto error_free; 432 } 433 434 if ((err = i2c_attach_client(new_client))) 435 goto error_free; 436 437 /* Some values (fan min, clock dividers, pwm registers) may be 438 needed before any update is triggered, so we better read them 439 at least once here. We don't usually do it that way, but in 440 this particular case, manually reading 5 registers out of 8 441 doesn't make much sense and we're better using the existing 442 function. */ 443 smsc47m1_update_device(&new_client->dev, 1); 444 445 /* Register sysfs hooks */ 446 data->class_dev = hwmon_device_register(&new_client->dev); 447 if (IS_ERR(data->class_dev)) { 448 err = PTR_ERR(data->class_dev); 449 goto error_detach; 450 } 451 452 if (fan1) { 453 device_create_file(&new_client->dev, &dev_attr_fan1_input); 454 device_create_file(&new_client->dev, &dev_attr_fan1_min); 455 device_create_file(&new_client->dev, &dev_attr_fan1_div); 456 } else 457 dev_dbg(&new_client->dev, "Fan 1 not enabled by hardware, " 458 "skipping\n"); 459 460 if (fan2) { 461 device_create_file(&new_client->dev, &dev_attr_fan2_input); 462 device_create_file(&new_client->dev, &dev_attr_fan2_min); 463 device_create_file(&new_client->dev, &dev_attr_fan2_div); 464 } else 465 dev_dbg(&new_client->dev, "Fan 2 not enabled by hardware, " 466 "skipping\n"); 467 468 if (pwm1) { 469 device_create_file(&new_client->dev, &dev_attr_pwm1); 470 device_create_file(&new_client->dev, &dev_attr_pwm1_enable); 471 } else 472 dev_dbg(&new_client->dev, "PWM 1 not enabled by hardware, " 473 "skipping\n"); 474 if (pwm2) { 475 device_create_file(&new_client->dev, &dev_attr_pwm2); 476 device_create_file(&new_client->dev, &dev_attr_pwm2_enable); 477 } else 478 dev_dbg(&new_client->dev, "PWM 2 not enabled by hardware, " 479 "skipping\n"); 480 481 device_create_file(&new_client->dev, &dev_attr_alarms); 482 483 return 0; 484 485 error_detach: 486 i2c_detach_client(new_client); 487 error_free: 488 kfree(data); 489 error_release: 490 release_region(address, SMSC_EXTENT); 491 return err; 492 } 493 494 static int smsc47m1_detach_client(struct i2c_client *client) 495 { 496 struct smsc47m1_data *data = i2c_get_clientdata(client); 497 int err; 498 499 hwmon_device_unregister(data->class_dev); 500 501 if ((err = i2c_detach_client(client))) 502 return err; 503 504 release_region(client->addr, SMSC_EXTENT); 505 kfree(data); 506 507 return 0; 508 } 509 510 static int smsc47m1_read_value(struct i2c_client *client, u8 reg) 511 { 512 int res; 513 514 down(&((struct smsc47m1_data *) i2c_get_clientdata(client))->lock); 515 res = inb_p(client->addr + reg); 516 up(&((struct smsc47m1_data *) i2c_get_clientdata(client))->lock); 517 return res; 518 } 519 520 static void smsc47m1_write_value(struct i2c_client *client, u8 reg, u8 value) 521 { 522 down(&((struct smsc47m1_data *) i2c_get_clientdata(client))->lock); 523 outb_p(value, client->addr + reg); 524 up(&((struct smsc47m1_data *) i2c_get_clientdata(client))->lock); 525 } 526 527 static struct smsc47m1_data *smsc47m1_update_device(struct device *dev, 528 int init) 529 { 530 struct i2c_client *client = to_i2c_client(dev); 531 struct smsc47m1_data *data = i2c_get_clientdata(client); 532 533 down(&data->update_lock); 534 535 if (time_after(jiffies, data->last_updated + HZ + HZ / 2) || init) { 536 int i; 537 538 for (i = 0; i < 2; i++) { 539 data->fan[i] = smsc47m1_read_value(client, 540 SMSC47M1_REG_FAN(i)); 541 data->fan_preload[i] = smsc47m1_read_value(client, 542 SMSC47M1_REG_FAN_PRELOAD(i)); 543 data->pwm[i] = smsc47m1_read_value(client, 544 SMSC47M1_REG_PWM(i)); 545 } 546 547 i = smsc47m1_read_value(client, SMSC47M1_REG_FANDIV); 548 data->fan_div[0] = (i >> 4) & 0x03; 549 data->fan_div[1] = i >> 6; 550 551 data->alarms = smsc47m1_read_value(client, 552 SMSC47M1_REG_ALARM) >> 6; 553 /* Clear alarms if needed */ 554 if (data->alarms) 555 smsc47m1_write_value(client, SMSC47M1_REG_ALARM, 0xC0); 556 557 data->last_updated = jiffies; 558 } 559 560 up(&data->update_lock); 561 return data; 562 } 563 564 static int __init sm_smsc47m1_init(void) 565 { 566 if (smsc47m1_find(&address)) { 567 return -ENODEV; 568 } 569 570 return i2c_isa_add_driver(&smsc47m1_driver); 571 } 572 573 static void __exit sm_smsc47m1_exit(void) 574 { 575 i2c_isa_del_driver(&smsc47m1_driver); 576 } 577 578 MODULE_AUTHOR("Mark D. Studebaker <mdsxyz123@yahoo.com>"); 579 MODULE_DESCRIPTION("SMSC LPC47M1xx fan sensors driver"); 580 MODULE_LICENSE("GPL"); 581 582 module_init(sm_smsc47m1_init); 583 module_exit(sm_smsc47m1_exit); 584