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