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