drivers/hwmon/applesmc.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * drivers/hwmon/applesmc.c - driver for Apple's SMC (accelerometer, temperature
   4  * sensors, fan control, keyboard backlight control) used in Intel-based Apple
   5  * computers.
   6  *
   7  * Copyright (C) 2007 Nicolas Boichat <[email protected]>
   8  * Copyright (C) 2010 Henrik Rydberg <[email protected]>
   9  *
  10  * Based on hdaps.c driver:
  11  * Copyright (C) 2005 Robert Love <[email protected]>
  12  * Copyright (C) 2005 Jesper Juhl <[email protected]>
  13  *
  14  * Fan control based on smcFanControl:
  15  * Copyright (C) 2006 Hendrik Holtmann <[email protected]>
  16  */
  17
  18 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  19
  20 #include <linux/delay.h>
  21 #include <linux/platform_device.h>
  22 #include <linux/input-polldev.h>
  23 #include <linux/kernel.h>
  24 #include <linux/slab.h>
  25 #include <linux/module.h>
  26 #include <linux/timer.h>
  27 #include <linux/dmi.h>
  28 #include <linux/mutex.h>
  29 #include <linux/hwmon-sysfs.h>
  30 #include <linux/io.h>
  31 #include <linux/leds.h>
  32 #include <linux/hwmon.h>
  33 #include <linux/workqueue.h>
  34 #include <linux/err.h>
  35
  36 /* data port used by Apple SMC */
  37 #define APPLESMC_DATA_PORT      0x300
  38 /* command/status port used by Apple SMC */
  39 #define APPLESMC_CMD_PORT       0x304
  40
  41 #define APPLESMC_NR_PORTS       32 /* 0x300-0x31f */
  42
  43 #define APPLESMC_MAX_DATA_LENGTH 32
  44
  45 /* wait up to 128 ms for a status change. */
  46 #define APPLESMC_MIN_WAIT       0x0010
  47 #define APPLESMC_RETRY_WAIT     0x0100
  48 #define APPLESMC_MAX_WAIT       0x20000
  49
  50 #define APPLESMC_READ_CMD       0x10
  51 #define APPLESMC_WRITE_CMD      0x11
  52 #define APPLESMC_GET_KEY_BY_INDEX_CMD   0x12
  53 #define APPLESMC_GET_KEY_TYPE_CMD       0x13
  54
  55 #define KEY_COUNT_KEY           "#KEY" /* r-o ui32 */
  56
  57 #define LIGHT_SENSOR_LEFT_KEY   "ALV0" /* r-o {alv (6-10 bytes) */
  58 #define LIGHT_SENSOR_RIGHT_KEY  "ALV1" /* r-o {alv (6-10 bytes) */
  59 #define BACKLIGHT_KEY           "LKSB" /* w-o {lkb (2 bytes) */
  60
  61 #define CLAMSHELL_KEY           "MSLD" /* r-o ui8 (unused) */
  62
  63 #define MOTION_SENSOR_X_KEY     "MO_X" /* r-o sp78 (2 bytes) */
  64 #define MOTION_SENSOR_Y_KEY     "MO_Y" /* r-o sp78 (2 bytes) */
  65 #define MOTION_SENSOR_Z_KEY     "MO_Z" /* r-o sp78 (2 bytes) */
  66 #define MOTION_SENSOR_KEY       "MOCN" /* r/w ui16 */
  67
  68 #define FANS_COUNT              "FNum" /* r-o ui8 */
  69 #define FANS_MANUAL             "FS! " /* r-w ui16 */
  70 #define FAN_ID_FMT              "F%dID" /* r-o char[16] */
  71
  72 #define TEMP_SENSOR_TYPE        "sp78"
  73
  74 /* List of keys used to read/write fan speeds */
  75 static const char *const fan_speed_fmt[] = {
  76         "F%dAc",                /* actual speed */
  77         "F%dMn",                /* minimum speed (rw) */
  78         "F%dMx",                /* maximum speed */
  79         "F%dSf",                /* safe speed - not all models */
  80         "F%dTg",                /* target speed (manual: rw) */
  81 };
  82
  83 #define INIT_TIMEOUT_MSECS      5000    /* wait up to 5s for device init ... */
  84 #define INIT_WAIT_MSECS         50      /* ... in 50ms increments */
  85
  86 #define APPLESMC_POLL_INTERVAL  50      /* msecs */
  87 #define APPLESMC_INPUT_FUZZ     4       /* input event threshold */
  88 #define APPLESMC_INPUT_FLAT     4
  89
  90 #define to_index(attr) (to_sensor_dev_attr(attr)->index & 0xffff)
  91 #define to_option(attr) (to_sensor_dev_attr(attr)->index >> 16)
  92
  93 /* Dynamic device node attributes */
  94 struct applesmc_dev_attr {
  95         struct sensor_device_attribute sda;     /* hwmon attributes */
  96         char name[32];                          /* room for node file name */
  97 };
  98
  99 /* Dynamic device node group */
 100 struct applesmc_node_group {
 101         char *format;                           /* format string */
 102         void *show;                             /* show function */
 103         void *store;                            /* store function */
 104         int option;                             /* function argument */
 105         struct applesmc_dev_attr *nodes;        /* dynamic node array */
 106 };
 107
 108 /* AppleSMC entry - cached register information */
 109 struct applesmc_entry {
 110         char key[5];            /* four-letter key code */
 111         u8 valid;               /* set when entry is successfully read once */
 112         u8 len;                 /* bounded by APPLESMC_MAX_DATA_LENGTH */
 113         char type[5];           /* four-letter type code */
 114         u8 flags;               /* 0x10: func; 0x40: write; 0x80: read */
 115 };
 116
 117 /* Register lookup and registers common to all SMCs */
 118 static struct applesmc_registers {
 119         struct mutex mutex;             /* register read/write mutex */
 120         unsigned int key_count;         /* number of SMC registers */
 121         unsigned int fan_count;         /* number of fans */
 122         unsigned int temp_count;        /* number of temperature registers */
 123         unsigned int temp_begin;        /* temperature lower index bound */
 124         unsigned int temp_end;          /* temperature upper index bound */
 125         unsigned int index_count;       /* size of temperature index array */
 126         int num_light_sensors;          /* number of light sensors */
 127         bool has_accelerometer;         /* has motion sensor */
 128         bool has_key_backlight;         /* has keyboard backlight */
 129         bool init_complete;             /* true when fully initialized */
 130         struct applesmc_entry *cache;   /* cached key entries */
 131         const char **index;             /* temperature key index */
 132 } smcreg = {
 133         .mutex = __MUTEX_INITIALIZER(smcreg.mutex),
 134 };
 135
 136 static const int debug;
 137 static struct platform_device *pdev;
 138 static s16 rest_x;
 139 static s16 rest_y;
 140 static u8 backlight_state[2];
 141
 142 static struct device *hwmon_dev;
 143 static struct input_polled_dev *applesmc_idev;
 144
 145 /*
 146  * Last index written to key_at_index sysfs file, and value to use for all other
 147  * key_at_index_* sysfs files.
 148  */
 149 static unsigned int key_at_index;
 150
 151 static struct workqueue_struct *applesmc_led_wq;
 152
 153 /*
 154  * wait_read - Wait for a byte to appear on SMC port. Callers must
 155  * hold applesmc_lock.
 156  */
 157 static int wait_read(void)
 158 {
 159         u8 status;
 160         int us;
 161         for (us = APPLESMC_MIN_WAIT; us < APPLESMC_MAX_WAIT; us <<= 1) {
 162                 udelay(us);
 163                 status = inb(APPLESMC_CMD_PORT);
 164                 /* read: wait for smc to settle */
 165                 if (status & 0x01)
 166                         return 0;
 167         }
 168
 169         pr_warn("wait_read() fail: 0x%02x\n", status);
 170         return -EIO;
 171 }
 172
 173 /*
 174  * send_byte - Write to SMC port, retrying when necessary. Callers
 175  * must hold applesmc_lock.
 176  */
 177 static int send_byte(u8 cmd, u16 port)
 178 {
 179         u8 status;
 180         int us;
 181
 182         outb(cmd, port);
 183         for (us = APPLESMC_MIN_WAIT; us < APPLESMC_MAX_WAIT; us <<= 1) {
 184                 udelay(us);
 185                 status = inb(APPLESMC_CMD_PORT);
 186                 /* write: wait for smc to settle */
 187                 if (status & 0x02)
 188                         continue;
 189                 /* ready: cmd accepted, return */
 190                 if (status & 0x04)
 191                         return 0;
 192                 /* timeout: give up */
 193                 if (us << 1 == APPLESMC_MAX_WAIT)
 194                         break;
 195                 /* busy: long wait and resend */
 196                 udelay(APPLESMC_RETRY_WAIT);
 197                 outb(cmd, port);
 198         }
 199
 200         pr_warn("send_byte(0x%02x, 0x%04x) fail: 0x%02x\n", cmd, port, status);
 201         return -EIO;
 202 }
 203
 204 static int send_command(u8 cmd)
 205 {
 206         return send_byte(cmd, APPLESMC_CMD_PORT);
 207 }
 208
 209 static int send_argument(const char *key)
 210 {
 211         int i;
 212
 213         for (i = 0; i < 4; i++)
 214                 if (send_byte(key[i], APPLESMC_DATA_PORT))
 215                         return -EIO;
 216         return 0;
 217 }
 218
 219 static int read_smc(u8 cmd, const char *key, u8 *buffer, u8 len)
 220 {
 221         u8 status, data = 0;
 222         int i;
 223
 224         if (send_command(cmd) || send_argument(key)) {
 225                 pr_warn("%.4s: read arg fail\n", key);
 226                 return -EIO;
 227         }
 228
 229         /* This has no effect on newer (2012) SMCs */
 230         if (send_byte(len, APPLESMC_DATA_PORT)) {
 231                 pr_warn("%.4s: read len fail\n", key);
 232                 return -EIO;
 233         }
 234
 235         for (i = 0; i < len; i++) {
 236                 if (wait_read()) {
 237                         pr_warn("%.4s: read data[%d] fail\n", key, i);
 238                         return -EIO;
 239                 }
 240                 buffer[i] = inb(APPLESMC_DATA_PORT);
 241         }
 242
 243         /* Read the data port until bit0 is cleared */
 244         for (i = 0; i < 16; i++) {
 245                 udelay(APPLESMC_MIN_WAIT);
 246                 status = inb(APPLESMC_CMD_PORT);
 247                 if (!(status & 0x01))
 248                         break;
 249                 data = inb(APPLESMC_DATA_PORT);
 250         }
 251         if (i)
 252                 pr_warn("flushed %d bytes, last value is: %d\n", i, data);
 253
 254         return 0;
 255 }
 256
 257 static int write_smc(u8 cmd, const char *key, const u8 *buffer, u8 len)
 258 {
 259         int i;
 260
 261         if (send_command(cmd) || send_argument(key)) {
 262                 pr_warn("%s: write arg fail\n", key);
 263                 return -EIO;
 264         }
 265
 266         if (send_byte(len, APPLESMC_DATA_PORT)) {
 267                 pr_warn("%.4s: write len fail\n", key);
 268                 return -EIO;
 269         }
 270
 271         for (i = 0; i < len; i++) {
 272                 if (send_byte(buffer[i], APPLESMC_DATA_PORT)) {
 273                         pr_warn("%s: write data fail\n", key);
 274                         return -EIO;
 275                 }
 276         }
 277
 278         return 0;
 279 }
 280
 281 static int read_register_count(unsigned int *count)
 282 {
 283         __be32 be;
 284         int ret;
 285
 286         ret = read_smc(APPLESMC_READ_CMD, KEY_COUNT_KEY, (u8 *)&be, 4);
 287         if (ret)
 288                 return ret;
 289
 290         *count = be32_to_cpu(be);
 291         return 0;
 292 }
 293
 294 /*
 295  * Serialized I/O
 296  *
 297  * Returns zero on success or a negative error on failure.
 298  * All functions below are concurrency safe - callers should NOT hold lock.
 299  */
 300
 301 static int applesmc_read_entry(const struct applesmc_entry *entry,
 302                                u8 *buf, u8 len)
 303 {
 304         int ret;
 305
 306         if (entry->len != len)
 307                 return -EINVAL;
 308         mutex_lock(&smcreg.mutex);
 309         ret = read_smc(APPLESMC_READ_CMD, entry->key, buf, len);
 310         mutex_unlock(&smcreg.mutex);
 311
 312         return ret;
 313 }
 314
 315 static int applesmc_write_entry(const struct applesmc_entry *entry,
 316                                 const u8 *buf, u8 len)
 317 {
 318         int ret;
 319
 320         if (entry->len != len)
 321                 return -EINVAL;
 322         mutex_lock(&smcreg.mutex);
 323         ret = write_smc(APPLESMC_WRITE_CMD, entry->key, buf, len);
 324         mutex_unlock(&smcreg.mutex);
 325         return ret;
 326 }
 327
 328 static const struct applesmc_entry *applesmc_get_entry_by_index(int index)
 329 {
 330         struct applesmc_entry *cache = &smcreg.cache[index];
 331         u8 key[4], info[6];
 332         __be32 be;
 333         int ret = 0;
 334
 335         if (cache->valid)
 336                 return cache;
 337
 338         mutex_lock(&smcreg.mutex);
 339
 340         if (cache->valid)
 341                 goto out;
 342         be = cpu_to_be32(index);
 343         ret = read_smc(APPLESMC_GET_KEY_BY_INDEX_CMD, (u8 *)&be, key, 4);
 344         if (ret)
 345                 goto out;
 346         ret = read_smc(APPLESMC_GET_KEY_TYPE_CMD, key, info, 6);
 347         if (ret)
 348                 goto out;
 349
 350         memcpy(cache->key, key, 4);
 351         cache->len = info[0];
 352         memcpy(cache->type, &info[1], 4);
 353         cache->flags = info[5];
 354         cache->valid = 1;
 355
 356 out:
 357         mutex_unlock(&smcreg.mutex);
 358         if (ret)
 359                 return ERR_PTR(ret);
 360         return cache;
 361 }
 362
 363 static int applesmc_get_lower_bound(unsigned int *lo, const char *key)
 364 {
 365         int begin = 0, end = smcreg.key_count;
 366         const struct applesmc_entry *entry;
 367
 368         while (begin != end) {
 369                 int middle = begin + (end - begin) / 2;
 370                 entry = applesmc_get_entry_by_index(middle);
 371                 if (IS_ERR(entry)) {
 372                         *lo = 0;
 373                         return PTR_ERR(entry);
 374                 }
 375                 if (strcmp(entry->key, key) < 0)
 376                         begin = middle + 1;
 377                 else
 378                         end = middle;
 379         }
 380
 381         *lo = begin;
 382         return 0;
 383 }
 384
 385 static int applesmc_get_upper_bound(unsigned int *hi, const char *key)
 386 {
 387         int begin = 0, end = smcreg.key_count;
 388         const struct applesmc_entry *entry;
 389
 390         while (begin != end) {
 391                 int middle = begin + (end - begin) / 2;
 392                 entry = applesmc_get_entry_by_index(middle);
 393                 if (IS_ERR(entry)) {
 394                         *hi = smcreg.key_count;
 395                         return PTR_ERR(entry);
 396                 }
 397                 if (strcmp(key, entry->key) < 0)
 398                         end = middle;
 399                 else
 400                         begin = middle + 1;
 401         }
 402
 403         *hi = begin;
 404         return 0;
 405 }
 406
 407 static const struct applesmc_entry *applesmc_get_entry_by_key(const char *key)
 408 {
 409         int begin, end;
 410         int ret;
 411
 412         ret = applesmc_get_lower_bound(&begin, key);
 413         if (ret)
 414                 return ERR_PTR(ret);
 415         ret = applesmc_get_upper_bound(&end, key);
 416         if (ret)
 417                 return ERR_PTR(ret);
 418         if (end - begin != 1)
 419                 return ERR_PTR(-EINVAL);
 420
 421         return applesmc_get_entry_by_index(begin);
 422 }
 423
 424 static int applesmc_read_key(const char *key, u8 *buffer, u8 len)
 425 {
 426         const struct applesmc_entry *entry;
 427
 428         entry = applesmc_get_entry_by_key(key);
 429         if (IS_ERR(entry))
 430                 return PTR_ERR(entry);
 431
 432         return applesmc_read_entry(entry, buffer, len);
 433 }
 434
 435 static int applesmc_write_key(const char *key, const u8 *buffer, u8 len)
 436 {
 437         const struct applesmc_entry *entry;
 438
 439         entry = applesmc_get_entry_by_key(key);
 440         if (IS_ERR(entry))
 441                 return PTR_ERR(entry);
 442
 443         return applesmc_write_entry(entry, buffer, len);
 444 }
 445
 446 static int applesmc_has_key(const char *key, bool *value)
 447 {
 448         const struct applesmc_entry *entry;
 449
 450         entry = applesmc_get_entry_by_key(key);
 451         if (IS_ERR(entry) && PTR_ERR(entry) != -EINVAL)
 452                 return PTR_ERR(entry);
 453
 454         *value = !IS_ERR(entry);
 455         return 0;
 456 }
 457
 458 /*
 459  * applesmc_read_s16 - Read 16-bit signed big endian register
 460  */
 461 static int applesmc_read_s16(const char *key, s16 *value)
 462 {
 463         u8 buffer[2];
 464         int ret;
 465
 466         ret = applesmc_read_key(key, buffer, 2);
 467         if (ret)
 468                 return ret;
 469
 470         *value = ((s16)buffer[0] << 8) | buffer[1];
 471         return 0;
 472 }
 473
 474 /*
 475  * applesmc_device_init - initialize the accelerometer.  Can sleep.
 476  */
 477 static void applesmc_device_init(void)
 478 {
 479         int total;
 480         u8 buffer[2];
 481
 482         if (!smcreg.has_accelerometer)
 483                 return;
 484
 485         for (total = INIT_TIMEOUT_MSECS; total > 0; total -= INIT_WAIT_MSECS) {
 486                 if (!applesmc_read_key(MOTION_SENSOR_KEY, buffer, 2) &&
 487                                 (buffer[0] != 0x00 || buffer[1] != 0x00))
 488                         return;
 489                 buffer[0] = 0xe0;
 490                 buffer[1] = 0x00;
 491                 applesmc_write_key(MOTION_SENSOR_KEY, buffer, 2);
 492                 msleep(INIT_WAIT_MSECS);
 493         }
 494
 495         pr_warn("failed to init the device\n");
 496 }
 497
 498 static int applesmc_init_index(struct applesmc_registers *s)
 499 {
 500         const struct applesmc_entry *entry;
 501         unsigned int i;
 502
 503         if (s->index)
 504                 return 0;
 505
 506         s->index = kcalloc(s->temp_count, sizeof(s->index[0]), GFP_KERNEL);
 507         if (!s->index)
 508                 return -ENOMEM;
 509
 510         for (i = s->temp_begin; i < s->temp_end; i++) {
 511                 entry = applesmc_get_entry_by_index(i);
 512                 if (IS_ERR(entry))
 513                         continue;
 514                 if (strcmp(entry->type, TEMP_SENSOR_TYPE))
 515                         continue;
 516                 s->index[s->index_count++] = entry->key;
 517         }
 518
 519         return 0;
 520 }
 521
 522 /*
 523  * applesmc_init_smcreg_try - Try to initialize register cache. Idempotent.
 524  */
 525 static int applesmc_init_smcreg_try(void)
 526 {
 527         struct applesmc_registers *s = &smcreg;
 528         bool left_light_sensor = 0, right_light_sensor = 0;
 529         unsigned int count;
 530         u8 tmp[1];
 531         int ret;
 532
 533         if (s->init_complete)
 534                 return 0;
 535
 536         ret = read_register_count(&count);
 537         if (ret)
 538                 return ret;
 539
 540         if (s->cache && s->key_count != count) {
 541                 pr_warn("key count changed from %d to %d\n",
 542                         s->key_count, count);
 543                 kfree(s->cache);
 544                 s->cache = NULL;
 545         }
 546         s->key_count = count;
 547
 548         if (!s->cache)
 549                 s->cache = kcalloc(s->key_count, sizeof(*s->cache), GFP_KERNEL);
 550         if (!s->cache)
 551                 return -ENOMEM;
 552
 553         ret = applesmc_read_key(FANS_COUNT, tmp, 1);
 554         if (ret)
 555                 return ret;
 556         s->fan_count = tmp[0];
 557         if (s->fan_count > 10)
 558                 s->fan_count = 10;
 559
 560         ret = applesmc_get_lower_bound(&s->temp_begin, "T");
 561         if (ret)
 562                 return ret;
 563         ret = applesmc_get_lower_bound(&s->temp_end, "U");
 564         if (ret)
 565                 return ret;
 566         s->temp_count = s->temp_end - s->temp_begin;
 567
 568         ret = applesmc_init_index(s);
 569         if (ret)
 570                 return ret;
 571
 572         ret = applesmc_has_key(LIGHT_SENSOR_LEFT_KEY, &left_light_sensor);
 573         if (ret)
 574                 return ret;
 575         ret = applesmc_has_key(LIGHT_SENSOR_RIGHT_KEY, &right_light_sensor);
 576         if (ret)
 577                 return ret;
 578         ret = applesmc_has_key(MOTION_SENSOR_KEY, &s->has_accelerometer);
 579         if (ret)
 580                 return ret;
 581         ret = applesmc_has_key(BACKLIGHT_KEY, &s->has_key_backlight);
 582         if (ret)
 583                 return ret;
 584
 585         s->num_light_sensors = left_light_sensor + right_light_sensor;
 586         s->init_complete = true;
 587
 588         pr_info("key=%d fan=%d temp=%d index=%d acc=%d lux=%d kbd=%d\n",
 589                s->key_count, s->fan_count, s->temp_count, s->index_count,
 590                s->has_accelerometer,
 591                s->num_light_sensors,
 592                s->has_key_backlight);
 593
 594         return 0;
 595 }
 596
 597 static void applesmc_destroy_smcreg(void)
 598 {
 599         kfree(smcreg.index);
 600         smcreg.index = NULL;
 601         kfree(smcreg.cache);
 602         smcreg.cache = NULL;
 603         smcreg.init_complete = false;
 604 }
 605
 606 /*
 607  * applesmc_init_smcreg - Initialize register cache.
 608  *
 609  * Retries until initialization is successful, or the operation times out.
 610  *
 611  */
 612 static int applesmc_init_smcreg(void)
 613 {
 614         int ms, ret;
 615
 616         for (ms = 0; ms < INIT_TIMEOUT_MSECS; ms += INIT_WAIT_MSECS) {
 617                 ret = applesmc_init_smcreg_try();
 618                 if (!ret) {
 619                         if (ms)
 620                                 pr_info("init_smcreg() took %d ms\n", ms);
 621                         return 0;
 622                 }
 623                 msleep(INIT_WAIT_MSECS);
 624         }
 625
 626         applesmc_destroy_smcreg();
 627
 628         return ret;
 629 }
 630
 631 /* Device model stuff */
 632 static int applesmc_probe(struct platform_device *dev)
 633 {
 634         int ret;
 635
 636         ret = applesmc_init_smcreg();
 637         if (ret)
 638                 return ret;
 639
 640         applesmc_device_init();
 641
 642         return 0;
 643 }
 644
 645 /* Synchronize device with memorized backlight state */
 646 static int applesmc_pm_resume(struct device *dev)
 647 {
 648         if (smcreg.has_key_backlight)
 649                 applesmc_write_key(BACKLIGHT_KEY, backlight_state, 2);
 650         return 0;
 651 }
 652
 653 /* Reinitialize device on resume from hibernation */
 654 static int applesmc_pm_restore(struct device *dev)
 655 {
 656         applesmc_device_init();
 657         return applesmc_pm_resume(dev);
 658 }
 659
 660 static const struct dev_pm_ops applesmc_pm_ops = {
 661         .resume = applesmc_pm_resume,
 662         .restore = applesmc_pm_restore,
 663 };
 664
 665 static struct platform_driver applesmc_driver = {
 666         .probe = applesmc_probe,
 667         .driver = {
 668                 .name = "applesmc",
 669                 .pm = &applesmc_pm_ops,
 670         },
 671 };
 672
 673 /*
 674  * applesmc_calibrate - Set our "resting" values.  Callers must
 675  * hold applesmc_lock.
 676  */
 677 static void applesmc_calibrate(void)
 678 {
 679         applesmc_read_s16(MOTION_SENSOR_X_KEY, &rest_x);
 680         applesmc_read_s16(MOTION_SENSOR_Y_KEY, &rest_y);
 681         rest_x = -rest_x;
 682 }
 683
 684 static void applesmc_idev_poll(struct input_polled_dev *dev)
 685 {
 686         struct input_dev *idev = dev->input;
 687         s16 x, y;
 688
 689         if (applesmc_read_s16(MOTION_SENSOR_X_KEY, &x))
 690                 return;
 691         if (applesmc_read_s16(MOTION_SENSOR_Y_KEY, &y))
 692                 return;
 693
 694         x = -x;
 695         input_report_abs(idev, ABS_X, x - rest_x);
 696         input_report_abs(idev, ABS_Y, y - rest_y);
 697         input_sync(idev);
 698 }
 699
 700 /* Sysfs Files */
 701
 702 static ssize_t applesmc_name_show(struct device *dev,
 703                                    struct device_attribute *attr, char *buf)
 704 {
 705         return snprintf(buf, PAGE_SIZE, "applesmc\n");
 706 }
 707
 708 static ssize_t applesmc_position_show(struct device *dev,
 709                                    struct device_attribute *attr, char *buf)
 710 {
 711         int ret;
 712         s16 x, y, z;
 713
 714         ret = applesmc_read_s16(MOTION_SENSOR_X_KEY, &x);
 715         if (ret)
 716                 goto out;
 717         ret = applesmc_read_s16(MOTION_SENSOR_Y_KEY, &y);
 718         if (ret)
 719                 goto out;
 720         ret = applesmc_read_s16(MOTION_SENSOR_Z_KEY, &z);
 721         if (ret)
 722                 goto out;
 723
 724 out:
 725         if (ret)
 726                 return ret;
 727         else
 728                 return snprintf(buf, PAGE_SIZE, "(%d,%d,%d)\n", x, y, z);
 729 }
 730
 731 static ssize_t applesmc_light_show(struct device *dev,
 732                                 struct device_attribute *attr, char *sysfsbuf)
 733 {
 734         const struct applesmc_entry *entry;
 735         static int data_length;
 736         int ret;
 737         u8 left = 0, right = 0;
 738         u8 buffer[10];
 739
 740         if (!data_length) {
 741                 entry = applesmc_get_entry_by_key(LIGHT_SENSOR_LEFT_KEY);
 742                 if (IS_ERR(entry))
 743                         return PTR_ERR(entry);
 744                 if (entry->len > 10)
 745                         return -ENXIO;
 746                 data_length = entry->len;
 747                 pr_info("light sensor data length set to %d\n", data_length);
 748         }
 749
 750         ret = applesmc_read_key(LIGHT_SENSOR_LEFT_KEY, buffer, data_length);
 751         /* newer macbooks report a single 10-bit bigendian value */
 752         if (data_length == 10) {
 753                 left = be16_to_cpu(*(__be16 *)(buffer + 6)) >> 2;
 754                 goto out;
 755         }
 756         left = buffer[2];
 757         if (ret)
 758                 goto out;
 759         ret = applesmc_read_key(LIGHT_SENSOR_RIGHT_KEY, buffer, data_length);
 760         right = buffer[2];
 761
 762 out:
 763         if (ret)
 764                 return ret;
 765         else
 766                 return snprintf(sysfsbuf, PAGE_SIZE, "(%d,%d)\n", left, right);
 767 }
 768
 769 /* Displays sensor key as label */
 770 static ssize_t applesmc_show_sensor_label(struct device *dev,
 771                         struct device_attribute *devattr, char *sysfsbuf)
 772 {
 773         const char *key = smcreg.index[to_index(devattr)];
 774
 775         return snprintf(sysfsbuf, PAGE_SIZE, "%s\n", key);
 776 }
 777
 778 /* Displays degree Celsius * 1000 */
 779 static ssize_t applesmc_show_temperature(struct device *dev,
 780                         struct device_attribute *devattr, char *sysfsbuf)
 781 {
 782         const char *key = smcreg.index[to_index(devattr)];
 783         int ret;
 784         s16 value;
 785         int temp;
 786
 787         ret = applesmc_read_s16(key, &value);
 788         if (ret)
 789                 return ret;
 790
 791         temp = 250 * (value >> 6);
 792
 793         return snprintf(sysfsbuf, PAGE_SIZE, "%d\n", temp);
 794 }
 795
 796 static ssize_t applesmc_show_fan_speed(struct device *dev,
 797                                 struct device_attribute *attr, char *sysfsbuf)
 798 {
 799         int ret;
 800         unsigned int speed = 0;
 801         char newkey[5];
 802         u8 buffer[2];
 803
 804         scnprintf(newkey, sizeof(newkey), fan_speed_fmt[to_option(attr)],
 805                   to_index(attr));
 806
 807         ret = applesmc_read_key(newkey, buffer, 2);
 808         speed = ((buffer[0] << 8 | buffer[1]) >> 2);
 809
 810         if (ret)
 811                 return ret;
 812         else
 813                 return snprintf(sysfsbuf, PAGE_SIZE, "%u\n", speed);
 814 }
 815
 816 static ssize_t applesmc_store_fan_speed(struct device *dev,
 817                                         struct device_attribute *attr,
 818                                         const char *sysfsbuf, size_t count)
 819 {
 820         int ret;
 821         unsigned long speed;
 822         char newkey[5];
 823         u8 buffer[2];
 824
 825         if (kstrtoul(sysfsbuf, 10, &speed) < 0 || speed >= 0x4000)
 826                 return -EINVAL;         /* Bigger than a 14-bit value */
 827
 828         scnprintf(newkey, sizeof(newkey), fan_speed_fmt[to_option(attr)],
 829                   to_index(attr));
 830
 831         buffer[0] = (speed >> 6) & 0xff;
 832         buffer[1] = (speed << 2) & 0xff;
 833         ret = applesmc_write_key(newkey, buffer, 2);
 834
 835         if (ret)
 836                 return ret;
 837         else
 838                 return count;
 839 }
 840
 841 static ssize_t applesmc_show_fan_manual(struct device *dev,
 842                         struct device_attribute *attr, char *sysfsbuf)
 843 {
 844         int ret;
 845         u16 manual = 0;
 846         u8 buffer[2];
 847
 848         ret = applesmc_read_key(FANS_MANUAL, buffer, 2);
 849         manual = ((buffer[0] << 8 | buffer[1]) >> to_index(attr)) & 0x01;
 850
 851         if (ret)
 852                 return ret;
 853         else
 854                 return snprintf(sysfsbuf, PAGE_SIZE, "%d\n", manual);
 855 }
 856
 857 static ssize_t applesmc_store_fan_manual(struct device *dev,
 858                                          struct device_attribute *attr,
 859                                          const char *sysfsbuf, size_t count)
 860 {
 861         int ret;
 862         u8 buffer[2];
 863         unsigned long input;
 864         u16 val;
 865
 866         if (kstrtoul(sysfsbuf, 10, &input) < 0)
 867                 return -EINVAL;
 868
 869         ret = applesmc_read_key(FANS_MANUAL, buffer, 2);
 870         val = (buffer[0] << 8 | buffer[1]);
 871         if (ret)
 872                 goto out;
 873
 874         if (input)
 875                 val = val | (0x01 << to_index(attr));
 876         else
 877                 val = val & ~(0x01 << to_index(attr));
 878
 879         buffer[0] = (val >> 8) & 0xFF;
 880         buffer[1] = val & 0xFF;
 881
 882         ret = applesmc_write_key(FANS_MANUAL, buffer, 2);
 883
 884 out:
 885         if (ret)
 886                 return ret;
 887         else
 888                 return count;
 889 }
 890
 891 static ssize_t applesmc_show_fan_position(struct device *dev,
 892                                 struct device_attribute *attr, char *sysfsbuf)
 893 {
 894         int ret;
 895         char newkey[5];
 896         u8 buffer[17];
 897
 898         scnprintf(newkey, sizeof(newkey), FAN_ID_FMT, to_index(attr));
 899
 900         ret = applesmc_read_key(newkey, buffer, 16);
 901         buffer[16] = 0;
 902
 903         if (ret)
 904                 return ret;
 905         else
 906                 return snprintf(sysfsbuf, PAGE_SIZE, "%s\n", buffer+4);
 907 }
 908
 909 static ssize_t applesmc_calibrate_show(struct device *dev,
 910                                 struct device_attribute *attr, char *sysfsbuf)
 911 {
 912         return snprintf(sysfsbuf, PAGE_SIZE, "(%d,%d)\n", rest_x, rest_y);
 913 }
 914
 915 static ssize_t applesmc_calibrate_store(struct device *dev,
 916         struct device_attribute *attr, const char *sysfsbuf, size_t count)
 917 {
 918         applesmc_calibrate();
 919
 920         return count;
 921 }
 922
 923 static void applesmc_backlight_set(struct work_struct *work)
 924 {
 925         applesmc_write_key(BACKLIGHT_KEY, backlight_state, 2);
 926 }
 927 static DECLARE_WORK(backlight_work, &applesmc_backlight_set);
 928
 929 static void applesmc_brightness_set(struct led_classdev *led_cdev,
 930                                                 enum led_brightness value)
 931 {
 932         int ret;
 933
 934         backlight_state[0] = value;
 935         ret = queue_work(applesmc_led_wq, &backlight_work);
 936
 937         if (debug && (!ret))
 938                 dev_dbg(led_cdev->dev, "work was already on the queue.\n");
 939 }
 940
 941 static ssize_t applesmc_key_count_show(struct device *dev,
 942                                 struct device_attribute *attr, char *sysfsbuf)
 943 {
 944         int ret;
 945         u8 buffer[4];
 946         u32 count;
 947
 948         ret = applesmc_read_key(KEY_COUNT_KEY, buffer, 4);
 949         count = ((u32)buffer[0]<<24) + ((u32)buffer[1]<<16) +
 950                                                 ((u32)buffer[2]<<8) + buffer[3];
 951
 952         if (ret)
 953                 return ret;
 954         else
 955                 return snprintf(sysfsbuf, PAGE_SIZE, "%d\n", count);
 956 }
 957
 958 static ssize_t applesmc_key_at_index_read_show(struct device *dev,
 959                                 struct device_attribute *attr, char *sysfsbuf)
 960 {
 961         const struct applesmc_entry *entry;
 962         int ret;
 963
 964         entry = applesmc_get_entry_by_index(key_at_index);
 965         if (IS_ERR(entry))
 966                 return PTR_ERR(entry);
 967         ret = applesmc_read_entry(entry, sysfsbuf, entry->len);
 968         if (ret)
 969                 return ret;
 970
 971         return entry->len;
 972 }
 973
 974 static ssize_t applesmc_key_at_index_data_length_show(struct device *dev,
 975                                 struct device_attribute *attr, char *sysfsbuf)
 976 {
 977         const struct applesmc_entry *entry;
 978
 979         entry = applesmc_get_entry_by_index(key_at_index);
 980         if (IS_ERR(entry))
 981                 return PTR_ERR(entry);
 982
 983         return snprintf(sysfsbuf, PAGE_SIZE, "%d\n", entry->len);
 984 }
 985
 986 static ssize_t applesmc_key_at_index_type_show(struct device *dev,
 987                                 struct device_attribute *attr, char *sysfsbuf)
 988 {
 989         const struct applesmc_entry *entry;
 990
 991         entry = applesmc_get_entry_by_index(key_at_index);
 992         if (IS_ERR(entry))
 993                 return PTR_ERR(entry);
 994
 995         return snprintf(sysfsbuf, PAGE_SIZE, "%s\n", entry->type);
 996 }
 997
 998 static ssize_t applesmc_key_at_index_name_show(struct device *dev,
 999                                 struct device_attribute *attr, char *sysfsbuf)
1000 {
1001         const struct applesmc_entry *entry;
1002
1003         entry = applesmc_get_entry_by_index(key_at_index);
1004         if (IS_ERR(entry))
1005                 return PTR_ERR(entry);
1006
1007         return snprintf(sysfsbuf, PAGE_SIZE, "%s\n", entry->key);
1008 }
1009
1010 static ssize_t applesmc_key_at_index_show(struct device *dev,
1011                                 struct device_attribute *attr, char *sysfsbuf)
1012 {
1013         return snprintf(sysfsbuf, PAGE_SIZE, "%d\n", key_at_index);
1014 }
1015
1016 static ssize_t applesmc_key_at_index_store(struct device *dev,
1017         struct device_attribute *attr, const char *sysfsbuf, size_t count)
1018 {
1019         unsigned long newkey;
1020
1021         if (kstrtoul(sysfsbuf, 10, &newkey) < 0
1022             || newkey >= smcreg.key_count)
1023                 return -EINVAL;
1024
1025         key_at_index = newkey;
1026         return count;
1027 }
1028
1029 static struct led_classdev applesmc_backlight = {
1030         .name                   = "smc::kbd_backlight",
1031         .default_trigger        = "nand-disk",
1032         .brightness_set         = applesmc_brightness_set,
1033 };
1034
1035 static struct applesmc_node_group info_group[] = {
1036         { "name", applesmc_name_show },
1037         { "key_count", applesmc_key_count_show },
1038         { "key_at_index", applesmc_key_at_index_show, applesmc_key_at_index_store },
1039         { "key_at_index_name", applesmc_key_at_index_name_show },
1040         { "key_at_index_type", applesmc_key_at_index_type_show },
1041         { "key_at_index_data_length", applesmc_key_at_index_data_length_show },
1042         { "key_at_index_data", applesmc_key_at_index_read_show },
1043         { }
1044 };
1045
1046 static struct applesmc_node_group accelerometer_group[] = {
1047         { "position", applesmc_position_show },
1048         { "calibrate", applesmc_calibrate_show, applesmc_calibrate_store },
1049         { }
1050 };
1051
1052 static struct applesmc_node_group light_sensor_group[] = {
1053         { "light", applesmc_light_show },
1054         { }
1055 };
1056
1057 static struct applesmc_node_group fan_group[] = {
1058         { "fan%d_label", applesmc_show_fan_position },
1059         { "fan%d_input", applesmc_show_fan_speed, NULL, 0 },
1060         { "fan%d_min", applesmc_show_fan_speed, applesmc_store_fan_speed, 1 },
1061         { "fan%d_max", applesmc_show_fan_speed, NULL, 2 },
1062         { "fan%d_safe", applesmc_show_fan_speed, NULL, 3 },
1063         { "fan%d_output", applesmc_show_fan_speed, applesmc_store_fan_speed, 4 },
1064         { "fan%d_manual", applesmc_show_fan_manual, applesmc_store_fan_manual },
1065         { }
1066 };
1067
1068 static struct applesmc_node_group temp_group[] = {
1069         { "temp%d_label", applesmc_show_sensor_label },
1070         { "temp%d_input", applesmc_show_temperature },
1071         { }
1072 };
1073
1074 /* Module stuff */
1075
1076 /*
1077  * applesmc_destroy_nodes - remove files and free associated memory
1078  */
1079 static void applesmc_destroy_nodes(struct applesmc_node_group *groups)
1080 {
1081         struct applesmc_node_group *grp;
1082         struct applesmc_dev_attr *node;
1083
1084         for (grp = groups; grp->nodes; grp++) {
1085                 for (node = grp->nodes; node->sda.dev_attr.attr.name; node++)
1086                         sysfs_remove_file(&pdev->dev.kobj,
1087                                           &node->sda.dev_attr.attr);
1088                 kfree(grp->nodes);
1089                 grp->nodes = NULL;
1090         }
1091 }
1092
1093 /*
1094  * applesmc_create_nodes - create a two-dimensional group of sysfs files
1095  */
1096 static int applesmc_create_nodes(struct applesmc_node_group *groups, int num)
1097 {
1098         struct applesmc_node_group *grp;
1099         struct applesmc_dev_attr *node;
1100         struct attribute *attr;
1101         int ret, i;
1102
1103         for (grp = groups; grp->format; grp++) {
1104                 grp->nodes = kcalloc(num + 1, sizeof(*node), GFP_KERNEL);
1105                 if (!grp->nodes) {
1106                         ret = -ENOMEM;
1107                         goto out;
1108                 }
1109                 for (i = 0; i < num; i++) {
1110                         node = &grp->nodes[i];
1111                         scnprintf(node->name, sizeof(node->name), grp->format,
1112                                   i + 1);
1113                         node->sda.index = (grp->option << 16) | (i & 0xffff);
1114                         node->sda.dev_attr.show = grp->show;
1115                         node->sda.dev_attr.store = grp->store;
1116                         attr = &node->sda.dev_attr.attr;
1117                         sysfs_attr_init(attr);
1118                         attr->name = node->name;
1119                         attr->mode = 0444 | (grp->store ? 0200 : 0);
1120                         ret = sysfs_create_file(&pdev->dev.kobj, attr);
1121                         if (ret) {
1122                                 attr->name = NULL;
1123                                 goto out;
1124                         }
1125                 }
1126         }
1127
1128         return 0;
1129 out:
1130         applesmc_destroy_nodes(groups);
1131         return ret;
1132 }
1133
1134 /* Create accelerometer resources */
1135 static int applesmc_create_accelerometer(void)
1136 {
1137         struct input_dev *idev;
1138         int ret;
1139
1140         if (!smcreg.has_accelerometer)
1141                 return 0;
1142
1143         ret = applesmc_create_nodes(accelerometer_group, 1);
1144         if (ret)
1145                 goto out;
1146
1147         applesmc_idev = input_allocate_polled_device();
1148         if (!applesmc_idev) {
1149                 ret = -ENOMEM;
1150                 goto out_sysfs;
1151         }
1152
1153         applesmc_idev->poll = applesmc_idev_poll;
1154         applesmc_idev->poll_interval = APPLESMC_POLL_INTERVAL;
1155
1156         /* initial calibrate for the input device */
1157         applesmc_calibrate();
1158
1159         /* initialize the input device */
1160         idev = applesmc_idev->input;
1161         idev->name = "applesmc";
1162         idev->id.bustype = BUS_HOST;
1163         idev->dev.parent = &pdev->dev;
1164         idev->evbit[0] = BIT_MASK(EV_ABS);
1165         input_set_abs_params(idev, ABS_X,
1166                         -256, 256, APPLESMC_INPUT_FUZZ, APPLESMC_INPUT_FLAT);
1167         input_set_abs_params(idev, ABS_Y,
1168                         -256, 256, APPLESMC_INPUT_FUZZ, APPLESMC_INPUT_FLAT);
1169
1170         ret = input_register_polled_device(applesmc_idev);
1171         if (ret)
1172                 goto out_idev;
1173
1174         return 0;
1175
1176 out_idev:
1177         input_free_polled_device(applesmc_idev);
1178
1179 out_sysfs:
1180         applesmc_destroy_nodes(accelerometer_group);
1181
1182 out:
1183         pr_warn("driver init failed (ret=%d)!\n", ret);
1184         return ret;
1185 }
1186
1187 /* Release all resources used by the accelerometer */
1188 static void applesmc_release_accelerometer(void)
1189 {
1190         if (!smcreg.has_accelerometer)
1191                 return;
1192         input_unregister_polled_device(applesmc_idev);
1193         input_free_polled_device(applesmc_idev);
1194         applesmc_destroy_nodes(accelerometer_group);
1195 }
1196
1197 static int applesmc_create_light_sensor(void)
1198 {
1199         if (!smcreg.num_light_sensors)
1200                 return 0;
1201         return applesmc_create_nodes(light_sensor_group, 1);
1202 }
1203
1204 static void applesmc_release_light_sensor(void)
1205 {
1206         if (!smcreg.num_light_sensors)
1207                 return;
1208         applesmc_destroy_nodes(light_sensor_group);
1209 }
1210
1211 static int applesmc_create_key_backlight(void)
1212 {
1213         if (!smcreg.has_key_backlight)
1214                 return 0;
1215         applesmc_led_wq = create_singlethread_workqueue("applesmc-led");
1216         if (!applesmc_led_wq)
1217                 return -ENOMEM;
1218         return led_classdev_register(&pdev->dev, &applesmc_backlight);
1219 }
1220
1221 static void applesmc_release_key_backlight(void)
1222 {
1223         if (!smcreg.has_key_backlight)
1224                 return;
1225         led_classdev_unregister(&applesmc_backlight);
1226         destroy_workqueue(applesmc_led_wq);
1227 }
1228
1229 static int applesmc_dmi_match(const struct dmi_system_id *id)
1230 {
1231         return 1;
1232 }
1233
1234 /*
1235  * Note that DMI_MATCH(...,"MacBook") will match "MacBookPro1,1".
1236  * So we need to put "Apple MacBook Pro" before "Apple MacBook".
1237  */
1238 static const struct dmi_system_id applesmc_whitelist[] __initconst = {
1239         { applesmc_dmi_match, "Apple MacBook Air", {
1240           DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),
1241           DMI_MATCH(DMI_PRODUCT_NAME, "MacBookAir") },
1242         },
1243         { applesmc_dmi_match, "Apple MacBook Pro", {
1244           DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),
1245           DMI_MATCH(DMI_PRODUCT_NAME, "MacBookPro") },
1246         },
1247         { applesmc_dmi_match, "Apple MacBook", {
1248           DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),
1249           DMI_MATCH(DMI_PRODUCT_NAME, "MacBook") },
1250         },
1251         { applesmc_dmi_match, "Apple Macmini", {
1252           DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),
1253           DMI_MATCH(DMI_PRODUCT_NAME, "Macmini") },
1254         },
1255         { applesmc_dmi_match, "Apple MacPro", {
1256           DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),
1257           DMI_MATCH(DMI_PRODUCT_NAME, "MacPro") },
1258         },
1259         { applesmc_dmi_match, "Apple iMac", {
1260           DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),
1261           DMI_MATCH(DMI_PRODUCT_NAME, "iMac") },
1262         },
1263         { .ident = NULL }
1264 };
1265
1266 static int __init applesmc_init(void)
1267 {
1268         int ret;
1269
1270         if (!dmi_check_system(applesmc_whitelist)) {
1271                 pr_warn("supported laptop not found!\n");
1272                 ret = -ENODEV;
1273                 goto out;
1274         }
1275
1276         if (!request_region(APPLESMC_DATA_PORT, APPLESMC_NR_PORTS,
1277                                                                 "applesmc")) {
1278                 ret = -ENXIO;
1279                 goto out;
1280         }
1281
1282         ret = platform_driver_register(&applesmc_driver);
1283         if (ret)
1284                 goto out_region;
1285
1286         pdev = platform_device_register_simple("applesmc", APPLESMC_DATA_PORT,
1287                                                NULL, 0);
1288         if (IS_ERR(pdev)) {
1289                 ret = PTR_ERR(pdev);
1290                 goto out_driver;
1291         }
1292
1293         /* create register cache */
1294         ret = applesmc_init_smcreg();
1295         if (ret)
1296                 goto out_device;
1297
1298         ret = applesmc_create_nodes(info_group, 1);
1299         if (ret)
1300                 goto out_smcreg;
1301
1302         ret = applesmc_create_nodes(fan_group, smcreg.fan_count);
1303         if (ret)
1304                 goto out_info;
1305
1306         ret = applesmc_create_nodes(temp_group, smcreg.index_count);
1307         if (ret)
1308                 goto out_fans;
1309
1310         ret = applesmc_create_accelerometer();
1311         if (ret)
1312                 goto out_temperature;
1313
1314         ret = applesmc_create_light_sensor();
1315         if (ret)
1316                 goto out_accelerometer;
1317
1318         ret = applesmc_create_key_backlight();
1319         if (ret)
1320                 goto out_light_sysfs;
1321
1322         hwmon_dev = hwmon_device_register(&pdev->dev);
1323         if (IS_ERR(hwmon_dev)) {
1324                 ret = PTR_ERR(hwmon_dev);
1325                 goto out_light_ledclass;
1326         }
1327
1328         return 0;
1329
1330 out_light_ledclass:
1331         applesmc_release_key_backlight();
1332 out_light_sysfs:
1333         applesmc_release_light_sensor();
1334 out_accelerometer:
1335         applesmc_release_accelerometer();
1336 out_temperature:
1337         applesmc_destroy_nodes(temp_group);
1338 out_fans:
1339         applesmc_destroy_nodes(fan_group);
1340 out_info:
1341         applesmc_destroy_nodes(info_group);
1342 out_smcreg:
1343         applesmc_destroy_smcreg();
1344 out_device:
1345         platform_device_unregister(pdev);
1346 out_driver:
1347         platform_driver_unregister(&applesmc_driver);
1348 out_region:
1349         release_region(APPLESMC_DATA_PORT, APPLESMC_NR_PORTS);
1350 out:
1351         pr_warn("driver init failed (ret=%d)!\n", ret);
1352         return ret;
1353 }
1354
1355 static void __exit applesmc_exit(void)
1356 {
1357         hwmon_device_unregister(hwmon_dev);
1358         applesmc_release_key_backlight();
1359         applesmc_release_light_sensor();
1360         applesmc_release_accelerometer();
1361         applesmc_destroy_nodes(temp_group);
1362         applesmc_destroy_nodes(fan_group);
1363         applesmc_destroy_nodes(info_group);
1364         applesmc_destroy_smcreg();
1365         platform_device_unregister(pdev);
1366         platform_driver_unregister(&applesmc_driver);
1367         release_region(APPLESMC_DATA_PORT, APPLESMC_NR_PORTS);
1368 }
1369
1370 module_init(applesmc_init);
1371 module_exit(applesmc_exit);
1372
1373 MODULE_AUTHOR("Nicolas Boichat");
1374 MODULE_DESCRIPTION("Apple SMC");
1375 MODULE_LICENSE("GPL v2");
1376 MODULE_DEVICE_TABLE(dmi, applesmc_whitelist);