drivers/hwmon/applesmc.c

   1 /*
   2  * drivers/hwmon/applesmc.c - driver for Apple's SMC (accelerometer, temperature
   3  * sensors, fan control, keyboard backlight control) used in Intel-based Apple
   4  * computers.
   5  *
   6  * Copyright (C) 2007 Nicolas Boichat <nicolas@boichat.ch>
   7  *
   8  * Based on hdaps.c driver:
   9  * Copyright (C) 2005 Robert Love <rml@novell.com>
  10  * Copyright (C) 2005 Jesper Juhl <jesper.juhl@gmail.com>
  11  *
  12  * Fan control based on smcFanControl:
  13  * Copyright (C) 2006 Hendrik Holtmann <holtmann@mac.com>
  14  *
  15  * This program is free software; you can redistribute it and/or modify it
  16  * under the terms of the GNU General Public License v2 as published by the
  17  * Free Software Foundation.
  18  *
  19  * This program is distributed in the hope that it will be useful, but WITHOUT
  20  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  21  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  22  * more details.
  23  *
  24  * You should have received a copy of the GNU General Public License along with
  25  * this program; if not, write to the Free Software Foundation, Inc.,
  26  * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
  27  */
  28
  29 #include <linux/delay.h>
  30 #include <linux/platform_device.h>
  31 #include <linux/input-polldev.h>
  32 #include <linux/kernel.h>
  33 #include <linux/module.h>
  34 #include <linux/timer.h>
  35 #include <linux/dmi.h>
  36 #include <linux/mutex.h>
  37 #include <linux/hwmon-sysfs.h>
  38 #include <asm/io.h>
  39 #include <linux/leds.h>
  40 #include <linux/hwmon.h>
  41 #include <linux/workqueue.h>
  42
  43 /* data port used by Apple SMC */
  44 #define APPLESMC_DATA_PORT      0x300
  45 /* command/status port used by Apple SMC */
  46 #define APPLESMC_CMD_PORT       0x304
  47
  48 #define APPLESMC_NR_PORTS       32 /* 0x300-0x31f */
  49
  50 #define APPLESMC_MAX_DATA_LENGTH 32
  51
  52 #define APPLESMC_MIN_WAIT       0x0040
  53 #define APPLESMC_MAX_WAIT       0x8000
  54
  55 #define APPLESMC_STATUS_MASK    0x0f
  56 #define APPLESMC_READ_CMD       0x10
  57 #define APPLESMC_WRITE_CMD      0x11
  58 #define APPLESMC_GET_KEY_BY_INDEX_CMD   0x12
  59 #define APPLESMC_GET_KEY_TYPE_CMD       0x13
  60
  61 #define KEY_COUNT_KEY           "#KEY" /* r-o ui32 */
  62
  63 #define LIGHT_SENSOR_LEFT_KEY   "ALV0" /* r-o {alv (6-10 bytes) */
  64 #define LIGHT_SENSOR_RIGHT_KEY  "ALV1" /* r-o {alv (6-10 bytes) */
  65 #define BACKLIGHT_KEY           "LKSB" /* w-o {lkb (2 bytes) */
  66
  67 #define CLAMSHELL_KEY           "MSLD" /* r-o ui8 (unused) */
  68
  69 #define MOTION_SENSOR_X_KEY     "MO_X" /* r-o sp78 (2 bytes) */
  70 #define MOTION_SENSOR_Y_KEY     "MO_Y" /* r-o sp78 (2 bytes) */
  71 #define MOTION_SENSOR_Z_KEY     "MO_Z" /* r-o sp78 (2 bytes) */
  72 #define MOTION_SENSOR_KEY       "MOCN" /* r/w ui16 */
  73
  74 #define FANS_COUNT              "FNum" /* r-o ui8 */
  75 #define FANS_MANUAL             "FS! " /* r-w ui16 */
  76 #define FAN_ACTUAL_SPEED        "F0Ac" /* r-o fpe2 (2 bytes) */
  77 #define FAN_MIN_SPEED           "F0Mn" /* r-o fpe2 (2 bytes) */
  78 #define FAN_MAX_SPEED           "F0Mx" /* r-o fpe2 (2 bytes) */
  79 #define FAN_SAFE_SPEED          "F0Sf" /* r-o fpe2 (2 bytes) */
  80 #define FAN_TARGET_SPEED        "F0Tg" /* r-w fpe2 (2 bytes) */
  81 #define FAN_POSITION            "F0ID" /* r-o char[16] */
  82
  83 /*
  84  * Temperature sensors keys (sp78 - 2 bytes).
  85  */
  86 static const char* temperature_sensors_sets[][36] = {
  87 /* Set 0: Macbook Pro */
  88         { "TA0P", "TB0T", "TC0D", "TC0P", "TG0H", "TG0P", "TG0T", "Th0H",
  89           "Th1H", "Tm0P", "Ts0P", "Ts1P", NULL },
  90 /* Set 1: Macbook2 set */
  91         { "TB0T", "TC0D", "TC0P", "TM0P", "TN0P", "TN1P", "TTF0", "Th0H",
  92           "Th0S", "Th1H", NULL },
  93 /* Set 2: Macbook set */
  94         { "TB0T", "TC0D", "TC0P", "TM0P", "TN0P", "TN1P", "Th0H", "Th0S",
  95           "Th1H", "Ts0P", NULL },
  96 /* Set 3: Macmini set */
  97         { "TC0D", "TC0P", NULL },
  98 /* Set 4: Mac Pro (2 x Quad-Core) */
  99         { "TA0P", "TCAG", "TCAH", "TCBG", "TCBH", "TC0C", "TC0D", "TC0P",
 100           "TC1C", "TC1D", "TC2C", "TC2D", "TC3C", "TC3D", "THTG", "TH0P",
 101           "TH1P", "TH2P", "TH3P", "TMAP", "TMAS", "TMBS", "TM0P", "TM0S",
 102           "TM1P", "TM1S", "TM2P", "TM2S", "TM3S", "TM8P", "TM8S", "TM9P",
 103           "TM9S", "TN0H", "TS0C", NULL },
 104 /* Set 5: iMac */
 105         { "TC0D", "TA0P", "TG0P", "TG0D", "TG0H", "TH0P", "Tm0P", "TO0P",
 106           "Tp0C", NULL },
 107 /* Set 6: Macbook3 set */
 108         { "TB0T", "TC0D", "TC0P", "TM0P", "TN0P", "TTF0", "TW0P", "Th0H",
 109           "Th0S", "Th1H", NULL },
 110 /* Set 7: Macbook Air */
 111         { "TB0T", "TB1S", "TB1T", "TB2S", "TB2T", "TC0D", "TC0P", "TCFP",
 112           "TTF0", "TW0P", "Th0H", "Tp0P", "TpFP", "Ts0P", "Ts0S", NULL },
 113 /* Set 8: Macbook Pro 4,1 (Penryn) */
 114         { "TB0T", "TC0D", "TC0P", "TG0D", "TG0H", "TTF0", "TW0P", "Th0H",
 115           "Th1H", "Th2H", "Tm0P", "Ts0P", NULL },
 116 /* Set 9: Macbook Pro 3,1 (Santa Rosa) */
 117         { "TALP", "TB0T", "TC0D", "TC0P", "TG0D", "TG0H", "TTF0", "TW0P",
 118           "Th0H", "Th1H", "Th2H", "Tm0P", "Ts0P", NULL },
 119 /* Set 10: iMac 5,1 */
 120         { "TA0P", "TC0D", "TC0P", "TG0D", "TH0P", "TO0P", "Tm0P", NULL },
 121 /* Set 11: Macbook 5,1 */
 122         { "TB0T", "TB1T", "TB2T", "TB3T", "TC0D", "TC0P", "TN0D", "TN0P",
 123           "TTF0", "Th0H", "Th1H", "ThFH", "Ts0P", "Ts0S", NULL },
 124 /* Set 12: Macbook Pro 5,1 */
 125         { "TB0T", "TB1T", "TB2T", "TB3T", "TC0D", "TC0F", "TC0P", "TG0D",
 126           "TG0F", "TG0H", "TG0P", "TG0T", "TG1H", "TN0D", "TN0P", "TTF0",
 127           "Th2H", "Tm0P", "Ts0P", "Ts0S", NULL },
 128 /* Set 13: iMac 8,1 */
 129         { "TA0P", "TC0D", "TC0H", "TC0P", "TG0D", "TG0H", "TG0P", "TH0P",
 130           "TL0P", "TO0P", "TW0P", "Tm0P", "Tp0P", NULL },
 131 /* Set 14: iMac 6,1 */
 132         { "TA0P", "TC0D", "TC0H", "TC0P", "TG0D", "TG0H", "TG0P", "TH0P",
 133           "TO0P", "Tp0P", NULL },
 134 /* Set 15: MacBook Air 2,1 */
 135         { "TB0T", "TB1S", "TB1T", "TB2S", "TB2T", "TC0D", "TN0D", "TTF0",
 136           "TV0P", "TVFP", "TW0P", "Th0P", "Tp0P", "Tp1P", "TpFP", "Ts0P",
 137           "Ts0S", NULL },
 138 };
 139
 140 /* List of keys used to read/write fan speeds */
 141 static const char* fan_speed_keys[] = {
 142         FAN_ACTUAL_SPEED,
 143         FAN_MIN_SPEED,
 144         FAN_MAX_SPEED,
 145         FAN_SAFE_SPEED,
 146         FAN_TARGET_SPEED
 147 };
 148
 149 #define INIT_TIMEOUT_MSECS      5000    /* wait up to 5s for device init ... */
 150 #define INIT_WAIT_MSECS         50      /* ... in 50ms increments */
 151
 152 #define APPLESMC_POLL_INTERVAL  50      /* msecs */
 153 #define APPLESMC_INPUT_FUZZ     4       /* input event threshold */
 154 #define APPLESMC_INPUT_FLAT     4
 155
 156 #define SENSOR_X 0
 157 #define SENSOR_Y 1
 158 #define SENSOR_Z 2
 159
 160 /* Structure to be passed to DMI_MATCH function */
 161 struct dmi_match_data {
 162 /* Indicates whether this computer has an accelerometer. */
 163         int accelerometer;
 164 /* Indicates whether this computer has light sensors and keyboard backlight. */
 165         int light;
 166 /* Indicates which temperature sensors set to use. */
 167         int temperature_set;
 168 };
 169
 170 static const int debug;
 171 static struct platform_device *pdev;
 172 static s16 rest_x;
 173 static s16 rest_y;
 174 static struct device *hwmon_dev;
 175 static struct input_polled_dev *applesmc_idev;
 176
 177 /* Indicates whether this computer has an accelerometer. */
 178 static unsigned int applesmc_accelerometer;
 179
 180 /* Indicates whether this computer has light sensors and keyboard backlight. */
 181 static unsigned int applesmc_light;
 182
 183 /* Indicates which temperature sensors set to use. */
 184 static unsigned int applesmc_temperature_set;
 185
 186 static DEFINE_MUTEX(applesmc_lock);
 187
 188 /*
 189  * Last index written to key_at_index sysfs file, and value to use for all other
 190  * key_at_index_* sysfs files.
 191  */
 192 static unsigned int key_at_index;
 193
 194 static struct workqueue_struct *applesmc_led_wq;
 195
 196 /*
 197  * __wait_status - Wait up to 32ms for the status port to get a certain value
 198  * (masked with 0x0f), returning zero if the value is obtained.  Callers must
 199  * hold applesmc_lock.
 200  */
 201 static int __wait_status(u8 val)
 202 {
 203         int us;
 204
 205         val = val & APPLESMC_STATUS_MASK;
 206
 207         for (us = APPLESMC_MIN_WAIT; us < APPLESMC_MAX_WAIT; us <<= 1) {
 208                 udelay(us);
 209                 if ((inb(APPLESMC_CMD_PORT) & APPLESMC_STATUS_MASK) == val) {
 210                         if (debug)
 211                                 printk(KERN_DEBUG
 212                                         "Waited %d us for status %x\n",
 213                                         2 * us - APPLESMC_MIN_WAIT, val);
 214                         return 0;
 215                 }
 216         }
 217
 218         printk(KERN_WARNING "applesmc: wait status failed: %x != %x\n",
 219                                                 val, inb(APPLESMC_CMD_PORT));
 220
 221         return -EIO;
 222 }
 223
 224 /*
 225  * special treatment of command port - on newer macbooks, it seems necessary
 226  * to resend the command byte before polling the status again. Callers must
 227  * hold applesmc_lock.
 228  */
 229 static int send_command(u8 cmd)
 230 {
 231         int us;
 232         for (us = APPLESMC_MIN_WAIT; us < APPLESMC_MAX_WAIT; us <<= 1) {
 233                 outb(cmd, APPLESMC_CMD_PORT);
 234                 udelay(us);
 235                 if ((inb(APPLESMC_CMD_PORT) & APPLESMC_STATUS_MASK) == 0x0c)
 236                         return 0;
 237         }
 238         printk(KERN_WARNING "applesmc: command failed: %x -> %x\n",
 239                 cmd, inb(APPLESMC_CMD_PORT));
 240         return -EIO;
 241 }
 242
 243 /*
 244  * applesmc_read_key - reads len bytes from a given key, and put them in buffer.
 245  * Returns zero on success or a negative error on failure. Callers must
 246  * hold applesmc_lock.
 247  */
 248 static int applesmc_read_key(const char* key, u8* buffer, u8 len)
 249 {
 250         int i;
 251
 252         if (len > APPLESMC_MAX_DATA_LENGTH) {
 253                 printk(KERN_ERR "applesmc_read_key: cannot read more than "
 254                                         "%d bytes\n", APPLESMC_MAX_DATA_LENGTH);
 255                 return -EINVAL;
 256         }
 257
 258         if (send_command(APPLESMC_READ_CMD))
 259                 return -EIO;
 260
 261         for (i = 0; i < 4; i++) {
 262                 outb(key[i], APPLESMC_DATA_PORT);
 263                 if (__wait_status(0x04))
 264                         return -EIO;
 265         }
 266         if (debug)
 267                 printk(KERN_DEBUG "<%s", key);
 268
 269         outb(len, APPLESMC_DATA_PORT);
 270         if (debug)
 271                 printk(KERN_DEBUG ">%x", len);
 272
 273         for (i = 0; i < len; i++) {
 274                 if (__wait_status(0x05))
 275                         return -EIO;
 276                 buffer[i] = inb(APPLESMC_DATA_PORT);
 277                 if (debug)
 278                         printk(KERN_DEBUG "<%x", buffer[i]);
 279         }
 280         if (debug)
 281                 printk(KERN_DEBUG "\n");
 282
 283         return 0;
 284 }
 285
 286 /*
 287  * applesmc_write_key - writes len bytes from buffer to a given key.
 288  * Returns zero on success or a negative error on failure. Callers must
 289  * hold applesmc_lock.
 290  */
 291 static int applesmc_write_key(const char* key, u8* buffer, u8 len)
 292 {
 293         int i;
 294
 295         if (len > APPLESMC_MAX_DATA_LENGTH) {
 296                 printk(KERN_ERR "applesmc_write_key: cannot write more than "
 297                                         "%d bytes\n", APPLESMC_MAX_DATA_LENGTH);
 298                 return -EINVAL;
 299         }
 300
 301         if (send_command(APPLESMC_WRITE_CMD))
 302                 return -EIO;
 303
 304         for (i = 0; i < 4; i++) {
 305                 outb(key[i], APPLESMC_DATA_PORT);
 306                 if (__wait_status(0x04))
 307                         return -EIO;
 308         }
 309
 310         outb(len, APPLESMC_DATA_PORT);
 311
 312         for (i = 0; i < len; i++) {
 313                 if (__wait_status(0x04))
 314                         return -EIO;
 315                 outb(buffer[i], APPLESMC_DATA_PORT);
 316         }
 317
 318         return 0;
 319 }
 320
 321 /*
 322  * applesmc_get_key_at_index - get key at index, and put the result in key
 323  * (char[6]). Returns zero on success or a negative error on failure. Callers
 324  * must hold applesmc_lock.
 325  */
 326 static int applesmc_get_key_at_index(int index, char* key)
 327 {
 328         int i;
 329         u8 readkey[4];
 330         readkey[0] = index >> 24;
 331         readkey[1] = index >> 16;
 332         readkey[2] = index >> 8;
 333         readkey[3] = index;
 334
 335         if (send_command(APPLESMC_GET_KEY_BY_INDEX_CMD))
 336                 return -EIO;
 337
 338         for (i = 0; i < 4; i++) {
 339                 outb(readkey[i], APPLESMC_DATA_PORT);
 340                 if (__wait_status(0x04))
 341                         return -EIO;
 342         }
 343
 344         outb(4, APPLESMC_DATA_PORT);
 345
 346         for (i = 0; i < 4; i++) {
 347                 if (__wait_status(0x05))
 348                         return -EIO;
 349                 key[i] = inb(APPLESMC_DATA_PORT);
 350         }
 351         key[4] = 0;
 352
 353         return 0;
 354 }
 355
 356 /*
 357  * applesmc_get_key_type - get key type, and put the result in type (char[6]).
 358  * Returns zero on success or a negative error on failure. Callers must
 359  * hold applesmc_lock.
 360  */
 361 static int applesmc_get_key_type(char* key, char* type)
 362 {
 363         int i;
 364
 365         if (send_command(APPLESMC_GET_KEY_TYPE_CMD))
 366                 return -EIO;
 367
 368         for (i = 0; i < 4; i++) {
 369                 outb(key[i], APPLESMC_DATA_PORT);
 370                 if (__wait_status(0x04))
 371                         return -EIO;
 372         }
 373
 374         outb(6, APPLESMC_DATA_PORT);
 375
 376         for (i = 0; i < 6; i++) {
 377                 if (__wait_status(0x05))
 378                         return -EIO;
 379                 type[i] = inb(APPLESMC_DATA_PORT);
 380         }
 381         type[5] = 0;
 382
 383         return 0;
 384 }
 385
 386 /*
 387  * applesmc_read_motion_sensor - Read motion sensor (X, Y or Z). Callers must
 388  * hold applesmc_lock.
 389  */
 390 static int applesmc_read_motion_sensor(int index, s16* value)
 391 {
 392         u8 buffer[2];
 393         int ret;
 394
 395         switch (index) {
 396         case SENSOR_X:
 397                 ret = applesmc_read_key(MOTION_SENSOR_X_KEY, buffer, 2);
 398                 break;
 399         case SENSOR_Y:
 400                 ret = applesmc_read_key(MOTION_SENSOR_Y_KEY, buffer, 2);
 401                 break;
 402         case SENSOR_Z:
 403                 ret = applesmc_read_key(MOTION_SENSOR_Z_KEY, buffer, 2);
 404                 break;
 405         default:
 406                 ret = -EINVAL;
 407         }
 408
 409         *value = ((s16)buffer[0] << 8) | buffer[1];
 410
 411         return ret;
 412 }
 413
 414 /*
 415  * applesmc_device_init - initialize the accelerometer.  Returns zero on success
 416  * and negative error code on failure.  Can sleep.
 417  */
 418 static int applesmc_device_init(void)
 419 {
 420         int total, ret = -ENXIO;
 421         u8 buffer[2];
 422
 423         if (!applesmc_accelerometer)
 424                 return 0;
 425
 426         mutex_lock(&applesmc_lock);
 427
 428         for (total = INIT_TIMEOUT_MSECS; total > 0; total -= INIT_WAIT_MSECS) {
 429                 if (debug)
 430                         printk(KERN_DEBUG "applesmc try %d\n", total);
 431                 if (!applesmc_read_key(MOTION_SENSOR_KEY, buffer, 2) &&
 432                                 (buffer[0] != 0x00 || buffer[1] != 0x00)) {
 433                         if (total == INIT_TIMEOUT_MSECS) {
 434                                 printk(KERN_DEBUG "applesmc: device has"
 435                                                 " already been initialized"
 436                                                 " (0x%02x, 0x%02x).\n",
 437                                                 buffer[0], buffer[1]);
 438                         } else {
 439                                 printk(KERN_DEBUG "applesmc: device"
 440                                                 " successfully initialized"
 441                                                 " (0x%02x, 0x%02x).\n",
 442                                                 buffer[0], buffer[1]);
 443                         }
 444                         ret = 0;
 445                         goto out;
 446                 }
 447                 buffer[0] = 0xe0;
 448                 buffer[1] = 0x00;
 449                 applesmc_write_key(MOTION_SENSOR_KEY, buffer, 2);
 450                 msleep(INIT_WAIT_MSECS);
 451         }
 452
 453         printk(KERN_WARNING "applesmc: failed to init the device\n");
 454
 455 out:
 456         mutex_unlock(&applesmc_lock);
 457         return ret;
 458 }
 459
 460 /*
 461  * applesmc_get_fan_count - get the number of fans. Callers must NOT hold
 462  * applesmc_lock.
 463  */
 464 static int applesmc_get_fan_count(void)
 465 {
 466         int ret;
 467         u8 buffer[1];
 468
 469         mutex_lock(&applesmc_lock);
 470
 471         ret = applesmc_read_key(FANS_COUNT, buffer, 1);
 472
 473         mutex_unlock(&applesmc_lock);
 474         if (ret)
 475                 return ret;
 476         else
 477                 return buffer[0];
 478 }
 479
 480 /* Device model stuff */
 481 static int applesmc_probe(struct platform_device *dev)
 482 {
 483         int ret;
 484
 485         ret = applesmc_device_init();
 486         if (ret)
 487                 return ret;
 488
 489         printk(KERN_INFO "applesmc: device successfully initialized.\n");
 490         return 0;
 491 }
 492
 493 static int applesmc_resume(struct platform_device *dev)
 494 {
 495         return applesmc_device_init();
 496 }
 497
 498 static struct platform_driver applesmc_driver = {
 499         .probe = applesmc_probe,
 500         .resume = applesmc_resume,
 501         .driver = {
 502                 .name = "applesmc",
 503                 .owner = THIS_MODULE,
 504         },
 505 };
 506
 507 /*
 508  * applesmc_calibrate - Set our "resting" values.  Callers must
 509  * hold applesmc_lock.
 510  */
 511 static void applesmc_calibrate(void)
 512 {
 513         applesmc_read_motion_sensor(SENSOR_X, &rest_x);
 514         applesmc_read_motion_sensor(SENSOR_Y, &rest_y);
 515         rest_x = -rest_x;
 516 }
 517
 518 static void applesmc_idev_poll(struct input_polled_dev *dev)
 519 {
 520         struct input_dev *idev = dev->input;
 521         s16 x, y;
 522
 523         mutex_lock(&applesmc_lock);
 524
 525         if (applesmc_read_motion_sensor(SENSOR_X, &x))
 526                 goto out;
 527         if (applesmc_read_motion_sensor(SENSOR_Y, &y))
 528                 goto out;
 529
 530         x = -x;
 531         input_report_abs(idev, ABS_X, x - rest_x);
 532         input_report_abs(idev, ABS_Y, y - rest_y);
 533         input_sync(idev);
 534
 535 out:
 536         mutex_unlock(&applesmc_lock);
 537 }
 538
 539 /* Sysfs Files */
 540
 541 static ssize_t applesmc_name_show(struct device *dev,
 542                                    struct device_attribute *attr, char *buf)
 543 {
 544         return snprintf(buf, PAGE_SIZE, "applesmc\n");
 545 }
 546
 547 static ssize_t applesmc_position_show(struct device *dev,
 548                                    struct device_attribute *attr, char *buf)
 549 {
 550         int ret;
 551         s16 x, y, z;
 552
 553         mutex_lock(&applesmc_lock);
 554
 555         ret = applesmc_read_motion_sensor(SENSOR_X, &x);
 556         if (ret)
 557                 goto out;
 558         ret = applesmc_read_motion_sensor(SENSOR_Y, &y);
 559         if (ret)
 560                 goto out;
 561         ret = applesmc_read_motion_sensor(SENSOR_Z, &z);
 562         if (ret)
 563                 goto out;
 564
 565 out:
 566         mutex_unlock(&applesmc_lock);
 567         if (ret)
 568                 return ret;
 569         else
 570                 return snprintf(buf, PAGE_SIZE, "(%d,%d,%d)\n", x, y, z);
 571 }
 572
 573 static ssize_t applesmc_light_show(struct device *dev,
 574                                 struct device_attribute *attr, char *sysfsbuf)
 575 {
 576         static int data_length;
 577         int ret;
 578         u8 left = 0, right = 0;
 579         u8 buffer[10], query[6];
 580
 581         mutex_lock(&applesmc_lock);
 582
 583         if (!data_length) {
 584                 ret = applesmc_get_key_type(LIGHT_SENSOR_LEFT_KEY, query);
 585                 if (ret)
 586                         goto out;
 587                 data_length = clamp_val(query[0], 0, 10);
 588                 printk(KERN_INFO "applesmc: light sensor data length set to "
 589                         "%d\n", data_length);
 590         }
 591
 592         ret = applesmc_read_key(LIGHT_SENSOR_LEFT_KEY, buffer, data_length);
 593         /* newer macbooks report a single 10-bit bigendian value */
 594         if (data_length == 10) {
 595                 left = be16_to_cpu(*(__be16 *)(buffer + 6)) >> 2;
 596                 goto out;
 597         }
 598         left = buffer[2];
 599         if (ret)
 600                 goto out;
 601         ret = applesmc_read_key(LIGHT_SENSOR_RIGHT_KEY, buffer, data_length);
 602         right = buffer[2];
 603
 604 out:
 605         mutex_unlock(&applesmc_lock);
 606         if (ret)
 607                 return ret;
 608         else
 609                 return snprintf(sysfsbuf, PAGE_SIZE, "(%d,%d)\n", left, right);
 610 }
 611
 612 /* Displays degree Celsius * 1000 */
 613 static ssize_t applesmc_show_temperature(struct device *dev,
 614                         struct device_attribute *devattr, char *sysfsbuf)
 615 {
 616         int ret;
 617         u8 buffer[2];
 618         unsigned int temp;
 619         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 620         const char* key =
 621                 temperature_sensors_sets[applesmc_temperature_set][attr->index];
 622
 623         mutex_lock(&applesmc_lock);
 624
 625         ret = applesmc_read_key(key, buffer, 2);
 626         temp = buffer[0]*1000;
 627         temp += (buffer[1] >> 6) * 250;
 628
 629         mutex_unlock(&applesmc_lock);
 630
 631         if (ret)
 632                 return ret;
 633         else
 634                 return snprintf(sysfsbuf, PAGE_SIZE, "%u\n", temp);
 635 }
 636
 637 static ssize_t applesmc_show_fan_speed(struct device *dev,
 638                                 struct device_attribute *attr, char *sysfsbuf)
 639 {
 640         int ret;
 641         unsigned int speed = 0;
 642         char newkey[5];
 643         u8 buffer[2];
 644         struct sensor_device_attribute_2 *sensor_attr =
 645                                                 to_sensor_dev_attr_2(attr);
 646
 647         newkey[0] = fan_speed_keys[sensor_attr->nr][0];
 648         newkey[1] = '0' + sensor_attr->index;
 649         newkey[2] = fan_speed_keys[sensor_attr->nr][2];
 650         newkey[3] = fan_speed_keys[sensor_attr->nr][3];
 651         newkey[4] = 0;
 652
 653         mutex_lock(&applesmc_lock);
 654
 655         ret = applesmc_read_key(newkey, buffer, 2);
 656         speed = ((buffer[0] << 8 | buffer[1]) >> 2);
 657
 658         mutex_unlock(&applesmc_lock);
 659         if (ret)
 660                 return ret;
 661         else
 662                 return snprintf(sysfsbuf, PAGE_SIZE, "%u\n", speed);
 663 }
 664
 665 static ssize_t applesmc_store_fan_speed(struct device *dev,
 666                                         struct device_attribute *attr,
 667                                         const char *sysfsbuf, size_t count)
 668 {
 669         int ret;
 670         u32 speed;
 671         char newkey[5];
 672         u8 buffer[2];
 673         struct sensor_device_attribute_2 *sensor_attr =
 674                                                 to_sensor_dev_attr_2(attr);
 675
 676         speed = simple_strtoul(sysfsbuf, NULL, 10);
 677
 678         if (speed > 0x4000) /* Bigger than a 14-bit value */
 679                 return -EINVAL;
 680
 681         newkey[0] = fan_speed_keys[sensor_attr->nr][0];
 682         newkey[1] = '0' + sensor_attr->index;
 683         newkey[2] = fan_speed_keys[sensor_attr->nr][2];
 684         newkey[3] = fan_speed_keys[sensor_attr->nr][3];
 685         newkey[4] = 0;
 686
 687         mutex_lock(&applesmc_lock);
 688
 689         buffer[0] = (speed >> 6) & 0xff;
 690         buffer[1] = (speed << 2) & 0xff;
 691         ret = applesmc_write_key(newkey, buffer, 2);
 692
 693         mutex_unlock(&applesmc_lock);
 694         if (ret)
 695                 return ret;
 696         else
 697                 return count;
 698 }
 699
 700 static ssize_t applesmc_show_fan_manual(struct device *dev,
 701                         struct device_attribute *devattr, char *sysfsbuf)
 702 {
 703         int ret;
 704         u16 manual = 0;
 705         u8 buffer[2];
 706         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 707
 708         mutex_lock(&applesmc_lock);
 709
 710         ret = applesmc_read_key(FANS_MANUAL, buffer, 2);
 711         manual = ((buffer[0] << 8 | buffer[1]) >> attr->index) & 0x01;
 712
 713         mutex_unlock(&applesmc_lock);
 714         if (ret)
 715                 return ret;
 716         else
 717                 return snprintf(sysfsbuf, PAGE_SIZE, "%d\n", manual);
 718 }
 719
 720 static ssize_t applesmc_store_fan_manual(struct device *dev,
 721                                          struct device_attribute *devattr,
 722                                          const char *sysfsbuf, size_t count)
 723 {
 724         int ret;
 725         u8 buffer[2];
 726         u32 input;
 727         u16 val;
 728         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 729
 730         input = simple_strtoul(sysfsbuf, NULL, 10);
 731
 732         mutex_lock(&applesmc_lock);
 733
 734         ret = applesmc_read_key(FANS_MANUAL, buffer, 2);
 735         val = (buffer[0] << 8 | buffer[1]);
 736         if (ret)
 737                 goto out;
 738
 739         if (input)
 740                 val = val | (0x01 << attr->index);
 741         else
 742                 val = val & ~(0x01 << attr->index);
 743
 744         buffer[0] = (val >> 8) & 0xFF;
 745         buffer[1] = val & 0xFF;
 746
 747         ret = applesmc_write_key(FANS_MANUAL, buffer, 2);
 748
 749 out:
 750         mutex_unlock(&applesmc_lock);
 751         if (ret)
 752                 return ret;
 753         else
 754                 return count;
 755 }
 756
 757 static ssize_t applesmc_show_fan_position(struct device *dev,
 758                                 struct device_attribute *attr, char *sysfsbuf)
 759 {
 760         int ret;
 761         char newkey[5];
 762         u8 buffer[17];
 763         struct sensor_device_attribute_2 *sensor_attr =
 764                                                 to_sensor_dev_attr_2(attr);
 765
 766         newkey[0] = FAN_POSITION[0];
 767         newkey[1] = '0' + sensor_attr->index;
 768         newkey[2] = FAN_POSITION[2];
 769         newkey[3] = FAN_POSITION[3];
 770         newkey[4] = 0;
 771
 772         mutex_lock(&applesmc_lock);
 773
 774         ret = applesmc_read_key(newkey, buffer, 16);
 775         buffer[16] = 0;
 776
 777         mutex_unlock(&applesmc_lock);
 778         if (ret)
 779                 return ret;
 780         else
 781                 return snprintf(sysfsbuf, PAGE_SIZE, "%s\n", buffer+4);
 782 }
 783
 784 static ssize_t applesmc_calibrate_show(struct device *dev,
 785                                 struct device_attribute *attr, char *sysfsbuf)
 786 {
 787         return snprintf(sysfsbuf, PAGE_SIZE, "(%d,%d)\n", rest_x, rest_y);
 788 }
 789
 790 static ssize_t applesmc_calibrate_store(struct device *dev,
 791         struct device_attribute *attr, const char *sysfsbuf, size_t count)
 792 {
 793         mutex_lock(&applesmc_lock);
 794         applesmc_calibrate();
 795         mutex_unlock(&applesmc_lock);
 796
 797         return count;
 798 }
 799
 800 /* Store the next backlight value to be written by the work */
 801 static unsigned int backlight_value;
 802
 803 static void applesmc_backlight_set(struct work_struct *work)
 804 {
 805         u8 buffer[2];
 806
 807         mutex_lock(&applesmc_lock);
 808         buffer[0] = backlight_value;
 809         buffer[1] = 0x00;
 810         applesmc_write_key(BACKLIGHT_KEY, buffer, 2);
 811         mutex_unlock(&applesmc_lock);
 812 }
 813 static DECLARE_WORK(backlight_work, &applesmc_backlight_set);
 814
 815 static void applesmc_brightness_set(struct led_classdev *led_cdev,
 816                                                 enum led_brightness value)
 817 {
 818         int ret;
 819
 820         backlight_value = value;
 821         ret = queue_work(applesmc_led_wq, &backlight_work);
 822
 823         if (debug && (!ret))
 824                 printk(KERN_DEBUG "applesmc: work was already on the queue.\n");
 825 }
 826
 827 static ssize_t applesmc_key_count_show(struct device *dev,
 828                                 struct device_attribute *attr, char *sysfsbuf)
 829 {
 830         int ret;
 831         u8 buffer[4];
 832         u32 count;
 833
 834         mutex_lock(&applesmc_lock);
 835
 836         ret = applesmc_read_key(KEY_COUNT_KEY, buffer, 4);
 837         count = ((u32)buffer[0]<<24) + ((u32)buffer[1]<<16) +
 838                                                 ((u32)buffer[2]<<8) + buffer[3];
 839
 840         mutex_unlock(&applesmc_lock);
 841         if (ret)
 842                 return ret;
 843         else
 844                 return snprintf(sysfsbuf, PAGE_SIZE, "%d\n", count);
 845 }
 846
 847 static ssize_t applesmc_key_at_index_read_show(struct device *dev,
 848                                 struct device_attribute *attr, char *sysfsbuf)
 849 {
 850         char key[5];
 851         char info[6];
 852         int ret;
 853
 854         mutex_lock(&applesmc_lock);
 855
 856         ret = applesmc_get_key_at_index(key_at_index, key);
 857
 858         if (ret || !key[0]) {
 859                 mutex_unlock(&applesmc_lock);
 860
 861                 return -EINVAL;
 862         }
 863
 864         ret = applesmc_get_key_type(key, info);
 865
 866         if (ret) {
 867                 mutex_unlock(&applesmc_lock);
 868
 869                 return ret;
 870         }
 871
 872         /*
 873          * info[0] maximum value (APPLESMC_MAX_DATA_LENGTH) is much lower than
 874          * PAGE_SIZE, so we don't need any checks before writing to sysfsbuf.
 875          */
 876         ret = applesmc_read_key(key, sysfsbuf, info[0]);
 877
 878         mutex_unlock(&applesmc_lock);
 879
 880         if (!ret) {
 881                 return info[0];
 882         } else {
 883                 return ret;
 884         }
 885 }
 886
 887 static ssize_t applesmc_key_at_index_data_length_show(struct device *dev,
 888                                 struct device_attribute *attr, char *sysfsbuf)
 889 {
 890         char key[5];
 891         char info[6];
 892         int ret;
 893
 894         mutex_lock(&applesmc_lock);
 895
 896         ret = applesmc_get_key_at_index(key_at_index, key);
 897
 898         if (ret || !key[0]) {
 899                 mutex_unlock(&applesmc_lock);
 900
 901                 return -EINVAL;
 902         }
 903
 904         ret = applesmc_get_key_type(key, info);
 905
 906         mutex_unlock(&applesmc_lock);
 907
 908         if (!ret)
 909                 return snprintf(sysfsbuf, PAGE_SIZE, "%d\n", info[0]);
 910         else
 911                 return ret;
 912 }
 913
 914 static ssize_t applesmc_key_at_index_type_show(struct device *dev,
 915                                 struct device_attribute *attr, char *sysfsbuf)
 916 {
 917         char key[5];
 918         char info[6];
 919         int ret;
 920
 921         mutex_lock(&applesmc_lock);
 922
 923         ret = applesmc_get_key_at_index(key_at_index, key);
 924
 925         if (ret || !key[0]) {
 926                 mutex_unlock(&applesmc_lock);
 927
 928                 return -EINVAL;
 929         }
 930
 931         ret = applesmc_get_key_type(key, info);
 932
 933         mutex_unlock(&applesmc_lock);
 934
 935         if (!ret)
 936                 return snprintf(sysfsbuf, PAGE_SIZE, "%s\n", info+1);
 937         else
 938                 return ret;
 939 }
 940
 941 static ssize_t applesmc_key_at_index_name_show(struct device *dev,
 942                                 struct device_attribute *attr, char *sysfsbuf)
 943 {
 944         char key[5];
 945         int ret;
 946
 947         mutex_lock(&applesmc_lock);
 948
 949         ret = applesmc_get_key_at_index(key_at_index, key);
 950
 951         mutex_unlock(&applesmc_lock);
 952
 953         if (!ret && key[0])
 954                 return snprintf(sysfsbuf, PAGE_SIZE, "%s\n", key);
 955         else
 956                 return -EINVAL;
 957 }
 958
 959 static ssize_t applesmc_key_at_index_show(struct device *dev,
 960                                 struct device_attribute *attr, char *sysfsbuf)
 961 {
 962         return snprintf(sysfsbuf, PAGE_SIZE, "%d\n", key_at_index);
 963 }
 964
 965 static ssize_t applesmc_key_at_index_store(struct device *dev,
 966         struct device_attribute *attr, const char *sysfsbuf, size_t count)
 967 {
 968         mutex_lock(&applesmc_lock);
 969
 970         key_at_index = simple_strtoul(sysfsbuf, NULL, 10);
 971
 972         mutex_unlock(&applesmc_lock);
 973
 974         return count;
 975 }
 976
 977 static struct led_classdev applesmc_backlight = {
 978         .name                   = "smc::kbd_backlight",
 979         .default_trigger        = "nand-disk",
 980         .brightness_set         = applesmc_brightness_set,
 981 };
 982
 983 static DEVICE_ATTR(name, 0444, applesmc_name_show, NULL);
 984
 985 static DEVICE_ATTR(position, 0444, applesmc_position_show, NULL);
 986 static DEVICE_ATTR(calibrate, 0644,
 987                         applesmc_calibrate_show, applesmc_calibrate_store);
 988
 989 static struct attribute *accelerometer_attributes[] = {
 990         &dev_attr_position.attr,
 991         &dev_attr_calibrate.attr,
 992         NULL
 993 };
 994
 995 static const struct attribute_group accelerometer_attributes_group =
 996         { .attrs = accelerometer_attributes };
 997
 998 static DEVICE_ATTR(light, 0444, applesmc_light_show, NULL);
 999
1000 static DEVICE_ATTR(key_count, 0444, applesmc_key_count_show, NULL);
1001 static DEVICE_ATTR(key_at_index, 0644,
1002                 applesmc_key_at_index_show, applesmc_key_at_index_store);
1003 static DEVICE_ATTR(key_at_index_name, 0444,
1004                                         applesmc_key_at_index_name_show, NULL);
1005 static DEVICE_ATTR(key_at_index_type, 0444,
1006                                         applesmc_key_at_index_type_show, NULL);
1007 static DEVICE_ATTR(key_at_index_data_length, 0444,
1008                                 applesmc_key_at_index_data_length_show, NULL);
1009 static DEVICE_ATTR(key_at_index_data, 0444,
1010                                 applesmc_key_at_index_read_show, NULL);
1011
1012 static struct attribute *key_enumeration_attributes[] = {
1013         &dev_attr_key_count.attr,
1014         &dev_attr_key_at_index.attr,
1015         &dev_attr_key_at_index_name.attr,
1016         &dev_attr_key_at_index_type.attr,
1017         &dev_attr_key_at_index_data_length.attr,
1018         &dev_attr_key_at_index_data.attr,
1019         NULL
1020 };
1021
1022 static const struct attribute_group key_enumeration_group =
1023         { .attrs = key_enumeration_attributes };
1024
1025 /*
1026  * Macro defining SENSOR_DEVICE_ATTR for a fan sysfs entries.
1027  *  - show actual speed
1028  *  - show/store minimum speed
1029  *  - show maximum speed
1030  *  - show safe speed
1031  *  - show/store target speed
1032  *  - show/store manual mode
1033  */
1034 #define sysfs_fan_speeds_offset(offset) \
1035 static SENSOR_DEVICE_ATTR_2(fan##offset##_input, S_IRUGO, \
1036                         applesmc_show_fan_speed, NULL, 0, offset-1); \
1037 \
1038 static SENSOR_DEVICE_ATTR_2(fan##offset##_min, S_IRUGO | S_IWUSR, \
1039         applesmc_show_fan_speed, applesmc_store_fan_speed, 1, offset-1); \
1040 \
1041 static SENSOR_DEVICE_ATTR_2(fan##offset##_max, S_IRUGO, \
1042                         applesmc_show_fan_speed, NULL, 2, offset-1); \
1043 \
1044 static SENSOR_DEVICE_ATTR_2(fan##offset##_safe, S_IRUGO, \
1045                         applesmc_show_fan_speed, NULL, 3, offset-1); \
1046 \
1047 static SENSOR_DEVICE_ATTR_2(fan##offset##_output, S_IRUGO | S_IWUSR, \
1048         applesmc_show_fan_speed, applesmc_store_fan_speed, 4, offset-1); \
1049 \
1050 static SENSOR_DEVICE_ATTR(fan##offset##_manual, S_IRUGO | S_IWUSR, \
1051         applesmc_show_fan_manual, applesmc_store_fan_manual, offset-1); \
1052 \
1053 static SENSOR_DEVICE_ATTR(fan##offset##_label, S_IRUGO, \
1054         applesmc_show_fan_position, NULL, offset-1); \
1055 \
1056 static struct attribute *fan##offset##_attributes[] = { \
1057         &sensor_dev_attr_fan##offset##_input.dev_attr.attr, \
1058         &sensor_dev_attr_fan##offset##_min.dev_attr.attr, \
1059         &sensor_dev_attr_fan##offset##_max.dev_attr.attr, \
1060         &sensor_dev_attr_fan##offset##_safe.dev_attr.attr, \
1061         &sensor_dev_attr_fan##offset##_output.dev_attr.attr, \
1062         &sensor_dev_attr_fan##offset##_manual.dev_attr.attr, \
1063         &sensor_dev_attr_fan##offset##_label.dev_attr.attr, \
1064         NULL \
1065 };
1066
1067 /*
1068  * Create the needed functions for each fan using the macro defined above
1069  * (4 fans are supported)
1070  */
1071 sysfs_fan_speeds_offset(1);
1072 sysfs_fan_speeds_offset(2);
1073 sysfs_fan_speeds_offset(3);
1074 sysfs_fan_speeds_offset(4);
1075
1076 static const struct attribute_group fan_attribute_groups[] = {
1077         { .attrs = fan1_attributes },
1078         { .attrs = fan2_attributes },
1079         { .attrs = fan3_attributes },
1080         { .attrs = fan4_attributes },
1081 };
1082
1083 /*
1084  * Temperature sensors sysfs entries.
1085  */
1086 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO,
1087                                         applesmc_show_temperature, NULL, 0);
1088 static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO,
1089                                         applesmc_show_temperature, NULL, 1);
1090 static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO,
1091                                         applesmc_show_temperature, NULL, 2);
1092 static SENSOR_DEVICE_ATTR(temp4_input, S_IRUGO,
1093                                         applesmc_show_temperature, NULL, 3);
1094 static SENSOR_DEVICE_ATTR(temp5_input, S_IRUGO,
1095                                         applesmc_show_temperature, NULL, 4);
1096 static SENSOR_DEVICE_ATTR(temp6_input, S_IRUGO,
1097                                         applesmc_show_temperature, NULL, 5);
1098 static SENSOR_DEVICE_ATTR(temp7_input, S_IRUGO,
1099                                         applesmc_show_temperature, NULL, 6);
1100 static SENSOR_DEVICE_ATTR(temp8_input, S_IRUGO,
1101                                         applesmc_show_temperature, NULL, 7);
1102 static SENSOR_DEVICE_ATTR(temp9_input, S_IRUGO,
1103                                         applesmc_show_temperature, NULL, 8);
1104 static SENSOR_DEVICE_ATTR(temp10_input, S_IRUGO,
1105                                         applesmc_show_temperature, NULL, 9);
1106 static SENSOR_DEVICE_ATTR(temp11_input, S_IRUGO,
1107                                         applesmc_show_temperature, NULL, 10);
1108 static SENSOR_DEVICE_ATTR(temp12_input, S_IRUGO,
1109                                         applesmc_show_temperature, NULL, 11);
1110 static SENSOR_DEVICE_ATTR(temp13_input, S_IRUGO,
1111                                         applesmc_show_temperature, NULL, 12);
1112 static SENSOR_DEVICE_ATTR(temp14_input, S_IRUGO,
1113                                         applesmc_show_temperature, NULL, 13);
1114 static SENSOR_DEVICE_ATTR(temp15_input, S_IRUGO,
1115                                         applesmc_show_temperature, NULL, 14);
1116 static SENSOR_DEVICE_ATTR(temp16_input, S_IRUGO,
1117                                         applesmc_show_temperature, NULL, 15);
1118 static SENSOR_DEVICE_ATTR(temp17_input, S_IRUGO,
1119                                         applesmc_show_temperature, NULL, 16);
1120 static SENSOR_DEVICE_ATTR(temp18_input, S_IRUGO,
1121                                         applesmc_show_temperature, NULL, 17);
1122 static SENSOR_DEVICE_ATTR(temp19_input, S_IRUGO,
1123                                         applesmc_show_temperature, NULL, 18);
1124 static SENSOR_DEVICE_ATTR(temp20_input, S_IRUGO,
1125                                         applesmc_show_temperature, NULL, 19);
1126 static SENSOR_DEVICE_ATTR(temp21_input, S_IRUGO,
1127                                         applesmc_show_temperature, NULL, 20);
1128 static SENSOR_DEVICE_ATTR(temp22_input, S_IRUGO,
1129                                         applesmc_show_temperature, NULL, 21);
1130 static SENSOR_DEVICE_ATTR(temp23_input, S_IRUGO,
1131                                         applesmc_show_temperature, NULL, 22);
1132 static SENSOR_DEVICE_ATTR(temp24_input, S_IRUGO,
1133                                         applesmc_show_temperature, NULL, 23);
1134 static SENSOR_DEVICE_ATTR(temp25_input, S_IRUGO,
1135                                         applesmc_show_temperature, NULL, 24);
1136 static SENSOR_DEVICE_ATTR(temp26_input, S_IRUGO,
1137                                         applesmc_show_temperature, NULL, 25);
1138 static SENSOR_DEVICE_ATTR(temp27_input, S_IRUGO,
1139                                         applesmc_show_temperature, NULL, 26);
1140 static SENSOR_DEVICE_ATTR(temp28_input, S_IRUGO,
1141                                         applesmc_show_temperature, NULL, 27);
1142 static SENSOR_DEVICE_ATTR(temp29_input, S_IRUGO,
1143                                         applesmc_show_temperature, NULL, 28);
1144 static SENSOR_DEVICE_ATTR(temp30_input, S_IRUGO,
1145                                         applesmc_show_temperature, NULL, 29);
1146 static SENSOR_DEVICE_ATTR(temp31_input, S_IRUGO,
1147                                         applesmc_show_temperature, NULL, 30);
1148 static SENSOR_DEVICE_ATTR(temp32_input, S_IRUGO,
1149                                         applesmc_show_temperature, NULL, 31);
1150 static SENSOR_DEVICE_ATTR(temp33_input, S_IRUGO,
1151                                         applesmc_show_temperature, NULL, 32);
1152 static SENSOR_DEVICE_ATTR(temp34_input, S_IRUGO,
1153                                         applesmc_show_temperature, NULL, 33);
1154 static SENSOR_DEVICE_ATTR(temp35_input, S_IRUGO,
1155                                         applesmc_show_temperature, NULL, 34);
1156
1157 static struct attribute *temperature_attributes[] = {
1158         &sensor_dev_attr_temp1_input.dev_attr.attr,
1159         &sensor_dev_attr_temp2_input.dev_attr.attr,
1160         &sensor_dev_attr_temp3_input.dev_attr.attr,
1161         &sensor_dev_attr_temp4_input.dev_attr.attr,
1162         &sensor_dev_attr_temp5_input.dev_attr.attr,
1163         &sensor_dev_attr_temp6_input.dev_attr.attr,
1164         &sensor_dev_attr_temp7_input.dev_attr.attr,
1165         &sensor_dev_attr_temp8_input.dev_attr.attr,
1166         &sensor_dev_attr_temp9_input.dev_attr.attr,
1167         &sensor_dev_attr_temp10_input.dev_attr.attr,
1168         &sensor_dev_attr_temp11_input.dev_attr.attr,
1169         &sensor_dev_attr_temp12_input.dev_attr.attr,
1170         &sensor_dev_attr_temp13_input.dev_attr.attr,
1171         &sensor_dev_attr_temp14_input.dev_attr.attr,
1172         &sensor_dev_attr_temp15_input.dev_attr.attr,
1173         &sensor_dev_attr_temp16_input.dev_attr.attr,
1174         &sensor_dev_attr_temp17_input.dev_attr.attr,
1175         &sensor_dev_attr_temp18_input.dev_attr.attr,
1176         &sensor_dev_attr_temp19_input.dev_attr.attr,
1177         &sensor_dev_attr_temp20_input.dev_attr.attr,
1178         &sensor_dev_attr_temp21_input.dev_attr.attr,
1179         &sensor_dev_attr_temp22_input.dev_attr.attr,
1180         &sensor_dev_attr_temp23_input.dev_attr.attr,
1181         &sensor_dev_attr_temp24_input.dev_attr.attr,
1182         &sensor_dev_attr_temp25_input.dev_attr.attr,
1183         &sensor_dev_attr_temp26_input.dev_attr.attr,
1184         &sensor_dev_attr_temp27_input.dev_attr.attr,
1185         &sensor_dev_attr_temp28_input.dev_attr.attr,
1186         &sensor_dev_attr_temp29_input.dev_attr.attr,
1187         &sensor_dev_attr_temp30_input.dev_attr.attr,
1188         &sensor_dev_attr_temp31_input.dev_attr.attr,
1189         &sensor_dev_attr_temp32_input.dev_attr.attr,
1190         &sensor_dev_attr_temp33_input.dev_attr.attr,
1191         &sensor_dev_attr_temp34_input.dev_attr.attr,
1192         &sensor_dev_attr_temp35_input.dev_attr.attr,
1193         NULL
1194 };
1195
1196 static const struct attribute_group temperature_attributes_group =
1197         { .attrs = temperature_attributes };
1198
1199 /* Module stuff */
1200
1201 /*
1202  * applesmc_dmi_match - found a match.  return one, short-circuiting the hunt.
1203  */
1204 static int applesmc_dmi_match(const struct dmi_system_id *id)
1205 {
1206         int i = 0;
1207         struct dmi_match_data* dmi_data = id->driver_data;
1208         printk(KERN_INFO "applesmc: %s detected:\n", id->ident);
1209         applesmc_accelerometer = dmi_data->accelerometer;
1210         printk(KERN_INFO "applesmc:  - Model %s accelerometer\n",
1211                                 applesmc_accelerometer ? "with" : "without");
1212         applesmc_light = dmi_data->light;
1213         printk(KERN_INFO "applesmc:  - Model %s light sensors and backlight\n",
1214                                         applesmc_light ? "with" : "without");
1215
1216         applesmc_temperature_set =  dmi_data->temperature_set;
1217         while (temperature_sensors_sets[applesmc_temperature_set][i] != NULL)
1218                 i++;
1219         printk(KERN_INFO "applesmc:  - Model with %d temperature sensors\n", i);
1220         return 1;
1221 }
1222
1223 /* Create accelerometer ressources */
1224 static int applesmc_create_accelerometer(void)
1225 {
1226         struct input_dev *idev;
1227         int ret;
1228
1229         ret = sysfs_create_group(&pdev->dev.kobj,
1230                                         &accelerometer_attributes_group);
1231         if (ret)
1232                 goto out;
1233
1234         applesmc_idev = input_allocate_polled_device();
1235         if (!applesmc_idev) {
1236                 ret = -ENOMEM;
1237                 goto out_sysfs;
1238         }
1239
1240         applesmc_idev->poll = applesmc_idev_poll;
1241         applesmc_idev->poll_interval = APPLESMC_POLL_INTERVAL;
1242
1243         /* initial calibrate for the input device */
1244         applesmc_calibrate();
1245
1246         /* initialize the input device */
1247         idev = applesmc_idev->input;
1248         idev->name = "applesmc";
1249         idev->id.bustype = BUS_HOST;
1250         idev->dev.parent = &pdev->dev;
1251         idev->evbit[0] = BIT_MASK(EV_ABS);
1252         input_set_abs_params(idev, ABS_X,
1253                         -256, 256, APPLESMC_INPUT_FUZZ, APPLESMC_INPUT_FLAT);
1254         input_set_abs_params(idev, ABS_Y,
1255                         -256, 256, APPLESMC_INPUT_FUZZ, APPLESMC_INPUT_FLAT);
1256
1257         ret = input_register_polled_device(applesmc_idev);
1258         if (ret)
1259                 goto out_idev;
1260
1261         return 0;
1262
1263 out_idev:
1264         input_free_polled_device(applesmc_idev);
1265
1266 out_sysfs:
1267         sysfs_remove_group(&pdev->dev.kobj, &accelerometer_attributes_group);
1268
1269 out:
1270         printk(KERN_WARNING "applesmc: driver init failed (ret=%d)!\n", ret);
1271         return ret;
1272 }
1273
1274 /* Release all ressources used by the accelerometer */
1275 static void applesmc_release_accelerometer(void)
1276 {
1277         input_unregister_polled_device(applesmc_idev);
1278         input_free_polled_device(applesmc_idev);
1279         sysfs_remove_group(&pdev->dev.kobj, &accelerometer_attributes_group);
1280 }
1281
1282 static __initdata struct dmi_match_data applesmc_dmi_data[] = {
1283 /* MacBook Pro: accelerometer, backlight and temperature set 0 */
1284         { .accelerometer = 1, .light = 1, .temperature_set = 0 },
1285 /* MacBook2: accelerometer and temperature set 1 */
1286         { .accelerometer = 1, .light = 0, .temperature_set = 1 },
1287 /* MacBook: accelerometer and temperature set 2 */
1288         { .accelerometer = 1, .light = 0, .temperature_set = 2 },
1289 /* MacMini: temperature set 3 */
1290         { .accelerometer = 0, .light = 0, .temperature_set = 3 },
1291 /* MacPro: temperature set 4 */
1292         { .accelerometer = 0, .light = 0, .temperature_set = 4 },
1293 /* iMac: temperature set 5 */
1294         { .accelerometer = 0, .light = 0, .temperature_set = 5 },
1295 /* MacBook3, MacBook4: accelerometer and temperature set 6 */
1296         { .accelerometer = 1, .light = 0, .temperature_set = 6 },
1297 /* MacBook Air: accelerometer, backlight and temperature set 7 */
1298         { .accelerometer = 1, .light = 1, .temperature_set = 7 },
1299 /* MacBook Pro 4: accelerometer, backlight and temperature set 8 */
1300         { .accelerometer = 1, .light = 1, .temperature_set = 8 },
1301 /* MacBook Pro 3: accelerometer, backlight and temperature set 9 */
1302         { .accelerometer = 1, .light = 1, .temperature_set = 9 },
1303 /* iMac 5: light sensor only, temperature set 10 */
1304         { .accelerometer = 0, .light = 0, .temperature_set = 10 },
1305 /* MacBook 5: accelerometer, backlight and temperature set 11 */
1306         { .accelerometer = 1, .light = 1, .temperature_set = 11 },
1307 /* MacBook Pro 5: accelerometer, backlight and temperature set 12 */
1308         { .accelerometer = 1, .light = 1, .temperature_set = 12 },
1309 /* iMac 8: light sensor only, temperature set 13 */
1310         { .accelerometer = 0, .light = 0, .temperature_set = 13 },
1311 /* iMac 6: light sensor only, temperature set 14 */
1312         { .accelerometer = 0, .light = 0, .temperature_set = 14 },
1313 /* MacBook Air 2,1: accelerometer, backlight and temperature set 15 */
1314         { .accelerometer = 1, .light = 1, .temperature_set = 15 },
1315 };
1316
1317 /* Note that DMI_MATCH(...,"MacBook") will match "MacBookPro1,1".
1318  * So we need to put "Apple MacBook Pro" before "Apple MacBook". */
1319 static __initdata struct dmi_system_id applesmc_whitelist[] = {
1320         { applesmc_dmi_match, "Apple MacBook Air 2", {
1321           DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),
1322           DMI_MATCH(DMI_PRODUCT_NAME, "MacBookAir2") },
1323                 &applesmc_dmi_data[15]},
1324         { applesmc_dmi_match, "Apple MacBook Air", {
1325           DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),
1326           DMI_MATCH(DMI_PRODUCT_NAME, "MacBookAir") },
1327                 &applesmc_dmi_data[7]},
1328         { applesmc_dmi_match, "Apple MacBook Pro 5", {
1329           DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),
1330           DMI_MATCH(DMI_PRODUCT_NAME, "MacBookPro5") },
1331                 &applesmc_dmi_data[12]},
1332         { applesmc_dmi_match, "Apple MacBook Pro 4", {
1333           DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),
1334           DMI_MATCH(DMI_PRODUCT_NAME, "MacBookPro4") },
1335                 &applesmc_dmi_data[8]},
1336         { applesmc_dmi_match, "Apple MacBook Pro 3", {
1337           DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),
1338           DMI_MATCH(DMI_PRODUCT_NAME, "MacBookPro3") },
1339                 &applesmc_dmi_data[9]},
1340         { applesmc_dmi_match, "Apple MacBook Pro", {
1341           DMI_MATCH(DMI_BOARD_VENDOR,"Apple"),
1342           DMI_MATCH(DMI_PRODUCT_NAME,"MacBookPro") },
1343                 &applesmc_dmi_data[0]},
1344         { applesmc_dmi_match, "Apple MacBook (v2)", {
1345           DMI_MATCH(DMI_BOARD_VENDOR,"Apple"),
1346           DMI_MATCH(DMI_PRODUCT_NAME,"MacBook2") },
1347                 &applesmc_dmi_data[1]},
1348         { applesmc_dmi_match, "Apple MacBook (v3)", {
1349           DMI_MATCH(DMI_BOARD_VENDOR,"Apple"),
1350           DMI_MATCH(DMI_PRODUCT_NAME,"MacBook3") },
1351                 &applesmc_dmi_data[6]},
1352         { applesmc_dmi_match, "Apple MacBook 4", {
1353           DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),
1354           DMI_MATCH(DMI_PRODUCT_NAME, "MacBook4") },
1355                 &applesmc_dmi_data[6]},
1356         { applesmc_dmi_match, "Apple MacBook 5", {
1357           DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),
1358           DMI_MATCH(DMI_PRODUCT_NAME, "MacBook5") },
1359                 &applesmc_dmi_data[11]},
1360         { applesmc_dmi_match, "Apple MacBook", {
1361           DMI_MATCH(DMI_BOARD_VENDOR,"Apple"),
1362           DMI_MATCH(DMI_PRODUCT_NAME,"MacBook") },
1363                 &applesmc_dmi_data[2]},
1364         { applesmc_dmi_match, "Apple Macmini", {
1365           DMI_MATCH(DMI_BOARD_VENDOR,"Apple"),
1366           DMI_MATCH(DMI_PRODUCT_NAME,"Macmini") },
1367                 &applesmc_dmi_data[3]},
1368         { applesmc_dmi_match, "Apple MacPro2", {
1369           DMI_MATCH(DMI_BOARD_VENDOR,"Apple"),
1370           DMI_MATCH(DMI_PRODUCT_NAME,"MacPro2") },
1371                 &applesmc_dmi_data[4]},
1372         { applesmc_dmi_match, "Apple MacPro", {
1373           DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),
1374           DMI_MATCH(DMI_PRODUCT_NAME, "MacPro") },
1375                 &applesmc_dmi_data[4]},
1376         { applesmc_dmi_match, "Apple iMac 8", {
1377           DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),
1378           DMI_MATCH(DMI_PRODUCT_NAME, "iMac8") },
1379                 &applesmc_dmi_data[13]},
1380         { applesmc_dmi_match, "Apple iMac 6", {
1381           DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),
1382           DMI_MATCH(DMI_PRODUCT_NAME, "iMac6") },
1383                 &applesmc_dmi_data[14]},
1384         { applesmc_dmi_match, "Apple iMac 5", {
1385           DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),
1386           DMI_MATCH(DMI_PRODUCT_NAME, "iMac5") },
1387                 &applesmc_dmi_data[10]},
1388         { applesmc_dmi_match, "Apple iMac", {
1389           DMI_MATCH(DMI_BOARD_VENDOR,"Apple"),
1390           DMI_MATCH(DMI_PRODUCT_NAME,"iMac") },
1391                 &applesmc_dmi_data[5]},
1392         { .ident = NULL }
1393 };
1394
1395 static int __init applesmc_init(void)
1396 {
1397         int ret;
1398         int count;
1399         int i;
1400
1401         if (!dmi_check_system(applesmc_whitelist)) {
1402                 printk(KERN_WARNING "applesmc: supported laptop not found!\n");
1403                 ret = -ENODEV;
1404                 goto out;
1405         }
1406
1407         if (!request_region(APPLESMC_DATA_PORT, APPLESMC_NR_PORTS,
1408                                                                 "applesmc")) {
1409                 ret = -ENXIO;
1410                 goto out;
1411         }
1412
1413         ret = platform_driver_register(&applesmc_driver);
1414         if (ret)
1415                 goto out_region;
1416
1417         pdev = platform_device_register_simple("applesmc", APPLESMC_DATA_PORT,
1418                                                NULL, 0);
1419         if (IS_ERR(pdev)) {
1420                 ret = PTR_ERR(pdev);
1421                 goto out_driver;
1422         }
1423
1424         ret = sysfs_create_file(&pdev->dev.kobj, &dev_attr_name.attr);
1425         if (ret)
1426                 goto out_device;
1427
1428         /* Create key enumeration sysfs files */
1429         ret = sysfs_create_group(&pdev->dev.kobj, &key_enumeration_group);
1430         if (ret)
1431                 goto out_name;
1432
1433         /* create fan files */
1434         count = applesmc_get_fan_count();
1435         if (count < 0) {
1436                 printk(KERN_ERR "applesmc: Cannot get the number of fans.\n");
1437         } else {
1438                 printk(KERN_INFO "applesmc: %d fans found.\n", count);
1439
1440                 switch (count) {
1441                 default:
1442                         printk(KERN_WARNING "applesmc: More than 4 fans found,"
1443                                         " but at most 4 fans are supported"
1444                                                 " by the driver.\n");
1445                 case 4:
1446                         ret = sysfs_create_group(&pdev->dev.kobj,
1447                                                  &fan_attribute_groups[3]);
1448                         if (ret)
1449                                 goto out_key_enumeration;
1450                 case 3:
1451                         ret = sysfs_create_group(&pdev->dev.kobj,
1452                                                  &fan_attribute_groups[2]);
1453                         if (ret)
1454                                 goto out_key_enumeration;
1455                 case 2:
1456                         ret = sysfs_create_group(&pdev->dev.kobj,
1457                                                  &fan_attribute_groups[1]);
1458                         if (ret)
1459                                 goto out_key_enumeration;
1460                 case 1:
1461                         ret = sysfs_create_group(&pdev->dev.kobj,
1462                                                  &fan_attribute_groups[0]);
1463                         if (ret)
1464                                 goto out_fan_1;
1465                 case 0:
1466                         ;
1467                 }
1468         }
1469
1470         for (i = 0;
1471              temperature_sensors_sets[applesmc_temperature_set][i] != NULL;
1472              i++) {
1473                 if (temperature_attributes[i] == NULL) {
1474                         printk(KERN_ERR "applesmc: More temperature sensors "
1475                                 "in temperature_sensors_sets (at least %i)"
1476                                 "than available sysfs files in "
1477                                 "temperature_attributes (%i), please report "
1478                                 "this bug.\n", i, i-1);
1479                         goto out_temperature;
1480                 }
1481                 ret = sysfs_create_file(&pdev->dev.kobj,
1482                                                 temperature_attributes[i]);
1483                 if (ret)
1484                         goto out_temperature;
1485         }
1486
1487         if (applesmc_accelerometer) {
1488                 ret = applesmc_create_accelerometer();
1489                 if (ret)
1490                         goto out_temperature;
1491         }
1492
1493         if (applesmc_light) {
1494                 /* Add light sensor file */
1495                 ret = sysfs_create_file(&pdev->dev.kobj, &dev_attr_light.attr);
1496                 if (ret)
1497                         goto out_accelerometer;
1498
1499                 /* Create the workqueue */
1500                 applesmc_led_wq = create_singlethread_workqueue("applesmc-led");
1501                 if (!applesmc_led_wq) {
1502                         ret = -ENOMEM;
1503                         goto out_light_sysfs;
1504                 }
1505
1506                 /* register as a led device */
1507                 ret = led_classdev_register(&pdev->dev, &applesmc_backlight);
1508                 if (ret < 0)
1509                         goto out_light_wq;
1510         }
1511
1512         hwmon_dev = hwmon_device_register(&pdev->dev);
1513         if (IS_ERR(hwmon_dev)) {
1514                 ret = PTR_ERR(hwmon_dev);
1515                 goto out_light_ledclass;
1516         }
1517
1518         printk(KERN_INFO "applesmc: driver successfully loaded.\n");
1519
1520         return 0;
1521
1522 out_light_ledclass:
1523         if (applesmc_light)
1524                 led_classdev_unregister(&applesmc_backlight);
1525 out_light_wq:
1526         if (applesmc_light)
1527                 destroy_workqueue(applesmc_led_wq);
1528 out_light_sysfs:
1529         if (applesmc_light)
1530                 sysfs_remove_file(&pdev->dev.kobj, &dev_attr_light.attr);
1531 out_accelerometer:
1532         if (applesmc_accelerometer)
1533                 applesmc_release_accelerometer();
1534 out_temperature:
1535         sysfs_remove_group(&pdev->dev.kobj, &temperature_attributes_group);
1536         sysfs_remove_group(&pdev->dev.kobj, &fan_attribute_groups[0]);
1537 out_fan_1:
1538         sysfs_remove_group(&pdev->dev.kobj, &fan_attribute_groups[1]);
1539 out_key_enumeration:
1540         sysfs_remove_group(&pdev->dev.kobj, &key_enumeration_group);
1541 out_name:
1542         sysfs_remove_file(&pdev->dev.kobj, &dev_attr_name.attr);
1543 out_device:
1544         platform_device_unregister(pdev);
1545 out_driver:
1546         platform_driver_unregister(&applesmc_driver);
1547 out_region:
1548         release_region(APPLESMC_DATA_PORT, APPLESMC_NR_PORTS);
1549 out:
1550         printk(KERN_WARNING "applesmc: driver init failed (ret=%d)!\n", ret);
1551         return ret;
1552 }
1553
1554 static void __exit applesmc_exit(void)
1555 {
1556         hwmon_device_unregister(hwmon_dev);
1557         if (applesmc_light) {
1558                 led_classdev_unregister(&applesmc_backlight);
1559                 destroy_workqueue(applesmc_led_wq);
1560                 sysfs_remove_file(&pdev->dev.kobj, &dev_attr_light.attr);
1561         }
1562         if (applesmc_accelerometer)
1563                 applesmc_release_accelerometer();
1564         sysfs_remove_group(&pdev->dev.kobj, &temperature_attributes_group);
1565         sysfs_remove_group(&pdev->dev.kobj, &fan_attribute_groups[0]);
1566         sysfs_remove_group(&pdev->dev.kobj, &fan_attribute_groups[1]);
1567         sysfs_remove_group(&pdev->dev.kobj, &key_enumeration_group);
1568         sysfs_remove_file(&pdev->dev.kobj, &dev_attr_name.attr);
1569         platform_device_unregister(pdev);
1570         platform_driver_unregister(&applesmc_driver);
1571         release_region(APPLESMC_DATA_PORT, APPLESMC_NR_PORTS);
1572
1573         printk(KERN_INFO "applesmc: driver unloaded.\n");
1574 }
1575
1576 module_init(applesmc_init);
1577 module_exit(applesmc_exit);
1578
1579 MODULE_AUTHOR("Nicolas Boichat");
1580 MODULE_DESCRIPTION("Apple SMC");
1581 MODULE_LICENSE("GPL v2");
1582 MODULE_DEVICE_TABLE(dmi, applesmc_whitelist);