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