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