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>
7 * Copyright (C) 2010 Henrik Rydberg <rydberg@euromail.se>
9 * Based on hdaps.c driver:
10 * Copyright (C) 2005 Robert Love <rml@novell.com>
11 * Copyright (C) 2005 Jesper Juhl <jesper.juhl@gmail.com>
13 * Fan control based on smcFanControl:
14 * Copyright (C) 2006 Hendrik Holtmann <holtmann@mac.com>
16 * This program is free software; you can redistribute it and/or modify it
17 * under the terms of the GNU General Public License v2 as published by the
18 * Free Software Foundation.
20 * This program is distributed in the hope that it will be useful, but WITHOUT
21 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
22 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
25 * You should have received a copy of the GNU General Public License along with
26 * this program; if not, write to the Free Software Foundation, Inc.,
27 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
30 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
32 #include <linux/delay.h>
33 #include <linux/platform_device.h>
34 #include <linux/input-polldev.h>
35 #include <linux/kernel.h>
36 #include <linux/slab.h>
37 #include <linux/module.h>
38 #include <linux/timer.h>
39 #include <linux/dmi.h>
40 #include <linux/mutex.h>
41 #include <linux/hwmon-sysfs.h>
43 #include <linux/leds.h>
44 #include <linux/hwmon.h>
45 #include <linux/workqueue.h>
47 /* data port used by Apple SMC */
48 #define APPLESMC_DATA_PORT 0x300
49 /* command/status port used by Apple SMC */
50 #define APPLESMC_CMD_PORT 0x304
52 #define APPLESMC_NR_PORTS 32 /* 0x300-0x31f */
54 #define APPLESMC_MAX_DATA_LENGTH 32
56 /* wait up to 32 ms for a status change. */
57 #define APPLESMC_MIN_WAIT 0x0040
58 #define APPLESMC_MAX_WAIT 0x8000
60 #define APPLESMC_STATUS_MASK 0x0f
61 #define APPLESMC_READ_CMD 0x10
62 #define APPLESMC_WRITE_CMD 0x11
63 #define APPLESMC_GET_KEY_BY_INDEX_CMD 0x12
64 #define APPLESMC_GET_KEY_TYPE_CMD 0x13
66 #define KEY_COUNT_KEY "#KEY" /* r-o ui32 */
68 #define LIGHT_SENSOR_LEFT_KEY "ALV0" /* r-o {alv (6-10 bytes) */
69 #define LIGHT_SENSOR_RIGHT_KEY "ALV1" /* r-o {alv (6-10 bytes) */
70 #define BACKLIGHT_KEY "LKSB" /* w-o {lkb (2 bytes) */
72 #define CLAMSHELL_KEY "MSLD" /* r-o ui8 (unused) */
74 #define MOTION_SENSOR_X_KEY "MO_X" /* r-o sp78 (2 bytes) */
75 #define MOTION_SENSOR_Y_KEY "MO_Y" /* r-o sp78 (2 bytes) */
76 #define MOTION_SENSOR_Z_KEY "MO_Z" /* r-o sp78 (2 bytes) */
77 #define MOTION_SENSOR_KEY "MOCN" /* r/w ui16 */
79 #define FANS_COUNT "FNum" /* r-o ui8 */
80 #define FANS_MANUAL "FS! " /* r-w ui16 */
81 #define FAN_ID_FMT "F%dID" /* r-o char[16] */
83 /* List of keys used to read/write fan speeds */
84 static const char *const fan_speed_fmt
[] = {
85 "F%dAc", /* actual speed */
86 "F%dMn", /* minimum speed (rw) */
87 "F%dMx", /* maximum speed */
88 "F%dSf", /* safe speed - not all models */
89 "F%dTg", /* target speed (manual: rw) */
92 #define INIT_TIMEOUT_MSECS 5000 /* wait up to 5s for device init ... */
93 #define INIT_WAIT_MSECS 50 /* ... in 50ms increments */
95 #define APPLESMC_POLL_INTERVAL 50 /* msecs */
96 #define APPLESMC_INPUT_FUZZ 4 /* input event threshold */
97 #define APPLESMC_INPUT_FLAT 4
103 #define to_index(attr) (to_sensor_dev_attr(attr)->index & 0xffff)
104 #define to_option(attr) (to_sensor_dev_attr(attr)->index >> 16)
106 /* Dynamic device node attributes */
107 struct applesmc_dev_attr
{
108 struct sensor_device_attribute sda
; /* hwmon attributes */
109 char name
[32]; /* room for node file name */
112 /* Dynamic device node group */
113 struct applesmc_node_group
{
114 char *format
; /* format string */
115 void *show
; /* show function */
116 void *store
; /* store function */
117 int option
; /* function argument */
118 struct applesmc_dev_attr
*nodes
; /* dynamic node array */
121 /* AppleSMC entry - cached register information */
122 struct applesmc_entry
{
123 char key
[5]; /* four-letter key code */
124 u8 valid
; /* set when entry is successfully read once */
125 u8 len
; /* bounded by APPLESMC_MAX_DATA_LENGTH */
126 char type
[5]; /* four-letter type code */
127 u8 flags
; /* 0x10: func; 0x40: write; 0x80: read */
130 /* Register lookup and registers common to all SMCs */
131 static struct applesmc_registers
{
132 struct mutex mutex
; /* register read/write mutex */
133 unsigned int key_count
; /* number of SMC registers */
134 unsigned int fan_count
; /* number of fans */
135 unsigned int temp_count
; /* number of temperature registers */
136 unsigned int temp_begin
; /* temperature lower index bound */
137 unsigned int temp_end
; /* temperature upper index bound */
138 int num_light_sensors
; /* number of light sensors */
139 bool has_accelerometer
; /* has motion sensor */
140 bool has_key_backlight
; /* has keyboard backlight */
141 bool init_complete
; /* true when fully initialized */
142 struct applesmc_entry
*cache
; /* cached key entries */
144 .mutex
= __MUTEX_INITIALIZER(smcreg
.mutex
),
147 static const int debug
;
148 static struct platform_device
*pdev
;
151 static u8 backlight_state
[2];
153 static struct device
*hwmon_dev
;
154 static struct input_polled_dev
*applesmc_idev
;
157 * Last index written to key_at_index sysfs file, and value to use for all other
158 * key_at_index_* sysfs files.
160 static unsigned int key_at_index
;
162 static struct workqueue_struct
*applesmc_led_wq
;
165 * __wait_status - Wait up to 32ms for the status port to get a certain value
166 * (masked with 0x0f), returning zero if the value is obtained. Callers must
167 * hold applesmc_lock.
169 static int __wait_status(u8 val
)
173 val
= val
& APPLESMC_STATUS_MASK
;
175 for (us
= APPLESMC_MIN_WAIT
; us
< APPLESMC_MAX_WAIT
; us
<<= 1) {
177 if ((inb(APPLESMC_CMD_PORT
) & APPLESMC_STATUS_MASK
) == val
) {
186 * special treatment of command port - on newer macbooks, it seems necessary
187 * to resend the command byte before polling the status again. Callers must
188 * hold applesmc_lock.
190 static int send_command(u8 cmd
)
193 for (us
= APPLESMC_MIN_WAIT
; us
< APPLESMC_MAX_WAIT
; us
<<= 1) {
194 outb(cmd
, APPLESMC_CMD_PORT
);
196 if ((inb(APPLESMC_CMD_PORT
) & APPLESMC_STATUS_MASK
) == 0x0c)
202 static int send_argument(const char *key
)
206 for (i
= 0; i
< 4; i
++) {
207 outb(key
[i
], APPLESMC_DATA_PORT
);
208 if (__wait_status(0x04))
214 static int read_smc(u8 cmd
, const char *key
, u8
*buffer
, u8 len
)
218 if (send_command(cmd
) || send_argument(key
)) {
219 pr_warn("%s: read arg fail\n", key
);
223 outb(len
, APPLESMC_DATA_PORT
);
225 for (i
= 0; i
< len
; i
++) {
226 if (__wait_status(0x05)) {
227 pr_warn("%s: read data fail\n", key
);
230 buffer
[i
] = inb(APPLESMC_DATA_PORT
);
236 static int write_smc(u8 cmd
, const char *key
, const u8
*buffer
, u8 len
)
240 if (send_command(cmd
) || send_argument(key
)) {
241 pr_warn("%s: write arg fail\n", key
);
245 outb(len
, APPLESMC_DATA_PORT
);
247 for (i
= 0; i
< len
; i
++) {
248 if (__wait_status(0x04)) {
249 pr_warn("%s: write data fail\n", key
);
252 outb(buffer
[i
], APPLESMC_DATA_PORT
);
258 static int read_register_count(unsigned int *count
)
263 ret
= read_smc(APPLESMC_READ_CMD
, KEY_COUNT_KEY
, (u8
*)&be
, 4);
267 *count
= be32_to_cpu(be
);
274 * Returns zero on success or a negative error on failure.
275 * All functions below are concurrency safe - callers should NOT hold lock.
278 static int applesmc_read_entry(const struct applesmc_entry
*entry
,
283 if (entry
->len
!= len
)
285 mutex_lock(&smcreg
.mutex
);
286 ret
= read_smc(APPLESMC_READ_CMD
, entry
->key
, buf
, len
);
287 mutex_unlock(&smcreg
.mutex
);
292 static int applesmc_write_entry(const struct applesmc_entry
*entry
,
293 const u8
*buf
, u8 len
)
297 if (entry
->len
!= len
)
299 mutex_lock(&smcreg
.mutex
);
300 ret
= write_smc(APPLESMC_WRITE_CMD
, entry
->key
, buf
, len
);
301 mutex_unlock(&smcreg
.mutex
);
305 static const struct applesmc_entry
*applesmc_get_entry_by_index(int index
)
307 struct applesmc_entry
*cache
= &smcreg
.cache
[index
];
315 mutex_lock(&smcreg
.mutex
);
319 be
= cpu_to_be32(index
);
320 ret
= read_smc(APPLESMC_GET_KEY_BY_INDEX_CMD
, (u8
*)&be
, key
, 4);
323 ret
= read_smc(APPLESMC_GET_KEY_TYPE_CMD
, key
, info
, 6);
327 memcpy(cache
->key
, key
, 4);
328 cache
->len
= info
[0];
329 memcpy(cache
->type
, &info
[1], 4);
330 cache
->flags
= info
[5];
334 mutex_unlock(&smcreg
.mutex
);
340 static int applesmc_get_lower_bound(unsigned int *lo
, const char *key
)
342 int begin
= 0, end
= smcreg
.key_count
;
343 const struct applesmc_entry
*entry
;
345 while (begin
!= end
) {
346 int middle
= begin
+ (end
- begin
) / 2;
347 entry
= applesmc_get_entry_by_index(middle
);
349 return PTR_ERR(entry
);
350 if (strcmp(entry
->key
, key
) < 0)
360 static int applesmc_get_upper_bound(unsigned int *hi
, const char *key
)
362 int begin
= 0, end
= smcreg
.key_count
;
363 const struct applesmc_entry
*entry
;
365 while (begin
!= end
) {
366 int middle
= begin
+ (end
- begin
) / 2;
367 entry
= applesmc_get_entry_by_index(middle
);
369 return PTR_ERR(entry
);
370 if (strcmp(key
, entry
->key
) < 0)
380 static const struct applesmc_entry
*applesmc_get_entry_by_key(const char *key
)
385 ret
= applesmc_get_lower_bound(&begin
, key
);
388 ret
= applesmc_get_upper_bound(&end
, key
);
391 if (end
- begin
!= 1)
392 return ERR_PTR(-EINVAL
);
394 return applesmc_get_entry_by_index(begin
);
397 static int applesmc_read_key(const char *key
, u8
*buffer
, u8 len
)
399 const struct applesmc_entry
*entry
;
401 entry
= applesmc_get_entry_by_key(key
);
403 return PTR_ERR(entry
);
405 return applesmc_read_entry(entry
, buffer
, len
);
408 static int applesmc_write_key(const char *key
, const u8
*buffer
, u8 len
)
410 const struct applesmc_entry
*entry
;
412 entry
= applesmc_get_entry_by_key(key
);
414 return PTR_ERR(entry
);
416 return applesmc_write_entry(entry
, buffer
, len
);
419 static int applesmc_has_key(const char *key
, bool *value
)
421 const struct applesmc_entry
*entry
;
423 entry
= applesmc_get_entry_by_key(key
);
424 if (IS_ERR(entry
) && PTR_ERR(entry
) != -EINVAL
)
425 return PTR_ERR(entry
);
427 *value
= !IS_ERR(entry
);
432 * applesmc_read_motion_sensor - Read motion sensor (X, Y or Z).
434 static int applesmc_read_motion_sensor(int index
, s16
* value
)
441 ret
= applesmc_read_key(MOTION_SENSOR_X_KEY
, buffer
, 2);
444 ret
= applesmc_read_key(MOTION_SENSOR_Y_KEY
, buffer
, 2);
447 ret
= applesmc_read_key(MOTION_SENSOR_Z_KEY
, buffer
, 2);
453 *value
= ((s16
)buffer
[0] << 8) | buffer
[1];
459 * applesmc_device_init - initialize the accelerometer. Can sleep.
461 static void applesmc_device_init(void)
466 if (!smcreg
.has_accelerometer
)
469 for (total
= INIT_TIMEOUT_MSECS
; total
> 0; total
-= INIT_WAIT_MSECS
) {
470 if (!applesmc_read_key(MOTION_SENSOR_KEY
, buffer
, 2) &&
471 (buffer
[0] != 0x00 || buffer
[1] != 0x00))
475 applesmc_write_key(MOTION_SENSOR_KEY
, buffer
, 2);
476 msleep(INIT_WAIT_MSECS
);
479 pr_warn("failed to init the device\n");
483 * applesmc_init_smcreg_try - Try to initialize register cache. Idempotent.
485 static int applesmc_init_smcreg_try(void)
487 struct applesmc_registers
*s
= &smcreg
;
488 bool left_light_sensor
, right_light_sensor
;
492 if (s
->init_complete
)
495 ret
= read_register_count(&s
->key_count
);
500 s
->cache
= kcalloc(s
->key_count
, sizeof(*s
->cache
), GFP_KERNEL
);
504 ret
= applesmc_read_key(FANS_COUNT
, tmp
, 1);
507 s
->fan_count
= tmp
[0];
509 ret
= applesmc_get_lower_bound(&s
->temp_begin
, "T");
512 ret
= applesmc_get_lower_bound(&s
->temp_end
, "U");
515 s
->temp_count
= s
->temp_end
- s
->temp_begin
;
517 ret
= applesmc_has_key(LIGHT_SENSOR_LEFT_KEY
, &left_light_sensor
);
520 ret
= applesmc_has_key(LIGHT_SENSOR_RIGHT_KEY
, &right_light_sensor
);
523 ret
= applesmc_has_key(MOTION_SENSOR_KEY
, &s
->has_accelerometer
);
526 ret
= applesmc_has_key(BACKLIGHT_KEY
, &s
->has_key_backlight
);
530 s
->num_light_sensors
= left_light_sensor
+ right_light_sensor
;
531 s
->init_complete
= true;
533 pr_info("key=%d fan=%d temp=%d acc=%d lux=%d kbd=%d\n",
534 s
->key_count
, s
->fan_count
, s
->temp_count
,
535 s
->has_accelerometer
,
536 s
->num_light_sensors
,
537 s
->has_key_backlight
);
543 * applesmc_init_smcreg - Initialize register cache.
545 * Retries until initialization is successful, or the operation times out.
548 static int applesmc_init_smcreg(void)
552 for (ms
= 0; ms
< INIT_TIMEOUT_MSECS
; ms
+= INIT_WAIT_MSECS
) {
553 ret
= applesmc_init_smcreg_try();
556 pr_info("init_smcreg() took %d ms\n", ms
);
559 msleep(INIT_WAIT_MSECS
);
568 static void applesmc_destroy_smcreg(void)
572 smcreg
.init_complete
= false;
575 /* Device model stuff */
576 static int applesmc_probe(struct platform_device
*dev
)
580 ret
= applesmc_init_smcreg();
584 applesmc_device_init();
589 /* Synchronize device with memorized backlight state */
590 static int applesmc_pm_resume(struct device
*dev
)
592 if (smcreg
.has_key_backlight
)
593 applesmc_write_key(BACKLIGHT_KEY
, backlight_state
, 2);
597 /* Reinitialize device on resume from hibernation */
598 static int applesmc_pm_restore(struct device
*dev
)
600 applesmc_device_init();
601 return applesmc_pm_resume(dev
);
604 static const struct dev_pm_ops applesmc_pm_ops
= {
605 .resume
= applesmc_pm_resume
,
606 .restore
= applesmc_pm_restore
,
609 static struct platform_driver applesmc_driver
= {
610 .probe
= applesmc_probe
,
613 .owner
= THIS_MODULE
,
614 .pm
= &applesmc_pm_ops
,
619 * applesmc_calibrate - Set our "resting" values. Callers must
620 * hold applesmc_lock.
622 static void applesmc_calibrate(void)
624 applesmc_read_motion_sensor(SENSOR_X
, &rest_x
);
625 applesmc_read_motion_sensor(SENSOR_Y
, &rest_y
);
629 static void applesmc_idev_poll(struct input_polled_dev
*dev
)
631 struct input_dev
*idev
= dev
->input
;
634 if (applesmc_read_motion_sensor(SENSOR_X
, &x
))
636 if (applesmc_read_motion_sensor(SENSOR_Y
, &y
))
640 input_report_abs(idev
, ABS_X
, x
- rest_x
);
641 input_report_abs(idev
, ABS_Y
, y
- rest_y
);
647 static ssize_t
applesmc_name_show(struct device
*dev
,
648 struct device_attribute
*attr
, char *buf
)
650 return snprintf(buf
, PAGE_SIZE
, "applesmc\n");
653 static ssize_t
applesmc_position_show(struct device
*dev
,
654 struct device_attribute
*attr
, char *buf
)
659 ret
= applesmc_read_motion_sensor(SENSOR_X
, &x
);
662 ret
= applesmc_read_motion_sensor(SENSOR_Y
, &y
);
665 ret
= applesmc_read_motion_sensor(SENSOR_Z
, &z
);
673 return snprintf(buf
, PAGE_SIZE
, "(%d,%d,%d)\n", x
, y
, z
);
676 static ssize_t
applesmc_light_show(struct device
*dev
,
677 struct device_attribute
*attr
, char *sysfsbuf
)
679 const struct applesmc_entry
*entry
;
680 static int data_length
;
682 u8 left
= 0, right
= 0;
686 entry
= applesmc_get_entry_by_key(LIGHT_SENSOR_LEFT_KEY
);
688 return PTR_ERR(entry
);
691 data_length
= entry
->len
;
692 pr_info("light sensor data length set to %d\n", data_length
);
695 ret
= applesmc_read_key(LIGHT_SENSOR_LEFT_KEY
, buffer
, data_length
);
696 /* newer macbooks report a single 10-bit bigendian value */
697 if (data_length
== 10) {
698 left
= be16_to_cpu(*(__be16
*)(buffer
+ 6)) >> 2;
704 ret
= applesmc_read_key(LIGHT_SENSOR_RIGHT_KEY
, buffer
, data_length
);
711 return snprintf(sysfsbuf
, PAGE_SIZE
, "(%d,%d)\n", left
, right
);
714 /* Displays sensor key as label */
715 static ssize_t
applesmc_show_sensor_label(struct device
*dev
,
716 struct device_attribute
*devattr
, char *sysfsbuf
)
718 int index
= smcreg
.temp_begin
+ to_index(devattr
);
719 const struct applesmc_entry
*entry
;
721 entry
= applesmc_get_entry_by_index(index
);
723 return PTR_ERR(entry
);
725 return snprintf(sysfsbuf
, PAGE_SIZE
, "%s\n", entry
->key
);
728 /* Displays degree Celsius * 1000 */
729 static ssize_t
applesmc_show_temperature(struct device
*dev
,
730 struct device_attribute
*devattr
, char *sysfsbuf
)
732 int index
= smcreg
.temp_begin
+ to_index(devattr
);
733 const struct applesmc_entry
*entry
;
738 entry
= applesmc_get_entry_by_index(index
);
740 return PTR_ERR(entry
);
744 ret
= applesmc_read_entry(entry
, buffer
, entry
->len
);
748 if (entry
->len
== 2) {
749 temp
= buffer
[0] * 1000;
750 temp
+= (buffer
[1] >> 6) * 250;
752 temp
= buffer
[0] * 4000;
755 return snprintf(sysfsbuf
, PAGE_SIZE
, "%u\n", temp
);
758 static ssize_t
applesmc_show_fan_speed(struct device
*dev
,
759 struct device_attribute
*attr
, char *sysfsbuf
)
762 unsigned int speed
= 0;
766 sprintf(newkey
, fan_speed_fmt
[to_option(attr
)], to_index(attr
));
768 ret
= applesmc_read_key(newkey
, buffer
, 2);
769 speed
= ((buffer
[0] << 8 | buffer
[1]) >> 2);
774 return snprintf(sysfsbuf
, PAGE_SIZE
, "%u\n", speed
);
777 static ssize_t
applesmc_store_fan_speed(struct device
*dev
,
778 struct device_attribute
*attr
,
779 const char *sysfsbuf
, size_t count
)
786 speed
= simple_strtoul(sysfsbuf
, NULL
, 10);
788 if (speed
> 0x4000) /* Bigger than a 14-bit value */
791 sprintf(newkey
, fan_speed_fmt
[to_option(attr
)], to_index(attr
));
793 buffer
[0] = (speed
>> 6) & 0xff;
794 buffer
[1] = (speed
<< 2) & 0xff;
795 ret
= applesmc_write_key(newkey
, buffer
, 2);
803 static ssize_t
applesmc_show_fan_manual(struct device
*dev
,
804 struct device_attribute
*attr
, char *sysfsbuf
)
810 ret
= applesmc_read_key(FANS_MANUAL
, buffer
, 2);
811 manual
= ((buffer
[0] << 8 | buffer
[1]) >> to_index(attr
)) & 0x01;
816 return snprintf(sysfsbuf
, PAGE_SIZE
, "%d\n", manual
);
819 static ssize_t
applesmc_store_fan_manual(struct device
*dev
,
820 struct device_attribute
*attr
,
821 const char *sysfsbuf
, size_t count
)
828 input
= simple_strtoul(sysfsbuf
, NULL
, 10);
830 ret
= applesmc_read_key(FANS_MANUAL
, buffer
, 2);
831 val
= (buffer
[0] << 8 | buffer
[1]);
836 val
= val
| (0x01 << to_index(attr
));
838 val
= val
& ~(0x01 << to_index(attr
));
840 buffer
[0] = (val
>> 8) & 0xFF;
841 buffer
[1] = val
& 0xFF;
843 ret
= applesmc_write_key(FANS_MANUAL
, buffer
, 2);
852 static ssize_t
applesmc_show_fan_position(struct device
*dev
,
853 struct device_attribute
*attr
, char *sysfsbuf
)
859 sprintf(newkey
, FAN_ID_FMT
, to_index(attr
));
861 ret
= applesmc_read_key(newkey
, buffer
, 16);
867 return snprintf(sysfsbuf
, PAGE_SIZE
, "%s\n", buffer
+4);
870 static ssize_t
applesmc_calibrate_show(struct device
*dev
,
871 struct device_attribute
*attr
, char *sysfsbuf
)
873 return snprintf(sysfsbuf
, PAGE_SIZE
, "(%d,%d)\n", rest_x
, rest_y
);
876 static ssize_t
applesmc_calibrate_store(struct device
*dev
,
877 struct device_attribute
*attr
, const char *sysfsbuf
, size_t count
)
879 applesmc_calibrate();
884 static void applesmc_backlight_set(struct work_struct
*work
)
886 applesmc_write_key(BACKLIGHT_KEY
, backlight_state
, 2);
888 static DECLARE_WORK(backlight_work
, &applesmc_backlight_set
);
890 static void applesmc_brightness_set(struct led_classdev
*led_cdev
,
891 enum led_brightness value
)
895 backlight_state
[0] = value
;
896 ret
= queue_work(applesmc_led_wq
, &backlight_work
);
899 printk(KERN_DEBUG
"applesmc: work was already on the queue.\n");
902 static ssize_t
applesmc_key_count_show(struct device
*dev
,
903 struct device_attribute
*attr
, char *sysfsbuf
)
909 ret
= applesmc_read_key(KEY_COUNT_KEY
, buffer
, 4);
910 count
= ((u32
)buffer
[0]<<24) + ((u32
)buffer
[1]<<16) +
911 ((u32
)buffer
[2]<<8) + buffer
[3];
916 return snprintf(sysfsbuf
, PAGE_SIZE
, "%d\n", count
);
919 static ssize_t
applesmc_key_at_index_read_show(struct device
*dev
,
920 struct device_attribute
*attr
, char *sysfsbuf
)
922 const struct applesmc_entry
*entry
;
925 entry
= applesmc_get_entry_by_index(key_at_index
);
927 return PTR_ERR(entry
);
928 ret
= applesmc_read_entry(entry
, sysfsbuf
, entry
->len
);
935 static ssize_t
applesmc_key_at_index_data_length_show(struct device
*dev
,
936 struct device_attribute
*attr
, char *sysfsbuf
)
938 const struct applesmc_entry
*entry
;
940 entry
= applesmc_get_entry_by_index(key_at_index
);
942 return PTR_ERR(entry
);
944 return snprintf(sysfsbuf
, PAGE_SIZE
, "%d\n", entry
->len
);
947 static ssize_t
applesmc_key_at_index_type_show(struct device
*dev
,
948 struct device_attribute
*attr
, char *sysfsbuf
)
950 const struct applesmc_entry
*entry
;
952 entry
= applesmc_get_entry_by_index(key_at_index
);
954 return PTR_ERR(entry
);
956 return snprintf(sysfsbuf
, PAGE_SIZE
, "%s\n", entry
->type
);
959 static ssize_t
applesmc_key_at_index_name_show(struct device
*dev
,
960 struct device_attribute
*attr
, char *sysfsbuf
)
962 const struct applesmc_entry
*entry
;
964 entry
= applesmc_get_entry_by_index(key_at_index
);
966 return PTR_ERR(entry
);
968 return snprintf(sysfsbuf
, PAGE_SIZE
, "%s\n", entry
->key
);
971 static ssize_t
applesmc_key_at_index_show(struct device
*dev
,
972 struct device_attribute
*attr
, char *sysfsbuf
)
974 return snprintf(sysfsbuf
, PAGE_SIZE
, "%d\n", key_at_index
);
977 static ssize_t
applesmc_key_at_index_store(struct device
*dev
,
978 struct device_attribute
*attr
, const char *sysfsbuf
, size_t count
)
980 unsigned long newkey
;
982 if (strict_strtoul(sysfsbuf
, 10, &newkey
) < 0
983 || newkey
>= smcreg
.key_count
)
986 key_at_index
= newkey
;
990 static struct led_classdev applesmc_backlight
= {
991 .name
= "smc::kbd_backlight",
992 .default_trigger
= "nand-disk",
993 .brightness_set
= applesmc_brightness_set
,
996 static struct applesmc_node_group info_group
[] = {
997 { "name", applesmc_name_show
},
998 { "key_count", applesmc_key_count_show
},
999 { "key_at_index", applesmc_key_at_index_show
, applesmc_key_at_index_store
},
1000 { "key_at_index_name", applesmc_key_at_index_name_show
},
1001 { "key_at_index_type", applesmc_key_at_index_type_show
},
1002 { "key_at_index_data_length", applesmc_key_at_index_data_length_show
},
1003 { "key_at_index_data", applesmc_key_at_index_read_show
},
1007 static struct applesmc_node_group accelerometer_group
[] = {
1008 { "position", applesmc_position_show
},
1009 { "calibrate", applesmc_calibrate_show
, applesmc_calibrate_store
},
1013 static struct applesmc_node_group light_sensor_group
[] = {
1014 { "light", applesmc_light_show
},
1018 static struct applesmc_node_group fan_group
[] = {
1019 { "fan%d_label", applesmc_show_fan_position
},
1020 { "fan%d_input", applesmc_show_fan_speed
, NULL
, 0 },
1021 { "fan%d_min", applesmc_show_fan_speed
, applesmc_store_fan_speed
, 1 },
1022 { "fan%d_max", applesmc_show_fan_speed
, NULL
, 2 },
1023 { "fan%d_safe", applesmc_show_fan_speed
, NULL
, 3 },
1024 { "fan%d_output", applesmc_show_fan_speed
, applesmc_store_fan_speed
, 4 },
1025 { "fan%d_manual", applesmc_show_fan_manual
, applesmc_store_fan_manual
},
1029 static struct applesmc_node_group temp_group
[] = {
1030 { "temp%d_label", applesmc_show_sensor_label
},
1031 { "temp%d_input", applesmc_show_temperature
},
1038 * applesmc_destroy_nodes - remove files and free associated memory
1040 static void applesmc_destroy_nodes(struct applesmc_node_group
*groups
)
1042 struct applesmc_node_group
*grp
;
1043 struct applesmc_dev_attr
*node
;
1045 for (grp
= groups
; grp
->nodes
; grp
++) {
1046 for (node
= grp
->nodes
; node
->sda
.dev_attr
.attr
.name
; node
++)
1047 sysfs_remove_file(&pdev
->dev
.kobj
,
1048 &node
->sda
.dev_attr
.attr
);
1055 * applesmc_create_nodes - create a two-dimensional group of sysfs files
1057 static int applesmc_create_nodes(struct applesmc_node_group
*groups
, int num
)
1059 struct applesmc_node_group
*grp
;
1060 struct applesmc_dev_attr
*node
;
1061 struct attribute
*attr
;
1064 for (grp
= groups
; grp
->format
; grp
++) {
1065 grp
->nodes
= kcalloc(num
+ 1, sizeof(*node
), GFP_KERNEL
);
1070 for (i
= 0; i
< num
; i
++) {
1071 node
= &grp
->nodes
[i
];
1072 sprintf(node
->name
, grp
->format
, i
+ 1);
1073 node
->sda
.index
= (grp
->option
<< 16) | (i
& 0xffff);
1074 node
->sda
.dev_attr
.show
= grp
->show
;
1075 node
->sda
.dev_attr
.store
= grp
->store
;
1076 attr
= &node
->sda
.dev_attr
.attr
;
1077 attr
->name
= node
->name
;
1078 attr
->mode
= S_IRUGO
| (grp
->store
? S_IWUSR
: 0);
1079 ret
= sysfs_create_file(&pdev
->dev
.kobj
, attr
);
1089 applesmc_destroy_nodes(groups
);
1093 /* Create accelerometer ressources */
1094 static int applesmc_create_accelerometer(void)
1096 struct input_dev
*idev
;
1099 if (!smcreg
.has_accelerometer
)
1102 ret
= applesmc_create_nodes(accelerometer_group
, 1);
1106 applesmc_idev
= input_allocate_polled_device();
1107 if (!applesmc_idev
) {
1112 applesmc_idev
->poll
= applesmc_idev_poll
;
1113 applesmc_idev
->poll_interval
= APPLESMC_POLL_INTERVAL
;
1115 /* initial calibrate for the input device */
1116 applesmc_calibrate();
1118 /* initialize the input device */
1119 idev
= applesmc_idev
->input
;
1120 idev
->name
= "applesmc";
1121 idev
->id
.bustype
= BUS_HOST
;
1122 idev
->dev
.parent
= &pdev
->dev
;
1123 idev
->evbit
[0] = BIT_MASK(EV_ABS
);
1124 input_set_abs_params(idev
, ABS_X
,
1125 -256, 256, APPLESMC_INPUT_FUZZ
, APPLESMC_INPUT_FLAT
);
1126 input_set_abs_params(idev
, ABS_Y
,
1127 -256, 256, APPLESMC_INPUT_FUZZ
, APPLESMC_INPUT_FLAT
);
1129 ret
= input_register_polled_device(applesmc_idev
);
1136 input_free_polled_device(applesmc_idev
);
1139 applesmc_destroy_nodes(accelerometer_group
);
1142 pr_warn("driver init failed (ret=%d)!\n", ret
);
1146 /* Release all ressources used by the accelerometer */
1147 static void applesmc_release_accelerometer(void)
1149 if (!smcreg
.has_accelerometer
)
1151 input_unregister_polled_device(applesmc_idev
);
1152 input_free_polled_device(applesmc_idev
);
1153 applesmc_destroy_nodes(accelerometer_group
);
1156 static int applesmc_create_light_sensor(void)
1158 if (!smcreg
.num_light_sensors
)
1160 return applesmc_create_nodes(light_sensor_group
, 1);
1163 static void applesmc_release_light_sensor(void)
1165 if (!smcreg
.num_light_sensors
)
1167 applesmc_destroy_nodes(light_sensor_group
);
1170 static int applesmc_create_key_backlight(void)
1172 if (!smcreg
.has_key_backlight
)
1174 applesmc_led_wq
= create_singlethread_workqueue("applesmc-led");
1175 if (!applesmc_led_wq
)
1177 return led_classdev_register(&pdev
->dev
, &applesmc_backlight
);
1180 static void applesmc_release_key_backlight(void)
1182 if (!smcreg
.has_key_backlight
)
1184 led_classdev_unregister(&applesmc_backlight
);
1185 destroy_workqueue(applesmc_led_wq
);
1188 static int applesmc_dmi_match(const struct dmi_system_id
*id
)
1193 /* Note that DMI_MATCH(...,"MacBook") will match "MacBookPro1,1".
1194 * So we need to put "Apple MacBook Pro" before "Apple MacBook". */
1195 static __initdata
struct dmi_system_id applesmc_whitelist
[] = {
1196 { applesmc_dmi_match
, "Apple MacBook Air", {
1197 DMI_MATCH(DMI_BOARD_VENDOR
, "Apple"),
1198 DMI_MATCH(DMI_PRODUCT_NAME
, "MacBookAir") },
1200 { applesmc_dmi_match
, "Apple MacBook Pro", {
1201 DMI_MATCH(DMI_BOARD_VENDOR
,"Apple"),
1202 DMI_MATCH(DMI_PRODUCT_NAME
,"MacBookPro") },
1204 { applesmc_dmi_match
, "Apple MacBook", {
1205 DMI_MATCH(DMI_BOARD_VENDOR
,"Apple"),
1206 DMI_MATCH(DMI_PRODUCT_NAME
,"MacBook") },
1208 { applesmc_dmi_match
, "Apple Macmini", {
1209 DMI_MATCH(DMI_BOARD_VENDOR
,"Apple"),
1210 DMI_MATCH(DMI_PRODUCT_NAME
,"Macmini") },
1212 { applesmc_dmi_match
, "Apple MacPro", {
1213 DMI_MATCH(DMI_BOARD_VENDOR
, "Apple"),
1214 DMI_MATCH(DMI_PRODUCT_NAME
, "MacPro") },
1216 { applesmc_dmi_match
, "Apple iMac", {
1217 DMI_MATCH(DMI_BOARD_VENDOR
,"Apple"),
1218 DMI_MATCH(DMI_PRODUCT_NAME
,"iMac") },
1223 static int __init
applesmc_init(void)
1227 if (!dmi_check_system(applesmc_whitelist
)) {
1228 pr_warn("supported laptop not found!\n");
1233 if (!request_region(APPLESMC_DATA_PORT
, APPLESMC_NR_PORTS
,
1239 ret
= platform_driver_register(&applesmc_driver
);
1243 pdev
= platform_device_register_simple("applesmc", APPLESMC_DATA_PORT
,
1246 ret
= PTR_ERR(pdev
);
1250 /* create register cache */
1251 ret
= applesmc_init_smcreg();
1255 ret
= applesmc_create_nodes(info_group
, 1);
1259 ret
= applesmc_create_nodes(fan_group
, smcreg
.fan_count
);
1263 ret
= applesmc_create_nodes(temp_group
, smcreg
.temp_count
);
1267 ret
= applesmc_create_accelerometer();
1269 goto out_temperature
;
1271 ret
= applesmc_create_light_sensor();
1273 goto out_accelerometer
;
1275 ret
= applesmc_create_key_backlight();
1277 goto out_light_sysfs
;
1279 hwmon_dev
= hwmon_device_register(&pdev
->dev
);
1280 if (IS_ERR(hwmon_dev
)) {
1281 ret
= PTR_ERR(hwmon_dev
);
1282 goto out_light_ledclass
;
1288 applesmc_release_key_backlight();
1290 applesmc_release_light_sensor();
1292 applesmc_release_accelerometer();
1294 applesmc_destroy_nodes(temp_group
);
1296 applesmc_destroy_nodes(fan_group
);
1298 applesmc_destroy_nodes(info_group
);
1300 applesmc_destroy_smcreg();
1302 platform_device_unregister(pdev
);
1304 platform_driver_unregister(&applesmc_driver
);
1306 release_region(APPLESMC_DATA_PORT
, APPLESMC_NR_PORTS
);
1308 pr_warn("driver init failed (ret=%d)!\n", ret
);
1312 static void __exit
applesmc_exit(void)
1314 hwmon_device_unregister(hwmon_dev
);
1315 applesmc_release_key_backlight();
1316 applesmc_release_light_sensor();
1317 applesmc_release_accelerometer();
1318 applesmc_destroy_nodes(temp_group
);
1319 applesmc_destroy_nodes(fan_group
);
1320 applesmc_destroy_nodes(info_group
);
1321 applesmc_destroy_smcreg();
1322 platform_device_unregister(pdev
);
1323 platform_driver_unregister(&applesmc_driver
);
1324 release_region(APPLESMC_DATA_PORT
, APPLESMC_NR_PORTS
);
1327 module_init(applesmc_init
);
1328 module_exit(applesmc_exit
);
1330 MODULE_AUTHOR("Nicolas Boichat");
1331 MODULE_DESCRIPTION("Apple SMC");
1332 MODULE_LICENSE("GPL v2");
1333 MODULE_DEVICE_TABLE(dmi
, applesmc_whitelist
);