drivers/hwmon/applesmc.c

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