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