1 // SPDX-License-Identifier: GPL-2.0-only
3 * drivers/hwmon/applesmc.c - driver for Apple's SMC (accelerometer, temperature
4 * sensors, fan control, keyboard backlight control) used in Intel-based Apple
7 * Copyright (C) 2007 Nicolas Boichat <nicolas@boichat.ch>
8 * Copyright (C) 2010 Henrik Rydberg <rydberg@euromail.se>
10 * Based on hdaps.c driver:
11 * Copyright (C) 2005 Robert Love <rml@novell.com>
12 * Copyright (C) 2005 Jesper Juhl <jj@chaosbits.net>
14 * Fan control based on smcFanControl:
15 * Copyright (C) 2006 Hendrik Holtmann <holtmann@mac.com>
18 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
20 #include <linux/delay.h>
21 #include <linux/platform_device.h>
22 #include <linux/input-polldev.h>
23 #include <linux/kernel.h>
24 #include <linux/slab.h>
25 #include <linux/module.h>
26 #include <linux/timer.h>
27 #include <linux/dmi.h>
28 #include <linux/mutex.h>
29 #include <linux/hwmon-sysfs.h>
31 #include <linux/leds.h>
32 #include <linux/hwmon.h>
33 #include <linux/workqueue.h>
34 #include <linux/err.h>
36 /* data port used by Apple SMC */
37 #define APPLESMC_DATA_PORT 0x300
38 /* command/status port used by Apple SMC */
39 #define APPLESMC_CMD_PORT 0x304
41 #define APPLESMC_NR_PORTS 32 /* 0x300-0x31f */
43 #define APPLESMC_MAX_DATA_LENGTH 32
45 /* wait up to 128 ms for a status change. */
46 #define APPLESMC_MIN_WAIT 0x0010
47 #define APPLESMC_RETRY_WAIT 0x0100
48 #define APPLESMC_MAX_WAIT 0x20000
50 #define APPLESMC_READ_CMD 0x10
51 #define APPLESMC_WRITE_CMD 0x11
52 #define APPLESMC_GET_KEY_BY_INDEX_CMD 0x12
53 #define APPLESMC_GET_KEY_TYPE_CMD 0x13
55 #define KEY_COUNT_KEY "#KEY" /* r-o ui32 */
57 #define LIGHT_SENSOR_LEFT_KEY "ALV0" /* r-o {alv (6-10 bytes) */
58 #define LIGHT_SENSOR_RIGHT_KEY "ALV1" /* r-o {alv (6-10 bytes) */
59 #define BACKLIGHT_KEY "LKSB" /* w-o {lkb (2 bytes) */
61 #define CLAMSHELL_KEY "MSLD" /* r-o ui8 (unused) */
63 #define MOTION_SENSOR_X_KEY "MO_X" /* r-o sp78 (2 bytes) */
64 #define MOTION_SENSOR_Y_KEY "MO_Y" /* r-o sp78 (2 bytes) */
65 #define MOTION_SENSOR_Z_KEY "MO_Z" /* r-o sp78 (2 bytes) */
66 #define MOTION_SENSOR_KEY "MOCN" /* r/w ui16 */
68 #define FANS_COUNT "FNum" /* r-o ui8 */
69 #define FANS_MANUAL "FS! " /* r-w ui16 */
70 #define FAN_ID_FMT "F%dID" /* r-o char[16] */
72 #define TEMP_SENSOR_TYPE "sp78"
74 /* List of keys used to read/write fan speeds */
75 static const char *const fan_speed_fmt
[] = {
76 "F%dAc", /* actual speed */
77 "F%dMn", /* minimum speed (rw) */
78 "F%dMx", /* maximum speed */
79 "F%dSf", /* safe speed - not all models */
80 "F%dTg", /* target speed (manual: rw) */
83 #define INIT_TIMEOUT_MSECS 5000 /* wait up to 5s for device init ... */
84 #define INIT_WAIT_MSECS 50 /* ... in 50ms increments */
86 #define APPLESMC_POLL_INTERVAL 50 /* msecs */
87 #define APPLESMC_INPUT_FUZZ 4 /* input event threshold */
88 #define APPLESMC_INPUT_FLAT 4
90 #define to_index(attr) (to_sensor_dev_attr(attr)->index & 0xffff)
91 #define to_option(attr) (to_sensor_dev_attr(attr)->index >> 16)
93 /* Dynamic device node attributes */
94 struct applesmc_dev_attr
{
95 struct sensor_device_attribute sda
; /* hwmon attributes */
96 char name
[32]; /* room for node file name */
99 /* Dynamic device node group */
100 struct applesmc_node_group
{
101 char *format
; /* format string */
102 void *show
; /* show function */
103 void *store
; /* store function */
104 int option
; /* function argument */
105 struct applesmc_dev_attr
*nodes
; /* dynamic node array */
108 /* AppleSMC entry - cached register information */
109 struct applesmc_entry
{
110 char key
[5]; /* four-letter key code */
111 u8 valid
; /* set when entry is successfully read once */
112 u8 len
; /* bounded by APPLESMC_MAX_DATA_LENGTH */
113 char type
[5]; /* four-letter type code */
114 u8 flags
; /* 0x10: func; 0x40: write; 0x80: read */
117 /* Register lookup and registers common to all SMCs */
118 static struct applesmc_registers
{
119 struct mutex mutex
; /* register read/write mutex */
120 unsigned int key_count
; /* number of SMC registers */
121 unsigned int fan_count
; /* number of fans */
122 unsigned int temp_count
; /* number of temperature registers */
123 unsigned int temp_begin
; /* temperature lower index bound */
124 unsigned int temp_end
; /* temperature upper index bound */
125 unsigned int index_count
; /* size of temperature index array */
126 int num_light_sensors
; /* number of light sensors */
127 bool has_accelerometer
; /* has motion sensor */
128 bool has_key_backlight
; /* has keyboard backlight */
129 bool init_complete
; /* true when fully initialized */
130 struct applesmc_entry
*cache
; /* cached key entries */
131 const char **index
; /* temperature key index */
133 .mutex
= __MUTEX_INITIALIZER(smcreg
.mutex
),
136 static const int debug
;
137 static struct platform_device
*pdev
;
140 static u8 backlight_state
[2];
142 static struct device
*hwmon_dev
;
143 static struct input_polled_dev
*applesmc_idev
;
146 * Last index written to key_at_index sysfs file, and value to use for all other
147 * key_at_index_* sysfs files.
149 static unsigned int key_at_index
;
151 static struct workqueue_struct
*applesmc_led_wq
;
154 * wait_read - Wait for a byte to appear on SMC port. Callers must
155 * hold applesmc_lock.
157 static int wait_read(void)
161 for (us
= APPLESMC_MIN_WAIT
; us
< APPLESMC_MAX_WAIT
; us
<<= 1) {
163 status
= inb(APPLESMC_CMD_PORT
);
164 /* read: wait for smc to settle */
169 pr_warn("wait_read() fail: 0x%02x\n", status
);
174 * send_byte - Write to SMC port, retrying when necessary. Callers
175 * must hold applesmc_lock.
177 static int send_byte(u8 cmd
, u16 port
)
183 for (us
= APPLESMC_MIN_WAIT
; us
< APPLESMC_MAX_WAIT
; us
<<= 1) {
185 status
= inb(APPLESMC_CMD_PORT
);
186 /* write: wait for smc to settle */
189 /* ready: cmd accepted, return */
192 /* timeout: give up */
193 if (us
<< 1 == APPLESMC_MAX_WAIT
)
195 /* busy: long wait and resend */
196 udelay(APPLESMC_RETRY_WAIT
);
200 pr_warn("send_byte(0x%02x, 0x%04x) fail: 0x%02x\n", cmd
, port
, status
);
204 static int send_command(u8 cmd
)
206 return send_byte(cmd
, APPLESMC_CMD_PORT
);
209 static int send_argument(const char *key
)
213 for (i
= 0; i
< 4; i
++)
214 if (send_byte(key
[i
], APPLESMC_DATA_PORT
))
219 static int read_smc(u8 cmd
, const char *key
, u8
*buffer
, u8 len
)
224 if (send_command(cmd
) || send_argument(key
)) {
225 pr_warn("%.4s: read arg fail\n", key
);
229 /* This has no effect on newer (2012) SMCs */
230 if (send_byte(len
, APPLESMC_DATA_PORT
)) {
231 pr_warn("%.4s: read len fail\n", key
);
235 for (i
= 0; i
< len
; i
++) {
237 pr_warn("%.4s: read data[%d] fail\n", key
, i
);
240 buffer
[i
] = inb(APPLESMC_DATA_PORT
);
243 /* Read the data port until bit0 is cleared */
244 for (i
= 0; i
< 16; i
++) {
245 udelay(APPLESMC_MIN_WAIT
);
246 status
= inb(APPLESMC_CMD_PORT
);
247 if (!(status
& 0x01))
249 data
= inb(APPLESMC_DATA_PORT
);
252 pr_warn("flushed %d bytes, last value is: %d\n", i
, data
);
257 static int write_smc(u8 cmd
, const char *key
, const u8
*buffer
, u8 len
)
261 if (send_command(cmd
) || send_argument(key
)) {
262 pr_warn("%s: write arg fail\n", key
);
266 if (send_byte(len
, APPLESMC_DATA_PORT
)) {
267 pr_warn("%.4s: write len fail\n", key
);
271 for (i
= 0; i
< len
; i
++) {
272 if (send_byte(buffer
[i
], APPLESMC_DATA_PORT
)) {
273 pr_warn("%s: write data fail\n", key
);
281 static int read_register_count(unsigned int *count
)
286 ret
= read_smc(APPLESMC_READ_CMD
, KEY_COUNT_KEY
, (u8
*)&be
, 4);
290 *count
= be32_to_cpu(be
);
297 * Returns zero on success or a negative error on failure.
298 * All functions below are concurrency safe - callers should NOT hold lock.
301 static int applesmc_read_entry(const struct applesmc_entry
*entry
,
306 if (entry
->len
!= len
)
308 mutex_lock(&smcreg
.mutex
);
309 ret
= read_smc(APPLESMC_READ_CMD
, entry
->key
, buf
, len
);
310 mutex_unlock(&smcreg
.mutex
);
315 static int applesmc_write_entry(const struct applesmc_entry
*entry
,
316 const u8
*buf
, u8 len
)
320 if (entry
->len
!= len
)
322 mutex_lock(&smcreg
.mutex
);
323 ret
= write_smc(APPLESMC_WRITE_CMD
, entry
->key
, buf
, len
);
324 mutex_unlock(&smcreg
.mutex
);
328 static const struct applesmc_entry
*applesmc_get_entry_by_index(int index
)
330 struct applesmc_entry
*cache
= &smcreg
.cache
[index
];
338 mutex_lock(&smcreg
.mutex
);
342 be
= cpu_to_be32(index
);
343 ret
= read_smc(APPLESMC_GET_KEY_BY_INDEX_CMD
, (u8
*)&be
, key
, 4);
346 ret
= read_smc(APPLESMC_GET_KEY_TYPE_CMD
, key
, info
, 6);
350 memcpy(cache
->key
, key
, 4);
351 cache
->len
= info
[0];
352 memcpy(cache
->type
, &info
[1], 4);
353 cache
->flags
= info
[5];
357 mutex_unlock(&smcreg
.mutex
);
363 static int applesmc_get_lower_bound(unsigned int *lo
, const char *key
)
365 int begin
= 0, end
= smcreg
.key_count
;
366 const struct applesmc_entry
*entry
;
368 while (begin
!= end
) {
369 int middle
= begin
+ (end
- begin
) / 2;
370 entry
= applesmc_get_entry_by_index(middle
);
373 return PTR_ERR(entry
);
375 if (strcmp(entry
->key
, key
) < 0)
385 static int applesmc_get_upper_bound(unsigned int *hi
, const char *key
)
387 int begin
= 0, end
= smcreg
.key_count
;
388 const struct applesmc_entry
*entry
;
390 while (begin
!= end
) {
391 int middle
= begin
+ (end
- begin
) / 2;
392 entry
= applesmc_get_entry_by_index(middle
);
394 *hi
= smcreg
.key_count
;
395 return PTR_ERR(entry
);
397 if (strcmp(key
, entry
->key
) < 0)
407 static const struct applesmc_entry
*applesmc_get_entry_by_key(const char *key
)
412 ret
= applesmc_get_lower_bound(&begin
, key
);
415 ret
= applesmc_get_upper_bound(&end
, key
);
418 if (end
- begin
!= 1)
419 return ERR_PTR(-EINVAL
);
421 return applesmc_get_entry_by_index(begin
);
424 static int applesmc_read_key(const char *key
, u8
*buffer
, u8 len
)
426 const struct applesmc_entry
*entry
;
428 entry
= applesmc_get_entry_by_key(key
);
430 return PTR_ERR(entry
);
432 return applesmc_read_entry(entry
, buffer
, len
);
435 static int applesmc_write_key(const char *key
, const u8
*buffer
, u8 len
)
437 const struct applesmc_entry
*entry
;
439 entry
= applesmc_get_entry_by_key(key
);
441 return PTR_ERR(entry
);
443 return applesmc_write_entry(entry
, buffer
, len
);
446 static int applesmc_has_key(const char *key
, bool *value
)
448 const struct applesmc_entry
*entry
;
450 entry
= applesmc_get_entry_by_key(key
);
451 if (IS_ERR(entry
) && PTR_ERR(entry
) != -EINVAL
)
452 return PTR_ERR(entry
);
454 *value
= !IS_ERR(entry
);
459 * applesmc_read_s16 - Read 16-bit signed big endian register
461 static int applesmc_read_s16(const char *key
, s16
*value
)
466 ret
= applesmc_read_key(key
, buffer
, 2);
470 *value
= ((s16
)buffer
[0] << 8) | buffer
[1];
475 * applesmc_device_init - initialize the accelerometer. Can sleep.
477 static void applesmc_device_init(void)
482 if (!smcreg
.has_accelerometer
)
485 for (total
= INIT_TIMEOUT_MSECS
; total
> 0; total
-= INIT_WAIT_MSECS
) {
486 if (!applesmc_read_key(MOTION_SENSOR_KEY
, buffer
, 2) &&
487 (buffer
[0] != 0x00 || buffer
[1] != 0x00))
491 applesmc_write_key(MOTION_SENSOR_KEY
, buffer
, 2);
492 msleep(INIT_WAIT_MSECS
);
495 pr_warn("failed to init the device\n");
498 static int applesmc_init_index(struct applesmc_registers
*s
)
500 const struct applesmc_entry
*entry
;
506 s
->index
= kcalloc(s
->temp_count
, sizeof(s
->index
[0]), GFP_KERNEL
);
510 for (i
= s
->temp_begin
; i
< s
->temp_end
; i
++) {
511 entry
= applesmc_get_entry_by_index(i
);
514 if (strcmp(entry
->type
, TEMP_SENSOR_TYPE
))
516 s
->index
[s
->index_count
++] = entry
->key
;
523 * applesmc_init_smcreg_try - Try to initialize register cache. Idempotent.
525 static int applesmc_init_smcreg_try(void)
527 struct applesmc_registers
*s
= &smcreg
;
528 bool left_light_sensor
= 0, right_light_sensor
= 0;
533 if (s
->init_complete
)
536 ret
= read_register_count(&count
);
540 if (s
->cache
&& s
->key_count
!= count
) {
541 pr_warn("key count changed from %d to %d\n",
542 s
->key_count
, count
);
546 s
->key_count
= count
;
549 s
->cache
= kcalloc(s
->key_count
, sizeof(*s
->cache
), GFP_KERNEL
);
553 ret
= applesmc_read_key(FANS_COUNT
, tmp
, 1);
556 s
->fan_count
= tmp
[0];
557 if (s
->fan_count
> 10)
560 ret
= applesmc_get_lower_bound(&s
->temp_begin
, "T");
563 ret
= applesmc_get_lower_bound(&s
->temp_end
, "U");
566 s
->temp_count
= s
->temp_end
- s
->temp_begin
;
568 ret
= applesmc_init_index(s
);
572 ret
= applesmc_has_key(LIGHT_SENSOR_LEFT_KEY
, &left_light_sensor
);
575 ret
= applesmc_has_key(LIGHT_SENSOR_RIGHT_KEY
, &right_light_sensor
);
578 ret
= applesmc_has_key(MOTION_SENSOR_KEY
, &s
->has_accelerometer
);
581 ret
= applesmc_has_key(BACKLIGHT_KEY
, &s
->has_key_backlight
);
585 s
->num_light_sensors
= left_light_sensor
+ right_light_sensor
;
586 s
->init_complete
= true;
588 pr_info("key=%d fan=%d temp=%d index=%d acc=%d lux=%d kbd=%d\n",
589 s
->key_count
, s
->fan_count
, s
->temp_count
, s
->index_count
,
590 s
->has_accelerometer
,
591 s
->num_light_sensors
,
592 s
->has_key_backlight
);
597 static void applesmc_destroy_smcreg(void)
603 smcreg
.init_complete
= false;
607 * applesmc_init_smcreg - Initialize register cache.
609 * Retries until initialization is successful, or the operation times out.
612 static int applesmc_init_smcreg(void)
616 for (ms
= 0; ms
< INIT_TIMEOUT_MSECS
; ms
+= INIT_WAIT_MSECS
) {
617 ret
= applesmc_init_smcreg_try();
620 pr_info("init_smcreg() took %d ms\n", ms
);
623 msleep(INIT_WAIT_MSECS
);
626 applesmc_destroy_smcreg();
631 /* Device model stuff */
632 static int applesmc_probe(struct platform_device
*dev
)
636 ret
= applesmc_init_smcreg();
640 applesmc_device_init();
645 /* Synchronize device with memorized backlight state */
646 static int applesmc_pm_resume(struct device
*dev
)
648 if (smcreg
.has_key_backlight
)
649 applesmc_write_key(BACKLIGHT_KEY
, backlight_state
, 2);
653 /* Reinitialize device on resume from hibernation */
654 static int applesmc_pm_restore(struct device
*dev
)
656 applesmc_device_init();
657 return applesmc_pm_resume(dev
);
660 static const struct dev_pm_ops applesmc_pm_ops
= {
661 .resume
= applesmc_pm_resume
,
662 .restore
= applesmc_pm_restore
,
665 static struct platform_driver applesmc_driver
= {
666 .probe
= applesmc_probe
,
669 .pm
= &applesmc_pm_ops
,
674 * applesmc_calibrate - Set our "resting" values. Callers must
675 * hold applesmc_lock.
677 static void applesmc_calibrate(void)
679 applesmc_read_s16(MOTION_SENSOR_X_KEY
, &rest_x
);
680 applesmc_read_s16(MOTION_SENSOR_Y_KEY
, &rest_y
);
684 static void applesmc_idev_poll(struct input_polled_dev
*dev
)
686 struct input_dev
*idev
= dev
->input
;
689 if (applesmc_read_s16(MOTION_SENSOR_X_KEY
, &x
))
691 if (applesmc_read_s16(MOTION_SENSOR_Y_KEY
, &y
))
695 input_report_abs(idev
, ABS_X
, x
- rest_x
);
696 input_report_abs(idev
, ABS_Y
, y
- rest_y
);
702 static ssize_t
applesmc_name_show(struct device
*dev
,
703 struct device_attribute
*attr
, char *buf
)
705 return snprintf(buf
, PAGE_SIZE
, "applesmc\n");
708 static ssize_t
applesmc_position_show(struct device
*dev
,
709 struct device_attribute
*attr
, char *buf
)
714 ret
= applesmc_read_s16(MOTION_SENSOR_X_KEY
, &x
);
717 ret
= applesmc_read_s16(MOTION_SENSOR_Y_KEY
, &y
);
720 ret
= applesmc_read_s16(MOTION_SENSOR_Z_KEY
, &z
);
728 return snprintf(buf
, PAGE_SIZE
, "(%d,%d,%d)\n", x
, y
, z
);
731 static ssize_t
applesmc_light_show(struct device
*dev
,
732 struct device_attribute
*attr
, char *sysfsbuf
)
734 const struct applesmc_entry
*entry
;
735 static int data_length
;
737 u8 left
= 0, right
= 0;
741 entry
= applesmc_get_entry_by_key(LIGHT_SENSOR_LEFT_KEY
);
743 return PTR_ERR(entry
);
746 data_length
= entry
->len
;
747 pr_info("light sensor data length set to %d\n", data_length
);
750 ret
= applesmc_read_key(LIGHT_SENSOR_LEFT_KEY
, buffer
, data_length
);
751 /* newer macbooks report a single 10-bit bigendian value */
752 if (data_length
== 10) {
753 left
= be16_to_cpu(*(__be16
*)(buffer
+ 6)) >> 2;
759 ret
= applesmc_read_key(LIGHT_SENSOR_RIGHT_KEY
, buffer
, data_length
);
766 return snprintf(sysfsbuf
, PAGE_SIZE
, "(%d,%d)\n", left
, right
);
769 /* Displays sensor key as label */
770 static ssize_t
applesmc_show_sensor_label(struct device
*dev
,
771 struct device_attribute
*devattr
, char *sysfsbuf
)
773 const char *key
= smcreg
.index
[to_index(devattr
)];
775 return snprintf(sysfsbuf
, PAGE_SIZE
, "%s\n", key
);
778 /* Displays degree Celsius * 1000 */
779 static ssize_t
applesmc_show_temperature(struct device
*dev
,
780 struct device_attribute
*devattr
, char *sysfsbuf
)
782 const char *key
= smcreg
.index
[to_index(devattr
)];
787 ret
= applesmc_read_s16(key
, &value
);
791 temp
= 250 * (value
>> 6);
793 return snprintf(sysfsbuf
, PAGE_SIZE
, "%d\n", temp
);
796 static ssize_t
applesmc_show_fan_speed(struct device
*dev
,
797 struct device_attribute
*attr
, char *sysfsbuf
)
800 unsigned int speed
= 0;
804 scnprintf(newkey
, sizeof(newkey
), fan_speed_fmt
[to_option(attr
)],
807 ret
= applesmc_read_key(newkey
, buffer
, 2);
808 speed
= ((buffer
[0] << 8 | buffer
[1]) >> 2);
813 return snprintf(sysfsbuf
, PAGE_SIZE
, "%u\n", speed
);
816 static ssize_t
applesmc_store_fan_speed(struct device
*dev
,
817 struct device_attribute
*attr
,
818 const char *sysfsbuf
, size_t count
)
825 if (kstrtoul(sysfsbuf
, 10, &speed
) < 0 || speed
>= 0x4000)
826 return -EINVAL
; /* Bigger than a 14-bit value */
828 scnprintf(newkey
, sizeof(newkey
), fan_speed_fmt
[to_option(attr
)],
831 buffer
[0] = (speed
>> 6) & 0xff;
832 buffer
[1] = (speed
<< 2) & 0xff;
833 ret
= applesmc_write_key(newkey
, buffer
, 2);
841 static ssize_t
applesmc_show_fan_manual(struct device
*dev
,
842 struct device_attribute
*attr
, char *sysfsbuf
)
848 ret
= applesmc_read_key(FANS_MANUAL
, buffer
, 2);
849 manual
= ((buffer
[0] << 8 | buffer
[1]) >> to_index(attr
)) & 0x01;
854 return snprintf(sysfsbuf
, PAGE_SIZE
, "%d\n", manual
);
857 static ssize_t
applesmc_store_fan_manual(struct device
*dev
,
858 struct device_attribute
*attr
,
859 const char *sysfsbuf
, size_t count
)
866 if (kstrtoul(sysfsbuf
, 10, &input
) < 0)
869 ret
= applesmc_read_key(FANS_MANUAL
, buffer
, 2);
870 val
= (buffer
[0] << 8 | buffer
[1]);
875 val
= val
| (0x01 << to_index(attr
));
877 val
= val
& ~(0x01 << to_index(attr
));
879 buffer
[0] = (val
>> 8) & 0xFF;
880 buffer
[1] = val
& 0xFF;
882 ret
= applesmc_write_key(FANS_MANUAL
, buffer
, 2);
891 static ssize_t
applesmc_show_fan_position(struct device
*dev
,
892 struct device_attribute
*attr
, char *sysfsbuf
)
898 scnprintf(newkey
, sizeof(newkey
), FAN_ID_FMT
, to_index(attr
));
900 ret
= applesmc_read_key(newkey
, buffer
, 16);
906 return snprintf(sysfsbuf
, PAGE_SIZE
, "%s\n", buffer
+4);
909 static ssize_t
applesmc_calibrate_show(struct device
*dev
,
910 struct device_attribute
*attr
, char *sysfsbuf
)
912 return snprintf(sysfsbuf
, PAGE_SIZE
, "(%d,%d)\n", rest_x
, rest_y
);
915 static ssize_t
applesmc_calibrate_store(struct device
*dev
,
916 struct device_attribute
*attr
, const char *sysfsbuf
, size_t count
)
918 applesmc_calibrate();
923 static void applesmc_backlight_set(struct work_struct
*work
)
925 applesmc_write_key(BACKLIGHT_KEY
, backlight_state
, 2);
927 static DECLARE_WORK(backlight_work
, &applesmc_backlight_set
);
929 static void applesmc_brightness_set(struct led_classdev
*led_cdev
,
930 enum led_brightness value
)
934 backlight_state
[0] = value
;
935 ret
= queue_work(applesmc_led_wq
, &backlight_work
);
938 dev_dbg(led_cdev
->dev
, "work was already on the queue.\n");
941 static ssize_t
applesmc_key_count_show(struct device
*dev
,
942 struct device_attribute
*attr
, char *sysfsbuf
)
948 ret
= applesmc_read_key(KEY_COUNT_KEY
, buffer
, 4);
949 count
= ((u32
)buffer
[0]<<24) + ((u32
)buffer
[1]<<16) +
950 ((u32
)buffer
[2]<<8) + buffer
[3];
955 return snprintf(sysfsbuf
, PAGE_SIZE
, "%d\n", count
);
958 static ssize_t
applesmc_key_at_index_read_show(struct device
*dev
,
959 struct device_attribute
*attr
, char *sysfsbuf
)
961 const struct applesmc_entry
*entry
;
964 entry
= applesmc_get_entry_by_index(key_at_index
);
966 return PTR_ERR(entry
);
967 ret
= applesmc_read_entry(entry
, sysfsbuf
, entry
->len
);
974 static ssize_t
applesmc_key_at_index_data_length_show(struct device
*dev
,
975 struct device_attribute
*attr
, char *sysfsbuf
)
977 const struct applesmc_entry
*entry
;
979 entry
= applesmc_get_entry_by_index(key_at_index
);
981 return PTR_ERR(entry
);
983 return snprintf(sysfsbuf
, PAGE_SIZE
, "%d\n", entry
->len
);
986 static ssize_t
applesmc_key_at_index_type_show(struct device
*dev
,
987 struct device_attribute
*attr
, char *sysfsbuf
)
989 const struct applesmc_entry
*entry
;
991 entry
= applesmc_get_entry_by_index(key_at_index
);
993 return PTR_ERR(entry
);
995 return snprintf(sysfsbuf
, PAGE_SIZE
, "%s\n", entry
->type
);
998 static ssize_t
applesmc_key_at_index_name_show(struct device
*dev
,
999 struct device_attribute
*attr
, char *sysfsbuf
)
1001 const struct applesmc_entry
*entry
;
1003 entry
= applesmc_get_entry_by_index(key_at_index
);
1005 return PTR_ERR(entry
);
1007 return snprintf(sysfsbuf
, PAGE_SIZE
, "%s\n", entry
->key
);
1010 static ssize_t
applesmc_key_at_index_show(struct device
*dev
,
1011 struct device_attribute
*attr
, char *sysfsbuf
)
1013 return snprintf(sysfsbuf
, PAGE_SIZE
, "%d\n", key_at_index
);
1016 static ssize_t
applesmc_key_at_index_store(struct device
*dev
,
1017 struct device_attribute
*attr
, const char *sysfsbuf
, size_t count
)
1019 unsigned long newkey
;
1021 if (kstrtoul(sysfsbuf
, 10, &newkey
) < 0
1022 || newkey
>= smcreg
.key_count
)
1025 key_at_index
= newkey
;
1029 static struct led_classdev applesmc_backlight
= {
1030 .name
= "smc::kbd_backlight",
1031 .default_trigger
= "nand-disk",
1032 .brightness_set
= applesmc_brightness_set
,
1035 static struct applesmc_node_group info_group
[] = {
1036 { "name", applesmc_name_show
},
1037 { "key_count", applesmc_key_count_show
},
1038 { "key_at_index", applesmc_key_at_index_show
, applesmc_key_at_index_store
},
1039 { "key_at_index_name", applesmc_key_at_index_name_show
},
1040 { "key_at_index_type", applesmc_key_at_index_type_show
},
1041 { "key_at_index_data_length", applesmc_key_at_index_data_length_show
},
1042 { "key_at_index_data", applesmc_key_at_index_read_show
},
1046 static struct applesmc_node_group accelerometer_group
[] = {
1047 { "position", applesmc_position_show
},
1048 { "calibrate", applesmc_calibrate_show
, applesmc_calibrate_store
},
1052 static struct applesmc_node_group light_sensor_group
[] = {
1053 { "light", applesmc_light_show
},
1057 static struct applesmc_node_group fan_group
[] = {
1058 { "fan%d_label", applesmc_show_fan_position
},
1059 { "fan%d_input", applesmc_show_fan_speed
, NULL
, 0 },
1060 { "fan%d_min", applesmc_show_fan_speed
, applesmc_store_fan_speed
, 1 },
1061 { "fan%d_max", applesmc_show_fan_speed
, NULL
, 2 },
1062 { "fan%d_safe", applesmc_show_fan_speed
, NULL
, 3 },
1063 { "fan%d_output", applesmc_show_fan_speed
, applesmc_store_fan_speed
, 4 },
1064 { "fan%d_manual", applesmc_show_fan_manual
, applesmc_store_fan_manual
},
1068 static struct applesmc_node_group temp_group
[] = {
1069 { "temp%d_label", applesmc_show_sensor_label
},
1070 { "temp%d_input", applesmc_show_temperature
},
1077 * applesmc_destroy_nodes - remove files and free associated memory
1079 static void applesmc_destroy_nodes(struct applesmc_node_group
*groups
)
1081 struct applesmc_node_group
*grp
;
1082 struct applesmc_dev_attr
*node
;
1084 for (grp
= groups
; grp
->nodes
; grp
++) {
1085 for (node
= grp
->nodes
; node
->sda
.dev_attr
.attr
.name
; node
++)
1086 sysfs_remove_file(&pdev
->dev
.kobj
,
1087 &node
->sda
.dev_attr
.attr
);
1094 * applesmc_create_nodes - create a two-dimensional group of sysfs files
1096 static int applesmc_create_nodes(struct applesmc_node_group
*groups
, int num
)
1098 struct applesmc_node_group
*grp
;
1099 struct applesmc_dev_attr
*node
;
1100 struct attribute
*attr
;
1103 for (grp
= groups
; grp
->format
; grp
++) {
1104 grp
->nodes
= kcalloc(num
+ 1, sizeof(*node
), GFP_KERNEL
);
1109 for (i
= 0; i
< num
; i
++) {
1110 node
= &grp
->nodes
[i
];
1111 scnprintf(node
->name
, sizeof(node
->name
), grp
->format
,
1113 node
->sda
.index
= (grp
->option
<< 16) | (i
& 0xffff);
1114 node
->sda
.dev_attr
.show
= grp
->show
;
1115 node
->sda
.dev_attr
.store
= grp
->store
;
1116 attr
= &node
->sda
.dev_attr
.attr
;
1117 sysfs_attr_init(attr
);
1118 attr
->name
= node
->name
;
1119 attr
->mode
= 0444 | (grp
->store
? 0200 : 0);
1120 ret
= sysfs_create_file(&pdev
->dev
.kobj
, attr
);
1130 applesmc_destroy_nodes(groups
);
1134 /* Create accelerometer resources */
1135 static int applesmc_create_accelerometer(void)
1137 struct input_dev
*idev
;
1140 if (!smcreg
.has_accelerometer
)
1143 ret
= applesmc_create_nodes(accelerometer_group
, 1);
1147 applesmc_idev
= input_allocate_polled_device();
1148 if (!applesmc_idev
) {
1153 applesmc_idev
->poll
= applesmc_idev_poll
;
1154 applesmc_idev
->poll_interval
= APPLESMC_POLL_INTERVAL
;
1156 /* initial calibrate for the input device */
1157 applesmc_calibrate();
1159 /* initialize the input device */
1160 idev
= applesmc_idev
->input
;
1161 idev
->name
= "applesmc";
1162 idev
->id
.bustype
= BUS_HOST
;
1163 idev
->dev
.parent
= &pdev
->dev
;
1164 idev
->evbit
[0] = BIT_MASK(EV_ABS
);
1165 input_set_abs_params(idev
, ABS_X
,
1166 -256, 256, APPLESMC_INPUT_FUZZ
, APPLESMC_INPUT_FLAT
);
1167 input_set_abs_params(idev
, ABS_Y
,
1168 -256, 256, APPLESMC_INPUT_FUZZ
, APPLESMC_INPUT_FLAT
);
1170 ret
= input_register_polled_device(applesmc_idev
);
1177 input_free_polled_device(applesmc_idev
);
1180 applesmc_destroy_nodes(accelerometer_group
);
1183 pr_warn("driver init failed (ret=%d)!\n", ret
);
1187 /* Release all resources used by the accelerometer */
1188 static void applesmc_release_accelerometer(void)
1190 if (!smcreg
.has_accelerometer
)
1192 input_unregister_polled_device(applesmc_idev
);
1193 input_free_polled_device(applesmc_idev
);
1194 applesmc_destroy_nodes(accelerometer_group
);
1197 static int applesmc_create_light_sensor(void)
1199 if (!smcreg
.num_light_sensors
)
1201 return applesmc_create_nodes(light_sensor_group
, 1);
1204 static void applesmc_release_light_sensor(void)
1206 if (!smcreg
.num_light_sensors
)
1208 applesmc_destroy_nodes(light_sensor_group
);
1211 static int applesmc_create_key_backlight(void)
1213 if (!smcreg
.has_key_backlight
)
1215 applesmc_led_wq
= create_singlethread_workqueue("applesmc-led");
1216 if (!applesmc_led_wq
)
1218 return led_classdev_register(&pdev
->dev
, &applesmc_backlight
);
1221 static void applesmc_release_key_backlight(void)
1223 if (!smcreg
.has_key_backlight
)
1225 led_classdev_unregister(&applesmc_backlight
);
1226 destroy_workqueue(applesmc_led_wq
);
1229 static int applesmc_dmi_match(const struct dmi_system_id
*id
)
1235 * Note that DMI_MATCH(...,"MacBook") will match "MacBookPro1,1".
1236 * So we need to put "Apple MacBook Pro" before "Apple MacBook".
1238 static const struct dmi_system_id applesmc_whitelist
[] __initconst
= {
1239 { applesmc_dmi_match
, "Apple MacBook Air", {
1240 DMI_MATCH(DMI_BOARD_VENDOR
, "Apple"),
1241 DMI_MATCH(DMI_PRODUCT_NAME
, "MacBookAir") },
1243 { applesmc_dmi_match
, "Apple MacBook Pro", {
1244 DMI_MATCH(DMI_BOARD_VENDOR
, "Apple"),
1245 DMI_MATCH(DMI_PRODUCT_NAME
, "MacBookPro") },
1247 { applesmc_dmi_match
, "Apple MacBook", {
1248 DMI_MATCH(DMI_BOARD_VENDOR
, "Apple"),
1249 DMI_MATCH(DMI_PRODUCT_NAME
, "MacBook") },
1251 { applesmc_dmi_match
, "Apple Macmini", {
1252 DMI_MATCH(DMI_BOARD_VENDOR
, "Apple"),
1253 DMI_MATCH(DMI_PRODUCT_NAME
, "Macmini") },
1255 { applesmc_dmi_match
, "Apple MacPro", {
1256 DMI_MATCH(DMI_BOARD_VENDOR
, "Apple"),
1257 DMI_MATCH(DMI_PRODUCT_NAME
, "MacPro") },
1259 { applesmc_dmi_match
, "Apple iMac", {
1260 DMI_MATCH(DMI_BOARD_VENDOR
, "Apple"),
1261 DMI_MATCH(DMI_PRODUCT_NAME
, "iMac") },
1266 static int __init
applesmc_init(void)
1270 if (!dmi_check_system(applesmc_whitelist
)) {
1271 pr_warn("supported laptop not found!\n");
1276 if (!request_region(APPLESMC_DATA_PORT
, APPLESMC_NR_PORTS
,
1282 ret
= platform_driver_register(&applesmc_driver
);
1286 pdev
= platform_device_register_simple("applesmc", APPLESMC_DATA_PORT
,
1289 ret
= PTR_ERR(pdev
);
1293 /* create register cache */
1294 ret
= applesmc_init_smcreg();
1298 ret
= applesmc_create_nodes(info_group
, 1);
1302 ret
= applesmc_create_nodes(fan_group
, smcreg
.fan_count
);
1306 ret
= applesmc_create_nodes(temp_group
, smcreg
.index_count
);
1310 ret
= applesmc_create_accelerometer();
1312 goto out_temperature
;
1314 ret
= applesmc_create_light_sensor();
1316 goto out_accelerometer
;
1318 ret
= applesmc_create_key_backlight();
1320 goto out_light_sysfs
;
1322 hwmon_dev
= hwmon_device_register(&pdev
->dev
);
1323 if (IS_ERR(hwmon_dev
)) {
1324 ret
= PTR_ERR(hwmon_dev
);
1325 goto out_light_ledclass
;
1331 applesmc_release_key_backlight();
1333 applesmc_release_light_sensor();
1335 applesmc_release_accelerometer();
1337 applesmc_destroy_nodes(temp_group
);
1339 applesmc_destroy_nodes(fan_group
);
1341 applesmc_destroy_nodes(info_group
);
1343 applesmc_destroy_smcreg();
1345 platform_device_unregister(pdev
);
1347 platform_driver_unregister(&applesmc_driver
);
1349 release_region(APPLESMC_DATA_PORT
, APPLESMC_NR_PORTS
);
1351 pr_warn("driver init failed (ret=%d)!\n", ret
);
1355 static void __exit
applesmc_exit(void)
1357 hwmon_device_unregister(hwmon_dev
);
1358 applesmc_release_key_backlight();
1359 applesmc_release_light_sensor();
1360 applesmc_release_accelerometer();
1361 applesmc_destroy_nodes(temp_group
);
1362 applesmc_destroy_nodes(fan_group
);
1363 applesmc_destroy_nodes(info_group
);
1364 applesmc_destroy_smcreg();
1365 platform_device_unregister(pdev
);
1366 platform_driver_unregister(&applesmc_driver
);
1367 release_region(APPLESMC_DATA_PORT
, APPLESMC_NR_PORTS
);
1370 module_init(applesmc_init
);
1371 module_exit(applesmc_exit
);
1373 MODULE_AUTHOR("Nicolas Boichat");
1374 MODULE_DESCRIPTION("Apple SMC");
1375 MODULE_LICENSE("GPL v2");
1376 MODULE_DEVICE_TABLE(dmi
, applesmc_whitelist
);