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