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