drivers/hwmon/applesmc.c

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