2 * drivers/hwmon/applesmc.c - driver for Apple's SMC (accelerometer, temperature
3 * sensors, fan control, keyboard backlight control) used in Intel-based Apple
6 * Copyright (C) 2007 Nicolas Boichat <nicolas@boichat.ch>
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>
12 * Fan control based on smcFanControl:
13 * Copyright (C) 2006 Hendrik Holtmann <holtmann@mac.com>
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.
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
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
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>
39 #include <linux/leds.h>
40 #include <linux/hwmon.h>
41 #include <linux/workqueue.h>
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
48 #define APPLESMC_NR_PORTS 32 /* 0x300-0x31f */
50 #define APPLESMC_MAX_DATA_LENGTH 32
52 #define APPLESMC_MIN_WAIT 0x0040
53 #define APPLESMC_MAX_WAIT 0x8000
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
61 #define KEY_COUNT_KEY "#KEY" /* r-o ui32 */
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) */
67 #define CLAMSHELL_KEY "MSLD" /* r-o ui8 (unused) */
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 */
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] */
84 * Temperature sensors keys (sp78 - 2 bytes).
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 },
105 { "TC0D", "TA0P", "TG0P", "TG0D", "TG0H", "TH0P", "Tm0P", "TO0P",
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 },
126 /* List of keys used to read/write fan speeds */
127 static const char* fan_speed_keys[] = {
135 #define INIT_TIMEOUT_MSECS 5000 /* wait up to 5s for device init ... */
136 #define INIT_WAIT_MSECS 50 /* ... in 50ms increments */
138 #define APPLESMC_POLL_INTERVAL 50 /* msecs */
139 #define APPLESMC_INPUT_FUZZ 4 /* input event threshold */
140 #define APPLESMC_INPUT_FLAT 4
146 /* Structure to be passed to DMI_MATCH function */
147 struct dmi_match_data {
148 /* Indicates whether this computer has an accelerometer. */
150 /* Indicates whether this computer has light sensors and keyboard backlight. */
152 /* Indicates which temperature sensors set to use. */
156 static const int debug;
157 static struct platform_device *pdev;
160 static struct device *hwmon_dev;
161 static struct input_polled_dev *applesmc_idev;
163 /* Indicates whether this computer has an accelerometer. */
164 static unsigned int applesmc_accelerometer;
166 /* Indicates whether this computer has light sensors and keyboard backlight. */
167 static unsigned int applesmc_light;
169 /* Indicates which temperature sensors set to use. */
170 static unsigned int applesmc_temperature_set;
172 static DEFINE_MUTEX(applesmc_lock);
175 * Last index written to key_at_index sysfs file, and value to use for all other
176 * key_at_index_* sysfs files.
178 static unsigned int key_at_index;
180 static struct workqueue_struct *applesmc_led_wq;
183 * __wait_status - Wait up to 32ms for the status port to get a certain value
184 * (masked with 0x0f), returning zero if the value is obtained. Callers must
185 * hold applesmc_lock.
187 static int __wait_status(u8 val)
191 val = val & APPLESMC_STATUS_MASK;
193 for (us = APPLESMC_MIN_WAIT; us < APPLESMC_MAX_WAIT; us <<= 1) {
195 if ((inb(APPLESMC_CMD_PORT) & APPLESMC_STATUS_MASK) == val) {
198 "Waited %d us for status %x\n",
199 2 * us - APPLESMC_MIN_WAIT, val);
204 printk(KERN_WARNING "applesmc: wait status failed: %x != %x\n",
205 val, inb(APPLESMC_CMD_PORT));
211 * special treatment of command port - on newer macbooks, it seems necessary
212 * to resend the command byte before polling the status again. Callers must
213 * hold applesmc_lock.
215 static int send_command(u8 cmd)
218 for (us = APPLESMC_MIN_WAIT; us < APPLESMC_MAX_WAIT; us <<= 1) {
219 outb(cmd, APPLESMC_CMD_PORT);
221 if ((inb(APPLESMC_CMD_PORT) & APPLESMC_STATUS_MASK) == 0x0c)
224 printk(KERN_WARNING "applesmc: command failed: %x -> %x\n",
225 cmd, inb(APPLESMC_CMD_PORT));
230 * applesmc_read_key - reads len bytes from a given key, and put them in buffer.
231 * Returns zero on success or a negative error on failure. Callers must
232 * hold applesmc_lock.
234 static int applesmc_read_key(const char* key, u8* buffer, u8 len)
238 if (len > APPLESMC_MAX_DATA_LENGTH) {
239 printk(KERN_ERR "applesmc_read_key: cannot read more than "
240 "%d bytes\n", APPLESMC_MAX_DATA_LENGTH);
244 if (send_command(APPLESMC_READ_CMD))
247 for (i = 0; i < 4; i++) {
248 outb(key[i], APPLESMC_DATA_PORT);
249 if (__wait_status(0x04))
253 printk(KERN_DEBUG "<%s", key);
255 outb(len, APPLESMC_DATA_PORT);
257 printk(KERN_DEBUG ">%x", len);
259 for (i = 0; i < len; i++) {
260 if (__wait_status(0x05))
262 buffer[i] = inb(APPLESMC_DATA_PORT);
264 printk(KERN_DEBUG "<%x", buffer[i]);
267 printk(KERN_DEBUG "\n");
273 * applesmc_write_key - writes len bytes from buffer to a given key.
274 * Returns zero on success or a negative error on failure. Callers must
275 * hold applesmc_lock.
277 static int applesmc_write_key(const char* key, u8* buffer, u8 len)
281 if (len > APPLESMC_MAX_DATA_LENGTH) {
282 printk(KERN_ERR "applesmc_write_key: cannot write more than "
283 "%d bytes\n", APPLESMC_MAX_DATA_LENGTH);
287 if (send_command(APPLESMC_WRITE_CMD))
290 for (i = 0; i < 4; i++) {
291 outb(key[i], APPLESMC_DATA_PORT);
292 if (__wait_status(0x04))
296 outb(len, APPLESMC_DATA_PORT);
298 for (i = 0; i < len; i++) {
299 if (__wait_status(0x04))
301 outb(buffer[i], APPLESMC_DATA_PORT);
308 * applesmc_get_key_at_index - get key at index, and put the result in key
309 * (char[6]). Returns zero on success or a negative error on failure. Callers
310 * must hold applesmc_lock.
312 static int applesmc_get_key_at_index(int index, char* key)
316 readkey[0] = index >> 24;
317 readkey[1] = index >> 16;
318 readkey[2] = index >> 8;
321 if (send_command(APPLESMC_GET_KEY_BY_INDEX_CMD))
324 for (i = 0; i < 4; i++) {
325 outb(readkey[i], APPLESMC_DATA_PORT);
326 if (__wait_status(0x04))
330 outb(4, APPLESMC_DATA_PORT);
332 for (i = 0; i < 4; i++) {
333 if (__wait_status(0x05))
335 key[i] = inb(APPLESMC_DATA_PORT);
343 * applesmc_get_key_type - get key type, and put the result in type (char[6]).
344 * Returns zero on success or a negative error on failure. Callers must
345 * hold applesmc_lock.
347 static int applesmc_get_key_type(char* key, char* type)
351 if (send_command(APPLESMC_GET_KEY_TYPE_CMD))
354 for (i = 0; i < 4; i++) {
355 outb(key[i], APPLESMC_DATA_PORT);
356 if (__wait_status(0x04))
360 outb(6, APPLESMC_DATA_PORT);
362 for (i = 0; i < 6; i++) {
363 if (__wait_status(0x05))
365 type[i] = inb(APPLESMC_DATA_PORT);
373 * applesmc_read_motion_sensor - Read motion sensor (X, Y or Z). Callers must
374 * hold applesmc_lock.
376 static int applesmc_read_motion_sensor(int index, s16* value)
383 ret = applesmc_read_key(MOTION_SENSOR_X_KEY, buffer, 2);
386 ret = applesmc_read_key(MOTION_SENSOR_Y_KEY, buffer, 2);
389 ret = applesmc_read_key(MOTION_SENSOR_Z_KEY, buffer, 2);
395 *value = ((s16)buffer[0] << 8) | buffer[1];
401 * applesmc_device_init - initialize the accelerometer. Returns zero on success
402 * and negative error code on failure. Can sleep.
404 static int applesmc_device_init(void)
406 int total, ret = -ENXIO;
409 if (!applesmc_accelerometer)
412 mutex_lock(&applesmc_lock);
414 for (total = INIT_TIMEOUT_MSECS; total > 0; total -= INIT_WAIT_MSECS) {
416 printk(KERN_DEBUG "applesmc try %d\n", total);
417 if (!applesmc_read_key(MOTION_SENSOR_KEY, buffer, 2) &&
418 (buffer[0] != 0x00 || buffer[1] != 0x00)) {
419 if (total == INIT_TIMEOUT_MSECS) {
420 printk(KERN_DEBUG "applesmc: device has"
421 " already been initialized"
422 " (0x%02x, 0x%02x).\n",
423 buffer[0], buffer[1]);
425 printk(KERN_DEBUG "applesmc: device"
426 " successfully initialized"
427 " (0x%02x, 0x%02x).\n",
428 buffer[0], buffer[1]);
435 applesmc_write_key(MOTION_SENSOR_KEY, buffer, 2);
436 msleep(INIT_WAIT_MSECS);
439 printk(KERN_WARNING "applesmc: failed to init the device\n");
442 mutex_unlock(&applesmc_lock);
447 * applesmc_get_fan_count - get the number of fans. Callers must NOT hold
450 static int applesmc_get_fan_count(void)
455 mutex_lock(&applesmc_lock);
457 ret = applesmc_read_key(FANS_COUNT, buffer, 1);
459 mutex_unlock(&applesmc_lock);
466 /* Device model stuff */
467 static int applesmc_probe(struct platform_device *dev)
471 ret = applesmc_device_init();
475 printk(KERN_INFO "applesmc: device successfully initialized.\n");
479 static int applesmc_resume(struct platform_device *dev)
481 return applesmc_device_init();
484 static struct platform_driver applesmc_driver = {
485 .probe = applesmc_probe,
486 .resume = applesmc_resume,
489 .owner = THIS_MODULE,
494 * applesmc_calibrate - Set our "resting" values. Callers must
495 * hold applesmc_lock.
497 static void applesmc_calibrate(void)
499 applesmc_read_motion_sensor(SENSOR_X, &rest_x);
500 applesmc_read_motion_sensor(SENSOR_Y, &rest_y);
504 static void applesmc_idev_poll(struct input_polled_dev *dev)
506 struct input_dev *idev = dev->input;
509 mutex_lock(&applesmc_lock);
511 if (applesmc_read_motion_sensor(SENSOR_X, &x))
513 if (applesmc_read_motion_sensor(SENSOR_Y, &y))
517 input_report_abs(idev, ABS_X, x - rest_x);
518 input_report_abs(idev, ABS_Y, y - rest_y);
522 mutex_unlock(&applesmc_lock);
527 static ssize_t applesmc_name_show(struct device *dev,
528 struct device_attribute *attr, char *buf)
530 return snprintf(buf, PAGE_SIZE, "applesmc\n");
533 static ssize_t applesmc_position_show(struct device *dev,
534 struct device_attribute *attr, char *buf)
539 mutex_lock(&applesmc_lock);
541 ret = applesmc_read_motion_sensor(SENSOR_X, &x);
544 ret = applesmc_read_motion_sensor(SENSOR_Y, &y);
547 ret = applesmc_read_motion_sensor(SENSOR_Z, &z);
552 mutex_unlock(&applesmc_lock);
556 return snprintf(buf, PAGE_SIZE, "(%d,%d,%d)\n", x, y, z);
559 static ssize_t applesmc_light_show(struct device *dev,
560 struct device_attribute *attr, char *sysfsbuf)
562 static int data_length;
564 u8 left = 0, right = 0;
565 u8 buffer[10], query[6];
567 mutex_lock(&applesmc_lock);
570 ret = applesmc_get_key_type(LIGHT_SENSOR_LEFT_KEY, query);
573 data_length = clamp_val(query[0], 0, 10);
574 printk(KERN_INFO "applesmc: light sensor data length set to "
575 "%d\n", data_length);
578 ret = applesmc_read_key(LIGHT_SENSOR_LEFT_KEY, buffer, data_length);
582 ret = applesmc_read_key(LIGHT_SENSOR_RIGHT_KEY, buffer, data_length);
586 mutex_unlock(&applesmc_lock);
590 return snprintf(sysfsbuf, PAGE_SIZE, "(%d,%d)\n", left, right);
593 /* Displays degree Celsius * 1000 */
594 static ssize_t applesmc_show_temperature(struct device *dev,
595 struct device_attribute *devattr, char *sysfsbuf)
600 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
602 temperature_sensors_sets[applesmc_temperature_set][attr->index];
604 mutex_lock(&applesmc_lock);
606 ret = applesmc_read_key(key, buffer, 2);
607 temp = buffer[0]*1000;
608 temp += (buffer[1] >> 6) * 250;
610 mutex_unlock(&applesmc_lock);
615 return snprintf(sysfsbuf, PAGE_SIZE, "%u\n", temp);
618 static ssize_t applesmc_show_fan_speed(struct device *dev,
619 struct device_attribute *attr, char *sysfsbuf)
622 unsigned int speed = 0;
625 struct sensor_device_attribute_2 *sensor_attr =
626 to_sensor_dev_attr_2(attr);
628 newkey[0] = fan_speed_keys[sensor_attr->nr][0];
629 newkey[1] = '0' + sensor_attr->index;
630 newkey[2] = fan_speed_keys[sensor_attr->nr][2];
631 newkey[3] = fan_speed_keys[sensor_attr->nr][3];
634 mutex_lock(&applesmc_lock);
636 ret = applesmc_read_key(newkey, buffer, 2);
637 speed = ((buffer[0] << 8 | buffer[1]) >> 2);
639 mutex_unlock(&applesmc_lock);
643 return snprintf(sysfsbuf, PAGE_SIZE, "%u\n", speed);
646 static ssize_t applesmc_store_fan_speed(struct device *dev,
647 struct device_attribute *attr,
648 const char *sysfsbuf, size_t count)
654 struct sensor_device_attribute_2 *sensor_attr =
655 to_sensor_dev_attr_2(attr);
657 speed = simple_strtoul(sysfsbuf, NULL, 10);
659 if (speed > 0x4000) /* Bigger than a 14-bit value */
662 newkey[0] = fan_speed_keys[sensor_attr->nr][0];
663 newkey[1] = '0' + sensor_attr->index;
664 newkey[2] = fan_speed_keys[sensor_attr->nr][2];
665 newkey[3] = fan_speed_keys[sensor_attr->nr][3];
668 mutex_lock(&applesmc_lock);
670 buffer[0] = (speed >> 6) & 0xff;
671 buffer[1] = (speed << 2) & 0xff;
672 ret = applesmc_write_key(newkey, buffer, 2);
674 mutex_unlock(&applesmc_lock);
681 static ssize_t applesmc_show_fan_manual(struct device *dev,
682 struct device_attribute *devattr, char *sysfsbuf)
687 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
689 mutex_lock(&applesmc_lock);
691 ret = applesmc_read_key(FANS_MANUAL, buffer, 2);
692 manual = ((buffer[0] << 8 | buffer[1]) >> attr->index) & 0x01;
694 mutex_unlock(&applesmc_lock);
698 return snprintf(sysfsbuf, PAGE_SIZE, "%d\n", manual);
701 static ssize_t applesmc_store_fan_manual(struct device *dev,
702 struct device_attribute *devattr,
703 const char *sysfsbuf, size_t count)
709 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
711 input = simple_strtoul(sysfsbuf, NULL, 10);
713 mutex_lock(&applesmc_lock);
715 ret = applesmc_read_key(FANS_MANUAL, buffer, 2);
716 val = (buffer[0] << 8 | buffer[1]);
721 val = val | (0x01 << attr->index);
723 val = val & ~(0x01 << attr->index);
725 buffer[0] = (val >> 8) & 0xFF;
726 buffer[1] = val & 0xFF;
728 ret = applesmc_write_key(FANS_MANUAL, buffer, 2);
731 mutex_unlock(&applesmc_lock);
738 static ssize_t applesmc_show_fan_position(struct device *dev,
739 struct device_attribute *attr, char *sysfsbuf)
744 struct sensor_device_attribute_2 *sensor_attr =
745 to_sensor_dev_attr_2(attr);
747 newkey[0] = FAN_POSITION[0];
748 newkey[1] = '0' + sensor_attr->index;
749 newkey[2] = FAN_POSITION[2];
750 newkey[3] = FAN_POSITION[3];
753 mutex_lock(&applesmc_lock);
755 ret = applesmc_read_key(newkey, buffer, 16);
758 mutex_unlock(&applesmc_lock);
762 return snprintf(sysfsbuf, PAGE_SIZE, "%s\n", buffer+4);
765 static ssize_t applesmc_calibrate_show(struct device *dev,
766 struct device_attribute *attr, char *sysfsbuf)
768 return snprintf(sysfsbuf, PAGE_SIZE, "(%d,%d)\n", rest_x, rest_y);
771 static ssize_t applesmc_calibrate_store(struct device *dev,
772 struct device_attribute *attr, const char *sysfsbuf, size_t count)
774 mutex_lock(&applesmc_lock);
775 applesmc_calibrate();
776 mutex_unlock(&applesmc_lock);
781 /* Store the next backlight value to be written by the work */
782 static unsigned int backlight_value;
784 static void applesmc_backlight_set(struct work_struct *work)
788 mutex_lock(&applesmc_lock);
789 buffer[0] = backlight_value;
791 applesmc_write_key(BACKLIGHT_KEY, buffer, 2);
792 mutex_unlock(&applesmc_lock);
794 static DECLARE_WORK(backlight_work, &applesmc_backlight_set);
796 static void applesmc_brightness_set(struct led_classdev *led_cdev,
797 enum led_brightness value)
801 backlight_value = value;
802 ret = queue_work(applesmc_led_wq, &backlight_work);
805 printk(KERN_DEBUG "applesmc: work was already on the queue.\n");
808 static ssize_t applesmc_key_count_show(struct device *dev,
809 struct device_attribute *attr, char *sysfsbuf)
815 mutex_lock(&applesmc_lock);
817 ret = applesmc_read_key(KEY_COUNT_KEY, buffer, 4);
818 count = ((u32)buffer[0]<<24) + ((u32)buffer[1]<<16) +
819 ((u32)buffer[2]<<8) + buffer[3];
821 mutex_unlock(&applesmc_lock);
825 return snprintf(sysfsbuf, PAGE_SIZE, "%d\n", count);
828 static ssize_t applesmc_key_at_index_read_show(struct device *dev,
829 struct device_attribute *attr, char *sysfsbuf)
835 mutex_lock(&applesmc_lock);
837 ret = applesmc_get_key_at_index(key_at_index, key);
839 if (ret || !key[0]) {
840 mutex_unlock(&applesmc_lock);
845 ret = applesmc_get_key_type(key, info);
848 mutex_unlock(&applesmc_lock);
854 * info[0] maximum value (APPLESMC_MAX_DATA_LENGTH) is much lower than
855 * PAGE_SIZE, so we don't need any checks before writing to sysfsbuf.
857 ret = applesmc_read_key(key, sysfsbuf, info[0]);
859 mutex_unlock(&applesmc_lock);
868 static ssize_t applesmc_key_at_index_data_length_show(struct device *dev,
869 struct device_attribute *attr, char *sysfsbuf)
875 mutex_lock(&applesmc_lock);
877 ret = applesmc_get_key_at_index(key_at_index, key);
879 if (ret || !key[0]) {
880 mutex_unlock(&applesmc_lock);
885 ret = applesmc_get_key_type(key, info);
887 mutex_unlock(&applesmc_lock);
890 return snprintf(sysfsbuf, PAGE_SIZE, "%d\n", info[0]);
895 static ssize_t applesmc_key_at_index_type_show(struct device *dev,
896 struct device_attribute *attr, char *sysfsbuf)
902 mutex_lock(&applesmc_lock);
904 ret = applesmc_get_key_at_index(key_at_index, key);
906 if (ret || !key[0]) {
907 mutex_unlock(&applesmc_lock);
912 ret = applesmc_get_key_type(key, info);
914 mutex_unlock(&applesmc_lock);
917 return snprintf(sysfsbuf, PAGE_SIZE, "%s\n", info+1);
922 static ssize_t applesmc_key_at_index_name_show(struct device *dev,
923 struct device_attribute *attr, char *sysfsbuf)
928 mutex_lock(&applesmc_lock);
930 ret = applesmc_get_key_at_index(key_at_index, key);
932 mutex_unlock(&applesmc_lock);
935 return snprintf(sysfsbuf, PAGE_SIZE, "%s\n", key);
940 static ssize_t applesmc_key_at_index_show(struct device *dev,
941 struct device_attribute *attr, char *sysfsbuf)
943 return snprintf(sysfsbuf, PAGE_SIZE, "%d\n", key_at_index);
946 static ssize_t applesmc_key_at_index_store(struct device *dev,
947 struct device_attribute *attr, const char *sysfsbuf, size_t count)
949 mutex_lock(&applesmc_lock);
951 key_at_index = simple_strtoul(sysfsbuf, NULL, 10);
953 mutex_unlock(&applesmc_lock);
958 static struct led_classdev applesmc_backlight = {
959 .name = "smc::kbd_backlight",
960 .default_trigger = "nand-disk",
961 .brightness_set = applesmc_brightness_set,
964 static DEVICE_ATTR(name, 0444, applesmc_name_show, NULL);
966 static DEVICE_ATTR(position, 0444, applesmc_position_show, NULL);
967 static DEVICE_ATTR(calibrate, 0644,
968 applesmc_calibrate_show, applesmc_calibrate_store);
970 static struct attribute *accelerometer_attributes[] = {
971 &dev_attr_position.attr,
972 &dev_attr_calibrate.attr,
976 static const struct attribute_group accelerometer_attributes_group =
977 { .attrs = accelerometer_attributes };
979 static DEVICE_ATTR(light, 0444, applesmc_light_show, NULL);
981 static DEVICE_ATTR(key_count, 0444, applesmc_key_count_show, NULL);
982 static DEVICE_ATTR(key_at_index, 0644,
983 applesmc_key_at_index_show, applesmc_key_at_index_store);
984 static DEVICE_ATTR(key_at_index_name, 0444,
985 applesmc_key_at_index_name_show, NULL);
986 static DEVICE_ATTR(key_at_index_type, 0444,
987 applesmc_key_at_index_type_show, NULL);
988 static DEVICE_ATTR(key_at_index_data_length, 0444,
989 applesmc_key_at_index_data_length_show, NULL);
990 static DEVICE_ATTR(key_at_index_data, 0444,
991 applesmc_key_at_index_read_show, NULL);
993 static struct attribute *key_enumeration_attributes[] = {
994 &dev_attr_key_count.attr,
995 &dev_attr_key_at_index.attr,
996 &dev_attr_key_at_index_name.attr,
997 &dev_attr_key_at_index_type.attr,
998 &dev_attr_key_at_index_data_length.attr,
999 &dev_attr_key_at_index_data.attr,
1003 static const struct attribute_group key_enumeration_group =
1004 { .attrs = key_enumeration_attributes };
1007 * Macro defining SENSOR_DEVICE_ATTR for a fan sysfs entries.
1008 * - show actual speed
1009 * - show/store minimum speed
1010 * - show maximum speed
1012 * - show/store target speed
1013 * - show/store manual mode
1015 #define sysfs_fan_speeds_offset(offset) \
1016 static SENSOR_DEVICE_ATTR_2(fan##offset##_input, S_IRUGO, \
1017 applesmc_show_fan_speed, NULL, 0, offset-1); \
1019 static SENSOR_DEVICE_ATTR_2(fan##offset##_min, S_IRUGO | S_IWUSR, \
1020 applesmc_show_fan_speed, applesmc_store_fan_speed, 1, offset-1); \
1022 static SENSOR_DEVICE_ATTR_2(fan##offset##_max, S_IRUGO, \
1023 applesmc_show_fan_speed, NULL, 2, offset-1); \
1025 static SENSOR_DEVICE_ATTR_2(fan##offset##_safe, S_IRUGO, \
1026 applesmc_show_fan_speed, NULL, 3, offset-1); \
1028 static SENSOR_DEVICE_ATTR_2(fan##offset##_output, S_IRUGO | S_IWUSR, \
1029 applesmc_show_fan_speed, applesmc_store_fan_speed, 4, offset-1); \
1031 static SENSOR_DEVICE_ATTR(fan##offset##_manual, S_IRUGO | S_IWUSR, \
1032 applesmc_show_fan_manual, applesmc_store_fan_manual, offset-1); \
1034 static SENSOR_DEVICE_ATTR(fan##offset##_label, S_IRUGO, \
1035 applesmc_show_fan_position, NULL, offset-1); \
1037 static struct attribute *fan##offset##_attributes[] = { \
1038 &sensor_dev_attr_fan##offset##_input.dev_attr.attr, \
1039 &sensor_dev_attr_fan##offset##_min.dev_attr.attr, \
1040 &sensor_dev_attr_fan##offset##_max.dev_attr.attr, \
1041 &sensor_dev_attr_fan##offset##_safe.dev_attr.attr, \
1042 &sensor_dev_attr_fan##offset##_output.dev_attr.attr, \
1043 &sensor_dev_attr_fan##offset##_manual.dev_attr.attr, \
1044 &sensor_dev_attr_fan##offset##_label.dev_attr.attr, \
1049 * Create the needed functions for each fan using the macro defined above
1050 * (4 fans are supported)
1052 sysfs_fan_speeds_offset(1);
1053 sysfs_fan_speeds_offset(2);
1054 sysfs_fan_speeds_offset(3);
1055 sysfs_fan_speeds_offset(4);
1057 static const struct attribute_group fan_attribute_groups[] = {
1058 { .attrs = fan1_attributes },
1059 { .attrs = fan2_attributes },
1060 { .attrs = fan3_attributes },
1061 { .attrs = fan4_attributes },
1065 * Temperature sensors sysfs entries.
1067 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO,
1068 applesmc_show_temperature, NULL, 0);
1069 static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO,
1070 applesmc_show_temperature, NULL, 1);
1071 static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO,
1072 applesmc_show_temperature, NULL, 2);
1073 static SENSOR_DEVICE_ATTR(temp4_input, S_IRUGO,
1074 applesmc_show_temperature, NULL, 3);
1075 static SENSOR_DEVICE_ATTR(temp5_input, S_IRUGO,
1076 applesmc_show_temperature, NULL, 4);
1077 static SENSOR_DEVICE_ATTR(temp6_input, S_IRUGO,
1078 applesmc_show_temperature, NULL, 5);
1079 static SENSOR_DEVICE_ATTR(temp7_input, S_IRUGO,
1080 applesmc_show_temperature, NULL, 6);
1081 static SENSOR_DEVICE_ATTR(temp8_input, S_IRUGO,
1082 applesmc_show_temperature, NULL, 7);
1083 static SENSOR_DEVICE_ATTR(temp9_input, S_IRUGO,
1084 applesmc_show_temperature, NULL, 8);
1085 static SENSOR_DEVICE_ATTR(temp10_input, S_IRUGO,
1086 applesmc_show_temperature, NULL, 9);
1087 static SENSOR_DEVICE_ATTR(temp11_input, S_IRUGO,
1088 applesmc_show_temperature, NULL, 10);
1089 static SENSOR_DEVICE_ATTR(temp12_input, S_IRUGO,
1090 applesmc_show_temperature, NULL, 11);
1091 static SENSOR_DEVICE_ATTR(temp13_input, S_IRUGO,
1092 applesmc_show_temperature, NULL, 12);
1093 static SENSOR_DEVICE_ATTR(temp14_input, S_IRUGO,
1094 applesmc_show_temperature, NULL, 13);
1095 static SENSOR_DEVICE_ATTR(temp15_input, S_IRUGO,
1096 applesmc_show_temperature, NULL, 14);
1097 static SENSOR_DEVICE_ATTR(temp16_input, S_IRUGO,
1098 applesmc_show_temperature, NULL, 15);
1099 static SENSOR_DEVICE_ATTR(temp17_input, S_IRUGO,
1100 applesmc_show_temperature, NULL, 16);
1101 static SENSOR_DEVICE_ATTR(temp18_input, S_IRUGO,
1102 applesmc_show_temperature, NULL, 17);
1103 static SENSOR_DEVICE_ATTR(temp19_input, S_IRUGO,
1104 applesmc_show_temperature, NULL, 18);
1105 static SENSOR_DEVICE_ATTR(temp20_input, S_IRUGO,
1106 applesmc_show_temperature, NULL, 19);
1107 static SENSOR_DEVICE_ATTR(temp21_input, S_IRUGO,
1108 applesmc_show_temperature, NULL, 20);
1109 static SENSOR_DEVICE_ATTR(temp22_input, S_IRUGO,
1110 applesmc_show_temperature, NULL, 21);
1111 static SENSOR_DEVICE_ATTR(temp23_input, S_IRUGO,
1112 applesmc_show_temperature, NULL, 22);
1113 static SENSOR_DEVICE_ATTR(temp24_input, S_IRUGO,
1114 applesmc_show_temperature, NULL, 23);
1115 static SENSOR_DEVICE_ATTR(temp25_input, S_IRUGO,
1116 applesmc_show_temperature, NULL, 24);
1117 static SENSOR_DEVICE_ATTR(temp26_input, S_IRUGO,
1118 applesmc_show_temperature, NULL, 25);
1119 static SENSOR_DEVICE_ATTR(temp27_input, S_IRUGO,
1120 applesmc_show_temperature, NULL, 26);
1121 static SENSOR_DEVICE_ATTR(temp28_input, S_IRUGO,
1122 applesmc_show_temperature, NULL, 27);
1123 static SENSOR_DEVICE_ATTR(temp29_input, S_IRUGO,
1124 applesmc_show_temperature, NULL, 28);
1125 static SENSOR_DEVICE_ATTR(temp30_input, S_IRUGO,
1126 applesmc_show_temperature, NULL, 29);
1127 static SENSOR_DEVICE_ATTR(temp31_input, S_IRUGO,
1128 applesmc_show_temperature, NULL, 30);
1129 static SENSOR_DEVICE_ATTR(temp32_input, S_IRUGO,
1130 applesmc_show_temperature, NULL, 31);
1131 static SENSOR_DEVICE_ATTR(temp33_input, S_IRUGO,
1132 applesmc_show_temperature, NULL, 32);
1133 static SENSOR_DEVICE_ATTR(temp34_input, S_IRUGO,
1134 applesmc_show_temperature, NULL, 33);
1135 static SENSOR_DEVICE_ATTR(temp35_input, S_IRUGO,
1136 applesmc_show_temperature, NULL, 34);
1138 static struct attribute *temperature_attributes[] = {
1139 &sensor_dev_attr_temp1_input.dev_attr.attr,
1140 &sensor_dev_attr_temp2_input.dev_attr.attr,
1141 &sensor_dev_attr_temp3_input.dev_attr.attr,
1142 &sensor_dev_attr_temp4_input.dev_attr.attr,
1143 &sensor_dev_attr_temp5_input.dev_attr.attr,
1144 &sensor_dev_attr_temp6_input.dev_attr.attr,
1145 &sensor_dev_attr_temp7_input.dev_attr.attr,
1146 &sensor_dev_attr_temp8_input.dev_attr.attr,
1147 &sensor_dev_attr_temp9_input.dev_attr.attr,
1148 &sensor_dev_attr_temp10_input.dev_attr.attr,
1149 &sensor_dev_attr_temp11_input.dev_attr.attr,
1150 &sensor_dev_attr_temp12_input.dev_attr.attr,
1151 &sensor_dev_attr_temp13_input.dev_attr.attr,
1152 &sensor_dev_attr_temp14_input.dev_attr.attr,
1153 &sensor_dev_attr_temp15_input.dev_attr.attr,
1154 &sensor_dev_attr_temp16_input.dev_attr.attr,
1155 &sensor_dev_attr_temp17_input.dev_attr.attr,
1156 &sensor_dev_attr_temp18_input.dev_attr.attr,
1157 &sensor_dev_attr_temp19_input.dev_attr.attr,
1158 &sensor_dev_attr_temp20_input.dev_attr.attr,
1159 &sensor_dev_attr_temp21_input.dev_attr.attr,
1160 &sensor_dev_attr_temp22_input.dev_attr.attr,
1161 &sensor_dev_attr_temp23_input.dev_attr.attr,
1162 &sensor_dev_attr_temp24_input.dev_attr.attr,
1163 &sensor_dev_attr_temp25_input.dev_attr.attr,
1164 &sensor_dev_attr_temp26_input.dev_attr.attr,
1165 &sensor_dev_attr_temp27_input.dev_attr.attr,
1166 &sensor_dev_attr_temp28_input.dev_attr.attr,
1167 &sensor_dev_attr_temp29_input.dev_attr.attr,
1168 &sensor_dev_attr_temp30_input.dev_attr.attr,
1169 &sensor_dev_attr_temp31_input.dev_attr.attr,
1170 &sensor_dev_attr_temp32_input.dev_attr.attr,
1171 &sensor_dev_attr_temp33_input.dev_attr.attr,
1172 &sensor_dev_attr_temp34_input.dev_attr.attr,
1173 &sensor_dev_attr_temp35_input.dev_attr.attr,
1177 static const struct attribute_group temperature_attributes_group =
1178 { .attrs = temperature_attributes };
1183 * applesmc_dmi_match - found a match. return one, short-circuiting the hunt.
1185 static int applesmc_dmi_match(const struct dmi_system_id *id)
1188 struct dmi_match_data* dmi_data = id->driver_data;
1189 printk(KERN_INFO "applesmc: %s detected:\n", id->ident);
1190 applesmc_accelerometer = dmi_data->accelerometer;
1191 printk(KERN_INFO "applesmc: - Model %s accelerometer\n",
1192 applesmc_accelerometer ? "with" : "without");
1193 applesmc_light = dmi_data->light;
1194 printk(KERN_INFO "applesmc: - Model %s light sensors and backlight\n",
1195 applesmc_light ? "with" : "without");
1197 applesmc_temperature_set = dmi_data->temperature_set;
1198 while (temperature_sensors_sets[applesmc_temperature_set][i] != NULL)
1200 printk(KERN_INFO "applesmc: - Model with %d temperature sensors\n", i);
1204 /* Create accelerometer ressources */
1205 static int applesmc_create_accelerometer(void)
1207 struct input_dev *idev;
1210 ret = sysfs_create_group(&pdev->dev.kobj,
1211 &accelerometer_attributes_group);
1215 applesmc_idev = input_allocate_polled_device();
1216 if (!applesmc_idev) {
1221 applesmc_idev->poll = applesmc_idev_poll;
1222 applesmc_idev->poll_interval = APPLESMC_POLL_INTERVAL;
1224 /* initial calibrate for the input device */
1225 applesmc_calibrate();
1227 /* initialize the input device */
1228 idev = applesmc_idev->input;
1229 idev->name = "applesmc";
1230 idev->id.bustype = BUS_HOST;
1231 idev->dev.parent = &pdev->dev;
1232 idev->evbit[0] = BIT_MASK(EV_ABS);
1233 input_set_abs_params(idev, ABS_X,
1234 -256, 256, APPLESMC_INPUT_FUZZ, APPLESMC_INPUT_FLAT);
1235 input_set_abs_params(idev, ABS_Y,
1236 -256, 256, APPLESMC_INPUT_FUZZ, APPLESMC_INPUT_FLAT);
1238 ret = input_register_polled_device(applesmc_idev);
1245 input_free_polled_device(applesmc_idev);
1248 sysfs_remove_group(&pdev->dev.kobj, &accelerometer_attributes_group);
1251 printk(KERN_WARNING "applesmc: driver init failed (ret=%d)!\n", ret);
1255 /* Release all ressources used by the accelerometer */
1256 static void applesmc_release_accelerometer(void)
1258 input_unregister_polled_device(applesmc_idev);
1259 input_free_polled_device(applesmc_idev);
1260 sysfs_remove_group(&pdev->dev.kobj, &accelerometer_attributes_group);
1263 static __initdata struct dmi_match_data applesmc_dmi_data[] = {
1264 /* MacBook Pro: accelerometer, backlight and temperature set 0 */
1265 { .accelerometer = 1, .light = 1, .temperature_set = 0 },
1266 /* MacBook2: accelerometer and temperature set 1 */
1267 { .accelerometer = 1, .light = 0, .temperature_set = 1 },
1268 /* MacBook: accelerometer and temperature set 2 */
1269 { .accelerometer = 1, .light = 0, .temperature_set = 2 },
1270 /* MacMini: temperature set 3 */
1271 { .accelerometer = 0, .light = 0, .temperature_set = 3 },
1272 /* MacPro: temperature set 4 */
1273 { .accelerometer = 0, .light = 0, .temperature_set = 4 },
1274 /* iMac: temperature set 5 */
1275 { .accelerometer = 0, .light = 0, .temperature_set = 5 },
1276 /* MacBook3: accelerometer and temperature set 6 */
1277 { .accelerometer = 1, .light = 0, .temperature_set = 6 },
1278 /* MacBook Air: accelerometer, backlight and temperature set 7 */
1279 { .accelerometer = 1, .light = 1, .temperature_set = 7 },
1280 /* MacBook Pro 4: accelerometer, backlight and temperature set 8 */
1281 { .accelerometer = 1, .light = 1, .temperature_set = 8 },
1282 /* MacBook Pro 3: accelerometer, backlight and temperature set 9 */
1283 { .accelerometer = 1, .light = 1, .temperature_set = 9 },
1284 /* iMac 5: light sensor only, temperature set 10 */
1285 { .accelerometer = 0, .light = 0, .temperature_set = 10 },
1286 /* MacBook 5: accelerometer, backlight and temperature set 11 */
1287 { .accelerometer = 1, .light = 1, .temperature_set = 11 },
1290 /* Note that DMI_MATCH(...,"MacBook") will match "MacBookPro1,1".
1291 * So we need to put "Apple MacBook Pro" before "Apple MacBook". */
1292 static __initdata struct dmi_system_id applesmc_whitelist[] = {
1293 { applesmc_dmi_match, "Apple MacBook Air", {
1294 DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),
1295 DMI_MATCH(DMI_PRODUCT_NAME, "MacBookAir") },
1296 &applesmc_dmi_data[7]},
1297 { applesmc_dmi_match, "Apple MacBook Pro 4", {
1298 DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),
1299 DMI_MATCH(DMI_PRODUCT_NAME, "MacBookPro4") },
1300 &applesmc_dmi_data[8]},
1301 { applesmc_dmi_match, "Apple MacBook Pro 3", {
1302 DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),
1303 DMI_MATCH(DMI_PRODUCT_NAME, "MacBookPro3") },
1304 &applesmc_dmi_data[9]},
1305 { applesmc_dmi_match, "Apple MacBook Pro", {
1306 DMI_MATCH(DMI_BOARD_VENDOR,"Apple"),
1307 DMI_MATCH(DMI_PRODUCT_NAME,"MacBookPro") },
1308 &applesmc_dmi_data[0]},
1309 { applesmc_dmi_match, "Apple MacBook (v2)", {
1310 DMI_MATCH(DMI_BOARD_VENDOR,"Apple"),
1311 DMI_MATCH(DMI_PRODUCT_NAME,"MacBook2") },
1312 &applesmc_dmi_data[1]},
1313 { applesmc_dmi_match, "Apple MacBook (v3)", {
1314 DMI_MATCH(DMI_BOARD_VENDOR,"Apple"),
1315 DMI_MATCH(DMI_PRODUCT_NAME,"MacBook3") },
1316 &applesmc_dmi_data[6]},
1317 { applesmc_dmi_match, "Apple MacBook 5", {
1318 DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),
1319 DMI_MATCH(DMI_PRODUCT_NAME, "MacBook5") },
1320 &applesmc_dmi_data[11]},
1321 { applesmc_dmi_match, "Apple MacBook", {
1322 DMI_MATCH(DMI_BOARD_VENDOR,"Apple"),
1323 DMI_MATCH(DMI_PRODUCT_NAME,"MacBook") },
1324 &applesmc_dmi_data[2]},
1325 { applesmc_dmi_match, "Apple Macmini", {
1326 DMI_MATCH(DMI_BOARD_VENDOR,"Apple"),
1327 DMI_MATCH(DMI_PRODUCT_NAME,"Macmini") },
1328 &applesmc_dmi_data[3]},
1329 { applesmc_dmi_match, "Apple MacPro2", {
1330 DMI_MATCH(DMI_BOARD_VENDOR,"Apple"),
1331 DMI_MATCH(DMI_PRODUCT_NAME,"MacPro2") },
1332 &applesmc_dmi_data[4]},
1333 { applesmc_dmi_match, "Apple iMac 5", {
1334 DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),
1335 DMI_MATCH(DMI_PRODUCT_NAME, "iMac5") },
1336 &applesmc_dmi_data[10]},
1337 { applesmc_dmi_match, "Apple iMac", {
1338 DMI_MATCH(DMI_BOARD_VENDOR,"Apple"),
1339 DMI_MATCH(DMI_PRODUCT_NAME,"iMac") },
1340 &applesmc_dmi_data[5]},
1344 static int __init applesmc_init(void)
1350 if (!dmi_check_system(applesmc_whitelist)) {
1351 printk(KERN_WARNING "applesmc: supported laptop not found!\n");
1356 if (!request_region(APPLESMC_DATA_PORT, APPLESMC_NR_PORTS,
1362 ret = platform_driver_register(&applesmc_driver);
1366 pdev = platform_device_register_simple("applesmc", APPLESMC_DATA_PORT,
1369 ret = PTR_ERR(pdev);
1373 ret = sysfs_create_file(&pdev->dev.kobj, &dev_attr_name.attr);
1377 /* Create key enumeration sysfs files */
1378 ret = sysfs_create_group(&pdev->dev.kobj, &key_enumeration_group);
1382 /* create fan files */
1383 count = applesmc_get_fan_count();
1385 printk(KERN_ERR "applesmc: Cannot get the number of fans.\n");
1387 printk(KERN_INFO "applesmc: %d fans found.\n", count);
1391 printk(KERN_WARNING "applesmc: More than 4 fans found,"
1392 " but at most 4 fans are supported"
1393 " by the driver.\n");
1395 ret = sysfs_create_group(&pdev->dev.kobj,
1396 &fan_attribute_groups[3]);
1398 goto out_key_enumeration;
1400 ret = sysfs_create_group(&pdev->dev.kobj,
1401 &fan_attribute_groups[2]);
1403 goto out_key_enumeration;
1405 ret = sysfs_create_group(&pdev->dev.kobj,
1406 &fan_attribute_groups[1]);
1408 goto out_key_enumeration;
1410 ret = sysfs_create_group(&pdev->dev.kobj,
1411 &fan_attribute_groups[0]);
1420 temperature_sensors_sets[applesmc_temperature_set][i] != NULL;
1422 if (temperature_attributes[i] == NULL) {
1423 printk(KERN_ERR "applesmc: More temperature sensors "
1424 "in temperature_sensors_sets (at least %i)"
1425 "than available sysfs files in "
1426 "temperature_attributes (%i), please report "
1427 "this bug.\n", i, i-1);
1428 goto out_temperature;
1430 ret = sysfs_create_file(&pdev->dev.kobj,
1431 temperature_attributes[i]);
1433 goto out_temperature;
1436 if (applesmc_accelerometer) {
1437 ret = applesmc_create_accelerometer();
1439 goto out_temperature;
1442 if (applesmc_light) {
1443 /* Add light sensor file */
1444 ret = sysfs_create_file(&pdev->dev.kobj, &dev_attr_light.attr);
1446 goto out_accelerometer;
1448 /* Create the workqueue */
1449 applesmc_led_wq = create_singlethread_workqueue("applesmc-led");
1450 if (!applesmc_led_wq) {
1452 goto out_light_sysfs;
1455 /* register as a led device */
1456 ret = led_classdev_register(&pdev->dev, &applesmc_backlight);
1461 hwmon_dev = hwmon_device_register(&pdev->dev);
1462 if (IS_ERR(hwmon_dev)) {
1463 ret = PTR_ERR(hwmon_dev);
1464 goto out_light_ledclass;
1467 printk(KERN_INFO "applesmc: driver successfully loaded.\n");
1473 led_classdev_unregister(&applesmc_backlight);
1476 destroy_workqueue(applesmc_led_wq);
1479 sysfs_remove_file(&pdev->dev.kobj, &dev_attr_light.attr);
1481 if (applesmc_accelerometer)
1482 applesmc_release_accelerometer();
1484 sysfs_remove_group(&pdev->dev.kobj, &temperature_attributes_group);
1485 sysfs_remove_group(&pdev->dev.kobj, &fan_attribute_groups[0]);
1487 sysfs_remove_group(&pdev->dev.kobj, &fan_attribute_groups[1]);
1488 out_key_enumeration:
1489 sysfs_remove_group(&pdev->dev.kobj, &key_enumeration_group);
1491 sysfs_remove_file(&pdev->dev.kobj, &dev_attr_name.attr);
1493 platform_device_unregister(pdev);
1495 platform_driver_unregister(&applesmc_driver);
1497 release_region(APPLESMC_DATA_PORT, APPLESMC_NR_PORTS);
1499 printk(KERN_WARNING "applesmc: driver init failed (ret=%d)!\n", ret);
1503 static void __exit applesmc_exit(void)
1505 hwmon_device_unregister(hwmon_dev);
1506 if (applesmc_light) {
1507 led_classdev_unregister(&applesmc_backlight);
1508 destroy_workqueue(applesmc_led_wq);
1509 sysfs_remove_file(&pdev->dev.kobj, &dev_attr_light.attr);
1511 if (applesmc_accelerometer)
1512 applesmc_release_accelerometer();
1513 sysfs_remove_group(&pdev->dev.kobj, &temperature_attributes_group);
1514 sysfs_remove_group(&pdev->dev.kobj, &fan_attribute_groups[0]);
1515 sysfs_remove_group(&pdev->dev.kobj, &fan_attribute_groups[1]);
1516 sysfs_remove_group(&pdev->dev.kobj, &key_enumeration_group);
1517 sysfs_remove_file(&pdev->dev.kobj, &dev_attr_name.attr);
1518 platform_device_unregister(pdev);
1519 platform_driver_unregister(&applesmc_driver);
1520 release_region(APPLESMC_DATA_PORT, APPLESMC_NR_PORTS);
1522 printk(KERN_INFO "applesmc: driver unloaded.\n");
1525 module_init(applesmc_init);
1526 module_exit(applesmc_exit);
1528 MODULE_AUTHOR("Nicolas Boichat");
1529 MODULE_DESCRIPTION("Apple SMC");
1530 MODULE_LICENSE("GPL v2");