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