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 <jj@chaosbits.net>
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>
46 #include <linux/err.h>
48 /* data port used by Apple SMC */
49 #define APPLESMC_DATA_PORT 0x300
50 /* command/status port used by Apple SMC */
51 #define APPLESMC_CMD_PORT 0x304
53 #define APPLESMC_NR_PORTS 32 /* 0x300-0x31f */
55 #define APPLESMC_MAX_DATA_LENGTH 32
57 /* wait up to 128 ms for a status change. */
58 #define APPLESMC_MIN_WAIT 0x0010
59 #define APPLESMC_RETRY_WAIT 0x0100
60 #define APPLESMC_MAX_WAIT 0x20000
62 #define APPLESMC_READ_CMD 0x10
63 #define APPLESMC_WRITE_CMD 0x11
64 #define APPLESMC_GET_KEY_BY_INDEX_CMD 0x12
65 #define APPLESMC_GET_KEY_TYPE_CMD 0x13
67 #define KEY_COUNT_KEY "#KEY" /* r-o ui32 */
69 #define LIGHT_SENSOR_LEFT_KEY "ALV0" /* r-o {alv (6-10 bytes) */
70 #define LIGHT_SENSOR_RIGHT_KEY "ALV1" /* r-o {alv (6-10 bytes) */
71 #define BACKLIGHT_KEY "LKSB" /* w-o {lkb (2 bytes) */
73 #define CLAMSHELL_KEY "MSLD" /* r-o ui8 (unused) */
75 #define MOTION_SENSOR_X_KEY "MO_X" /* r-o sp78 (2 bytes) */
76 #define MOTION_SENSOR_Y_KEY "MO_Y" /* r-o sp78 (2 bytes) */
77 #define MOTION_SENSOR_Z_KEY "MO_Z" /* r-o sp78 (2 bytes) */
78 #define MOTION_SENSOR_KEY "MOCN" /* r/w ui16 */
80 #define FANS_COUNT "FNum" /* r-o ui8 */
81 #define FANS_MANUAL "FS! " /* r-w ui16 */
82 #define FAN_ID_FMT "F%dID" /* r-o char[16] */
84 #define TEMP_SENSOR_TYPE "sp78"
86 /* List of keys used to read/write fan speeds */
87 static const char *const fan_speed_fmt
[] = {
88 "F%dAc", /* actual speed */
89 "F%dMn", /* minimum speed (rw) */
90 "F%dMx", /* maximum speed */
91 "F%dSf", /* safe speed - not all models */
92 "F%dTg", /* target speed (manual: rw) */
95 #define INIT_TIMEOUT_MSECS 5000 /* wait up to 5s for device init ... */
96 #define INIT_WAIT_MSECS 50 /* ... in 50ms increments */
98 #define APPLESMC_POLL_INTERVAL 50 /* msecs */
99 #define APPLESMC_INPUT_FUZZ 4 /* input event threshold */
100 #define APPLESMC_INPUT_FLAT 4
102 #define to_index(attr) (to_sensor_dev_attr(attr)->index & 0xffff)
103 #define to_option(attr) (to_sensor_dev_attr(attr)->index >> 16)
105 /* Dynamic device node attributes */
106 struct applesmc_dev_attr
{
107 struct sensor_device_attribute sda
; /* hwmon attributes */
108 char name
[32]; /* room for node file name */
111 /* Dynamic device node group */
112 struct applesmc_node_group
{
113 char *format
; /* format string */
114 void *show
; /* show function */
115 void *store
; /* store function */
116 int option
; /* function argument */
117 struct applesmc_dev_attr
*nodes
; /* dynamic node array */
120 /* AppleSMC entry - cached register information */
121 struct applesmc_entry
{
122 char key
[5]; /* four-letter key code */
123 u8 valid
; /* set when entry is successfully read once */
124 u8 len
; /* bounded by APPLESMC_MAX_DATA_LENGTH */
125 char type
[5]; /* four-letter type code */
126 u8 flags
; /* 0x10: func; 0x40: write; 0x80: read */
129 /* Register lookup and registers common to all SMCs */
130 static struct applesmc_registers
{
131 struct mutex mutex
; /* register read/write mutex */
132 unsigned int key_count
; /* number of SMC registers */
133 unsigned int fan_count
; /* number of fans */
134 unsigned int temp_count
; /* number of temperature registers */
135 unsigned int temp_begin
; /* temperature lower index bound */
136 unsigned int temp_end
; /* temperature upper index bound */
137 unsigned int index_count
; /* size of temperature index array */
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 */
143 const char **index
; /* temperature key index */
145 .mutex
= __MUTEX_INITIALIZER(smcreg
.mutex
),
148 static const int debug
;
149 static struct platform_device
*pdev
;
152 static u8 backlight_state
[2];
154 static struct device
*hwmon_dev
;
155 static struct input_polled_dev
*applesmc_idev
;
158 * Last index written to key_at_index sysfs file, and value to use for all other
159 * key_at_index_* sysfs files.
161 static unsigned int key_at_index
;
163 static struct workqueue_struct
*applesmc_led_wq
;
166 * wait_read - Wait for a byte to appear on SMC port. Callers must
167 * hold applesmc_lock.
169 static int wait_read(void)
173 for (us
= APPLESMC_MIN_WAIT
; us
< APPLESMC_MAX_WAIT
; us
<<= 1) {
175 status
= inb(APPLESMC_CMD_PORT
);
176 /* read: wait for smc to settle */
181 pr_warn("wait_read() fail: 0x%02x\n", status
);
186 * send_byte - Write to SMC port, retrying when necessary. Callers
187 * must hold applesmc_lock.
189 static int send_byte(u8 cmd
, u16 port
)
195 for (us
= APPLESMC_MIN_WAIT
; us
< APPLESMC_MAX_WAIT
; us
<<= 1) {
197 status
= inb(APPLESMC_CMD_PORT
);
198 /* write: wait for smc to settle */
201 /* ready: cmd accepted, return */
204 /* timeout: give up */
205 if (us
<< 1 == APPLESMC_MAX_WAIT
)
207 /* busy: long wait and resend */
208 udelay(APPLESMC_RETRY_WAIT
);
212 pr_warn("send_byte(0x%02x, 0x%04x) fail: 0x%02x\n", cmd
, port
, status
);
216 static int send_command(u8 cmd
)
218 return send_byte(cmd
, APPLESMC_CMD_PORT
);
221 static int send_argument(const char *key
)
225 for (i
= 0; i
< 4; i
++)
226 if (send_byte(key
[i
], APPLESMC_DATA_PORT
))
231 static int read_smc(u8 cmd
, const char *key
, u8
*buffer
, u8 len
)
235 if (send_command(cmd
) || send_argument(key
)) {
236 pr_warn("%.4s: read arg fail\n", key
);
240 if (send_byte(len
, APPLESMC_DATA_PORT
)) {
241 pr_warn("%.4s: read len fail\n", key
);
245 for (i
= 0; i
< len
; i
++) {
247 pr_warn("%.4s: read data[%d] fail\n", key
, i
);
250 buffer
[i
] = inb(APPLESMC_DATA_PORT
);
256 static int write_smc(u8 cmd
, const char *key
, const u8
*buffer
, u8 len
)
260 if (send_command(cmd
) || send_argument(key
)) {
261 pr_warn("%s: write arg fail\n", key
);
265 if (send_byte(len
, APPLESMC_DATA_PORT
)) {
266 pr_warn("%.4s: write len fail\n", key
);
270 for (i
= 0; i
< len
; i
++) {
271 if (send_byte(buffer
[i
], APPLESMC_DATA_PORT
)) {
272 pr_warn("%s: write data fail\n", key
);
280 static int read_register_count(unsigned int *count
)
285 ret
= read_smc(APPLESMC_READ_CMD
, KEY_COUNT_KEY
, (u8
*)&be
, 4);
289 *count
= be32_to_cpu(be
);
296 * Returns zero on success or a negative error on failure.
297 * All functions below are concurrency safe - callers should NOT hold lock.
300 static int applesmc_read_entry(const struct applesmc_entry
*entry
,
305 if (entry
->len
!= len
)
307 mutex_lock(&smcreg
.mutex
);
308 ret
= read_smc(APPLESMC_READ_CMD
, entry
->key
, buf
, len
);
309 mutex_unlock(&smcreg
.mutex
);
314 static int applesmc_write_entry(const struct applesmc_entry
*entry
,
315 const u8
*buf
, u8 len
)
319 if (entry
->len
!= len
)
321 mutex_lock(&smcreg
.mutex
);
322 ret
= write_smc(APPLESMC_WRITE_CMD
, entry
->key
, buf
, len
);
323 mutex_unlock(&smcreg
.mutex
);
327 static const struct applesmc_entry
*applesmc_get_entry_by_index(int index
)
329 struct applesmc_entry
*cache
= &smcreg
.cache
[index
];
337 mutex_lock(&smcreg
.mutex
);
341 be
= cpu_to_be32(index
);
342 ret
= read_smc(APPLESMC_GET_KEY_BY_INDEX_CMD
, (u8
*)&be
, key
, 4);
345 ret
= read_smc(APPLESMC_GET_KEY_TYPE_CMD
, key
, info
, 6);
349 memcpy(cache
->key
, key
, 4);
350 cache
->len
= info
[0];
351 memcpy(cache
->type
, &info
[1], 4);
352 cache
->flags
= info
[5];
356 mutex_unlock(&smcreg
.mutex
);
362 static int applesmc_get_lower_bound(unsigned int *lo
, const char *key
)
364 int begin
= 0, end
= smcreg
.key_count
;
365 const struct applesmc_entry
*entry
;
367 while (begin
!= end
) {
368 int middle
= begin
+ (end
- begin
) / 2;
369 entry
= applesmc_get_entry_by_index(middle
);
372 return PTR_ERR(entry
);
374 if (strcmp(entry
->key
, key
) < 0)
384 static int applesmc_get_upper_bound(unsigned int *hi
, const char *key
)
386 int begin
= 0, end
= smcreg
.key_count
;
387 const struct applesmc_entry
*entry
;
389 while (begin
!= end
) {
390 int middle
= begin
+ (end
- begin
) / 2;
391 entry
= applesmc_get_entry_by_index(middle
);
393 *hi
= smcreg
.key_count
;
394 return PTR_ERR(entry
);
396 if (strcmp(key
, entry
->key
) < 0)
406 static const struct applesmc_entry
*applesmc_get_entry_by_key(const char *key
)
411 ret
= applesmc_get_lower_bound(&begin
, key
);
414 ret
= applesmc_get_upper_bound(&end
, key
);
417 if (end
- begin
!= 1)
418 return ERR_PTR(-EINVAL
);
420 return applesmc_get_entry_by_index(begin
);
423 static int applesmc_read_key(const char *key
, u8
*buffer
, u8 len
)
425 const struct applesmc_entry
*entry
;
427 entry
= applesmc_get_entry_by_key(key
);
429 return PTR_ERR(entry
);
431 return applesmc_read_entry(entry
, buffer
, len
);
434 static int applesmc_write_key(const char *key
, const u8
*buffer
, u8 len
)
436 const struct applesmc_entry
*entry
;
438 entry
= applesmc_get_entry_by_key(key
);
440 return PTR_ERR(entry
);
442 return applesmc_write_entry(entry
, buffer
, len
);
445 static int applesmc_has_key(const char *key
, bool *value
)
447 const struct applesmc_entry
*entry
;
449 entry
= applesmc_get_entry_by_key(key
);
450 if (IS_ERR(entry
) && PTR_ERR(entry
) != -EINVAL
)
451 return PTR_ERR(entry
);
453 *value
= !IS_ERR(entry
);
458 * applesmc_read_s16 - Read 16-bit signed big endian register
460 static int applesmc_read_s16(const char *key
, s16
*value
)
465 ret
= applesmc_read_key(key
, buffer
, 2);
469 *value
= ((s16
)buffer
[0] << 8) | buffer
[1];
474 * applesmc_device_init - initialize the accelerometer. Can sleep.
476 static void applesmc_device_init(void)
481 if (!smcreg
.has_accelerometer
)
484 for (total
= INIT_TIMEOUT_MSECS
; total
> 0; total
-= INIT_WAIT_MSECS
) {
485 if (!applesmc_read_key(MOTION_SENSOR_KEY
, buffer
, 2) &&
486 (buffer
[0] != 0x00 || buffer
[1] != 0x00))
490 applesmc_write_key(MOTION_SENSOR_KEY
, buffer
, 2);
491 msleep(INIT_WAIT_MSECS
);
494 pr_warn("failed to init the device\n");
497 static int applesmc_init_index(struct applesmc_registers
*s
)
499 const struct applesmc_entry
*entry
;
505 s
->index
= kcalloc(s
->temp_count
, sizeof(s
->index
[0]), GFP_KERNEL
);
509 for (i
= s
->temp_begin
; i
< s
->temp_end
; i
++) {
510 entry
= applesmc_get_entry_by_index(i
);
513 if (strcmp(entry
->type
, TEMP_SENSOR_TYPE
))
515 s
->index
[s
->index_count
++] = entry
->key
;
522 * applesmc_init_smcreg_try - Try to initialize register cache. Idempotent.
524 static int applesmc_init_smcreg_try(void)
526 struct applesmc_registers
*s
= &smcreg
;
527 bool left_light_sensor
, right_light_sensor
;
532 if (s
->init_complete
)
535 ret
= read_register_count(&count
);
539 if (s
->cache
&& s
->key_count
!= count
) {
540 pr_warn("key count changed from %d to %d\n",
541 s
->key_count
, count
);
545 s
->key_count
= count
;
548 s
->cache
= kcalloc(s
->key_count
, sizeof(*s
->cache
), GFP_KERNEL
);
552 ret
= applesmc_read_key(FANS_COUNT
, tmp
, 1);
555 s
->fan_count
= tmp
[0];
557 ret
= applesmc_get_lower_bound(&s
->temp_begin
, "T");
560 ret
= applesmc_get_lower_bound(&s
->temp_end
, "U");
563 s
->temp_count
= s
->temp_end
- s
->temp_begin
;
565 ret
= applesmc_init_index(s
);
569 ret
= applesmc_has_key(LIGHT_SENSOR_LEFT_KEY
, &left_light_sensor
);
572 ret
= applesmc_has_key(LIGHT_SENSOR_RIGHT_KEY
, &right_light_sensor
);
575 ret
= applesmc_has_key(MOTION_SENSOR_KEY
, &s
->has_accelerometer
);
578 ret
= applesmc_has_key(BACKLIGHT_KEY
, &s
->has_key_backlight
);
582 s
->num_light_sensors
= left_light_sensor
+ right_light_sensor
;
583 s
->init_complete
= true;
585 pr_info("key=%d fan=%d temp=%d index=%d acc=%d lux=%d kbd=%d\n",
586 s
->key_count
, s
->fan_count
, s
->temp_count
, s
->index_count
,
587 s
->has_accelerometer
,
588 s
->num_light_sensors
,
589 s
->has_key_backlight
);
594 static void applesmc_destroy_smcreg(void)
600 smcreg
.init_complete
= false;
604 * applesmc_init_smcreg - Initialize register cache.
606 * Retries until initialization is successful, or the operation times out.
609 static int applesmc_init_smcreg(void)
613 for (ms
= 0; ms
< INIT_TIMEOUT_MSECS
; ms
+= INIT_WAIT_MSECS
) {
614 ret
= applesmc_init_smcreg_try();
617 pr_info("init_smcreg() took %d ms\n", ms
);
620 msleep(INIT_WAIT_MSECS
);
623 applesmc_destroy_smcreg();
628 /* Device model stuff */
629 static int applesmc_probe(struct platform_device
*dev
)
633 ret
= applesmc_init_smcreg();
637 applesmc_device_init();
642 /* Synchronize device with memorized backlight state */
643 static int applesmc_pm_resume(struct device
*dev
)
645 if (smcreg
.has_key_backlight
)
646 applesmc_write_key(BACKLIGHT_KEY
, backlight_state
, 2);
650 /* Reinitialize device on resume from hibernation */
651 static int applesmc_pm_restore(struct device
*dev
)
653 applesmc_device_init();
654 return applesmc_pm_resume(dev
);
657 static const struct dev_pm_ops applesmc_pm_ops
= {
658 .resume
= applesmc_pm_resume
,
659 .restore
= applesmc_pm_restore
,
662 static struct platform_driver applesmc_driver
= {
663 .probe
= applesmc_probe
,
666 .owner
= THIS_MODULE
,
667 .pm
= &applesmc_pm_ops
,
672 * applesmc_calibrate - Set our "resting" values. Callers must
673 * hold applesmc_lock.
675 static void applesmc_calibrate(void)
677 applesmc_read_s16(MOTION_SENSOR_X_KEY
, &rest_x
);
678 applesmc_read_s16(MOTION_SENSOR_Y_KEY
, &rest_y
);
682 static void applesmc_idev_poll(struct input_polled_dev
*dev
)
684 struct input_dev
*idev
= dev
->input
;
687 if (applesmc_read_s16(MOTION_SENSOR_X_KEY
, &x
))
689 if (applesmc_read_s16(MOTION_SENSOR_Y_KEY
, &y
))
693 input_report_abs(idev
, ABS_X
, x
- rest_x
);
694 input_report_abs(idev
, ABS_Y
, y
- rest_y
);
700 static ssize_t
applesmc_name_show(struct device
*dev
,
701 struct device_attribute
*attr
, char *buf
)
703 return snprintf(buf
, PAGE_SIZE
, "applesmc\n");
706 static ssize_t
applesmc_position_show(struct device
*dev
,
707 struct device_attribute
*attr
, char *buf
)
712 ret
= applesmc_read_s16(MOTION_SENSOR_X_KEY
, &x
);
715 ret
= applesmc_read_s16(MOTION_SENSOR_Y_KEY
, &y
);
718 ret
= applesmc_read_s16(MOTION_SENSOR_Z_KEY
, &z
);
726 return snprintf(buf
, PAGE_SIZE
, "(%d,%d,%d)\n", x
, y
, z
);
729 static ssize_t
applesmc_light_show(struct device
*dev
,
730 struct device_attribute
*attr
, char *sysfsbuf
)
732 const struct applesmc_entry
*entry
;
733 static int data_length
;
735 u8 left
= 0, right
= 0;
739 entry
= applesmc_get_entry_by_key(LIGHT_SENSOR_LEFT_KEY
);
741 return PTR_ERR(entry
);
744 data_length
= entry
->len
;
745 pr_info("light sensor data length set to %d\n", data_length
);
748 ret
= applesmc_read_key(LIGHT_SENSOR_LEFT_KEY
, buffer
, data_length
);
749 /* newer macbooks report a single 10-bit bigendian value */
750 if (data_length
== 10) {
751 left
= be16_to_cpu(*(__be16
*)(buffer
+ 6)) >> 2;
757 ret
= applesmc_read_key(LIGHT_SENSOR_RIGHT_KEY
, buffer
, data_length
);
764 return snprintf(sysfsbuf
, PAGE_SIZE
, "(%d,%d)\n", left
, right
);
767 /* Displays sensor key as label */
768 static ssize_t
applesmc_show_sensor_label(struct device
*dev
,
769 struct device_attribute
*devattr
, char *sysfsbuf
)
771 const char *key
= smcreg
.index
[to_index(devattr
)];
773 return snprintf(sysfsbuf
, PAGE_SIZE
, "%s\n", key
);
776 /* Displays degree Celsius * 1000 */
777 static ssize_t
applesmc_show_temperature(struct device
*dev
,
778 struct device_attribute
*devattr
, char *sysfsbuf
)
780 const char *key
= smcreg
.index
[to_index(devattr
)];
785 ret
= applesmc_read_s16(key
, &value
);
789 temp
= 250 * (value
>> 6);
791 return snprintf(sysfsbuf
, PAGE_SIZE
, "%d\n", temp
);
794 static ssize_t
applesmc_show_fan_speed(struct device
*dev
,
795 struct device_attribute
*attr
, char *sysfsbuf
)
798 unsigned int speed
= 0;
802 sprintf(newkey
, fan_speed_fmt
[to_option(attr
)], to_index(attr
));
804 ret
= applesmc_read_key(newkey
, buffer
, 2);
805 speed
= ((buffer
[0] << 8 | buffer
[1]) >> 2);
810 return snprintf(sysfsbuf
, PAGE_SIZE
, "%u\n", speed
);
813 static ssize_t
applesmc_store_fan_speed(struct device
*dev
,
814 struct device_attribute
*attr
,
815 const char *sysfsbuf
, size_t count
)
822 if (kstrtoul(sysfsbuf
, 10, &speed
) < 0 || speed
>= 0x4000)
823 return -EINVAL
; /* Bigger than a 14-bit value */
825 sprintf(newkey
, fan_speed_fmt
[to_option(attr
)], to_index(attr
));
827 buffer
[0] = (speed
>> 6) & 0xff;
828 buffer
[1] = (speed
<< 2) & 0xff;
829 ret
= applesmc_write_key(newkey
, buffer
, 2);
837 static ssize_t
applesmc_show_fan_manual(struct device
*dev
,
838 struct device_attribute
*attr
, char *sysfsbuf
)
844 ret
= applesmc_read_key(FANS_MANUAL
, buffer
, 2);
845 manual
= ((buffer
[0] << 8 | buffer
[1]) >> to_index(attr
)) & 0x01;
850 return snprintf(sysfsbuf
, PAGE_SIZE
, "%d\n", manual
);
853 static ssize_t
applesmc_store_fan_manual(struct device
*dev
,
854 struct device_attribute
*attr
,
855 const char *sysfsbuf
, size_t count
)
862 if (kstrtoul(sysfsbuf
, 10, &input
) < 0)
865 ret
= applesmc_read_key(FANS_MANUAL
, buffer
, 2);
866 val
= (buffer
[0] << 8 | buffer
[1]);
871 val
= val
| (0x01 << to_index(attr
));
873 val
= val
& ~(0x01 << to_index(attr
));
875 buffer
[0] = (val
>> 8) & 0xFF;
876 buffer
[1] = val
& 0xFF;
878 ret
= applesmc_write_key(FANS_MANUAL
, buffer
, 2);
887 static ssize_t
applesmc_show_fan_position(struct device
*dev
,
888 struct device_attribute
*attr
, char *sysfsbuf
)
894 sprintf(newkey
, FAN_ID_FMT
, to_index(attr
));
896 ret
= applesmc_read_key(newkey
, buffer
, 16);
902 return snprintf(sysfsbuf
, PAGE_SIZE
, "%s\n", buffer
+4);
905 static ssize_t
applesmc_calibrate_show(struct device
*dev
,
906 struct device_attribute
*attr
, char *sysfsbuf
)
908 return snprintf(sysfsbuf
, PAGE_SIZE
, "(%d,%d)\n", rest_x
, rest_y
);
911 static ssize_t
applesmc_calibrate_store(struct device
*dev
,
912 struct device_attribute
*attr
, const char *sysfsbuf
, size_t count
)
914 applesmc_calibrate();
919 static void applesmc_backlight_set(struct work_struct
*work
)
921 applesmc_write_key(BACKLIGHT_KEY
, backlight_state
, 2);
923 static DECLARE_WORK(backlight_work
, &applesmc_backlight_set
);
925 static void applesmc_brightness_set(struct led_classdev
*led_cdev
,
926 enum led_brightness value
)
930 backlight_state
[0] = value
;
931 ret
= queue_work(applesmc_led_wq
, &backlight_work
);
934 dev_dbg(led_cdev
->dev
, "work was already on the queue.\n");
937 static ssize_t
applesmc_key_count_show(struct device
*dev
,
938 struct device_attribute
*attr
, char *sysfsbuf
)
944 ret
= applesmc_read_key(KEY_COUNT_KEY
, buffer
, 4);
945 count
= ((u32
)buffer
[0]<<24) + ((u32
)buffer
[1]<<16) +
946 ((u32
)buffer
[2]<<8) + buffer
[3];
951 return snprintf(sysfsbuf
, PAGE_SIZE
, "%d\n", count
);
954 static ssize_t
applesmc_key_at_index_read_show(struct device
*dev
,
955 struct device_attribute
*attr
, char *sysfsbuf
)
957 const struct applesmc_entry
*entry
;
960 entry
= applesmc_get_entry_by_index(key_at_index
);
962 return PTR_ERR(entry
);
963 ret
= applesmc_read_entry(entry
, sysfsbuf
, entry
->len
);
970 static ssize_t
applesmc_key_at_index_data_length_show(struct device
*dev
,
971 struct device_attribute
*attr
, char *sysfsbuf
)
973 const struct applesmc_entry
*entry
;
975 entry
= applesmc_get_entry_by_index(key_at_index
);
977 return PTR_ERR(entry
);
979 return snprintf(sysfsbuf
, PAGE_SIZE
, "%d\n", entry
->len
);
982 static ssize_t
applesmc_key_at_index_type_show(struct device
*dev
,
983 struct device_attribute
*attr
, char *sysfsbuf
)
985 const struct applesmc_entry
*entry
;
987 entry
= applesmc_get_entry_by_index(key_at_index
);
989 return PTR_ERR(entry
);
991 return snprintf(sysfsbuf
, PAGE_SIZE
, "%s\n", entry
->type
);
994 static ssize_t
applesmc_key_at_index_name_show(struct device
*dev
,
995 struct device_attribute
*attr
, char *sysfsbuf
)
997 const struct applesmc_entry
*entry
;
999 entry
= applesmc_get_entry_by_index(key_at_index
);
1001 return PTR_ERR(entry
);
1003 return snprintf(sysfsbuf
, PAGE_SIZE
, "%s\n", entry
->key
);
1006 static ssize_t
applesmc_key_at_index_show(struct device
*dev
,
1007 struct device_attribute
*attr
, char *sysfsbuf
)
1009 return snprintf(sysfsbuf
, PAGE_SIZE
, "%d\n", key_at_index
);
1012 static ssize_t
applesmc_key_at_index_store(struct device
*dev
,
1013 struct device_attribute
*attr
, const char *sysfsbuf
, size_t count
)
1015 unsigned long newkey
;
1017 if (kstrtoul(sysfsbuf
, 10, &newkey
) < 0
1018 || newkey
>= smcreg
.key_count
)
1021 key_at_index
= newkey
;
1025 static struct led_classdev applesmc_backlight
= {
1026 .name
= "smc::kbd_backlight",
1027 .default_trigger
= "nand-disk",
1028 .brightness_set
= applesmc_brightness_set
,
1031 static struct applesmc_node_group info_group
[] = {
1032 { "name", applesmc_name_show
},
1033 { "key_count", applesmc_key_count_show
},
1034 { "key_at_index", applesmc_key_at_index_show
, applesmc_key_at_index_store
},
1035 { "key_at_index_name", applesmc_key_at_index_name_show
},
1036 { "key_at_index_type", applesmc_key_at_index_type_show
},
1037 { "key_at_index_data_length", applesmc_key_at_index_data_length_show
},
1038 { "key_at_index_data", applesmc_key_at_index_read_show
},
1042 static struct applesmc_node_group accelerometer_group
[] = {
1043 { "position", applesmc_position_show
},
1044 { "calibrate", applesmc_calibrate_show
, applesmc_calibrate_store
},
1048 static struct applesmc_node_group light_sensor_group
[] = {
1049 { "light", applesmc_light_show
},
1053 static struct applesmc_node_group fan_group
[] = {
1054 { "fan%d_label", applesmc_show_fan_position
},
1055 { "fan%d_input", applesmc_show_fan_speed
, NULL
, 0 },
1056 { "fan%d_min", applesmc_show_fan_speed
, applesmc_store_fan_speed
, 1 },
1057 { "fan%d_max", applesmc_show_fan_speed
, NULL
, 2 },
1058 { "fan%d_safe", applesmc_show_fan_speed
, NULL
, 3 },
1059 { "fan%d_output", applesmc_show_fan_speed
, applesmc_store_fan_speed
, 4 },
1060 { "fan%d_manual", applesmc_show_fan_manual
, applesmc_store_fan_manual
},
1064 static struct applesmc_node_group temp_group
[] = {
1065 { "temp%d_label", applesmc_show_sensor_label
},
1066 { "temp%d_input", applesmc_show_temperature
},
1073 * applesmc_destroy_nodes - remove files and free associated memory
1075 static void applesmc_destroy_nodes(struct applesmc_node_group
*groups
)
1077 struct applesmc_node_group
*grp
;
1078 struct applesmc_dev_attr
*node
;
1080 for (grp
= groups
; grp
->nodes
; grp
++) {
1081 for (node
= grp
->nodes
; node
->sda
.dev_attr
.attr
.name
; node
++)
1082 sysfs_remove_file(&pdev
->dev
.kobj
,
1083 &node
->sda
.dev_attr
.attr
);
1090 * applesmc_create_nodes - create a two-dimensional group of sysfs files
1092 static int applesmc_create_nodes(struct applesmc_node_group
*groups
, int num
)
1094 struct applesmc_node_group
*grp
;
1095 struct applesmc_dev_attr
*node
;
1096 struct attribute
*attr
;
1099 for (grp
= groups
; grp
->format
; grp
++) {
1100 grp
->nodes
= kcalloc(num
+ 1, sizeof(*node
), GFP_KERNEL
);
1105 for (i
= 0; i
< num
; i
++) {
1106 node
= &grp
->nodes
[i
];
1107 sprintf(node
->name
, grp
->format
, i
+ 1);
1108 node
->sda
.index
= (grp
->option
<< 16) | (i
& 0xffff);
1109 node
->sda
.dev_attr
.show
= grp
->show
;
1110 node
->sda
.dev_attr
.store
= grp
->store
;
1111 attr
= &node
->sda
.dev_attr
.attr
;
1112 sysfs_attr_init(attr
);
1113 attr
->name
= node
->name
;
1114 attr
->mode
= S_IRUGO
| (grp
->store
? S_IWUSR
: 0);
1115 ret
= sysfs_create_file(&pdev
->dev
.kobj
, attr
);
1125 applesmc_destroy_nodes(groups
);
1129 /* Create accelerometer ressources */
1130 static int applesmc_create_accelerometer(void)
1132 struct input_dev
*idev
;
1135 if (!smcreg
.has_accelerometer
)
1138 ret
= applesmc_create_nodes(accelerometer_group
, 1);
1142 applesmc_idev
= input_allocate_polled_device();
1143 if (!applesmc_idev
) {
1148 applesmc_idev
->poll
= applesmc_idev_poll
;
1149 applesmc_idev
->poll_interval
= APPLESMC_POLL_INTERVAL
;
1151 /* initial calibrate for the input device */
1152 applesmc_calibrate();
1154 /* initialize the input device */
1155 idev
= applesmc_idev
->input
;
1156 idev
->name
= "applesmc";
1157 idev
->id
.bustype
= BUS_HOST
;
1158 idev
->dev
.parent
= &pdev
->dev
;
1159 idev
->evbit
[0] = BIT_MASK(EV_ABS
);
1160 input_set_abs_params(idev
, ABS_X
,
1161 -256, 256, APPLESMC_INPUT_FUZZ
, APPLESMC_INPUT_FLAT
);
1162 input_set_abs_params(idev
, ABS_Y
,
1163 -256, 256, APPLESMC_INPUT_FUZZ
, APPLESMC_INPUT_FLAT
);
1165 ret
= input_register_polled_device(applesmc_idev
);
1172 input_free_polled_device(applesmc_idev
);
1175 applesmc_destroy_nodes(accelerometer_group
);
1178 pr_warn("driver init failed (ret=%d)!\n", ret
);
1182 /* Release all ressources used by the accelerometer */
1183 static void applesmc_release_accelerometer(void)
1185 if (!smcreg
.has_accelerometer
)
1187 input_unregister_polled_device(applesmc_idev
);
1188 input_free_polled_device(applesmc_idev
);
1189 applesmc_destroy_nodes(accelerometer_group
);
1192 static int applesmc_create_light_sensor(void)
1194 if (!smcreg
.num_light_sensors
)
1196 return applesmc_create_nodes(light_sensor_group
, 1);
1199 static void applesmc_release_light_sensor(void)
1201 if (!smcreg
.num_light_sensors
)
1203 applesmc_destroy_nodes(light_sensor_group
);
1206 static int applesmc_create_key_backlight(void)
1208 if (!smcreg
.has_key_backlight
)
1210 applesmc_led_wq
= create_singlethread_workqueue("applesmc-led");
1211 if (!applesmc_led_wq
)
1213 return led_classdev_register(&pdev
->dev
, &applesmc_backlight
);
1216 static void applesmc_release_key_backlight(void)
1218 if (!smcreg
.has_key_backlight
)
1220 led_classdev_unregister(&applesmc_backlight
);
1221 destroy_workqueue(applesmc_led_wq
);
1224 static int applesmc_dmi_match(const struct dmi_system_id
*id
)
1230 * Note that DMI_MATCH(...,"MacBook") will match "MacBookPro1,1".
1231 * So we need to put "Apple MacBook Pro" before "Apple MacBook".
1233 static __initdata
struct dmi_system_id applesmc_whitelist
[] = {
1234 { applesmc_dmi_match
, "Apple MacBook Air", {
1235 DMI_MATCH(DMI_BOARD_VENDOR
, "Apple"),
1236 DMI_MATCH(DMI_PRODUCT_NAME
, "MacBookAir") },
1238 { applesmc_dmi_match
, "Apple MacBook Pro", {
1239 DMI_MATCH(DMI_BOARD_VENDOR
, "Apple"),
1240 DMI_MATCH(DMI_PRODUCT_NAME
, "MacBookPro") },
1242 { applesmc_dmi_match
, "Apple MacBook", {
1243 DMI_MATCH(DMI_BOARD_VENDOR
, "Apple"),
1244 DMI_MATCH(DMI_PRODUCT_NAME
, "MacBook") },
1246 { applesmc_dmi_match
, "Apple Macmini", {
1247 DMI_MATCH(DMI_BOARD_VENDOR
, "Apple"),
1248 DMI_MATCH(DMI_PRODUCT_NAME
, "Macmini") },
1250 { applesmc_dmi_match
, "Apple MacPro", {
1251 DMI_MATCH(DMI_BOARD_VENDOR
, "Apple"),
1252 DMI_MATCH(DMI_PRODUCT_NAME
, "MacPro") },
1254 { applesmc_dmi_match
, "Apple iMac", {
1255 DMI_MATCH(DMI_BOARD_VENDOR
, "Apple"),
1256 DMI_MATCH(DMI_PRODUCT_NAME
, "iMac") },
1261 static int __init
applesmc_init(void)
1265 if (!dmi_check_system(applesmc_whitelist
)) {
1266 pr_warn("supported laptop not found!\n");
1271 if (!request_region(APPLESMC_DATA_PORT
, APPLESMC_NR_PORTS
,
1277 ret
= platform_driver_register(&applesmc_driver
);
1281 pdev
= platform_device_register_simple("applesmc", APPLESMC_DATA_PORT
,
1284 ret
= PTR_ERR(pdev
);
1288 /* create register cache */
1289 ret
= applesmc_init_smcreg();
1293 ret
= applesmc_create_nodes(info_group
, 1);
1297 ret
= applesmc_create_nodes(fan_group
, smcreg
.fan_count
);
1301 ret
= applesmc_create_nodes(temp_group
, smcreg
.index_count
);
1305 ret
= applesmc_create_accelerometer();
1307 goto out_temperature
;
1309 ret
= applesmc_create_light_sensor();
1311 goto out_accelerometer
;
1313 ret
= applesmc_create_key_backlight();
1315 goto out_light_sysfs
;
1317 hwmon_dev
= hwmon_device_register(&pdev
->dev
);
1318 if (IS_ERR(hwmon_dev
)) {
1319 ret
= PTR_ERR(hwmon_dev
);
1320 goto out_light_ledclass
;
1326 applesmc_release_key_backlight();
1328 applesmc_release_light_sensor();
1330 applesmc_release_accelerometer();
1332 applesmc_destroy_nodes(temp_group
);
1334 applesmc_destroy_nodes(fan_group
);
1336 applesmc_destroy_nodes(info_group
);
1338 applesmc_destroy_smcreg();
1340 platform_device_unregister(pdev
);
1342 platform_driver_unregister(&applesmc_driver
);
1344 release_region(APPLESMC_DATA_PORT
, APPLESMC_NR_PORTS
);
1346 pr_warn("driver init failed (ret=%d)!\n", ret
);
1350 static void __exit
applesmc_exit(void)
1352 hwmon_device_unregister(hwmon_dev
);
1353 applesmc_release_key_backlight();
1354 applesmc_release_light_sensor();
1355 applesmc_release_accelerometer();
1356 applesmc_destroy_nodes(temp_group
);
1357 applesmc_destroy_nodes(fan_group
);
1358 applesmc_destroy_nodes(info_group
);
1359 applesmc_destroy_smcreg();
1360 platform_device_unregister(pdev
);
1361 platform_driver_unregister(&applesmc_driver
);
1362 release_region(APPLESMC_DATA_PORT
, APPLESMC_NR_PORTS
);
1365 module_init(applesmc_init
);
1366 module_exit(applesmc_exit
);
1368 MODULE_AUTHOR("Nicolas Boichat");
1369 MODULE_DESCRIPTION("Apple SMC");
1370 MODULE_LICENSE("GPL v2");
1371 MODULE_DEVICE_TABLE(dmi
, applesmc_whitelist
);