1 /* 2 * drivers/hwmon/applesmc.c - driver for Apple's SMC (accelerometer, temperature 3 * sensors, fan control, keyboard backlight control) used in Intel-based Apple 4 * computers. 5 * 6 * Copyright (C) 2007 Nicolas Boichat <nicolas@boichat.ch> 7 * 8 * Based on hdaps.c driver: 9 * Copyright (C) 2005 Robert Love <rml@novell.com> 10 * Copyright (C) 2005 Jesper Juhl <jesper.juhl@gmail.com> 11 * 12 * Fan control based on smcFanControl: 13 * Copyright (C) 2006 Hendrik Holtmann <holtmann@mac.com> 14 * 15 * This program is free software; you can redistribute it and/or modify it 16 * under the terms of the GNU General Public License v2 as published by the 17 * Free Software Foundation. 18 * 19 * This program is distributed in the hope that it will be useful, but WITHOUT 20 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 21 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 22 * more details. 23 * 24 * You should have received a copy of the GNU General Public License along with 25 * this program; if not, write to the Free Software Foundation, Inc., 26 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA 27 */ 28 29 #include <linux/delay.h> 30 #include <linux/platform_device.h> 31 #include <linux/input-polldev.h> 32 #include <linux/kernel.h> 33 #include <linux/module.h> 34 #include <linux/timer.h> 35 #include <linux/dmi.h> 36 #include <linux/mutex.h> 37 #include <linux/hwmon-sysfs.h> 38 #include <asm/io.h> 39 #include <linux/leds.h> 40 #include <linux/hwmon.h> 41 #include <linux/workqueue.h> 42 43 /* data port used by Apple SMC */ 44 #define APPLESMC_DATA_PORT 0x300 45 /* command/status port used by Apple SMC */ 46 #define APPLESMC_CMD_PORT 0x304 47 48 #define APPLESMC_NR_PORTS 32 /* 0x300-0x31f */ 49 50 #define APPLESMC_MAX_DATA_LENGTH 32 51 52 #define APPLESMC_MIN_WAIT 0x0040 53 #define APPLESMC_MAX_WAIT 0x8000 54 55 #define APPLESMC_STATUS_MASK 0x0f 56 #define APPLESMC_READ_CMD 0x10 57 #define APPLESMC_WRITE_CMD 0x11 58 #define APPLESMC_GET_KEY_BY_INDEX_CMD 0x12 59 #define APPLESMC_GET_KEY_TYPE_CMD 0x13 60 61 #define KEY_COUNT_KEY "#KEY" /* r-o ui32 */ 62 63 #define LIGHT_SENSOR_LEFT_KEY "ALV0" /* r-o {alv (6-10 bytes) */ 64 #define LIGHT_SENSOR_RIGHT_KEY "ALV1" /* r-o {alv (6-10 bytes) */ 65 #define BACKLIGHT_KEY "LKSB" /* w-o {lkb (2 bytes) */ 66 67 #define CLAMSHELL_KEY "MSLD" /* r-o ui8 (unused) */ 68 69 #define MOTION_SENSOR_X_KEY "MO_X" /* r-o sp78 (2 bytes) */ 70 #define MOTION_SENSOR_Y_KEY "MO_Y" /* r-o sp78 (2 bytes) */ 71 #define MOTION_SENSOR_Z_KEY "MO_Z" /* r-o sp78 (2 bytes) */ 72 #define MOTION_SENSOR_KEY "MOCN" /* r/w ui16 */ 73 74 #define FANS_COUNT "FNum" /* r-o ui8 */ 75 #define FANS_MANUAL "FS! " /* r-w ui16 */ 76 #define FAN_ACTUAL_SPEED "F0Ac" /* r-o fpe2 (2 bytes) */ 77 #define FAN_MIN_SPEED "F0Mn" /* r-o fpe2 (2 bytes) */ 78 #define FAN_MAX_SPEED "F0Mx" /* r-o fpe2 (2 bytes) */ 79 #define FAN_SAFE_SPEED "F0Sf" /* r-o fpe2 (2 bytes) */ 80 #define FAN_TARGET_SPEED "F0Tg" /* r-w fpe2 (2 bytes) */ 81 #define FAN_POSITION "F0ID" /* r-o char[16] */ 82 83 /* 84 * Temperature sensors keys (sp78 - 2 bytes). 85 */ 86 static const char* temperature_sensors_sets[][36] = { 87 /* Set 0: Macbook Pro */ 88 { "TA0P", "TB0T", "TC0D", "TC0P", "TG0H", "TG0P", "TG0T", "Th0H", 89 "Th1H", "Tm0P", "Ts0P", "Ts1P", NULL }, 90 /* Set 1: Macbook2 set */ 91 { "TB0T", "TC0D", "TC0P", "TM0P", "TN0P", "TN1P", "TTF0", "Th0H", 92 "Th0S", "Th1H", NULL }, 93 /* Set 2: Macbook set */ 94 { "TB0T", "TC0D", "TC0P", "TM0P", "TN0P", "TN1P", "Th0H", "Th0S", 95 "Th1H", "Ts0P", NULL }, 96 /* Set 3: Macmini set */ 97 { "TC0D", "TC0P", NULL }, 98 /* Set 4: Mac Pro (2 x Quad-Core) */ 99 { "TA0P", "TCAG", "TCAH", "TCBG", "TCBH", "TC0C", "TC0D", "TC0P", 100 "TC1C", "TC1D", "TC2C", "TC2D", "TC3C", "TC3D", "THTG", "TH0P", 101 "TH1P", "TH2P", "TH3P", "TMAP", "TMAS", "TMBS", "TM0P", "TM0S", 102 "TM1P", "TM1S", "TM2P", "TM2S", "TM3S", "TM8P", "TM8S", "TM9P", 103 "TM9S", "TN0H", "TS0C", NULL }, 104 /* Set 5: iMac */ 105 { "TC0D", "TA0P", "TG0P", "TG0D", "TG0H", "TH0P", "Tm0P", "TO0P", 106 "Tp0C", NULL }, 107 /* Set 6: Macbook3 set */ 108 { "TB0T", "TC0D", "TC0P", "TM0P", "TN0P", "TTF0", "TW0P", "Th0H", 109 "Th0S", "Th1H", NULL }, 110 /* Set 7: Macbook Air */ 111 { "TB0T", "TB1S", "TB1T", "TB2S", "TB2T", "TC0D", "TC0P", "TCFP", 112 "TTF0", "TW0P", "Th0H", "Tp0P", "TpFP", "Ts0P", "Ts0S", NULL }, 113 /* Set 8: Macbook Pro 4,1 (Penryn) */ 114 { "TB0T", "TC0D", "TC0P", "TG0D", "TG0H", "TTF0", "TW0P", "Th0H", 115 "Th1H", "Th2H", "Tm0P", "Ts0P", NULL }, 116 /* Set 9: Macbook Pro 3,1 (Santa Rosa) */ 117 { "TALP", "TB0T", "TC0D", "TC0P", "TG0D", "TG0H", "TTF0", "TW0P", 118 "Th0H", "Th1H", "Th2H", "Tm0P", "Ts0P", NULL }, 119 }; 120 121 /* List of keys used to read/write fan speeds */ 122 static const char* fan_speed_keys[] = { 123 FAN_ACTUAL_SPEED, 124 FAN_MIN_SPEED, 125 FAN_MAX_SPEED, 126 FAN_SAFE_SPEED, 127 FAN_TARGET_SPEED 128 }; 129 130 #define INIT_TIMEOUT_MSECS 5000 /* wait up to 5s for device init ... */ 131 #define INIT_WAIT_MSECS 50 /* ... in 50ms increments */ 132 133 #define APPLESMC_POLL_INTERVAL 50 /* msecs */ 134 #define APPLESMC_INPUT_FUZZ 4 /* input event threshold */ 135 #define APPLESMC_INPUT_FLAT 4 136 137 #define SENSOR_X 0 138 #define SENSOR_Y 1 139 #define SENSOR_Z 2 140 141 /* Structure to be passed to DMI_MATCH function */ 142 struct dmi_match_data { 143 /* Indicates whether this computer has an accelerometer. */ 144 int accelerometer; 145 /* Indicates whether this computer has light sensors and keyboard backlight. */ 146 int light; 147 /* Indicates which temperature sensors set to use. */ 148 int temperature_set; 149 }; 150 151 static const int debug; 152 static struct platform_device *pdev; 153 static s16 rest_x; 154 static s16 rest_y; 155 static struct device *hwmon_dev; 156 static struct input_polled_dev *applesmc_idev; 157 158 /* Indicates whether this computer has an accelerometer. */ 159 static unsigned int applesmc_accelerometer; 160 161 /* Indicates whether this computer has light sensors and keyboard backlight. */ 162 static unsigned int applesmc_light; 163 164 /* Indicates which temperature sensors set to use. */ 165 static unsigned int applesmc_temperature_set; 166 167 static DEFINE_MUTEX(applesmc_lock); 168 169 /* 170 * Last index written to key_at_index sysfs file, and value to use for all other 171 * key_at_index_* sysfs files. 172 */ 173 static unsigned int key_at_index; 174 175 static struct workqueue_struct *applesmc_led_wq; 176 177 /* 178 * __wait_status - Wait up to 32ms for the status port to get a certain value 179 * (masked with 0x0f), returning zero if the value is obtained. Callers must 180 * hold applesmc_lock. 181 */ 182 static int __wait_status(u8 val) 183 { 184 int us; 185 186 val = val & APPLESMC_STATUS_MASK; 187 188 for (us = APPLESMC_MIN_WAIT; us < APPLESMC_MAX_WAIT; us <<= 1) { 189 udelay(us); 190 if ((inb(APPLESMC_CMD_PORT) & APPLESMC_STATUS_MASK) == val) { 191 if (debug) 192 printk(KERN_DEBUG 193 "Waited %d us for status %x\n", 194 2 * us - APPLESMC_MIN_WAIT, val); 195 return 0; 196 } 197 } 198 199 printk(KERN_WARNING "applesmc: wait status failed: %x != %x\n", 200 val, inb(APPLESMC_CMD_PORT)); 201 202 return -EIO; 203 } 204 205 /* 206 * special treatment of command port - on newer macbooks, it seems necessary 207 * to resend the command byte before polling the status again. Callers must 208 * hold applesmc_lock. 209 */ 210 static int send_command(u8 cmd) 211 { 212 int us; 213 for (us = APPLESMC_MIN_WAIT; us < APPLESMC_MAX_WAIT; us <<= 1) { 214 outb(cmd, APPLESMC_CMD_PORT); 215 udelay(us); 216 if ((inb(APPLESMC_CMD_PORT) & APPLESMC_STATUS_MASK) == 0x0c) 217 return 0; 218 } 219 printk(KERN_WARNING "applesmc: command failed: %x -> %x\n", 220 cmd, inb(APPLESMC_CMD_PORT)); 221 return -EIO; 222 } 223 224 /* 225 * applesmc_read_key - reads len bytes from a given key, and put them in buffer. 226 * Returns zero on success or a negative error on failure. Callers must 227 * hold applesmc_lock. 228 */ 229 static int applesmc_read_key(const char* key, u8* buffer, u8 len) 230 { 231 int i; 232 233 if (len > APPLESMC_MAX_DATA_LENGTH) { 234 printk(KERN_ERR "applesmc_read_key: cannot read more than " 235 "%d bytes\n", APPLESMC_MAX_DATA_LENGTH); 236 return -EINVAL; 237 } 238 239 if (send_command(APPLESMC_READ_CMD)) 240 return -EIO; 241 242 for (i = 0; i < 4; i++) { 243 outb(key[i], APPLESMC_DATA_PORT); 244 if (__wait_status(0x04)) 245 return -EIO; 246 } 247 if (debug) 248 printk(KERN_DEBUG "<%s", key); 249 250 outb(len, APPLESMC_DATA_PORT); 251 if (debug) 252 printk(KERN_DEBUG ">%x", len); 253 254 for (i = 0; i < len; i++) { 255 if (__wait_status(0x05)) 256 return -EIO; 257 buffer[i] = inb(APPLESMC_DATA_PORT); 258 if (debug) 259 printk(KERN_DEBUG "<%x", buffer[i]); 260 } 261 if (debug) 262 printk(KERN_DEBUG "\n"); 263 264 return 0; 265 } 266 267 /* 268 * applesmc_write_key - writes len bytes from buffer to a given key. 269 * Returns zero on success or a negative error on failure. Callers must 270 * hold applesmc_lock. 271 */ 272 static int applesmc_write_key(const char* key, u8* buffer, u8 len) 273 { 274 int i; 275 276 if (len > APPLESMC_MAX_DATA_LENGTH) { 277 printk(KERN_ERR "applesmc_write_key: cannot write more than " 278 "%d bytes\n", APPLESMC_MAX_DATA_LENGTH); 279 return -EINVAL; 280 } 281 282 if (send_command(APPLESMC_WRITE_CMD)) 283 return -EIO; 284 285 for (i = 0; i < 4; i++) { 286 outb(key[i], APPLESMC_DATA_PORT); 287 if (__wait_status(0x04)) 288 return -EIO; 289 } 290 291 outb(len, APPLESMC_DATA_PORT); 292 293 for (i = 0; i < len; i++) { 294 if (__wait_status(0x04)) 295 return -EIO; 296 outb(buffer[i], APPLESMC_DATA_PORT); 297 } 298 299 return 0; 300 } 301 302 /* 303 * applesmc_get_key_at_index - get key at index, and put the result in key 304 * (char[6]). Returns zero on success or a negative error on failure. Callers 305 * must hold applesmc_lock. 306 */ 307 static int applesmc_get_key_at_index(int index, char* key) 308 { 309 int i; 310 u8 readkey[4]; 311 readkey[0] = index >> 24; 312 readkey[1] = index >> 16; 313 readkey[2] = index >> 8; 314 readkey[3] = index; 315 316 if (send_command(APPLESMC_GET_KEY_BY_INDEX_CMD)) 317 return -EIO; 318 319 for (i = 0; i < 4; i++) { 320 outb(readkey[i], APPLESMC_DATA_PORT); 321 if (__wait_status(0x04)) 322 return -EIO; 323 } 324 325 outb(4, APPLESMC_DATA_PORT); 326 327 for (i = 0; i < 4; i++) { 328 if (__wait_status(0x05)) 329 return -EIO; 330 key[i] = inb(APPLESMC_DATA_PORT); 331 } 332 key[4] = 0; 333 334 return 0; 335 } 336 337 /* 338 * applesmc_get_key_type - get key type, and put the result in type (char[6]). 339 * Returns zero on success or a negative error on failure. Callers must 340 * hold applesmc_lock. 341 */ 342 static int applesmc_get_key_type(char* key, char* type) 343 { 344 int i; 345 346 if (send_command(APPLESMC_GET_KEY_TYPE_CMD)) 347 return -EIO; 348 349 for (i = 0; i < 4; i++) { 350 outb(key[i], APPLESMC_DATA_PORT); 351 if (__wait_status(0x04)) 352 return -EIO; 353 } 354 355 outb(6, APPLESMC_DATA_PORT); 356 357 for (i = 0; i < 6; i++) { 358 if (__wait_status(0x05)) 359 return -EIO; 360 type[i] = inb(APPLESMC_DATA_PORT); 361 } 362 type[5] = 0; 363 364 return 0; 365 } 366 367 /* 368 * applesmc_read_motion_sensor - Read motion sensor (X, Y or Z). Callers must 369 * hold applesmc_lock. 370 */ 371 static int applesmc_read_motion_sensor(int index, s16* value) 372 { 373 u8 buffer[2]; 374 int ret; 375 376 switch (index) { 377 case SENSOR_X: 378 ret = applesmc_read_key(MOTION_SENSOR_X_KEY, buffer, 2); 379 break; 380 case SENSOR_Y: 381 ret = applesmc_read_key(MOTION_SENSOR_Y_KEY, buffer, 2); 382 break; 383 case SENSOR_Z: 384 ret = applesmc_read_key(MOTION_SENSOR_Z_KEY, buffer, 2); 385 break; 386 default: 387 ret = -EINVAL; 388 } 389 390 *value = ((s16)buffer[0] << 8) | buffer[1]; 391 392 return ret; 393 } 394 395 /* 396 * applesmc_device_init - initialize the accelerometer. Returns zero on success 397 * and negative error code on failure. Can sleep. 398 */ 399 static int applesmc_device_init(void) 400 { 401 int total, ret = -ENXIO; 402 u8 buffer[2]; 403 404 if (!applesmc_accelerometer) 405 return 0; 406 407 mutex_lock(&applesmc_lock); 408 409 for (total = INIT_TIMEOUT_MSECS; total > 0; total -= INIT_WAIT_MSECS) { 410 if (debug) 411 printk(KERN_DEBUG "applesmc try %d\n", total); 412 if (!applesmc_read_key(MOTION_SENSOR_KEY, buffer, 2) && 413 (buffer[0] != 0x00 || buffer[1] != 0x00)) { 414 if (total == INIT_TIMEOUT_MSECS) { 415 printk(KERN_DEBUG "applesmc: device has" 416 " already been initialized" 417 " (0x%02x, 0x%02x).\n", 418 buffer[0], buffer[1]); 419 } else { 420 printk(KERN_DEBUG "applesmc: device" 421 " successfully initialized" 422 " (0x%02x, 0x%02x).\n", 423 buffer[0], buffer[1]); 424 } 425 ret = 0; 426 goto out; 427 } 428 buffer[0] = 0xe0; 429 buffer[1] = 0x00; 430 applesmc_write_key(MOTION_SENSOR_KEY, buffer, 2); 431 msleep(INIT_WAIT_MSECS); 432 } 433 434 printk(KERN_WARNING "applesmc: failed to init the device\n"); 435 436 out: 437 mutex_unlock(&applesmc_lock); 438 return ret; 439 } 440 441 /* 442 * applesmc_get_fan_count - get the number of fans. Callers must NOT hold 443 * applesmc_lock. 444 */ 445 static int applesmc_get_fan_count(void) 446 { 447 int ret; 448 u8 buffer[1]; 449 450 mutex_lock(&applesmc_lock); 451 452 ret = applesmc_read_key(FANS_COUNT, buffer, 1); 453 454 mutex_unlock(&applesmc_lock); 455 if (ret) 456 return ret; 457 else 458 return buffer[0]; 459 } 460 461 /* Device model stuff */ 462 static int applesmc_probe(struct platform_device *dev) 463 { 464 int ret; 465 466 ret = applesmc_device_init(); 467 if (ret) 468 return ret; 469 470 printk(KERN_INFO "applesmc: device successfully initialized.\n"); 471 return 0; 472 } 473 474 static int applesmc_resume(struct platform_device *dev) 475 { 476 return applesmc_device_init(); 477 } 478 479 static struct platform_driver applesmc_driver = { 480 .probe = applesmc_probe, 481 .resume = applesmc_resume, 482 .driver = { 483 .name = "applesmc", 484 .owner = THIS_MODULE, 485 }, 486 }; 487 488 /* 489 * applesmc_calibrate - Set our "resting" values. Callers must 490 * hold applesmc_lock. 491 */ 492 static void applesmc_calibrate(void) 493 { 494 applesmc_read_motion_sensor(SENSOR_X, &rest_x); 495 applesmc_read_motion_sensor(SENSOR_Y, &rest_y); 496 rest_x = -rest_x; 497 } 498 499 static void applesmc_idev_poll(struct input_polled_dev *dev) 500 { 501 struct input_dev *idev = dev->input; 502 s16 x, y; 503 504 mutex_lock(&applesmc_lock); 505 506 if (applesmc_read_motion_sensor(SENSOR_X, &x)) 507 goto out; 508 if (applesmc_read_motion_sensor(SENSOR_Y, &y)) 509 goto out; 510 511 x = -x; 512 input_report_abs(idev, ABS_X, x - rest_x); 513 input_report_abs(idev, ABS_Y, y - rest_y); 514 input_sync(idev); 515 516 out: 517 mutex_unlock(&applesmc_lock); 518 } 519 520 /* Sysfs Files */ 521 522 static ssize_t applesmc_name_show(struct device *dev, 523 struct device_attribute *attr, char *buf) 524 { 525 return snprintf(buf, PAGE_SIZE, "applesmc\n"); 526 } 527 528 static ssize_t applesmc_position_show(struct device *dev, 529 struct device_attribute *attr, char *buf) 530 { 531 int ret; 532 s16 x, y, z; 533 534 mutex_lock(&applesmc_lock); 535 536 ret = applesmc_read_motion_sensor(SENSOR_X, &x); 537 if (ret) 538 goto out; 539 ret = applesmc_read_motion_sensor(SENSOR_Y, &y); 540 if (ret) 541 goto out; 542 ret = applesmc_read_motion_sensor(SENSOR_Z, &z); 543 if (ret) 544 goto out; 545 546 out: 547 mutex_unlock(&applesmc_lock); 548 if (ret) 549 return ret; 550 else 551 return snprintf(buf, PAGE_SIZE, "(%d,%d,%d)\n", x, y, z); 552 } 553 554 static ssize_t applesmc_light_show(struct device *dev, 555 struct device_attribute *attr, char *sysfsbuf) 556 { 557 static int data_length; 558 int ret; 559 u8 left = 0, right = 0; 560 u8 buffer[10], query[6]; 561 562 mutex_lock(&applesmc_lock); 563 564 if (!data_length) { 565 ret = applesmc_get_key_type(LIGHT_SENSOR_LEFT_KEY, query); 566 if (ret) 567 goto out; 568 data_length = clamp_val(query[0], 0, 10); 569 printk(KERN_INFO "applesmc: light sensor data length set to " 570 "%d\n", data_length); 571 } 572 573 ret = applesmc_read_key(LIGHT_SENSOR_LEFT_KEY, buffer, data_length); 574 left = buffer[2]; 575 if (ret) 576 goto out; 577 ret = applesmc_read_key(LIGHT_SENSOR_RIGHT_KEY, buffer, data_length); 578 right = buffer[2]; 579 580 out: 581 mutex_unlock(&applesmc_lock); 582 if (ret) 583 return ret; 584 else 585 return snprintf(sysfsbuf, PAGE_SIZE, "(%d,%d)\n", left, right); 586 } 587 588 /* Displays degree Celsius * 1000 */ 589 static ssize_t applesmc_show_temperature(struct device *dev, 590 struct device_attribute *devattr, char *sysfsbuf) 591 { 592 int ret; 593 u8 buffer[2]; 594 unsigned int temp; 595 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 596 const char* key = 597 temperature_sensors_sets[applesmc_temperature_set][attr->index]; 598 599 mutex_lock(&applesmc_lock); 600 601 ret = applesmc_read_key(key, buffer, 2); 602 temp = buffer[0]*1000; 603 temp += (buffer[1] >> 6) * 250; 604 605 mutex_unlock(&applesmc_lock); 606 607 if (ret) 608 return ret; 609 else 610 return snprintf(sysfsbuf, PAGE_SIZE, "%u\n", temp); 611 } 612 613 static ssize_t applesmc_show_fan_speed(struct device *dev, 614 struct device_attribute *attr, char *sysfsbuf) 615 { 616 int ret; 617 unsigned int speed = 0; 618 char newkey[5]; 619 u8 buffer[2]; 620 struct sensor_device_attribute_2 *sensor_attr = 621 to_sensor_dev_attr_2(attr); 622 623 newkey[0] = fan_speed_keys[sensor_attr->nr][0]; 624 newkey[1] = '0' + sensor_attr->index; 625 newkey[2] = fan_speed_keys[sensor_attr->nr][2]; 626 newkey[3] = fan_speed_keys[sensor_attr->nr][3]; 627 newkey[4] = 0; 628 629 mutex_lock(&applesmc_lock); 630 631 ret = applesmc_read_key(newkey, buffer, 2); 632 speed = ((buffer[0] << 8 | buffer[1]) >> 2); 633 634 mutex_unlock(&applesmc_lock); 635 if (ret) 636 return ret; 637 else 638 return snprintf(sysfsbuf, PAGE_SIZE, "%u\n", speed); 639 } 640 641 static ssize_t applesmc_store_fan_speed(struct device *dev, 642 struct device_attribute *attr, 643 const char *sysfsbuf, size_t count) 644 { 645 int ret; 646 u32 speed; 647 char newkey[5]; 648 u8 buffer[2]; 649 struct sensor_device_attribute_2 *sensor_attr = 650 to_sensor_dev_attr_2(attr); 651 652 speed = simple_strtoul(sysfsbuf, NULL, 10); 653 654 if (speed > 0x4000) /* Bigger than a 14-bit value */ 655 return -EINVAL; 656 657 newkey[0] = fan_speed_keys[sensor_attr->nr][0]; 658 newkey[1] = '0' + sensor_attr->index; 659 newkey[2] = fan_speed_keys[sensor_attr->nr][2]; 660 newkey[3] = fan_speed_keys[sensor_attr->nr][3]; 661 newkey[4] = 0; 662 663 mutex_lock(&applesmc_lock); 664 665 buffer[0] = (speed >> 6) & 0xff; 666 buffer[1] = (speed << 2) & 0xff; 667 ret = applesmc_write_key(newkey, buffer, 2); 668 669 mutex_unlock(&applesmc_lock); 670 if (ret) 671 return ret; 672 else 673 return count; 674 } 675 676 static ssize_t applesmc_show_fan_manual(struct device *dev, 677 struct device_attribute *devattr, char *sysfsbuf) 678 { 679 int ret; 680 u16 manual = 0; 681 u8 buffer[2]; 682 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 683 684 mutex_lock(&applesmc_lock); 685 686 ret = applesmc_read_key(FANS_MANUAL, buffer, 2); 687 manual = ((buffer[0] << 8 | buffer[1]) >> attr->index) & 0x01; 688 689 mutex_unlock(&applesmc_lock); 690 if (ret) 691 return ret; 692 else 693 return snprintf(sysfsbuf, PAGE_SIZE, "%d\n", manual); 694 } 695 696 static ssize_t applesmc_store_fan_manual(struct device *dev, 697 struct device_attribute *devattr, 698 const char *sysfsbuf, size_t count) 699 { 700 int ret; 701 u8 buffer[2]; 702 u32 input; 703 u16 val; 704 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 705 706 input = simple_strtoul(sysfsbuf, NULL, 10); 707 708 mutex_lock(&applesmc_lock); 709 710 ret = applesmc_read_key(FANS_MANUAL, buffer, 2); 711 val = (buffer[0] << 8 | buffer[1]); 712 if (ret) 713 goto out; 714 715 if (input) 716 val = val | (0x01 << attr->index); 717 else 718 val = val & ~(0x01 << attr->index); 719 720 buffer[0] = (val >> 8) & 0xFF; 721 buffer[1] = val & 0xFF; 722 723 ret = applesmc_write_key(FANS_MANUAL, buffer, 2); 724 725 out: 726 mutex_unlock(&applesmc_lock); 727 if (ret) 728 return ret; 729 else 730 return count; 731 } 732 733 static ssize_t applesmc_show_fan_position(struct device *dev, 734 struct device_attribute *attr, char *sysfsbuf) 735 { 736 int ret; 737 char newkey[5]; 738 u8 buffer[17]; 739 struct sensor_device_attribute_2 *sensor_attr = 740 to_sensor_dev_attr_2(attr); 741 742 newkey[0] = FAN_POSITION[0]; 743 newkey[1] = '0' + sensor_attr->index; 744 newkey[2] = FAN_POSITION[2]; 745 newkey[3] = FAN_POSITION[3]; 746 newkey[4] = 0; 747 748 mutex_lock(&applesmc_lock); 749 750 ret = applesmc_read_key(newkey, buffer, 16); 751 buffer[16] = 0; 752 753 mutex_unlock(&applesmc_lock); 754 if (ret) 755 return ret; 756 else 757 return snprintf(sysfsbuf, PAGE_SIZE, "%s\n", buffer+4); 758 } 759 760 static ssize_t applesmc_calibrate_show(struct device *dev, 761 struct device_attribute *attr, char *sysfsbuf) 762 { 763 return snprintf(sysfsbuf, PAGE_SIZE, "(%d,%d)\n", rest_x, rest_y); 764 } 765 766 static ssize_t applesmc_calibrate_store(struct device *dev, 767 struct device_attribute *attr, const char *sysfsbuf, size_t count) 768 { 769 mutex_lock(&applesmc_lock); 770 applesmc_calibrate(); 771 mutex_unlock(&applesmc_lock); 772 773 return count; 774 } 775 776 /* Store the next backlight value to be written by the work */ 777 static unsigned int backlight_value; 778 779 static void applesmc_backlight_set(struct work_struct *work) 780 { 781 u8 buffer[2]; 782 783 mutex_lock(&applesmc_lock); 784 buffer[0] = backlight_value; 785 buffer[1] = 0x00; 786 applesmc_write_key(BACKLIGHT_KEY, buffer, 2); 787 mutex_unlock(&applesmc_lock); 788 } 789 static DECLARE_WORK(backlight_work, &applesmc_backlight_set); 790 791 static void applesmc_brightness_set(struct led_classdev *led_cdev, 792 enum led_brightness value) 793 { 794 int ret; 795 796 backlight_value = value; 797 ret = queue_work(applesmc_led_wq, &backlight_work); 798 799 if (debug && (!ret)) 800 printk(KERN_DEBUG "applesmc: work was already on the queue.\n"); 801 } 802 803 static ssize_t applesmc_key_count_show(struct device *dev, 804 struct device_attribute *attr, char *sysfsbuf) 805 { 806 int ret; 807 u8 buffer[4]; 808 u32 count; 809 810 mutex_lock(&applesmc_lock); 811 812 ret = applesmc_read_key(KEY_COUNT_KEY, buffer, 4); 813 count = ((u32)buffer[0]<<24) + ((u32)buffer[1]<<16) + 814 ((u32)buffer[2]<<8) + buffer[3]; 815 816 mutex_unlock(&applesmc_lock); 817 if (ret) 818 return ret; 819 else 820 return snprintf(sysfsbuf, PAGE_SIZE, "%d\n", count); 821 } 822 823 static ssize_t applesmc_key_at_index_read_show(struct device *dev, 824 struct device_attribute *attr, char *sysfsbuf) 825 { 826 char key[5]; 827 char info[6]; 828 int ret; 829 830 mutex_lock(&applesmc_lock); 831 832 ret = applesmc_get_key_at_index(key_at_index, key); 833 834 if (ret || !key[0]) { 835 mutex_unlock(&applesmc_lock); 836 837 return -EINVAL; 838 } 839 840 ret = applesmc_get_key_type(key, info); 841 842 if (ret) { 843 mutex_unlock(&applesmc_lock); 844 845 return ret; 846 } 847 848 /* 849 * info[0] maximum value (APPLESMC_MAX_DATA_LENGTH) is much lower than 850 * PAGE_SIZE, so we don't need any checks before writing to sysfsbuf. 851 */ 852 ret = applesmc_read_key(key, sysfsbuf, info[0]); 853 854 mutex_unlock(&applesmc_lock); 855 856 if (!ret) { 857 return info[0]; 858 } else { 859 return ret; 860 } 861 } 862 863 static ssize_t applesmc_key_at_index_data_length_show(struct device *dev, 864 struct device_attribute *attr, char *sysfsbuf) 865 { 866 char key[5]; 867 char info[6]; 868 int ret; 869 870 mutex_lock(&applesmc_lock); 871 872 ret = applesmc_get_key_at_index(key_at_index, key); 873 874 if (ret || !key[0]) { 875 mutex_unlock(&applesmc_lock); 876 877 return -EINVAL; 878 } 879 880 ret = applesmc_get_key_type(key, info); 881 882 mutex_unlock(&applesmc_lock); 883 884 if (!ret) 885 return snprintf(sysfsbuf, PAGE_SIZE, "%d\n", info[0]); 886 else 887 return ret; 888 } 889 890 static ssize_t applesmc_key_at_index_type_show(struct device *dev, 891 struct device_attribute *attr, char *sysfsbuf) 892 { 893 char key[5]; 894 char info[6]; 895 int ret; 896 897 mutex_lock(&applesmc_lock); 898 899 ret = applesmc_get_key_at_index(key_at_index, key); 900 901 if (ret || !key[0]) { 902 mutex_unlock(&applesmc_lock); 903 904 return -EINVAL; 905 } 906 907 ret = applesmc_get_key_type(key, info); 908 909 mutex_unlock(&applesmc_lock); 910 911 if (!ret) 912 return snprintf(sysfsbuf, PAGE_SIZE, "%s\n", info+1); 913 else 914 return ret; 915 } 916 917 static ssize_t applesmc_key_at_index_name_show(struct device *dev, 918 struct device_attribute *attr, char *sysfsbuf) 919 { 920 char key[5]; 921 int ret; 922 923 mutex_lock(&applesmc_lock); 924 925 ret = applesmc_get_key_at_index(key_at_index, key); 926 927 mutex_unlock(&applesmc_lock); 928 929 if (!ret && key[0]) 930 return snprintf(sysfsbuf, PAGE_SIZE, "%s\n", key); 931 else 932 return -EINVAL; 933 } 934 935 static ssize_t applesmc_key_at_index_show(struct device *dev, 936 struct device_attribute *attr, char *sysfsbuf) 937 { 938 return snprintf(sysfsbuf, PAGE_SIZE, "%d\n", key_at_index); 939 } 940 941 static ssize_t applesmc_key_at_index_store(struct device *dev, 942 struct device_attribute *attr, const char *sysfsbuf, size_t count) 943 { 944 mutex_lock(&applesmc_lock); 945 946 key_at_index = simple_strtoul(sysfsbuf, NULL, 10); 947 948 mutex_unlock(&applesmc_lock); 949 950 return count; 951 } 952 953 static struct led_classdev applesmc_backlight = { 954 .name = "smc::kbd_backlight", 955 .default_trigger = "nand-disk", 956 .brightness_set = applesmc_brightness_set, 957 }; 958 959 static DEVICE_ATTR(name, 0444, applesmc_name_show, NULL); 960 961 static DEVICE_ATTR(position, 0444, applesmc_position_show, NULL); 962 static DEVICE_ATTR(calibrate, 0644, 963 applesmc_calibrate_show, applesmc_calibrate_store); 964 965 static struct attribute *accelerometer_attributes[] = { 966 &dev_attr_position.attr, 967 &dev_attr_calibrate.attr, 968 NULL 969 }; 970 971 static const struct attribute_group accelerometer_attributes_group = 972 { .attrs = accelerometer_attributes }; 973 974 static DEVICE_ATTR(light, 0444, applesmc_light_show, NULL); 975 976 static DEVICE_ATTR(key_count, 0444, applesmc_key_count_show, NULL); 977 static DEVICE_ATTR(key_at_index, 0644, 978 applesmc_key_at_index_show, applesmc_key_at_index_store); 979 static DEVICE_ATTR(key_at_index_name, 0444, 980 applesmc_key_at_index_name_show, NULL); 981 static DEVICE_ATTR(key_at_index_type, 0444, 982 applesmc_key_at_index_type_show, NULL); 983 static DEVICE_ATTR(key_at_index_data_length, 0444, 984 applesmc_key_at_index_data_length_show, NULL); 985 static DEVICE_ATTR(key_at_index_data, 0444, 986 applesmc_key_at_index_read_show, NULL); 987 988 static struct attribute *key_enumeration_attributes[] = { 989 &dev_attr_key_count.attr, 990 &dev_attr_key_at_index.attr, 991 &dev_attr_key_at_index_name.attr, 992 &dev_attr_key_at_index_type.attr, 993 &dev_attr_key_at_index_data_length.attr, 994 &dev_attr_key_at_index_data.attr, 995 NULL 996 }; 997 998 static const struct attribute_group key_enumeration_group = 999 { .attrs = key_enumeration_attributes }; 1000 1001 /* 1002 * Macro defining SENSOR_DEVICE_ATTR for a fan sysfs entries. 1003 * - show actual speed 1004 * - show/store minimum speed 1005 * - show maximum speed 1006 * - show safe speed 1007 * - show/store target speed 1008 * - show/store manual mode 1009 */ 1010 #define sysfs_fan_speeds_offset(offset) \ 1011 static SENSOR_DEVICE_ATTR_2(fan##offset##_input, S_IRUGO, \ 1012 applesmc_show_fan_speed, NULL, 0, offset-1); \ 1013 \ 1014 static SENSOR_DEVICE_ATTR_2(fan##offset##_min, S_IRUGO | S_IWUSR, \ 1015 applesmc_show_fan_speed, applesmc_store_fan_speed, 1, offset-1); \ 1016 \ 1017 static SENSOR_DEVICE_ATTR_2(fan##offset##_max, S_IRUGO, \ 1018 applesmc_show_fan_speed, NULL, 2, offset-1); \ 1019 \ 1020 static SENSOR_DEVICE_ATTR_2(fan##offset##_safe, S_IRUGO, \ 1021 applesmc_show_fan_speed, NULL, 3, offset-1); \ 1022 \ 1023 static SENSOR_DEVICE_ATTR_2(fan##offset##_output, S_IRUGO | S_IWUSR, \ 1024 applesmc_show_fan_speed, applesmc_store_fan_speed, 4, offset-1); \ 1025 \ 1026 static SENSOR_DEVICE_ATTR(fan##offset##_manual, S_IRUGO | S_IWUSR, \ 1027 applesmc_show_fan_manual, applesmc_store_fan_manual, offset-1); \ 1028 \ 1029 static SENSOR_DEVICE_ATTR(fan##offset##_label, S_IRUGO, \ 1030 applesmc_show_fan_position, NULL, offset-1); \ 1031 \ 1032 static struct attribute *fan##offset##_attributes[] = { \ 1033 &sensor_dev_attr_fan##offset##_input.dev_attr.attr, \ 1034 &sensor_dev_attr_fan##offset##_min.dev_attr.attr, \ 1035 &sensor_dev_attr_fan##offset##_max.dev_attr.attr, \ 1036 &sensor_dev_attr_fan##offset##_safe.dev_attr.attr, \ 1037 &sensor_dev_attr_fan##offset##_output.dev_attr.attr, \ 1038 &sensor_dev_attr_fan##offset##_manual.dev_attr.attr, \ 1039 &sensor_dev_attr_fan##offset##_label.dev_attr.attr, \ 1040 NULL \ 1041 }; 1042 1043 /* 1044 * Create the needed functions for each fan using the macro defined above 1045 * (4 fans are supported) 1046 */ 1047 sysfs_fan_speeds_offset(1); 1048 sysfs_fan_speeds_offset(2); 1049 sysfs_fan_speeds_offset(3); 1050 sysfs_fan_speeds_offset(4); 1051 1052 static const struct attribute_group fan_attribute_groups[] = { 1053 { .attrs = fan1_attributes }, 1054 { .attrs = fan2_attributes }, 1055 { .attrs = fan3_attributes }, 1056 { .attrs = fan4_attributes }, 1057 }; 1058 1059 /* 1060 * Temperature sensors sysfs entries. 1061 */ 1062 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, 1063 applesmc_show_temperature, NULL, 0); 1064 static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, 1065 applesmc_show_temperature, NULL, 1); 1066 static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, 1067 applesmc_show_temperature, NULL, 2); 1068 static SENSOR_DEVICE_ATTR(temp4_input, S_IRUGO, 1069 applesmc_show_temperature, NULL, 3); 1070 static SENSOR_DEVICE_ATTR(temp5_input, S_IRUGO, 1071 applesmc_show_temperature, NULL, 4); 1072 static SENSOR_DEVICE_ATTR(temp6_input, S_IRUGO, 1073 applesmc_show_temperature, NULL, 5); 1074 static SENSOR_DEVICE_ATTR(temp7_input, S_IRUGO, 1075 applesmc_show_temperature, NULL, 6); 1076 static SENSOR_DEVICE_ATTR(temp8_input, S_IRUGO, 1077 applesmc_show_temperature, NULL, 7); 1078 static SENSOR_DEVICE_ATTR(temp9_input, S_IRUGO, 1079 applesmc_show_temperature, NULL, 8); 1080 static SENSOR_DEVICE_ATTR(temp10_input, S_IRUGO, 1081 applesmc_show_temperature, NULL, 9); 1082 static SENSOR_DEVICE_ATTR(temp11_input, S_IRUGO, 1083 applesmc_show_temperature, NULL, 10); 1084 static SENSOR_DEVICE_ATTR(temp12_input, S_IRUGO, 1085 applesmc_show_temperature, NULL, 11); 1086 static SENSOR_DEVICE_ATTR(temp13_input, S_IRUGO, 1087 applesmc_show_temperature, NULL, 12); 1088 static SENSOR_DEVICE_ATTR(temp14_input, S_IRUGO, 1089 applesmc_show_temperature, NULL, 13); 1090 static SENSOR_DEVICE_ATTR(temp15_input, S_IRUGO, 1091 applesmc_show_temperature, NULL, 14); 1092 static SENSOR_DEVICE_ATTR(temp16_input, S_IRUGO, 1093 applesmc_show_temperature, NULL, 15); 1094 static SENSOR_DEVICE_ATTR(temp17_input, S_IRUGO, 1095 applesmc_show_temperature, NULL, 16); 1096 static SENSOR_DEVICE_ATTR(temp18_input, S_IRUGO, 1097 applesmc_show_temperature, NULL, 17); 1098 static SENSOR_DEVICE_ATTR(temp19_input, S_IRUGO, 1099 applesmc_show_temperature, NULL, 18); 1100 static SENSOR_DEVICE_ATTR(temp20_input, S_IRUGO, 1101 applesmc_show_temperature, NULL, 19); 1102 static SENSOR_DEVICE_ATTR(temp21_input, S_IRUGO, 1103 applesmc_show_temperature, NULL, 20); 1104 static SENSOR_DEVICE_ATTR(temp22_input, S_IRUGO, 1105 applesmc_show_temperature, NULL, 21); 1106 static SENSOR_DEVICE_ATTR(temp23_input, S_IRUGO, 1107 applesmc_show_temperature, NULL, 22); 1108 static SENSOR_DEVICE_ATTR(temp24_input, S_IRUGO, 1109 applesmc_show_temperature, NULL, 23); 1110 static SENSOR_DEVICE_ATTR(temp25_input, S_IRUGO, 1111 applesmc_show_temperature, NULL, 24); 1112 static SENSOR_DEVICE_ATTR(temp26_input, S_IRUGO, 1113 applesmc_show_temperature, NULL, 25); 1114 static SENSOR_DEVICE_ATTR(temp27_input, S_IRUGO, 1115 applesmc_show_temperature, NULL, 26); 1116 static SENSOR_DEVICE_ATTR(temp28_input, S_IRUGO, 1117 applesmc_show_temperature, NULL, 27); 1118 static SENSOR_DEVICE_ATTR(temp29_input, S_IRUGO, 1119 applesmc_show_temperature, NULL, 28); 1120 static SENSOR_DEVICE_ATTR(temp30_input, S_IRUGO, 1121 applesmc_show_temperature, NULL, 29); 1122 static SENSOR_DEVICE_ATTR(temp31_input, S_IRUGO, 1123 applesmc_show_temperature, NULL, 30); 1124 static SENSOR_DEVICE_ATTR(temp32_input, S_IRUGO, 1125 applesmc_show_temperature, NULL, 31); 1126 static SENSOR_DEVICE_ATTR(temp33_input, S_IRUGO, 1127 applesmc_show_temperature, NULL, 32); 1128 static SENSOR_DEVICE_ATTR(temp34_input, S_IRUGO, 1129 applesmc_show_temperature, NULL, 33); 1130 static SENSOR_DEVICE_ATTR(temp35_input, S_IRUGO, 1131 applesmc_show_temperature, NULL, 34); 1132 1133 static struct attribute *temperature_attributes[] = { 1134 &sensor_dev_attr_temp1_input.dev_attr.attr, 1135 &sensor_dev_attr_temp2_input.dev_attr.attr, 1136 &sensor_dev_attr_temp3_input.dev_attr.attr, 1137 &sensor_dev_attr_temp4_input.dev_attr.attr, 1138 &sensor_dev_attr_temp5_input.dev_attr.attr, 1139 &sensor_dev_attr_temp6_input.dev_attr.attr, 1140 &sensor_dev_attr_temp7_input.dev_attr.attr, 1141 &sensor_dev_attr_temp8_input.dev_attr.attr, 1142 &sensor_dev_attr_temp9_input.dev_attr.attr, 1143 &sensor_dev_attr_temp10_input.dev_attr.attr, 1144 &sensor_dev_attr_temp11_input.dev_attr.attr, 1145 &sensor_dev_attr_temp12_input.dev_attr.attr, 1146 &sensor_dev_attr_temp13_input.dev_attr.attr, 1147 &sensor_dev_attr_temp14_input.dev_attr.attr, 1148 &sensor_dev_attr_temp15_input.dev_attr.attr, 1149 &sensor_dev_attr_temp16_input.dev_attr.attr, 1150 &sensor_dev_attr_temp17_input.dev_attr.attr, 1151 &sensor_dev_attr_temp18_input.dev_attr.attr, 1152 &sensor_dev_attr_temp19_input.dev_attr.attr, 1153 &sensor_dev_attr_temp20_input.dev_attr.attr, 1154 &sensor_dev_attr_temp21_input.dev_attr.attr, 1155 &sensor_dev_attr_temp22_input.dev_attr.attr, 1156 &sensor_dev_attr_temp23_input.dev_attr.attr, 1157 &sensor_dev_attr_temp24_input.dev_attr.attr, 1158 &sensor_dev_attr_temp25_input.dev_attr.attr, 1159 &sensor_dev_attr_temp26_input.dev_attr.attr, 1160 &sensor_dev_attr_temp27_input.dev_attr.attr, 1161 &sensor_dev_attr_temp28_input.dev_attr.attr, 1162 &sensor_dev_attr_temp29_input.dev_attr.attr, 1163 &sensor_dev_attr_temp30_input.dev_attr.attr, 1164 &sensor_dev_attr_temp31_input.dev_attr.attr, 1165 &sensor_dev_attr_temp32_input.dev_attr.attr, 1166 &sensor_dev_attr_temp33_input.dev_attr.attr, 1167 &sensor_dev_attr_temp34_input.dev_attr.attr, 1168 &sensor_dev_attr_temp35_input.dev_attr.attr, 1169 NULL 1170 }; 1171 1172 static const struct attribute_group temperature_attributes_group = 1173 { .attrs = temperature_attributes }; 1174 1175 /* Module stuff */ 1176 1177 /* 1178 * applesmc_dmi_match - found a match. return one, short-circuiting the hunt. 1179 */ 1180 static int applesmc_dmi_match(const struct dmi_system_id *id) 1181 { 1182 int i = 0; 1183 struct dmi_match_data* dmi_data = id->driver_data; 1184 printk(KERN_INFO "applesmc: %s detected:\n", id->ident); 1185 applesmc_accelerometer = dmi_data->accelerometer; 1186 printk(KERN_INFO "applesmc: - Model %s accelerometer\n", 1187 applesmc_accelerometer ? "with" : "without"); 1188 applesmc_light = dmi_data->light; 1189 printk(KERN_INFO "applesmc: - Model %s light sensors and backlight\n", 1190 applesmc_light ? "with" : "without"); 1191 1192 applesmc_temperature_set = dmi_data->temperature_set; 1193 while (temperature_sensors_sets[applesmc_temperature_set][i] != NULL) 1194 i++; 1195 printk(KERN_INFO "applesmc: - Model with %d temperature sensors\n", i); 1196 return 1; 1197 } 1198 1199 /* Create accelerometer ressources */ 1200 static int applesmc_create_accelerometer(void) 1201 { 1202 struct input_dev *idev; 1203 int ret; 1204 1205 ret = sysfs_create_group(&pdev->dev.kobj, 1206 &accelerometer_attributes_group); 1207 if (ret) 1208 goto out; 1209 1210 applesmc_idev = input_allocate_polled_device(); 1211 if (!applesmc_idev) { 1212 ret = -ENOMEM; 1213 goto out_sysfs; 1214 } 1215 1216 applesmc_idev->poll = applesmc_idev_poll; 1217 applesmc_idev->poll_interval = APPLESMC_POLL_INTERVAL; 1218 1219 /* initial calibrate for the input device */ 1220 applesmc_calibrate(); 1221 1222 /* initialize the input device */ 1223 idev = applesmc_idev->input; 1224 idev->name = "applesmc"; 1225 idev->id.bustype = BUS_HOST; 1226 idev->dev.parent = &pdev->dev; 1227 idev->evbit[0] = BIT_MASK(EV_ABS); 1228 input_set_abs_params(idev, ABS_X, 1229 -256, 256, APPLESMC_INPUT_FUZZ, APPLESMC_INPUT_FLAT); 1230 input_set_abs_params(idev, ABS_Y, 1231 -256, 256, APPLESMC_INPUT_FUZZ, APPLESMC_INPUT_FLAT); 1232 1233 ret = input_register_polled_device(applesmc_idev); 1234 if (ret) 1235 goto out_idev; 1236 1237 return 0; 1238 1239 out_idev: 1240 input_free_polled_device(applesmc_idev); 1241 1242 out_sysfs: 1243 sysfs_remove_group(&pdev->dev.kobj, &accelerometer_attributes_group); 1244 1245 out: 1246 printk(KERN_WARNING "applesmc: driver init failed (ret=%d)!\n", ret); 1247 return ret; 1248 } 1249 1250 /* Release all ressources used by the accelerometer */ 1251 static void applesmc_release_accelerometer(void) 1252 { 1253 input_unregister_polled_device(applesmc_idev); 1254 input_free_polled_device(applesmc_idev); 1255 sysfs_remove_group(&pdev->dev.kobj, &accelerometer_attributes_group); 1256 } 1257 1258 static __initdata struct dmi_match_data applesmc_dmi_data[] = { 1259 /* MacBook Pro: accelerometer, backlight and temperature set 0 */ 1260 { .accelerometer = 1, .light = 1, .temperature_set = 0 }, 1261 /* MacBook2: accelerometer and temperature set 1 */ 1262 { .accelerometer = 1, .light = 0, .temperature_set = 1 }, 1263 /* MacBook: accelerometer and temperature set 2 */ 1264 { .accelerometer = 1, .light = 0, .temperature_set = 2 }, 1265 /* MacMini: temperature set 3 */ 1266 { .accelerometer = 0, .light = 0, .temperature_set = 3 }, 1267 /* MacPro: temperature set 4 */ 1268 { .accelerometer = 0, .light = 0, .temperature_set = 4 }, 1269 /* iMac: temperature set 5 */ 1270 { .accelerometer = 0, .light = 0, .temperature_set = 5 }, 1271 /* MacBook3: accelerometer and temperature set 6 */ 1272 { .accelerometer = 1, .light = 0, .temperature_set = 6 }, 1273 /* MacBook Air: accelerometer, backlight and temperature set 7 */ 1274 { .accelerometer = 1, .light = 1, .temperature_set = 7 }, 1275 /* MacBook Pro 4: accelerometer, backlight and temperature set 8 */ 1276 { .accelerometer = 1, .light = 1, .temperature_set = 8 }, 1277 /* MacBook Pro 3: accelerometer, backlight and temperature set 9 */ 1278 { .accelerometer = 1, .light = 1, .temperature_set = 9 }, 1279 }; 1280 1281 /* Note that DMI_MATCH(...,"MacBook") will match "MacBookPro1,1". 1282 * So we need to put "Apple MacBook Pro" before "Apple MacBook". */ 1283 static __initdata struct dmi_system_id applesmc_whitelist[] = { 1284 { applesmc_dmi_match, "Apple MacBook Air", { 1285 DMI_MATCH(DMI_BOARD_VENDOR, "Apple"), 1286 DMI_MATCH(DMI_PRODUCT_NAME, "MacBookAir") }, 1287 &applesmc_dmi_data[7]}, 1288 { applesmc_dmi_match, "Apple MacBook Pro 4", { 1289 DMI_MATCH(DMI_BOARD_VENDOR, "Apple"), 1290 DMI_MATCH(DMI_PRODUCT_NAME, "MacBookPro4") }, 1291 &applesmc_dmi_data[8]}, 1292 { applesmc_dmi_match, "Apple MacBook Pro 3", { 1293 DMI_MATCH(DMI_BOARD_VENDOR, "Apple"), 1294 DMI_MATCH(DMI_PRODUCT_NAME, "MacBookPro3") }, 1295 &applesmc_dmi_data[9]}, 1296 { applesmc_dmi_match, "Apple MacBook Pro", { 1297 DMI_MATCH(DMI_BOARD_VENDOR,"Apple"), 1298 DMI_MATCH(DMI_PRODUCT_NAME,"MacBookPro") }, 1299 &applesmc_dmi_data[0]}, 1300 { applesmc_dmi_match, "Apple MacBook (v2)", { 1301 DMI_MATCH(DMI_BOARD_VENDOR,"Apple"), 1302 DMI_MATCH(DMI_PRODUCT_NAME,"MacBook2") }, 1303 &applesmc_dmi_data[1]}, 1304 { applesmc_dmi_match, "Apple MacBook (v3)", { 1305 DMI_MATCH(DMI_BOARD_VENDOR,"Apple"), 1306 DMI_MATCH(DMI_PRODUCT_NAME,"MacBook3") }, 1307 &applesmc_dmi_data[6]}, 1308 { applesmc_dmi_match, "Apple MacBook", { 1309 DMI_MATCH(DMI_BOARD_VENDOR,"Apple"), 1310 DMI_MATCH(DMI_PRODUCT_NAME,"MacBook") }, 1311 &applesmc_dmi_data[2]}, 1312 { applesmc_dmi_match, "Apple Macmini", { 1313 DMI_MATCH(DMI_BOARD_VENDOR,"Apple"), 1314 DMI_MATCH(DMI_PRODUCT_NAME,"Macmini") }, 1315 &applesmc_dmi_data[3]}, 1316 { applesmc_dmi_match, "Apple MacPro2", { 1317 DMI_MATCH(DMI_BOARD_VENDOR,"Apple"), 1318 DMI_MATCH(DMI_PRODUCT_NAME,"MacPro2") }, 1319 &applesmc_dmi_data[4]}, 1320 { applesmc_dmi_match, "Apple iMac", { 1321 DMI_MATCH(DMI_BOARD_VENDOR,"Apple"), 1322 DMI_MATCH(DMI_PRODUCT_NAME,"iMac") }, 1323 &applesmc_dmi_data[5]}, 1324 { .ident = NULL } 1325 }; 1326 1327 static int __init applesmc_init(void) 1328 { 1329 int ret; 1330 int count; 1331 int i; 1332 1333 if (!dmi_check_system(applesmc_whitelist)) { 1334 printk(KERN_WARNING "applesmc: supported laptop not found!\n"); 1335 ret = -ENODEV; 1336 goto out; 1337 } 1338 1339 if (!request_region(APPLESMC_DATA_PORT, APPLESMC_NR_PORTS, 1340 "applesmc")) { 1341 ret = -ENXIO; 1342 goto out; 1343 } 1344 1345 ret = platform_driver_register(&applesmc_driver); 1346 if (ret) 1347 goto out_region; 1348 1349 pdev = platform_device_register_simple("applesmc", APPLESMC_DATA_PORT, 1350 NULL, 0); 1351 if (IS_ERR(pdev)) { 1352 ret = PTR_ERR(pdev); 1353 goto out_driver; 1354 } 1355 1356 ret = sysfs_create_file(&pdev->dev.kobj, &dev_attr_name.attr); 1357 if (ret) 1358 goto out_device; 1359 1360 /* Create key enumeration sysfs files */ 1361 ret = sysfs_create_group(&pdev->dev.kobj, &key_enumeration_group); 1362 if (ret) 1363 goto out_name; 1364 1365 /* create fan files */ 1366 count = applesmc_get_fan_count(); 1367 if (count < 0) { 1368 printk(KERN_ERR "applesmc: Cannot get the number of fans.\n"); 1369 } else { 1370 printk(KERN_INFO "applesmc: %d fans found.\n", count); 1371 1372 switch (count) { 1373 default: 1374 printk(KERN_WARNING "applesmc: More than 4 fans found," 1375 " but at most 4 fans are supported" 1376 " by the driver.\n"); 1377 case 4: 1378 ret = sysfs_create_group(&pdev->dev.kobj, 1379 &fan_attribute_groups[3]); 1380 if (ret) 1381 goto out_key_enumeration; 1382 case 3: 1383 ret = sysfs_create_group(&pdev->dev.kobj, 1384 &fan_attribute_groups[2]); 1385 if (ret) 1386 goto out_key_enumeration; 1387 case 2: 1388 ret = sysfs_create_group(&pdev->dev.kobj, 1389 &fan_attribute_groups[1]); 1390 if (ret) 1391 goto out_key_enumeration; 1392 case 1: 1393 ret = sysfs_create_group(&pdev->dev.kobj, 1394 &fan_attribute_groups[0]); 1395 if (ret) 1396 goto out_fan_1; 1397 case 0: 1398 ; 1399 } 1400 } 1401 1402 for (i = 0; 1403 temperature_sensors_sets[applesmc_temperature_set][i] != NULL; 1404 i++) { 1405 if (temperature_attributes[i] == NULL) { 1406 printk(KERN_ERR "applesmc: More temperature sensors " 1407 "in temperature_sensors_sets (at least %i)" 1408 "than available sysfs files in " 1409 "temperature_attributes (%i), please report " 1410 "this bug.\n", i, i-1); 1411 goto out_temperature; 1412 } 1413 ret = sysfs_create_file(&pdev->dev.kobj, 1414 temperature_attributes[i]); 1415 if (ret) 1416 goto out_temperature; 1417 } 1418 1419 if (applesmc_accelerometer) { 1420 ret = applesmc_create_accelerometer(); 1421 if (ret) 1422 goto out_temperature; 1423 } 1424 1425 if (applesmc_light) { 1426 /* Add light sensor file */ 1427 ret = sysfs_create_file(&pdev->dev.kobj, &dev_attr_light.attr); 1428 if (ret) 1429 goto out_accelerometer; 1430 1431 /* Create the workqueue */ 1432 applesmc_led_wq = create_singlethread_workqueue("applesmc-led"); 1433 if (!applesmc_led_wq) { 1434 ret = -ENOMEM; 1435 goto out_light_sysfs; 1436 } 1437 1438 /* register as a led device */ 1439 ret = led_classdev_register(&pdev->dev, &applesmc_backlight); 1440 if (ret < 0) 1441 goto out_light_wq; 1442 } 1443 1444 hwmon_dev = hwmon_device_register(&pdev->dev); 1445 if (IS_ERR(hwmon_dev)) { 1446 ret = PTR_ERR(hwmon_dev); 1447 goto out_light_ledclass; 1448 } 1449 1450 printk(KERN_INFO "applesmc: driver successfully loaded.\n"); 1451 1452 return 0; 1453 1454 out_light_ledclass: 1455 if (applesmc_light) 1456 led_classdev_unregister(&applesmc_backlight); 1457 out_light_wq: 1458 if (applesmc_light) 1459 destroy_workqueue(applesmc_led_wq); 1460 out_light_sysfs: 1461 if (applesmc_light) 1462 sysfs_remove_file(&pdev->dev.kobj, &dev_attr_light.attr); 1463 out_accelerometer: 1464 if (applesmc_accelerometer) 1465 applesmc_release_accelerometer(); 1466 out_temperature: 1467 sysfs_remove_group(&pdev->dev.kobj, &temperature_attributes_group); 1468 sysfs_remove_group(&pdev->dev.kobj, &fan_attribute_groups[0]); 1469 out_fan_1: 1470 sysfs_remove_group(&pdev->dev.kobj, &fan_attribute_groups[1]); 1471 out_key_enumeration: 1472 sysfs_remove_group(&pdev->dev.kobj, &key_enumeration_group); 1473 out_name: 1474 sysfs_remove_file(&pdev->dev.kobj, &dev_attr_name.attr); 1475 out_device: 1476 platform_device_unregister(pdev); 1477 out_driver: 1478 platform_driver_unregister(&applesmc_driver); 1479 out_region: 1480 release_region(APPLESMC_DATA_PORT, APPLESMC_NR_PORTS); 1481 out: 1482 printk(KERN_WARNING "applesmc: driver init failed (ret=%d)!\n", ret); 1483 return ret; 1484 } 1485 1486 static void __exit applesmc_exit(void) 1487 { 1488 hwmon_device_unregister(hwmon_dev); 1489 if (applesmc_light) { 1490 led_classdev_unregister(&applesmc_backlight); 1491 destroy_workqueue(applesmc_led_wq); 1492 sysfs_remove_file(&pdev->dev.kobj, &dev_attr_light.attr); 1493 } 1494 if (applesmc_accelerometer) 1495 applesmc_release_accelerometer(); 1496 sysfs_remove_group(&pdev->dev.kobj, &temperature_attributes_group); 1497 sysfs_remove_group(&pdev->dev.kobj, &fan_attribute_groups[0]); 1498 sysfs_remove_group(&pdev->dev.kobj, &fan_attribute_groups[1]); 1499 sysfs_remove_group(&pdev->dev.kobj, &key_enumeration_group); 1500 sysfs_remove_file(&pdev->dev.kobj, &dev_attr_name.attr); 1501 platform_device_unregister(pdev); 1502 platform_driver_unregister(&applesmc_driver); 1503 release_region(APPLESMC_DATA_PORT, APPLESMC_NR_PORTS); 1504 1505 printk(KERN_INFO "applesmc: driver unloaded.\n"); 1506 } 1507 1508 module_init(applesmc_init); 1509 module_exit(applesmc_exit); 1510 1511 MODULE_AUTHOR("Nicolas Boichat"); 1512 MODULE_DESCRIPTION("Apple SMC"); 1513 MODULE_LICENSE("GPL v2"); 1514