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