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 #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 */
  79 static 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 */
  98 struct 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 */
 104 struct 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 */
 113 struct 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 */
 122 static 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
 140 static const int debug;
 141 static struct platform_device *pdev;
 142 static s16 rest_x;
 143 static s16 rest_y;
 144 static u8 backlight_state[2];
 145
 146 static struct device *hwmon_dev;
 147 static 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  */
 153 static unsigned int key_at_index;
 154
 155 static 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
 165 static 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
 185 static 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
 208 static 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
 225 static 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
 238 static 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
 248 static 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
 292 static 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
 321 static 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
 341 static 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
 355 static 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
 368 static 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
 396 out:
 397         mutex_unlock(&smcreg.mutex);
 398         if (ret)
 399                 return ERR_PTR(ret);
 400         return cache;
 401 }
 402
 403 static 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
 425 static 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
 447 static 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
 464 static 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
 475 static 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
 486 static 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  */
 501 static 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  */
 517 static 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
 538 static 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  */
 565 static 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
 637 static 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  */
 652 static 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 */
 672 static 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 */
 686 static 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 */
 694 static int applesmc_pm_restore(struct device *dev)
 695 {
 696         applesmc_device_init();
 697         return applesmc_pm_resume(dev);
 698 }
 699
 700 static const struct dev_pm_ops applesmc_pm_ops = {
 701         .resume = applesmc_pm_resume,
 702         .restore = applesmc_pm_restore,
 703 };
 704
 705 static 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  */
 717 static 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
 724 static 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
 741 static 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
 747 static 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
 763 out:
 764         if (ret)
 765                 return ret;
 766
 767         return sysfs_emit(buf, "(%d,%d,%d)\n", x, y, z);
 768 }
 769
 770 static 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
 804 out:
 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 */
 812 static 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 */
 821 static 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
 838 static 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
 857 static 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
 882 static 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
 897 static 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
 925 out:
 926         if (ret)
 927                 return ret;
 928         else
 929                 return count;
 930 }
 931
 932 static 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
 950 static 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
 956 static 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
 964 static void applesmc_backlight_set(struct work_struct *work)
 965 {
 966         applesmc_write_key(BACKLIGHT_KEY, backlight_state, 2);
 967 }
 968 static DECLARE_WORK(backlight_work, &applesmc_backlight_set);
 969
 970 static 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
 982 static 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
 998 static 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
1014 static 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
1026 static 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
1038 static 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
1050 static 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
1056 static 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
1069 static struct led_classdev applesmc_backlight = {
1070         .name                   = "smc::kbd_backlight",
1071         .default_trigger        = "nand-disk",
1072         .brightness_set         = applesmc_brightness_set,
1073 };
1074
1075 static 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
1086 static struct applesmc_node_group accelerometer_group[] = {
1087         { "position", applesmc_position_show },
1088         { "calibrate", applesmc_calibrate_show, applesmc_calibrate_store },
1089         { }
1090 };
1091
1092 static struct applesmc_node_group light_sensor_group[] = {
1093         { "light", applesmc_light_show },
1094         { }
1095 };
1096
1097 static 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
1108 static 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  */
1119 static 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  */
1136 static 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;
1169 out:
1170         applesmc_destroy_nodes(groups);
1171         return ret;
1172 }
1173
1174 /* Create accelerometer resources */
1175 static 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
1216 out_idev:
1217         input_free_device(applesmc_idev);
1218
1219 out_sysfs:
1220         applesmc_destroy_nodes(accelerometer_group);
1221
1222 out:
1223         pr_warn("driver init failed (ret=%d)!\n", ret);
1224         return ret;
1225 }
1226
1227 /* Release all resources used by the accelerometer */
1228 static 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
1236 static 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
1243 static void applesmc_release_light_sensor(void)
1244 {
1245         if (!smcreg.num_light_sensors)
1246                 return;
1247         applesmc_destroy_nodes(light_sensor_group);
1248 }
1249
1250 static 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
1260 static 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
1268 static 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  */
1277 static 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
1309 static 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
1373 out_light_ledclass:
1374         applesmc_release_key_backlight();
1375 out_light_sysfs:
1376         applesmc_release_light_sensor();
1377 out_accelerometer:
1378         applesmc_release_accelerometer();
1379 out_temperature:
1380         applesmc_destroy_nodes(temp_group);
1381 out_fans:
1382         applesmc_destroy_nodes(fan_group);
1383 out_info:
1384         applesmc_destroy_nodes(info_group);
1385 out_smcreg:
1386         applesmc_destroy_smcreg();
1387 out_device:
1388         platform_device_unregister(pdev);
1389 out_driver:
1390         platform_driver_unregister(&applesmc_driver);
1391 out_region:
1392         release_region(APPLESMC_DATA_PORT, APPLESMC_NR_PORTS);
1393 out:
1394         pr_warn("driver init failed (ret=%d)!\n", ret);
1395         return ret;
1396 }
1397
1398 static 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
1413 module_init(applesmc_init);
1414 module_exit(applesmc_exit);
1415
1416 MODULE_AUTHOR("Nicolas Boichat");
1417 MODULE_DESCRIPTION("Apple SMC");
1418 MODULE_LICENSE("GPL v2");
1419 MODULE_DEVICE_TABLE(dmi, applesmc_whitelist);