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 <nicolas@boichat.ch>
   8  * Copyright (C) 2010 Henrik Rydberg <rydberg@euromail.se>
   9  *
  10  * Based on hdaps.c driver:
  11  * Copyright (C) 2005 Robert Love <rml@novell.com>
  12  * Copyright (C) 2005 Jesper Juhl <jj@chaosbits.net>
  13  *
  14  * Fan control based on smcFanControl:
  15  * Copyright (C) 2006 Hendrik Holtmann <holtmann@mac.com>
  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         if (ret)
 752                 goto out;
 753         /* newer macbooks report a single 10-bit bigendian value */
 754         if (data_length == 10) {
 755                 left = be16_to_cpu(*(__be16 *)(buffer + 6)) >> 2;
 756                 goto out;
 757         }
 758         left = buffer[2];
 759
 760         ret = applesmc_read_key(LIGHT_SENSOR_RIGHT_KEY, buffer, data_length);
 761         if (ret)
 762                 goto out;
 763         right = buffer[2];
 764
 765 out:
 766         if (ret)
 767                 return ret;
 768         else
 769                 return snprintf(sysfsbuf, PAGE_SIZE, "(%d,%d)\n", left, right);
 770 }
 771
 772 /* Displays sensor key as label */
 773 static ssize_t applesmc_show_sensor_label(struct device *dev,
 774                         struct device_attribute *devattr, char *sysfsbuf)
 775 {
 776         const char *key = smcreg.index[to_index(devattr)];
 777
 778         return snprintf(sysfsbuf, PAGE_SIZE, "%s\n", key);
 779 }
 780
 781 /* Displays degree Celsius * 1000 */
 782 static ssize_t applesmc_show_temperature(struct device *dev,
 783                         struct device_attribute *devattr, char *sysfsbuf)
 784 {
 785         const char *key = smcreg.index[to_index(devattr)];
 786         int ret;
 787         s16 value;
 788         int temp;
 789
 790         ret = applesmc_read_s16(key, &value);
 791         if (ret)
 792                 return ret;
 793
 794         temp = 250 * (value >> 6);
 795
 796         return snprintf(sysfsbuf, PAGE_SIZE, "%d\n", temp);
 797 }
 798
 799 static ssize_t applesmc_show_fan_speed(struct device *dev,
 800                                 struct device_attribute *attr, char *sysfsbuf)
 801 {
 802         int ret;
 803         unsigned int speed = 0;
 804         char newkey[5];
 805         u8 buffer[2];
 806
 807         scnprintf(newkey, sizeof(newkey), fan_speed_fmt[to_option(attr)],
 808                   to_index(attr));
 809
 810         ret = applesmc_read_key(newkey, buffer, 2);
 811         if (ret)
 812                 return ret;
 813
 814         speed = ((buffer[0] << 8 | buffer[1]) >> 2);
 815         return snprintf(sysfsbuf, PAGE_SIZE, "%u\n", speed);
 816 }
 817
 818 static ssize_t applesmc_store_fan_speed(struct device *dev,
 819                                         struct device_attribute *attr,
 820                                         const char *sysfsbuf, size_t count)
 821 {
 822         int ret;
 823         unsigned long speed;
 824         char newkey[5];
 825         u8 buffer[2];
 826
 827         if (kstrtoul(sysfsbuf, 10, &speed) < 0 || speed >= 0x4000)
 828                 return -EINVAL;         /* Bigger than a 14-bit value */
 829
 830         scnprintf(newkey, sizeof(newkey), fan_speed_fmt[to_option(attr)],
 831                   to_index(attr));
 832
 833         buffer[0] = (speed >> 6) & 0xff;
 834         buffer[1] = (speed << 2) & 0xff;
 835         ret = applesmc_write_key(newkey, buffer, 2);
 836
 837         if (ret)
 838                 return ret;
 839         else
 840                 return count;
 841 }
 842
 843 static ssize_t applesmc_show_fan_manual(struct device *dev,
 844                         struct device_attribute *attr, char *sysfsbuf)
 845 {
 846         int ret;
 847         u16 manual = 0;
 848         u8 buffer[2];
 849
 850         ret = applesmc_read_key(FANS_MANUAL, buffer, 2);
 851         if (ret)
 852                 return ret;
 853
 854         manual = ((buffer[0] << 8 | buffer[1]) >> to_index(attr)) & 0x01;
 855         return snprintf(sysfsbuf, PAGE_SIZE, "%d\n", manual);
 856 }
 857
 858 static ssize_t applesmc_store_fan_manual(struct device *dev,
 859                                          struct device_attribute *attr,
 860                                          const char *sysfsbuf, size_t count)
 861 {
 862         int ret;
 863         u8 buffer[2];
 864         unsigned long input;
 865         u16 val;
 866
 867         if (kstrtoul(sysfsbuf, 10, &input) < 0)
 868                 return -EINVAL;
 869
 870         ret = applesmc_read_key(FANS_MANUAL, buffer, 2);
 871         if (ret)
 872                 goto out;
 873
 874         val = (buffer[0] << 8 | buffer[1]);
 875
 876         if (input)
 877                 val = val | (0x01 << to_index(attr));
 878         else
 879                 val = val & ~(0x01 << to_index(attr));
 880
 881         buffer[0] = (val >> 8) & 0xFF;
 882         buffer[1] = val & 0xFF;
 883
 884         ret = applesmc_write_key(FANS_MANUAL, buffer, 2);
 885
 886 out:
 887         if (ret)
 888                 return ret;
 889         else
 890                 return count;
 891 }
 892
 893 static ssize_t applesmc_show_fan_position(struct device *dev,
 894                                 struct device_attribute *attr, char *sysfsbuf)
 895 {
 896         int ret;
 897         char newkey[5];
 898         u8 buffer[17];
 899
 900         scnprintf(newkey, sizeof(newkey), FAN_ID_FMT, to_index(attr));
 901
 902         ret = applesmc_read_key(newkey, buffer, 16);
 903         buffer[16] = 0;
 904
 905         if (ret)
 906                 return ret;
 907         else
 908                 return snprintf(sysfsbuf, PAGE_SIZE, "%s\n", buffer+4);
 909 }
 910
 911 static ssize_t applesmc_calibrate_show(struct device *dev,
 912                                 struct device_attribute *attr, char *sysfsbuf)
 913 {
 914         return snprintf(sysfsbuf, PAGE_SIZE, "(%d,%d)\n", rest_x, rest_y);
 915 }
 916
 917 static ssize_t applesmc_calibrate_store(struct device *dev,
 918         struct device_attribute *attr, const char *sysfsbuf, size_t count)
 919 {
 920         applesmc_calibrate();
 921
 922         return count;
 923 }
 924
 925 static void applesmc_backlight_set(struct work_struct *work)
 926 {
 927         applesmc_write_key(BACKLIGHT_KEY, backlight_state, 2);
 928 }
 929 static DECLARE_WORK(backlight_work, &applesmc_backlight_set);
 930
 931 static void applesmc_brightness_set(struct led_classdev *led_cdev,
 932                                                 enum led_brightness value)
 933 {
 934         int ret;
 935
 936         backlight_state[0] = value;
 937         ret = queue_work(applesmc_led_wq, &backlight_work);
 938
 939         if (debug && (!ret))
 940                 dev_dbg(led_cdev->dev, "work was already on the queue.\n");
 941 }
 942
 943 static ssize_t applesmc_key_count_show(struct device *dev,
 944                                 struct device_attribute *attr, char *sysfsbuf)
 945 {
 946         int ret;
 947         u8 buffer[4];
 948         u32 count;
 949
 950         ret = applesmc_read_key(KEY_COUNT_KEY, buffer, 4);
 951         if (ret)
 952                 return ret;
 953
 954         count = ((u32)buffer[0]<<24) + ((u32)buffer[1]<<16) +
 955                                                 ((u32)buffer[2]<<8) + buffer[3];
 956         return snprintf(sysfsbuf, PAGE_SIZE, "%d\n", count);
 957 }
 958
 959 static ssize_t applesmc_key_at_index_read_show(struct device *dev,
 960                                 struct device_attribute *attr, char *sysfsbuf)
 961 {
 962         const struct applesmc_entry *entry;
 963         int ret;
 964
 965         entry = applesmc_get_entry_by_index(key_at_index);
 966         if (IS_ERR(entry))
 967                 return PTR_ERR(entry);
 968         ret = applesmc_read_entry(entry, sysfsbuf, entry->len);
 969         if (ret)
 970                 return ret;
 971
 972         return entry->len;
 973 }
 974
 975 static ssize_t applesmc_key_at_index_data_length_show(struct device *dev,
 976                                 struct device_attribute *attr, char *sysfsbuf)
 977 {
 978         const struct applesmc_entry *entry;
 979
 980         entry = applesmc_get_entry_by_index(key_at_index);
 981         if (IS_ERR(entry))
 982                 return PTR_ERR(entry);
 983
 984         return snprintf(sysfsbuf, PAGE_SIZE, "%d\n", entry->len);
 985 }
 986
 987 static ssize_t applesmc_key_at_index_type_show(struct device *dev,
 988                                 struct device_attribute *attr, char *sysfsbuf)
 989 {
 990         const struct applesmc_entry *entry;
 991
 992         entry = applesmc_get_entry_by_index(key_at_index);
 993         if (IS_ERR(entry))
 994                 return PTR_ERR(entry);
 995
 996         return snprintf(sysfsbuf, PAGE_SIZE, "%s\n", entry->type);
 997 }
 998
 999 static ssize_t applesmc_key_at_index_name_show(struct device *dev,
1000                                 struct device_attribute *attr, char *sysfsbuf)
1001 {
1002         const struct applesmc_entry *entry;
1003
1004         entry = applesmc_get_entry_by_index(key_at_index);
1005         if (IS_ERR(entry))
1006                 return PTR_ERR(entry);
1007
1008         return snprintf(sysfsbuf, PAGE_SIZE, "%s\n", entry->key);
1009 }
1010
1011 static ssize_t applesmc_key_at_index_show(struct device *dev,
1012                                 struct device_attribute *attr, char *sysfsbuf)
1013 {
1014         return snprintf(sysfsbuf, PAGE_SIZE, "%d\n", key_at_index);
1015 }
1016
1017 static ssize_t applesmc_key_at_index_store(struct device *dev,
1018         struct device_attribute *attr, const char *sysfsbuf, size_t count)
1019 {
1020         unsigned long newkey;
1021
1022         if (kstrtoul(sysfsbuf, 10, &newkey) < 0
1023             || newkey >= smcreg.key_count)
1024                 return -EINVAL;
1025
1026         key_at_index = newkey;
1027         return count;
1028 }
1029
1030 static struct led_classdev applesmc_backlight = {
1031         .name                   = "smc::kbd_backlight",
1032         .default_trigger        = "nand-disk",
1033         .brightness_set         = applesmc_brightness_set,
1034 };
1035
1036 static struct applesmc_node_group info_group[] = {
1037         { "name", applesmc_name_show },
1038         { "key_count", applesmc_key_count_show },
1039         { "key_at_index", applesmc_key_at_index_show, applesmc_key_at_index_store },
1040         { "key_at_index_name", applesmc_key_at_index_name_show },
1041         { "key_at_index_type", applesmc_key_at_index_type_show },
1042         { "key_at_index_data_length", applesmc_key_at_index_data_length_show },
1043         { "key_at_index_data", applesmc_key_at_index_read_show },
1044         { }
1045 };
1046
1047 static struct applesmc_node_group accelerometer_group[] = {
1048         { "position", applesmc_position_show },
1049         { "calibrate", applesmc_calibrate_show, applesmc_calibrate_store },
1050         { }
1051 };
1052
1053 static struct applesmc_node_group light_sensor_group[] = {
1054         { "light", applesmc_light_show },
1055         { }
1056 };
1057
1058 static struct applesmc_node_group fan_group[] = {
1059         { "fan%d_label", applesmc_show_fan_position },
1060         { "fan%d_input", applesmc_show_fan_speed, NULL, 0 },
1061         { "fan%d_min", applesmc_show_fan_speed, applesmc_store_fan_speed, 1 },
1062         { "fan%d_max", applesmc_show_fan_speed, NULL, 2 },
1063         { "fan%d_safe", applesmc_show_fan_speed, NULL, 3 },
1064         { "fan%d_output", applesmc_show_fan_speed, applesmc_store_fan_speed, 4 },
1065         { "fan%d_manual", applesmc_show_fan_manual, applesmc_store_fan_manual },
1066         { }
1067 };
1068
1069 static struct applesmc_node_group temp_group[] = {
1070         { "temp%d_label", applesmc_show_sensor_label },
1071         { "temp%d_input", applesmc_show_temperature },
1072         { }
1073 };
1074
1075 /* Module stuff */
1076
1077 /*
1078  * applesmc_destroy_nodes - remove files and free associated memory
1079  */
1080 static void applesmc_destroy_nodes(struct applesmc_node_group *groups)
1081 {
1082         struct applesmc_node_group *grp;
1083         struct applesmc_dev_attr *node;
1084
1085         for (grp = groups; grp->nodes; grp++) {
1086                 for (node = grp->nodes; node->sda.dev_attr.attr.name; node++)
1087                         sysfs_remove_file(&pdev->dev.kobj,
1088                                           &node->sda.dev_attr.attr);
1089                 kfree(grp->nodes);
1090                 grp->nodes = NULL;
1091         }
1092 }
1093
1094 /*
1095  * applesmc_create_nodes - create a two-dimensional group of sysfs files
1096  */
1097 static int applesmc_create_nodes(struct applesmc_node_group *groups, int num)
1098 {
1099         struct applesmc_node_group *grp;
1100         struct applesmc_dev_attr *node;
1101         struct attribute *attr;
1102         int ret, i;
1103
1104         for (grp = groups; grp->format; grp++) {
1105                 grp->nodes = kcalloc(num + 1, sizeof(*node), GFP_KERNEL);
1106                 if (!grp->nodes) {
1107                         ret = -ENOMEM;
1108                         goto out;
1109                 }
1110                 for (i = 0; i < num; i++) {
1111                         node = &grp->nodes[i];
1112                         scnprintf(node->name, sizeof(node->name), grp->format,
1113                                   i + 1);
1114                         node->sda.index = (grp->option << 16) | (i & 0xffff);
1115                         node->sda.dev_attr.show = grp->show;
1116                         node->sda.dev_attr.store = grp->store;
1117                         attr = &node->sda.dev_attr.attr;
1118                         sysfs_attr_init(attr);
1119                         attr->name = node->name;
1120                         attr->mode = 0444 | (grp->store ? 0200 : 0);
1121                         ret = sysfs_create_file(&pdev->dev.kobj, attr);
1122                         if (ret) {
1123                                 attr->name = NULL;
1124                                 goto out;
1125                         }
1126                 }
1127         }
1128
1129         return 0;
1130 out:
1131         applesmc_destroy_nodes(groups);
1132         return ret;
1133 }
1134
1135 /* Create accelerometer resources */
1136 static int applesmc_create_accelerometer(void)
1137 {
1138         struct input_dev *idev;
1139         int ret;
1140
1141         if (!smcreg.has_accelerometer)
1142                 return 0;
1143
1144         ret = applesmc_create_nodes(accelerometer_group, 1);
1145         if (ret)
1146                 goto out;
1147
1148         applesmc_idev = input_allocate_polled_device();
1149         if (!applesmc_idev) {
1150                 ret = -ENOMEM;
1151                 goto out_sysfs;
1152         }
1153
1154         applesmc_idev->poll = applesmc_idev_poll;
1155         applesmc_idev->poll_interval = APPLESMC_POLL_INTERVAL;
1156
1157         /* initial calibrate for the input device */
1158         applesmc_calibrate();
1159
1160         /* initialize the input device */
1161         idev = applesmc_idev->input;
1162         idev->name = "applesmc";
1163         idev->id.bustype = BUS_HOST;
1164         idev->dev.parent = &pdev->dev;
1165         idev->evbit[0] = BIT_MASK(EV_ABS);
1166         input_set_abs_params(idev, ABS_X,
1167                         -256, 256, APPLESMC_INPUT_FUZZ, APPLESMC_INPUT_FLAT);
1168         input_set_abs_params(idev, ABS_Y,
1169                         -256, 256, APPLESMC_INPUT_FUZZ, APPLESMC_INPUT_FLAT);
1170
1171         ret = input_register_polled_device(applesmc_idev);
1172         if (ret)
1173                 goto out_idev;
1174
1175         return 0;
1176
1177 out_idev:
1178         input_free_polled_device(applesmc_idev);
1179
1180 out_sysfs:
1181         applesmc_destroy_nodes(accelerometer_group);
1182
1183 out:
1184         pr_warn("driver init failed (ret=%d)!\n", ret);
1185         return ret;
1186 }
1187
1188 /* Release all resources used by the accelerometer */
1189 static void applesmc_release_accelerometer(void)
1190 {
1191         if (!smcreg.has_accelerometer)
1192                 return;
1193         input_unregister_polled_device(applesmc_idev);
1194         input_free_polled_device(applesmc_idev);
1195         applesmc_destroy_nodes(accelerometer_group);
1196 }
1197
1198 static int applesmc_create_light_sensor(void)
1199 {
1200         if (!smcreg.num_light_sensors)
1201                 return 0;
1202         return applesmc_create_nodes(light_sensor_group, 1);
1203 }
1204
1205 static void applesmc_release_light_sensor(void)
1206 {
1207         if (!smcreg.num_light_sensors)
1208                 return;
1209         applesmc_destroy_nodes(light_sensor_group);
1210 }
1211
1212 static int applesmc_create_key_backlight(void)
1213 {
1214         if (!smcreg.has_key_backlight)
1215                 return 0;
1216         applesmc_led_wq = create_singlethread_workqueue("applesmc-led");
1217         if (!applesmc_led_wq)
1218                 return -ENOMEM;
1219         return led_classdev_register(&pdev->dev, &applesmc_backlight);
1220 }
1221
1222 static void applesmc_release_key_backlight(void)
1223 {
1224         if (!smcreg.has_key_backlight)
1225                 return;
1226         led_classdev_unregister(&applesmc_backlight);
1227         destroy_workqueue(applesmc_led_wq);
1228 }
1229
1230 static int applesmc_dmi_match(const struct dmi_system_id *id)
1231 {
1232         return 1;
1233 }
1234
1235 /*
1236  * Note that DMI_MATCH(...,"MacBook") will match "MacBookPro1,1".
1237  * So we need to put "Apple MacBook Pro" before "Apple MacBook".
1238  */
1239 static const struct dmi_system_id applesmc_whitelist[] __initconst = {
1240         { applesmc_dmi_match, "Apple MacBook Air", {
1241           DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),
1242           DMI_MATCH(DMI_PRODUCT_NAME, "MacBookAir") },
1243         },
1244         { applesmc_dmi_match, "Apple MacBook Pro", {
1245           DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),
1246           DMI_MATCH(DMI_PRODUCT_NAME, "MacBookPro") },
1247         },
1248         { applesmc_dmi_match, "Apple MacBook", {
1249           DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),
1250           DMI_MATCH(DMI_PRODUCT_NAME, "MacBook") },
1251         },
1252         { applesmc_dmi_match, "Apple Macmini", {
1253           DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),
1254           DMI_MATCH(DMI_PRODUCT_NAME, "Macmini") },
1255         },
1256         { applesmc_dmi_match, "Apple MacPro", {
1257           DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),
1258           DMI_MATCH(DMI_PRODUCT_NAME, "MacPro") },
1259         },
1260         { applesmc_dmi_match, "Apple iMac", {
1261           DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),
1262           DMI_MATCH(DMI_PRODUCT_NAME, "iMac") },
1263         },
1264         { .ident = NULL }
1265 };
1266
1267 static int __init applesmc_init(void)
1268 {
1269         int ret;
1270
1271         if (!dmi_check_system(applesmc_whitelist)) {
1272                 pr_warn("supported laptop not found!\n");
1273                 ret = -ENODEV;
1274                 goto out;
1275         }
1276
1277         if (!request_region(APPLESMC_DATA_PORT, APPLESMC_NR_PORTS,
1278                                                                 "applesmc")) {
1279                 ret = -ENXIO;
1280                 goto out;
1281         }
1282
1283         ret = platform_driver_register(&applesmc_driver);
1284         if (ret)
1285                 goto out_region;
1286
1287         pdev = platform_device_register_simple("applesmc", APPLESMC_DATA_PORT,
1288                                                NULL, 0);
1289         if (IS_ERR(pdev)) {
1290                 ret = PTR_ERR(pdev);
1291                 goto out_driver;
1292         }
1293
1294         /* create register cache */
1295         ret = applesmc_init_smcreg();
1296         if (ret)
1297                 goto out_device;
1298
1299         ret = applesmc_create_nodes(info_group, 1);
1300         if (ret)
1301                 goto out_smcreg;
1302
1303         ret = applesmc_create_nodes(fan_group, smcreg.fan_count);
1304         if (ret)
1305                 goto out_info;
1306
1307         ret = applesmc_create_nodes(temp_group, smcreg.index_count);
1308         if (ret)
1309                 goto out_fans;
1310
1311         ret = applesmc_create_accelerometer();
1312         if (ret)
1313                 goto out_temperature;
1314
1315         ret = applesmc_create_light_sensor();
1316         if (ret)
1317                 goto out_accelerometer;
1318
1319         ret = applesmc_create_key_backlight();
1320         if (ret)
1321                 goto out_light_sysfs;
1322
1323         hwmon_dev = hwmon_device_register(&pdev->dev);
1324         if (IS_ERR(hwmon_dev)) {
1325                 ret = PTR_ERR(hwmon_dev);
1326                 goto out_light_ledclass;
1327         }
1328
1329         return 0;
1330
1331 out_light_ledclass:
1332         applesmc_release_key_backlight();
1333 out_light_sysfs:
1334         applesmc_release_light_sensor();
1335 out_accelerometer:
1336         applesmc_release_accelerometer();
1337 out_temperature:
1338         applesmc_destroy_nodes(temp_group);
1339 out_fans:
1340         applesmc_destroy_nodes(fan_group);
1341 out_info:
1342         applesmc_destroy_nodes(info_group);
1343 out_smcreg:
1344         applesmc_destroy_smcreg();
1345 out_device:
1346         platform_device_unregister(pdev);
1347 out_driver:
1348         platform_driver_unregister(&applesmc_driver);
1349 out_region:
1350         release_region(APPLESMC_DATA_PORT, APPLESMC_NR_PORTS);
1351 out:
1352         pr_warn("driver init failed (ret=%d)!\n", ret);
1353         return ret;
1354 }
1355
1356 static void __exit applesmc_exit(void)
1357 {
1358         hwmon_device_unregister(hwmon_dev);
1359         applesmc_release_key_backlight();
1360         applesmc_release_light_sensor();
1361         applesmc_release_accelerometer();
1362         applesmc_destroy_nodes(temp_group);
1363         applesmc_destroy_nodes(fan_group);
1364         applesmc_destroy_nodes(info_group);
1365         applesmc_destroy_smcreg();
1366         platform_device_unregister(pdev);
1367         platform_driver_unregister(&applesmc_driver);
1368         release_region(APPLESMC_DATA_PORT, APPLESMC_NR_PORTS);
1369 }
1370
1371 module_init(applesmc_init);
1372 module_exit(applesmc_exit);
1373
1374 MODULE_AUTHOR("Nicolas Boichat");
1375 MODULE_DESCRIPTION("Apple SMC");
1376 MODULE_LICENSE("GPL v2");
1377 MODULE_DEVICE_TABLE(dmi, applesmc_whitelist);