Merge branch 'for-linus' of git://oss.sgi.com:8090/xfs/xfs-2.6
[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.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_STATUS_MASK    0x0f
53 #define APPLESMC_READ_CMD       0x10
54 #define APPLESMC_WRITE_CMD      0x11
55 #define APPLESMC_GET_KEY_BY_INDEX_CMD   0x12
56 #define APPLESMC_GET_KEY_TYPE_CMD       0x13
57
58 #define KEY_COUNT_KEY           "#KEY" /* r-o ui32 */
59
60 #define LIGHT_SENSOR_LEFT_KEY   "ALV0" /* r-o {alv (6 bytes) */
61 #define LIGHT_SENSOR_RIGHT_KEY  "ALV1" /* r-o {alv (6 bytes) */
62 #define BACKLIGHT_KEY           "LKSB" /* w-o {lkb (2 bytes) */
63
64 #define CLAMSHELL_KEY           "MSLD" /* r-o ui8 (unused) */
65
66 #define MOTION_SENSOR_X_KEY     "MO_X" /* r-o sp78 (2 bytes) */
67 #define MOTION_SENSOR_Y_KEY     "MO_Y" /* r-o sp78 (2 bytes) */
68 #define MOTION_SENSOR_Z_KEY     "MO_Z" /* r-o sp78 (2 bytes) */
69 #define MOTION_SENSOR_KEY       "MOCN" /* r/w ui16 */
70
71 #define FANS_COUNT              "FNum" /* r-o ui8 */
72 #define FANS_MANUAL             "FS! " /* r-w ui16 */
73 #define FAN_ACTUAL_SPEED        "F0Ac" /* r-o fpe2 (2 bytes) */
74 #define FAN_MIN_SPEED           "F0Mn" /* r-o fpe2 (2 bytes) */
75 #define FAN_MAX_SPEED           "F0Mx" /* r-o fpe2 (2 bytes) */
76 #define FAN_SAFE_SPEED          "F0Sf" /* r-o fpe2 (2 bytes) */
77 #define FAN_TARGET_SPEED        "F0Tg" /* r-w fpe2 (2 bytes) */
78 #define FAN_POSITION            "F0ID" /* r-o char[16] */
79
80 /*
81  * Temperature sensors keys (sp78 - 2 bytes).
82  * First set for Macbook(Pro), second for Macmini.
83  */
84 static const char* temperature_sensors_sets[][13] = {
85         { "TA0P", "TB0T", "TC0D", "TC0P", "TG0H", "TG0P", "TG0T", "Th0H",
86           "Th1H", "Tm0P", "Ts0P", "Ts1P", NULL },
87         { "TC0D", "TC0P", NULL }
88 };
89
90 /* List of keys used to read/write fan speeds */
91 static const char* fan_speed_keys[] = {
92         FAN_ACTUAL_SPEED,
93         FAN_MIN_SPEED,
94         FAN_MAX_SPEED,
95         FAN_SAFE_SPEED,
96         FAN_TARGET_SPEED
97 };
98
99 #define INIT_TIMEOUT_MSECS      5000    /* wait up to 5s for device init ... */
100 #define INIT_WAIT_MSECS         50      /* ... in 50ms increments */
101
102 #define APPLESMC_POLL_PERIOD    (HZ/20) /* poll for input every 1/20s */
103 #define APPLESMC_INPUT_FUZZ     4       /* input event threshold */
104 #define APPLESMC_INPUT_FLAT     4
105
106 #define SENSOR_X 0
107 #define SENSOR_Y 1
108 #define SENSOR_Z 2
109
110 /* Structure to be passed to DMI_MATCH function */
111 struct dmi_match_data {
112 /* Indicates whether this computer has an accelerometer. */
113         int accelerometer;
114 /* Indicates whether this computer has light sensors and keyboard backlight. */
115         int light;
116 /* Indicates which temperature sensors set to use. */
117         int temperature_set;
118 };
119
120 static const int debug;
121 static struct platform_device *pdev;
122 static s16 rest_x;
123 static s16 rest_y;
124 static struct timer_list applesmc_timer;
125 static struct input_dev *applesmc_idev;
126 static struct class_device *hwmon_class_dev;
127
128 /* Indicates whether this computer has an accelerometer. */
129 static unsigned int applesmc_accelerometer;
130
131 /* Indicates whether this computer has light sensors and keyboard backlight. */
132 static unsigned int applesmc_light;
133
134 /* Indicates which temperature sensors set to use. */
135 static unsigned int applesmc_temperature_set;
136
137 static struct mutex applesmc_lock;
138
139 /*
140  * Last index written to key_at_index sysfs file, and value to use for all other
141  * key_at_index_* sysfs files.
142  */
143 static unsigned int key_at_index;
144
145 static struct workqueue_struct *applesmc_led_wq;
146
147 /*
148  * __wait_status - Wait up to 2ms for the status port to get a certain value
149  * (masked with 0x0f), returning zero if the value is obtained.  Callers must
150  * hold applesmc_lock.
151  */
152 static int __wait_status(u8 val)
153 {
154         unsigned int i;
155
156         val = val & APPLESMC_STATUS_MASK;
157
158         for (i = 0; i < 200; i++) {
159                 if ((inb(APPLESMC_CMD_PORT) & APPLESMC_STATUS_MASK) == val) {
160                         if (debug)
161                                 printk(KERN_DEBUG
162                                                 "Waited %d us for status %x\n",
163                                                 i*10, val);
164                         return 0;
165                 }
166                 udelay(10);
167         }
168
169         printk(KERN_WARNING "applesmc: wait status failed: %x != %x\n",
170                                                 val, inb(APPLESMC_CMD_PORT));
171
172         return -EIO;
173 }
174
175 /*
176  * applesmc_read_key - reads len bytes from a given key, and put them in buffer.
177  * Returns zero on success or a negative error on failure. Callers must
178  * hold applesmc_lock.
179  */
180 static int applesmc_read_key(const char* key, u8* buffer, u8 len)
181 {
182         int i;
183
184         if (len > APPLESMC_MAX_DATA_LENGTH) {
185                 printk(KERN_ERR "applesmc_read_key: cannot read more than "
186                                         "%d bytes\n", APPLESMC_MAX_DATA_LENGTH);
187                 return -EINVAL;
188         }
189
190         outb(APPLESMC_READ_CMD, APPLESMC_CMD_PORT);
191         if (__wait_status(0x0c))
192                 return -EIO;
193
194         for (i = 0; i < 4; i++) {
195                 outb(key[i], APPLESMC_DATA_PORT);
196                 if (__wait_status(0x04))
197                         return -EIO;
198         }
199         if (debug)
200                 printk(KERN_DEBUG "<%s", key);
201
202         outb(len, APPLESMC_DATA_PORT);
203         if (debug)
204                 printk(KERN_DEBUG ">%x", len);
205
206         for (i = 0; i < len; i++) {
207                 if (__wait_status(0x05))
208                         return -EIO;
209                 buffer[i] = inb(APPLESMC_DATA_PORT);
210                 if (debug)
211                         printk(KERN_DEBUG "<%x", buffer[i]);
212         }
213         if (debug)
214                 printk(KERN_DEBUG "\n");
215
216         return 0;
217 }
218
219 /*
220  * applesmc_write_key - writes len bytes from buffer to a given key.
221  * Returns zero on success or a negative error on failure. Callers must
222  * hold applesmc_lock.
223  */
224 static int applesmc_write_key(const char* key, u8* buffer, u8 len)
225 {
226         int i;
227
228         if (len > APPLESMC_MAX_DATA_LENGTH) {
229                 printk(KERN_ERR "applesmc_write_key: cannot write more than "
230                                         "%d bytes\n", APPLESMC_MAX_DATA_LENGTH);
231                 return -EINVAL;
232         }
233
234         outb(APPLESMC_WRITE_CMD, APPLESMC_CMD_PORT);
235         if (__wait_status(0x0c))
236                 return -EIO;
237
238         for (i = 0; i < 4; i++) {
239                 outb(key[i], APPLESMC_DATA_PORT);
240                 if (__wait_status(0x04))
241                         return -EIO;
242         }
243
244         outb(len, APPLESMC_DATA_PORT);
245
246         for (i = 0; i < len; i++) {
247                 if (__wait_status(0x04))
248                         return -EIO;
249                 outb(buffer[i], APPLESMC_DATA_PORT);
250         }
251
252         return 0;
253 }
254
255 /*
256  * applesmc_get_key_at_index - get key at index, and put the result in key
257  * (char[6]). Returns zero on success or a negative error on failure. Callers
258  * must hold applesmc_lock.
259  */
260 static int applesmc_get_key_at_index(int index, char* key)
261 {
262         int i;
263         u8 readkey[4];
264         readkey[0] = index >> 24;
265         readkey[1] = index >> 16;
266         readkey[2] = index >> 8;
267         readkey[3] = index;
268
269         outb(APPLESMC_GET_KEY_BY_INDEX_CMD, APPLESMC_CMD_PORT);
270         if (__wait_status(0x0c))
271                 return -EIO;
272
273         for (i = 0; i < 4; i++) {
274                 outb(readkey[i], APPLESMC_DATA_PORT);
275                 if (__wait_status(0x04))
276                         return -EIO;
277         }
278
279         outb(4, APPLESMC_DATA_PORT);
280
281         for (i = 0; i < 4; i++) {
282                 if (__wait_status(0x05))
283                         return -EIO;
284                 key[i] = inb(APPLESMC_DATA_PORT);
285         }
286         key[4] = 0;
287
288         return 0;
289 }
290
291 /*
292  * applesmc_get_key_type - get key type, and put the result in type (char[6]).
293  * Returns zero on success or a negative error on failure. Callers must
294  * hold applesmc_lock.
295  */
296 static int applesmc_get_key_type(char* key, char* type)
297 {
298         int i;
299
300         outb(APPLESMC_GET_KEY_TYPE_CMD, APPLESMC_CMD_PORT);
301         if (__wait_status(0x0c))
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(5, APPLESMC_DATA_PORT);
311
312         for (i = 0; i < 6; i++) {
313                 if (__wait_status(0x05))
314                         return -EIO;
315                 type[i] = inb(APPLESMC_DATA_PORT);
316         }
317         type[5] = 0;
318
319         return 0;
320 }
321
322 /*
323  * applesmc_read_motion_sensor - Read motion sensor (X, Y or Z). Callers must
324  * hold applesmc_lock.
325  */
326 static int applesmc_read_motion_sensor(int index, s16* value)
327 {
328         u8 buffer[2];
329         int ret;
330
331         switch (index) {
332         case SENSOR_X:
333                 ret = applesmc_read_key(MOTION_SENSOR_X_KEY, buffer, 2);
334                 break;
335         case SENSOR_Y:
336                 ret = applesmc_read_key(MOTION_SENSOR_Y_KEY, buffer, 2);
337                 break;
338         case SENSOR_Z:
339                 ret = applesmc_read_key(MOTION_SENSOR_Z_KEY, buffer, 2);
340                 break;
341         default:
342                 ret = -EINVAL;
343         }
344
345         *value = ((s16)buffer[0] << 8) | buffer[1];
346
347         return ret;
348 }
349
350 /*
351  * applesmc_device_init - initialize the accelerometer.  Returns zero on success
352  * and negative error code on failure.  Can sleep.
353  */
354 static int applesmc_device_init(void)
355 {
356         int total, ret = -ENXIO;
357         u8 buffer[2];
358
359         if (!applesmc_accelerometer)
360                 return 0;
361
362         mutex_lock(&applesmc_lock);
363
364         for (total = INIT_TIMEOUT_MSECS; total > 0; total -= INIT_WAIT_MSECS) {
365                 if (debug)
366                         printk(KERN_DEBUG "applesmc try %d\n", total);
367                 if (!applesmc_read_key(MOTION_SENSOR_KEY, buffer, 2) &&
368                                 (buffer[0] != 0x00 || buffer[1] != 0x00)) {
369                         if (total == INIT_TIMEOUT_MSECS) {
370                                 printk(KERN_DEBUG "applesmc: device has"
371                                                 " already been initialized"
372                                                 " (0x%02x, 0x%02x).\n",
373                                                 buffer[0], buffer[1]);
374                         } else {
375                                 printk(KERN_DEBUG "applesmc: device"
376                                                 " successfully initialized"
377                                                 " (0x%02x, 0x%02x).\n",
378                                                 buffer[0], buffer[1]);
379                         }
380                         ret = 0;
381                         goto out;
382                 }
383                 buffer[0] = 0xe0;
384                 buffer[1] = 0x00;
385                 applesmc_write_key(MOTION_SENSOR_KEY, buffer, 2);
386                 msleep(INIT_WAIT_MSECS);
387         }
388
389         printk(KERN_WARNING "applesmc: failed to init the device\n");
390
391 out:
392         mutex_unlock(&applesmc_lock);
393         return ret;
394 }
395
396 /*
397  * applesmc_get_fan_count - get the number of fans. Callers must NOT hold
398  * applesmc_lock.
399  */
400 static int applesmc_get_fan_count(void)
401 {
402         int ret;
403         u8 buffer[1];
404
405         mutex_lock(&applesmc_lock);
406
407         ret = applesmc_read_key(FANS_COUNT, buffer, 1);
408
409         mutex_unlock(&applesmc_lock);
410         if (ret)
411                 return ret;
412         else
413                 return buffer[0];
414 }
415
416 /* Device model stuff */
417 static int applesmc_probe(struct platform_device *dev)
418 {
419         int ret;
420
421         ret = applesmc_device_init();
422         if (ret)
423                 return ret;
424
425         printk(KERN_INFO "applesmc: device successfully initialized.\n");
426         return 0;
427 }
428
429 static int applesmc_resume(struct platform_device *dev)
430 {
431         return applesmc_device_init();
432 }
433
434 static struct platform_driver applesmc_driver = {
435         .probe = applesmc_probe,
436         .resume = applesmc_resume,
437         .driver = {
438                 .name = "applesmc",
439                 .owner = THIS_MODULE,
440         },
441 };
442
443 /*
444  * applesmc_calibrate - Set our "resting" values.  Callers must
445  * hold applesmc_lock.
446  */
447 static void applesmc_calibrate(void)
448 {
449         applesmc_read_motion_sensor(SENSOR_X, &rest_x);
450         applesmc_read_motion_sensor(SENSOR_Y, &rest_y);
451         rest_x = -rest_x;
452 }
453
454 static int applesmc_idev_open(struct input_dev *dev)
455 {
456         add_timer(&applesmc_timer);
457
458         return 0;
459 }
460
461 static void applesmc_idev_close(struct input_dev *dev)
462 {
463         del_timer_sync(&applesmc_timer);
464 }
465
466 static void applesmc_idev_poll(unsigned long unused)
467 {
468         s16 x, y;
469
470         /* Cannot sleep.  Try nonblockingly.  If we fail, try again later. */
471         if (!mutex_trylock(&applesmc_lock)) {
472                 mod_timer(&applesmc_timer, jiffies + APPLESMC_POLL_PERIOD);
473                 return;
474         }
475
476         if (applesmc_read_motion_sensor(SENSOR_X, &x))
477                 goto out;
478         if (applesmc_read_motion_sensor(SENSOR_Y, &y))
479                 goto out;
480
481         x = -x;
482         input_report_abs(applesmc_idev, ABS_X, x - rest_x);
483         input_report_abs(applesmc_idev, ABS_Y, y - rest_y);
484         input_sync(applesmc_idev);
485
486 out:
487         mod_timer(&applesmc_timer, jiffies + APPLESMC_POLL_PERIOD);
488
489         mutex_unlock(&applesmc_lock);
490 }
491
492 /* Sysfs Files */
493
494 static ssize_t applesmc_name_show(struct device *dev,
495                                    struct device_attribute *attr, char *buf)
496 {
497         return snprintf(buf, PAGE_SIZE, "applesmc\n");
498 }
499
500 static ssize_t applesmc_position_show(struct device *dev,
501                                    struct device_attribute *attr, char *buf)
502 {
503         int ret;
504         s16 x, y, z;
505
506         mutex_lock(&applesmc_lock);
507
508         ret = applesmc_read_motion_sensor(SENSOR_X, &x);
509         if (ret)
510                 goto out;
511         ret = applesmc_read_motion_sensor(SENSOR_Y, &y);
512         if (ret)
513                 goto out;
514         ret = applesmc_read_motion_sensor(SENSOR_Z, &z);
515         if (ret)
516                 goto out;
517
518 out:
519         mutex_unlock(&applesmc_lock);
520         if (ret)
521                 return ret;
522         else
523                 return snprintf(buf, PAGE_SIZE, "(%d,%d,%d)\n", x, y, z);
524 }
525
526 static ssize_t applesmc_light_show(struct device *dev,
527                                 struct device_attribute *attr, char *sysfsbuf)
528 {
529         int ret;
530         u8 left = 0, right = 0;
531         u8 buffer[6];
532
533         mutex_lock(&applesmc_lock);
534
535         ret = applesmc_read_key(LIGHT_SENSOR_LEFT_KEY, buffer, 6);
536         left = buffer[2];
537         if (ret)
538                 goto out;
539         ret = applesmc_read_key(LIGHT_SENSOR_RIGHT_KEY, buffer, 6);
540         right = buffer[2];
541
542 out:
543         mutex_unlock(&applesmc_lock);
544         if (ret)
545                 return ret;
546         else
547                 return snprintf(sysfsbuf, PAGE_SIZE, "(%d,%d)\n", left, right);
548 }
549
550 /* Displays degree Celsius * 1000 */
551 static ssize_t applesmc_show_temperature(struct device *dev,
552                         struct device_attribute *devattr, char *sysfsbuf)
553 {
554         int ret;
555         u8 buffer[2];
556         unsigned int temp;
557         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
558         const char* key =
559                 temperature_sensors_sets[applesmc_temperature_set][attr->index];
560
561         mutex_lock(&applesmc_lock);
562
563         ret = applesmc_read_key(key, buffer, 2);
564         temp = buffer[0]*1000;
565         temp += (buffer[1] >> 6) * 250;
566
567         mutex_unlock(&applesmc_lock);
568
569         if (ret)
570                 return ret;
571         else
572                 return snprintf(sysfsbuf, PAGE_SIZE, "%u\n", temp);
573 }
574
575 static ssize_t applesmc_show_fan_speed(struct device *dev,
576                                 struct device_attribute *attr, char *sysfsbuf)
577 {
578         int ret;
579         unsigned int speed = 0;
580         char newkey[5];
581         u8 buffer[2];
582         struct sensor_device_attribute_2 *sensor_attr =
583                                                 to_sensor_dev_attr_2(attr);
584
585         newkey[0] = fan_speed_keys[sensor_attr->nr][0];
586         newkey[1] = '0' + sensor_attr->index;
587         newkey[2] = fan_speed_keys[sensor_attr->nr][2];
588         newkey[3] = fan_speed_keys[sensor_attr->nr][3];
589         newkey[4] = 0;
590
591         mutex_lock(&applesmc_lock);
592
593         ret = applesmc_read_key(newkey, buffer, 2);
594         speed = ((buffer[0] << 8 | buffer[1]) >> 2);
595
596         mutex_unlock(&applesmc_lock);
597         if (ret)
598                 return ret;
599         else
600                 return snprintf(sysfsbuf, PAGE_SIZE, "%u\n", speed);
601 }
602
603 static ssize_t applesmc_store_fan_speed(struct device *dev,
604                                         struct device_attribute *attr,
605                                         const char *sysfsbuf, size_t count)
606 {
607         int ret;
608         u32 speed;
609         char newkey[5];
610         u8 buffer[2];
611         struct sensor_device_attribute_2 *sensor_attr =
612                                                 to_sensor_dev_attr_2(attr);
613
614         speed = simple_strtoul(sysfsbuf, NULL, 10);
615
616         if (speed > 0x4000) /* Bigger than a 14-bit value */
617                 return -EINVAL;
618
619         newkey[0] = fan_speed_keys[sensor_attr->nr][0];
620         newkey[1] = '0' + sensor_attr->index;
621         newkey[2] = fan_speed_keys[sensor_attr->nr][2];
622         newkey[3] = fan_speed_keys[sensor_attr->nr][3];
623         newkey[4] = 0;
624
625         mutex_lock(&applesmc_lock);
626
627         buffer[0] = (speed >> 6) & 0xff;
628         buffer[1] = (speed << 2) & 0xff;
629         ret = applesmc_write_key(newkey, buffer, 2);
630
631         mutex_unlock(&applesmc_lock);
632         if (ret)
633                 return ret;
634         else
635                 return count;
636 }
637
638 static ssize_t applesmc_show_fan_manual(struct device *dev,
639                         struct device_attribute *devattr, char *sysfsbuf)
640 {
641         int ret;
642         u16 manual = 0;
643         u8 buffer[2];
644         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
645
646         mutex_lock(&applesmc_lock);
647
648         ret = applesmc_read_key(FANS_MANUAL, buffer, 2);
649         manual = ((buffer[0] << 8 | buffer[1]) >> attr->index) & 0x01;
650
651         mutex_unlock(&applesmc_lock);
652         if (ret)
653                 return ret;
654         else
655                 return snprintf(sysfsbuf, PAGE_SIZE, "%d\n", manual);
656 }
657
658 static ssize_t applesmc_store_fan_manual(struct device *dev,
659                                          struct device_attribute *devattr,
660                                          const char *sysfsbuf, size_t count)
661 {
662         int ret;
663         u8 buffer[2];
664         u32 input;
665         u16 val;
666         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
667
668         input = simple_strtoul(sysfsbuf, NULL, 10);
669
670         mutex_lock(&applesmc_lock);
671
672         ret = applesmc_read_key(FANS_MANUAL, buffer, 2);
673         val = (buffer[0] << 8 | buffer[1]);
674         if (ret)
675                 goto out;
676
677         if (input)
678                 val = val | (0x01 << attr->index);
679         else
680                 val = val & ~(0x01 << attr->index);
681
682         buffer[0] = (val >> 8) & 0xFF;
683         buffer[1] = val & 0xFF;
684
685         ret = applesmc_write_key(FANS_MANUAL, buffer, 2);
686
687 out:
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_position(struct device *dev,
696                                 struct device_attribute *attr, char *sysfsbuf)
697 {
698         int ret;
699         char newkey[5];
700         u8 buffer[17];
701         struct sensor_device_attribute_2 *sensor_attr =
702                                                 to_sensor_dev_attr_2(attr);
703
704         newkey[0] = FAN_POSITION[0];
705         newkey[1] = '0' + sensor_attr->index;
706         newkey[2] = FAN_POSITION[2];
707         newkey[3] = FAN_POSITION[3];
708         newkey[4] = 0;
709
710         mutex_lock(&applesmc_lock);
711
712         ret = applesmc_read_key(newkey, buffer, 16);
713         buffer[16] = 0;
714
715         mutex_unlock(&applesmc_lock);
716         if (ret)
717                 return ret;
718         else
719                 return snprintf(sysfsbuf, PAGE_SIZE, "%s\n", buffer+4);
720 }
721
722 static ssize_t applesmc_calibrate_show(struct device *dev,
723                                 struct device_attribute *attr, char *sysfsbuf)
724 {
725         return snprintf(sysfsbuf, PAGE_SIZE, "(%d,%d)\n", rest_x, rest_y);
726 }
727
728 static ssize_t applesmc_calibrate_store(struct device *dev,
729         struct device_attribute *attr, const char *sysfsbuf, size_t count)
730 {
731         mutex_lock(&applesmc_lock);
732         applesmc_calibrate();
733         mutex_unlock(&applesmc_lock);
734
735         return count;
736 }
737
738 /* Store the next backlight value to be written by the work */
739 static unsigned int backlight_value;
740
741 static void applesmc_backlight_set(struct work_struct *work)
742 {
743         u8 buffer[2];
744
745         mutex_lock(&applesmc_lock);
746         buffer[0] = backlight_value;
747         buffer[1] = 0x00;
748         applesmc_write_key(BACKLIGHT_KEY, buffer, 2);
749         mutex_unlock(&applesmc_lock);
750 }
751 static DECLARE_WORK(backlight_work, &applesmc_backlight_set);
752
753 static void applesmc_brightness_set(struct led_classdev *led_cdev,
754                                                 enum led_brightness value)
755 {
756         int ret;
757
758         backlight_value = value;
759         ret = queue_work(applesmc_led_wq, &backlight_work);
760
761         if (debug && (!ret))
762                 printk(KERN_DEBUG "applesmc: work was already on the queue.\n");
763 }
764
765 static ssize_t applesmc_key_count_show(struct device *dev,
766                                 struct device_attribute *attr, char *sysfsbuf)
767 {
768         int ret;
769         u8 buffer[4];
770         u32 count;
771
772         mutex_lock(&applesmc_lock);
773
774         ret = applesmc_read_key(KEY_COUNT_KEY, buffer, 4);
775         count = ((u32)buffer[0]<<24) + ((u32)buffer[1]<<16) +
776                                                 ((u32)buffer[2]<<8) + buffer[3];
777
778         mutex_unlock(&applesmc_lock);
779         if (ret)
780                 return ret;
781         else
782                 return snprintf(sysfsbuf, PAGE_SIZE, "%d\n", count);
783 }
784
785 static ssize_t applesmc_key_at_index_read_show(struct device *dev,
786                                 struct device_attribute *attr, char *sysfsbuf)
787 {
788         char key[5];
789         char info[6];
790         int ret;
791
792         mutex_lock(&applesmc_lock);
793
794         ret = applesmc_get_key_at_index(key_at_index, key);
795
796         if (ret || !key[0]) {
797                 mutex_unlock(&applesmc_lock);
798
799                 return -EINVAL;
800         }
801
802         ret = applesmc_get_key_type(key, info);
803
804         if (ret) {
805                 mutex_unlock(&applesmc_lock);
806
807                 return ret;
808         }
809
810         /*
811          * info[0] maximum value (APPLESMC_MAX_DATA_LENGTH) is much lower than
812          * PAGE_SIZE, so we don't need any checks before writing to sysfsbuf.
813          */
814         ret = applesmc_read_key(key, sysfsbuf, info[0]);
815
816         mutex_unlock(&applesmc_lock);
817
818         if (!ret) {
819                 return info[0];
820         }
821         else {
822                 return ret;
823         }
824 }
825
826 static ssize_t applesmc_key_at_index_data_length_show(struct device *dev,
827                                 struct device_attribute *attr, char *sysfsbuf)
828 {
829         char key[5];
830         char info[6];
831         int ret;
832
833         mutex_lock(&applesmc_lock);
834
835         ret = applesmc_get_key_at_index(key_at_index, key);
836
837         if (ret || !key[0]) {
838                 mutex_unlock(&applesmc_lock);
839
840                 return -EINVAL;
841         }
842
843         ret = applesmc_get_key_type(key, info);
844
845         mutex_unlock(&applesmc_lock);
846
847         if (!ret)
848                 return snprintf(sysfsbuf, PAGE_SIZE, "%d\n", info[0]);
849         else
850                 return ret;
851 }
852
853 static ssize_t applesmc_key_at_index_type_show(struct device *dev,
854                                 struct device_attribute *attr, char *sysfsbuf)
855 {
856         char key[5];
857         char info[6];
858         int ret;
859
860         mutex_lock(&applesmc_lock);
861
862         ret = applesmc_get_key_at_index(key_at_index, key);
863
864         if (ret || !key[0]) {
865                 mutex_unlock(&applesmc_lock);
866
867                 return -EINVAL;
868         }
869
870         ret = applesmc_get_key_type(key, info);
871
872         mutex_unlock(&applesmc_lock);
873
874         if (!ret)
875                 return snprintf(sysfsbuf, PAGE_SIZE, "%s\n", info+1);
876         else
877                 return ret;
878 }
879
880 static ssize_t applesmc_key_at_index_name_show(struct device *dev,
881                                 struct device_attribute *attr, char *sysfsbuf)
882 {
883         char key[5];
884         int ret;
885
886         mutex_lock(&applesmc_lock);
887
888         ret = applesmc_get_key_at_index(key_at_index, key);
889
890         mutex_unlock(&applesmc_lock);
891
892         if (!ret && key[0])
893                 return snprintf(sysfsbuf, PAGE_SIZE, "%s\n", key);
894         else
895                 return -EINVAL;
896 }
897
898 static ssize_t applesmc_key_at_index_show(struct device *dev,
899                                 struct device_attribute *attr, char *sysfsbuf)
900 {
901         return snprintf(sysfsbuf, PAGE_SIZE, "%d\n", key_at_index);
902 }
903
904 static ssize_t applesmc_key_at_index_store(struct device *dev,
905         struct device_attribute *attr, const char *sysfsbuf, size_t count)
906 {
907         mutex_lock(&applesmc_lock);
908
909         key_at_index = simple_strtoul(sysfsbuf, NULL, 10);
910
911         mutex_unlock(&applesmc_lock);
912
913         return count;
914 }
915
916 static struct led_classdev applesmc_backlight = {
917         .name                   = "smc:kbd_backlight",
918         .default_trigger        = "nand-disk",
919         .brightness_set         = applesmc_brightness_set,
920 };
921
922 static DEVICE_ATTR(name, 0444, applesmc_name_show, NULL);
923
924 static DEVICE_ATTR(position, 0444, applesmc_position_show, NULL);
925 static DEVICE_ATTR(calibrate, 0644,
926                         applesmc_calibrate_show, applesmc_calibrate_store);
927
928 static struct attribute *accelerometer_attributes[] = {
929         &dev_attr_position.attr,
930         &dev_attr_calibrate.attr,
931         NULL
932 };
933
934 static const struct attribute_group accelerometer_attributes_group =
935         { .attrs = accelerometer_attributes };
936
937 static DEVICE_ATTR(light, 0444, applesmc_light_show, NULL);
938
939 static DEVICE_ATTR(key_count, 0444, applesmc_key_count_show, NULL);
940 static DEVICE_ATTR(key_at_index, 0644,
941                 applesmc_key_at_index_show, applesmc_key_at_index_store);
942 static DEVICE_ATTR(key_at_index_name, 0444,
943                                         applesmc_key_at_index_name_show, NULL);
944 static DEVICE_ATTR(key_at_index_type, 0444,
945                                         applesmc_key_at_index_type_show, NULL);
946 static DEVICE_ATTR(key_at_index_data_length, 0444,
947                                 applesmc_key_at_index_data_length_show, NULL);
948 static DEVICE_ATTR(key_at_index_data, 0444,
949                                 applesmc_key_at_index_read_show, NULL);
950
951 static struct attribute *key_enumeration_attributes[] = {
952         &dev_attr_key_count.attr,
953         &dev_attr_key_at_index.attr,
954         &dev_attr_key_at_index_name.attr,
955         &dev_attr_key_at_index_type.attr,
956         &dev_attr_key_at_index_data_length.attr,
957         &dev_attr_key_at_index_data.attr,
958         NULL
959 };
960
961 static const struct attribute_group key_enumeration_group =
962         { .attrs = key_enumeration_attributes };
963
964 /*
965  * Macro defining SENSOR_DEVICE_ATTR for a fan sysfs entries.
966  *  - show actual speed
967  *  - show/store minimum speed
968  *  - show maximum speed
969  *  - show safe speed
970  *  - show/store target speed
971  *  - show/store manual mode
972  */
973 #define sysfs_fan_speeds_offset(offset) \
974 static SENSOR_DEVICE_ATTR_2(fan##offset##_input, S_IRUGO, \
975                         applesmc_show_fan_speed, NULL, 0, offset-1); \
976 \
977 static SENSOR_DEVICE_ATTR_2(fan##offset##_min, S_IRUGO | S_IWUSR, \
978         applesmc_show_fan_speed, applesmc_store_fan_speed, 1, offset-1); \
979 \
980 static SENSOR_DEVICE_ATTR_2(fan##offset##_max, S_IRUGO, \
981                         applesmc_show_fan_speed, NULL, 2, offset-1); \
982 \
983 static SENSOR_DEVICE_ATTR_2(fan##offset##_safe, S_IRUGO, \
984                         applesmc_show_fan_speed, NULL, 3, offset-1); \
985 \
986 static SENSOR_DEVICE_ATTR_2(fan##offset##_output, S_IRUGO | S_IWUSR, \
987         applesmc_show_fan_speed, applesmc_store_fan_speed, 4, offset-1); \
988 \
989 static SENSOR_DEVICE_ATTR(fan##offset##_manual, S_IRUGO | S_IWUSR, \
990         applesmc_show_fan_manual, applesmc_store_fan_manual, offset-1); \
991 \
992 static SENSOR_DEVICE_ATTR(fan##offset##_label, S_IRUGO, \
993         applesmc_show_fan_position, NULL, offset-1); \
994 \
995 static struct attribute *fan##offset##_attributes[] = { \
996         &sensor_dev_attr_fan##offset##_input.dev_attr.attr, \
997         &sensor_dev_attr_fan##offset##_min.dev_attr.attr, \
998         &sensor_dev_attr_fan##offset##_max.dev_attr.attr, \
999         &sensor_dev_attr_fan##offset##_safe.dev_attr.attr, \
1000         &sensor_dev_attr_fan##offset##_output.dev_attr.attr, \
1001         &sensor_dev_attr_fan##offset##_manual.dev_attr.attr, \
1002         &sensor_dev_attr_fan##offset##_label.dev_attr.attr, \
1003         NULL \
1004 };
1005
1006 /*
1007  * Create the needed functions for each fan using the macro defined above
1008  * (2 fans are supported)
1009  */
1010 sysfs_fan_speeds_offset(1);
1011 sysfs_fan_speeds_offset(2);
1012
1013 static const struct attribute_group fan_attribute_groups[] = {
1014         { .attrs = fan1_attributes },
1015         { .attrs = fan2_attributes }
1016 };
1017
1018 /*
1019  * Temperature sensors sysfs entries.
1020  */
1021 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO,
1022                                         applesmc_show_temperature, NULL, 0);
1023 static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO,
1024                                         applesmc_show_temperature, NULL, 1);
1025 static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO,
1026                                         applesmc_show_temperature, NULL, 2);
1027 static SENSOR_DEVICE_ATTR(temp4_input, S_IRUGO,
1028                                         applesmc_show_temperature, NULL, 3);
1029 static SENSOR_DEVICE_ATTR(temp5_input, S_IRUGO,
1030                                         applesmc_show_temperature, NULL, 4);
1031 static SENSOR_DEVICE_ATTR(temp6_input, S_IRUGO,
1032                                         applesmc_show_temperature, NULL, 5);
1033 static SENSOR_DEVICE_ATTR(temp7_input, S_IRUGO,
1034                                         applesmc_show_temperature, NULL, 6);
1035 static SENSOR_DEVICE_ATTR(temp8_input, S_IRUGO,
1036                                         applesmc_show_temperature, NULL, 7);
1037 static SENSOR_DEVICE_ATTR(temp9_input, S_IRUGO,
1038                                         applesmc_show_temperature, NULL, 8);
1039 static SENSOR_DEVICE_ATTR(temp10_input, S_IRUGO,
1040                                         applesmc_show_temperature, NULL, 9);
1041 static SENSOR_DEVICE_ATTR(temp11_input, S_IRUGO,
1042                                         applesmc_show_temperature, NULL, 10);
1043 static SENSOR_DEVICE_ATTR(temp12_input, S_IRUGO,
1044                                         applesmc_show_temperature, NULL, 11);
1045
1046 static struct attribute *temperature_attributes[] = {
1047         &sensor_dev_attr_temp1_input.dev_attr.attr,
1048         &sensor_dev_attr_temp2_input.dev_attr.attr,
1049         &sensor_dev_attr_temp3_input.dev_attr.attr,
1050         &sensor_dev_attr_temp4_input.dev_attr.attr,
1051         &sensor_dev_attr_temp5_input.dev_attr.attr,
1052         &sensor_dev_attr_temp6_input.dev_attr.attr,
1053         &sensor_dev_attr_temp7_input.dev_attr.attr,
1054         &sensor_dev_attr_temp8_input.dev_attr.attr,
1055         &sensor_dev_attr_temp9_input.dev_attr.attr,
1056         &sensor_dev_attr_temp10_input.dev_attr.attr,
1057         &sensor_dev_attr_temp11_input.dev_attr.attr,
1058         &sensor_dev_attr_temp12_input.dev_attr.attr,
1059         NULL
1060 };
1061
1062 static const struct attribute_group temperature_attributes_group =
1063         { .attrs = temperature_attributes };
1064
1065 /* Module stuff */
1066
1067 /*
1068  * applesmc_dmi_match - found a match.  return one, short-circuiting the hunt.
1069  */
1070 static int applesmc_dmi_match(struct dmi_system_id *id)
1071 {
1072         int i = 0;
1073         struct dmi_match_data* dmi_data = id->driver_data;
1074         printk(KERN_INFO "applesmc: %s detected:\n", id->ident);
1075         applesmc_accelerometer = dmi_data->accelerometer;
1076         printk(KERN_INFO "applesmc:  - Model %s accelerometer\n",
1077                                 applesmc_accelerometer ? "with" : "without");
1078         applesmc_light = dmi_data->light;
1079         printk(KERN_INFO "applesmc:  - Model %s light sensors and backlight\n",
1080                                         applesmc_light ? "with" : "without");
1081
1082         applesmc_temperature_set =  dmi_data->temperature_set;
1083         while (temperature_sensors_sets[applesmc_temperature_set][i] != NULL)
1084                 i++;
1085         printk(KERN_INFO "applesmc:  - Model with %d temperature sensors\n", i);
1086         return 1;
1087 }
1088
1089 /* Create accelerometer ressources */
1090 static int applesmc_create_accelerometer(void)
1091 {
1092         int ret;
1093
1094         ret = sysfs_create_group(&pdev->dev.kobj,
1095                                         &accelerometer_attributes_group);
1096         if (ret)
1097                 goto out;
1098
1099         applesmc_idev = input_allocate_device();
1100         if (!applesmc_idev) {
1101                 ret = -ENOMEM;
1102                 goto out_sysfs;
1103         }
1104
1105         /* initial calibrate for the input device */
1106         applesmc_calibrate();
1107
1108         /* initialize the input class */
1109         applesmc_idev->name = "applesmc";
1110         applesmc_idev->id.bustype = BUS_HOST;
1111         applesmc_idev->dev.parent = &pdev->dev;
1112         applesmc_idev->evbit[0] = BIT(EV_ABS);
1113         applesmc_idev->open = applesmc_idev_open;
1114         applesmc_idev->close = applesmc_idev_close;
1115         input_set_abs_params(applesmc_idev, ABS_X,
1116                         -256, 256, APPLESMC_INPUT_FUZZ, APPLESMC_INPUT_FLAT);
1117         input_set_abs_params(applesmc_idev, ABS_Y,
1118                         -256, 256, APPLESMC_INPUT_FUZZ, APPLESMC_INPUT_FLAT);
1119
1120         ret = input_register_device(applesmc_idev);
1121         if (ret)
1122                 goto out_idev;
1123
1124         /* start up our timer for the input device */
1125         init_timer(&applesmc_timer);
1126         applesmc_timer.function = applesmc_idev_poll;
1127         applesmc_timer.expires = jiffies + APPLESMC_POLL_PERIOD;
1128
1129         return 0;
1130
1131 out_idev:
1132         input_free_device(applesmc_idev);
1133
1134 out_sysfs:
1135         sysfs_remove_group(&pdev->dev.kobj, &accelerometer_attributes_group);
1136
1137 out:
1138         printk(KERN_WARNING "applesmc: driver init failed (ret=%d)!\n", ret);
1139         return ret;
1140 }
1141
1142 /* Release all ressources used by the accelerometer */
1143 static void applesmc_release_accelerometer(void)
1144 {
1145         del_timer_sync(&applesmc_timer);
1146         input_unregister_device(applesmc_idev);
1147         sysfs_remove_group(&pdev->dev.kobj, &accelerometer_attributes_group);
1148 }
1149
1150 static __initdata struct dmi_match_data applesmc_dmi_data[] = {
1151 /* MacBook Pro: accelerometer, backlight and temperature set 0 */
1152         { .accelerometer = 1, .light = 1, .temperature_set = 0 },
1153 /* MacBook: accelerometer and temperature set 0 */
1154         { .accelerometer = 1, .light = 0, .temperature_set = 0 },
1155 /* MacBook: temperature set 1 */
1156         { .accelerometer = 0, .light = 0, .temperature_set = 1 }
1157 };
1158
1159 /* Note that DMI_MATCH(...,"MacBook") will match "MacBookPro1,1".
1160  * So we need to put "Apple MacBook Pro" before "Apple MacBook". */
1161 static __initdata struct dmi_system_id applesmc_whitelist[] = {
1162         { applesmc_dmi_match, "Apple MacBook Pro", {
1163           DMI_MATCH(DMI_BOARD_VENDOR,"Apple"),
1164           DMI_MATCH(DMI_PRODUCT_NAME,"MacBookPro") },
1165                 (void*)&applesmc_dmi_data[0]},
1166         { applesmc_dmi_match, "Apple MacBook", {
1167           DMI_MATCH(DMI_BOARD_VENDOR,"Apple"),
1168           DMI_MATCH(DMI_PRODUCT_NAME,"MacBook") },
1169                 (void*)&applesmc_dmi_data[1]},
1170         { applesmc_dmi_match, "Apple Macmini", {
1171           DMI_MATCH(DMI_BOARD_VENDOR,"Apple"),
1172           DMI_MATCH(DMI_PRODUCT_NAME,"Macmini") },
1173                 (void*)&applesmc_dmi_data[2]},
1174         { .ident = NULL }
1175 };
1176
1177 static int __init applesmc_init(void)
1178 {
1179         int ret;
1180         int count;
1181         int i;
1182
1183         mutex_init(&applesmc_lock);
1184
1185         if (!dmi_check_system(applesmc_whitelist)) {
1186                 printk(KERN_WARNING "applesmc: supported laptop not found!\n");
1187                 ret = -ENODEV;
1188                 goto out;
1189         }
1190
1191         if (!request_region(APPLESMC_DATA_PORT, APPLESMC_NR_PORTS,
1192                                                                 "applesmc")) {
1193                 ret = -ENXIO;
1194                 goto out;
1195         }
1196
1197         ret = platform_driver_register(&applesmc_driver);
1198         if (ret)
1199                 goto out_region;
1200
1201         pdev = platform_device_register_simple("applesmc", APPLESMC_DATA_PORT,
1202                                                NULL, 0);
1203         if (IS_ERR(pdev)) {
1204                 ret = PTR_ERR(pdev);
1205                 goto out_driver;
1206         }
1207
1208         ret = sysfs_create_file(&pdev->dev.kobj, &dev_attr_name.attr);
1209         if (ret)
1210                 goto out_device;
1211
1212         /* Create key enumeration sysfs files */
1213         ret = sysfs_create_group(&pdev->dev.kobj, &key_enumeration_group);
1214         if (ret)
1215                 goto out_name;
1216
1217         /* create fan files */
1218         count = applesmc_get_fan_count();
1219         if (count < 0) {
1220                 printk(KERN_ERR "applesmc: Cannot get the number of fans.\n");
1221         } else {
1222                 printk(KERN_INFO "applesmc: %d fans found.\n", count);
1223
1224                 switch (count) {
1225                 default:
1226                         printk(KERN_WARNING "applesmc: More than 2 fans found,"
1227                                         " but at most 2 fans are supported"
1228                                                 " by the driver.\n");
1229                 case 2:
1230                         ret = sysfs_create_group(&pdev->dev.kobj,
1231                                                  &fan_attribute_groups[1]);
1232                         if (ret)
1233                                 goto out_key_enumeration;
1234                 case 1:
1235                         ret = sysfs_create_group(&pdev->dev.kobj,
1236                                                  &fan_attribute_groups[0]);
1237                         if (ret)
1238                                 goto out_fan_1;
1239                 case 0:
1240                         ;
1241                 }
1242         }
1243
1244         for (i = 0;
1245              temperature_sensors_sets[applesmc_temperature_set][i] != NULL;
1246              i++) {
1247                 if (temperature_attributes[i] == NULL) {
1248                         printk(KERN_ERR "applesmc: More temperature sensors "
1249                                 "in temperature_sensors_sets (at least %i)"
1250                                 "than available sysfs files in "
1251                                 "temperature_attributes (%i), please report "
1252                                 "this bug.\n", i, i-1);
1253                         goto out_temperature;
1254                 }
1255                 ret = sysfs_create_file(&pdev->dev.kobj,
1256                                                 temperature_attributes[i]);
1257                 if (ret)
1258                         goto out_temperature;
1259         }
1260
1261         if (applesmc_accelerometer) {
1262                 ret = applesmc_create_accelerometer();
1263                 if (ret)
1264                         goto out_temperature;
1265         }
1266
1267         if (applesmc_light) {
1268                 /* Add light sensor file */
1269                 ret = sysfs_create_file(&pdev->dev.kobj, &dev_attr_light.attr);
1270                 if (ret)
1271                         goto out_accelerometer;
1272
1273                 /* Create the workqueue */
1274                 applesmc_led_wq = create_singlethread_workqueue("applesmc-led");
1275                 if (!applesmc_led_wq) {
1276                         ret = -ENOMEM;
1277                         goto out_light_sysfs;
1278                 }
1279
1280                 /* register as a led device */
1281                 ret = led_classdev_register(&pdev->dev, &applesmc_backlight);
1282                 if (ret < 0)
1283                         goto out_light_wq;
1284         }
1285
1286         hwmon_class_dev = hwmon_device_register(&pdev->dev);
1287         if (IS_ERR(hwmon_class_dev)) {
1288                 ret = PTR_ERR(hwmon_class_dev);
1289                 goto out_light_ledclass;
1290         }
1291
1292         printk(KERN_INFO "applesmc: driver successfully loaded.\n");
1293
1294         return 0;
1295
1296 out_light_ledclass:
1297         if (applesmc_light)
1298                 led_classdev_unregister(&applesmc_backlight);
1299 out_light_wq:
1300         if (applesmc_light)
1301                 destroy_workqueue(applesmc_led_wq);
1302 out_light_sysfs:
1303         if (applesmc_light)
1304                 sysfs_remove_file(&pdev->dev.kobj, &dev_attr_light.attr);
1305 out_accelerometer:
1306         if (applesmc_accelerometer)
1307                 applesmc_release_accelerometer();
1308 out_temperature:
1309         sysfs_remove_group(&pdev->dev.kobj, &temperature_attributes_group);
1310         sysfs_remove_group(&pdev->dev.kobj, &fan_attribute_groups[0]);
1311 out_fan_1:
1312         sysfs_remove_group(&pdev->dev.kobj, &fan_attribute_groups[1]);
1313 out_key_enumeration:
1314         sysfs_remove_group(&pdev->dev.kobj, &key_enumeration_group);
1315 out_name:
1316         sysfs_remove_file(&pdev->dev.kobj, &dev_attr_name.attr);
1317 out_device:
1318         platform_device_unregister(pdev);
1319 out_driver:
1320         platform_driver_unregister(&applesmc_driver);
1321 out_region:
1322         release_region(APPLESMC_DATA_PORT, APPLESMC_NR_PORTS);
1323 out:
1324         printk(KERN_WARNING "applesmc: driver init failed (ret=%d)!\n", ret);
1325         return ret;
1326 }
1327
1328 static void __exit applesmc_exit(void)
1329 {
1330         hwmon_device_unregister(hwmon_class_dev);
1331         if (applesmc_light) {
1332                 led_classdev_unregister(&applesmc_backlight);
1333                 destroy_workqueue(applesmc_led_wq);
1334                 sysfs_remove_file(&pdev->dev.kobj, &dev_attr_light.attr);
1335         }
1336         if (applesmc_accelerometer)
1337                 applesmc_release_accelerometer();
1338         sysfs_remove_group(&pdev->dev.kobj, &temperature_attributes_group);
1339         sysfs_remove_group(&pdev->dev.kobj, &fan_attribute_groups[0]);
1340         sysfs_remove_group(&pdev->dev.kobj, &fan_attribute_groups[1]);
1341         sysfs_remove_group(&pdev->dev.kobj, &key_enumeration_group);
1342         sysfs_remove_file(&pdev->dev.kobj, &dev_attr_name.attr);
1343         platform_device_unregister(pdev);
1344         platform_driver_unregister(&applesmc_driver);
1345         release_region(APPLESMC_DATA_PORT, APPLESMC_NR_PORTS);
1346
1347         printk(KERN_INFO "applesmc: driver unloaded.\n");
1348 }
1349
1350 module_init(applesmc_init);
1351 module_exit(applesmc_exit);
1352
1353 MODULE_AUTHOR("Nicolas Boichat");
1354 MODULE_DESCRIPTION("Apple SMC");
1355 MODULE_LICENSE("GPL v2");