2 * eeepc-laptop.c - Asus Eee PC extras
4 * Based on asus_acpi.c as patched for the Eee PC by Asus:
5 * ftp://ftp.asus.com/pub/ASUS/EeePC/701/ASUS_ACPI_071126.rar
6 * Based on eee.c from eeepc-linux
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
19 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
21 #include <linux/kernel.h>
22 #include <linux/module.h>
23 #include <linux/init.h>
24 #include <linux/types.h>
25 #include <linux/platform_device.h>
26 #include <linux/backlight.h>
28 #include <linux/hwmon.h>
29 #include <linux/hwmon-sysfs.h>
30 #include <acpi/acpi_drivers.h>
31 #include <acpi/acpi_bus.h>
32 #include <linux/uaccess.h>
33 #include <linux/input.h>
34 #include <linux/rfkill.h>
35 #include <linux/pci.h>
36 #include <linux/pci_hotplug.h>
37 #include <linux/leds.h>
39 #define EEEPC_LAPTOP_VERSION "0.1"
40 #define EEEPC_LAPTOP_NAME "Eee PC Hotkey Driver"
41 #define EEEPC_LAPTOP_FILE "eeepc"
43 #define EEEPC_ACPI_CLASS "hotkey"
44 #define EEEPC_ACPI_DEVICE_NAME "Hotkey"
45 #define EEEPC_ACPI_HID "ASUS010"
47 MODULE_AUTHOR("Corentin Chary, Eric Cooper");
48 MODULE_DESCRIPTION(EEEPC_LAPTOP_NAME
);
49 MODULE_LICENSE("GPL");
52 * Definitions for Asus EeePC
54 #define NOTIFY_BRN_MIN 0x20
55 #define NOTIFY_BRN_MAX 0x2f
58 DISABLE_ASL_WLAN
= 0x0001,
59 DISABLE_ASL_BLUETOOTH
= 0x0002,
60 DISABLE_ASL_IRDA
= 0x0004,
61 DISABLE_ASL_CAMERA
= 0x0008,
62 DISABLE_ASL_TV
= 0x0010,
63 DISABLE_ASL_GPS
= 0x0020,
64 DISABLE_ASL_DISPLAYSWITCH
= 0x0040,
65 DISABLE_ASL_MODEM
= 0x0080,
66 DISABLE_ASL_CARDREADER
= 0x0100,
67 DISABLE_ASL_3G
= 0x0200,
68 DISABLE_ASL_WIMAX
= 0x0400,
69 DISABLE_ASL_HWCF
= 0x0800
86 CM_ASL_CPUTEMPERATURE
,
99 CM_ASL_PANELPOWER
, /*P901*/
103 static const char *cm_getv
[] = {
104 "WLDG", "BTHG", NULL
, NULL
,
105 "CAMG", NULL
, NULL
, NULL
,
106 NULL
, "PBLG", NULL
, NULL
,
107 "CFVG", NULL
, NULL
, NULL
,
108 "USBG", NULL
, NULL
, "MODG",
109 "CRDG", "M3GG", "WIMG", "HWCF",
110 "LIDG", "TYPE", "PBPG", "TPDG"
113 static const char *cm_setv
[] = {
114 "WLDS", "BTHS", NULL
, NULL
,
115 "CAMS", NULL
, NULL
, NULL
,
116 "SDSP", "PBLS", "HDPS", NULL
,
117 "CFVS", NULL
, NULL
, NULL
,
118 "USBG", NULL
, NULL
, "MODS",
119 "CRDS", "M3GS", "WIMS", NULL
,
120 NULL
, NULL
, "PBPS", "TPDS"
129 enum { KE_KEY
, KE_END
};
131 static struct key_entry eeepc_keymap
[] = {
132 /* Sleep already handled via generic ACPI code */
133 {KE_KEY
, 0x10, KEY_WLAN
},
134 {KE_KEY
, 0x11, KEY_WLAN
},
135 {KE_KEY
, 0x12, KEY_PROG1
},
136 {KE_KEY
, 0x13, KEY_MUTE
},
137 {KE_KEY
, 0x14, KEY_VOLUMEDOWN
},
138 {KE_KEY
, 0x15, KEY_VOLUMEUP
},
139 {KE_KEY
, 0x1a, KEY_COFFEE
},
140 {KE_KEY
, 0x1b, KEY_ZOOM
},
141 {KE_KEY
, 0x1c, KEY_PROG2
},
142 {KE_KEY
, 0x1d, KEY_PROG3
},
143 {KE_KEY
, NOTIFY_BRN_MIN
, KEY_BRIGHTNESSDOWN
},
144 {KE_KEY
, NOTIFY_BRN_MAX
, KEY_BRIGHTNESSUP
},
145 {KE_KEY
, 0x30, KEY_SWITCHVIDEOMODE
},
146 {KE_KEY
, 0x31, KEY_SWITCHVIDEOMODE
},
147 {KE_KEY
, 0x32, KEY_SWITCHVIDEOMODE
},
153 * This is the main structure, we can use it to store useful information
155 struct eeepc_laptop
{
156 struct acpi_device
*device
; /* the device we are in */
157 acpi_handle handle
; /* the handle of the hotk device */
158 u32 cm_supported
; /* the control methods supported
160 u16 event_count
[128]; /* count for each event */
161 struct input_dev
*inputdev
;
163 struct rfkill
*wlan_rfkill
;
164 struct rfkill
*bluetooth_rfkill
;
165 struct rfkill
*wwan3g_rfkill
;
166 struct rfkill
*wimax_rfkill
;
167 struct hotplug_slot
*hotplug_slot
;
168 struct mutex hotplug_lock
;
171 /* The actual device the driver binds to */
172 static struct eeepc_laptop
*eeepc
;
174 /* The platform device */
175 static struct platform_device
*platform_device
;
177 /* The backlight device /sys/class/backlight */
178 static struct backlight_device
*eeepc_backlight_device
;
180 /* The hwmon device */
181 static struct device
*eeepc_hwmon_device
;
187 static int write_acpi_int(acpi_handle handle
, const char *method
, int val
)
189 struct acpi_object_list params
;
190 union acpi_object in_obj
;
194 params
.pointer
= &in_obj
;
195 in_obj
.type
= ACPI_TYPE_INTEGER
;
196 in_obj
.integer
.value
= val
;
198 status
= acpi_evaluate_object(handle
, (char *)method
, ¶ms
, NULL
);
199 return (status
== AE_OK
? 0 : -1);
202 static int read_acpi_int(acpi_handle handle
, const char *method
, int *val
)
205 unsigned long long result
;
207 status
= acpi_evaluate_integer(handle
, (char *)method
, NULL
, &result
);
208 if (ACPI_FAILURE(status
)) {
217 static int set_acpi(int cm
, int value
)
219 const char *method
= cm_setv
[cm
];
223 if ((eeepc
->cm_supported
& (0x1 << cm
)) == 0)
226 if (write_acpi_int(eeepc
->handle
, method
, value
))
227 pr_warning("Error writing %s\n", method
);
231 static int get_acpi(int cm
)
233 const char *method
= cm_getv
[cm
];
238 if ((eeepc
->cm_supported
& (0x1 << cm
)) == 0)
241 if (read_acpi_int(eeepc
->handle
, method
, &value
))
242 pr_warning("Error reading %s\n", method
);
249 static int parse_arg(const char *buf
, unsigned long count
, int *val
)
253 if (sscanf(buf
, "%i", val
) != 1)
258 static ssize_t
store_sys_acpi(int cm
, const char *buf
, size_t count
)
262 rv
= parse_arg(buf
, count
, &value
);
264 value
= set_acpi(cm
, value
);
270 static ssize_t
show_sys_acpi(int cm
, char *buf
)
272 int value
= get_acpi(cm
);
276 return sprintf(buf
, "%d\n", value
);
279 #define EEEPC_CREATE_DEVICE_ATTR(_name, _mode, _cm) \
280 static ssize_t show_##_name(struct device *dev, \
281 struct device_attribute *attr, \
284 return show_sys_acpi(_cm, buf); \
286 static ssize_t store_##_name(struct device *dev, \
287 struct device_attribute *attr, \
288 const char *buf, size_t count) \
290 return store_sys_acpi(_cm, buf, count); \
292 static struct device_attribute dev_attr_##_name = { \
294 .name = __stringify(_name), \
296 .show = show_##_name, \
297 .store = store_##_name, \
300 EEEPC_CREATE_DEVICE_ATTR(camera
, 0644, CM_ASL_CAMERA
);
301 EEEPC_CREATE_DEVICE_ATTR(cardr
, 0644, CM_ASL_CARDREADER
);
302 EEEPC_CREATE_DEVICE_ATTR(disp
, 0200, CM_ASL_DISPLAYSWITCH
);
309 static int get_cpufv(struct eeepc_cpufv
*c
)
311 c
->cur
= get_acpi(CM_ASL_CPUFV
);
312 c
->num
= (c
->cur
>> 8) & 0xff;
314 if (c
->cur
< 0 || c
->num
<= 0 || c
->num
> 12)
319 static ssize_t
show_available_cpufv(struct device
*dev
,
320 struct device_attribute
*attr
,
323 struct eeepc_cpufv c
;
329 for (i
= 0; i
< c
.num
; i
++)
330 len
+= sprintf(buf
+ len
, "%d ", i
);
331 len
+= sprintf(buf
+ len
, "\n");
335 static ssize_t
show_cpufv(struct device
*dev
,
336 struct device_attribute
*attr
,
339 struct eeepc_cpufv c
;
343 return sprintf(buf
, "%#x\n", (c
.num
<< 8) | c
.cur
);
346 static ssize_t
store_cpufv(struct device
*dev
,
347 struct device_attribute
*attr
,
348 const char *buf
, size_t count
)
350 struct eeepc_cpufv c
;
355 rv
= parse_arg(buf
, count
, &value
);
358 if (!rv
|| value
< 0 || value
>= c
.num
)
360 set_acpi(CM_ASL_CPUFV
, value
);
364 static struct device_attribute dev_attr_cpufv
= {
372 static struct device_attribute dev_attr_available_cpufv
= {
374 .name
= "available_cpufv",
376 .show
= show_available_cpufv
379 static struct attribute
*platform_attributes
[] = {
380 &dev_attr_camera
.attr
,
381 &dev_attr_cardr
.attr
,
383 &dev_attr_cpufv
.attr
,
384 &dev_attr_available_cpufv
.attr
,
388 static struct attribute_group platform_attribute_group
= {
389 .attrs
= platform_attributes
392 static int eeepc_platform_init(void)
396 platform_device
= platform_device_alloc(EEEPC_LAPTOP_FILE
, -1);
397 if (!platform_device
)
400 result
= platform_device_add(platform_device
);
402 goto fail_platform_device
;
404 result
= sysfs_create_group(&platform_device
->dev
.kobj
,
405 &platform_attribute_group
);
411 platform_device_del(platform_device
);
412 fail_platform_device
:
413 platform_device_put(platform_device
);
417 static void eeepc_platform_exit(void)
419 sysfs_remove_group(&platform_device
->dev
.kobj
,
420 &platform_attribute_group
);
421 platform_device_unregister(platform_device
);
428 * These functions actually update the LED's, and are called from a
429 * workqueue. By doing this as separate work rather than when the LED
430 * subsystem asks, we avoid messing with the Asus ACPI stuff during a
431 * potentially bad time, such as a timer interrupt.
433 static int tpd_led_wk
;
435 static void tpd_led_update(struct work_struct
*ignored
)
437 int value
= tpd_led_wk
;
438 set_acpi(CM_ASL_TPD
, value
);
441 static struct workqueue_struct
*led_workqueue
;
442 static DECLARE_WORK(tpd_led_work
, tpd_led_update
);
444 static void tpd_led_set(struct led_classdev
*led_cdev
,
445 enum led_brightness value
)
447 tpd_led_wk
= (value
> 0) ? 1 : 0;
448 queue_work(led_workqueue
, &tpd_led_work
);
451 static struct led_classdev tpd_led
= {
452 .name
= "eeepc::touchpad",
453 .brightness_set
= tpd_led_set
,
457 static int eeepc_led_init(struct device
*dev
)
461 if (get_acpi(CM_ASL_TPD
) == -ENODEV
)
464 led_workqueue
= create_singlethread_workqueue("led_workqueue");
468 rv
= led_classdev_register(dev
, &tpd_led
);
470 destroy_workqueue(led_workqueue
);
477 static void eeepc_led_exit(void)
480 led_classdev_unregister(&tpd_led
);
482 destroy_workqueue(led_workqueue
);
487 * PCI hotplug (for wlan rfkill)
489 static bool eeepc_wlan_rfkill_blocked(void)
491 if (get_acpi(CM_ASL_WLAN
) == 1)
496 static void eeepc_rfkill_hotplug(void)
500 bool blocked
= eeepc_wlan_rfkill_blocked();
502 if (eeepc
->wlan_rfkill
)
503 rfkill_set_sw_state(eeepc
->wlan_rfkill
, blocked
);
505 mutex_lock(&eeepc
->hotplug_lock
);
507 if (eeepc
->hotplug_slot
) {
508 bus
= pci_find_bus(0, 1);
510 pr_warning("Unable to find PCI bus 1?\n");
515 dev
= pci_get_slot(bus
, 0);
517 /* Device already present */
521 dev
= pci_scan_single_device(bus
, 0);
523 pci_bus_assign_resources(bus
);
524 if (pci_bus_add_device(dev
))
525 pr_err("Unable to hotplug wifi\n");
528 dev
= pci_get_slot(bus
, 0);
530 pci_remove_bus_device(dev
);
537 mutex_unlock(&eeepc
->hotplug_lock
);
540 static void eeepc_rfkill_notify(acpi_handle handle
, u32 event
, void *data
)
542 if (event
!= ACPI_NOTIFY_BUS_CHECK
)
545 eeepc_rfkill_hotplug();
548 static int eeepc_register_rfkill_notifier(char *node
)
550 acpi_status status
= AE_OK
;
553 status
= acpi_get_handle(NULL
, node
, &handle
);
555 if (ACPI_SUCCESS(status
)) {
556 status
= acpi_install_notify_handler(handle
,
560 if (ACPI_FAILURE(status
))
561 pr_warning("Failed to register notify on %s\n", node
);
568 static void eeepc_unregister_rfkill_notifier(char *node
)
570 acpi_status status
= AE_OK
;
573 status
= acpi_get_handle(NULL
, node
, &handle
);
575 if (ACPI_SUCCESS(status
)) {
576 status
= acpi_remove_notify_handler(handle
,
578 eeepc_rfkill_notify
);
579 if (ACPI_FAILURE(status
))
580 pr_err("Error removing rfkill notify handler %s\n",
585 static int eeepc_get_adapter_status(struct hotplug_slot
*hotplug_slot
,
588 int val
= get_acpi(CM_ASL_WLAN
);
590 if (val
== 1 || val
== 0)
598 static void eeepc_cleanup_pci_hotplug(struct hotplug_slot
*hotplug_slot
)
600 kfree(hotplug_slot
->info
);
604 static struct hotplug_slot_ops eeepc_hotplug_slot_ops
= {
605 .owner
= THIS_MODULE
,
606 .get_adapter_status
= eeepc_get_adapter_status
,
607 .get_power_status
= eeepc_get_adapter_status
,
610 static int eeepc_setup_pci_hotplug(void)
613 struct pci_bus
*bus
= pci_find_bus(0, 1);
616 pr_err("Unable to find wifi PCI bus\n");
620 eeepc
->hotplug_slot
= kzalloc(sizeof(struct hotplug_slot
), GFP_KERNEL
);
621 if (!eeepc
->hotplug_slot
)
624 eeepc
->hotplug_slot
->info
= kzalloc(sizeof(struct hotplug_slot_info
),
626 if (!eeepc
->hotplug_slot
->info
)
629 eeepc
->hotplug_slot
->private = eeepc
;
630 eeepc
->hotplug_slot
->release
= &eeepc_cleanup_pci_hotplug
;
631 eeepc
->hotplug_slot
->ops
= &eeepc_hotplug_slot_ops
;
632 eeepc_get_adapter_status(eeepc
->hotplug_slot
,
633 &eeepc
->hotplug_slot
->info
->adapter_status
);
635 ret
= pci_hp_register(eeepc
->hotplug_slot
, bus
, 0, "eeepc-wifi");
637 pr_err("Unable to register hotplug slot - %d\n", ret
);
644 kfree(eeepc
->hotplug_slot
->info
);
646 kfree(eeepc
->hotplug_slot
);
647 eeepc
->hotplug_slot
= NULL
;
655 static int eeepc_rfkill_set(void *data
, bool blocked
)
657 unsigned long asl
= (unsigned long)data
;
658 return set_acpi(asl
, !blocked
);
661 static const struct rfkill_ops eeepc_rfkill_ops
= {
662 .set_block
= eeepc_rfkill_set
,
665 static int eeepc_new_rfkill(struct rfkill
**rfkill
,
666 const char *name
, struct device
*dev
,
667 enum rfkill_type type
, int cm
)
671 result
= get_acpi(cm
);
675 *rfkill
= rfkill_alloc(name
, dev
, type
,
676 &eeepc_rfkill_ops
, (void *)(unsigned long)cm
);
681 rfkill_init_sw_state(*rfkill
, get_acpi(cm
) != 1);
682 result
= rfkill_register(*rfkill
);
684 rfkill_destroy(*rfkill
);
691 static void eeepc_rfkill_exit(void)
693 eeepc_unregister_rfkill_notifier("\\_SB.PCI0.P0P5");
694 eeepc_unregister_rfkill_notifier("\\_SB.PCI0.P0P6");
695 eeepc_unregister_rfkill_notifier("\\_SB.PCI0.P0P7");
696 if (eeepc
->wlan_rfkill
) {
697 rfkill_unregister(eeepc
->wlan_rfkill
);
698 rfkill_destroy(eeepc
->wlan_rfkill
);
699 eeepc
->wlan_rfkill
= NULL
;
702 * Refresh pci hotplug in case the rfkill state was changed after
703 * eeepc_unregister_rfkill_notifier()
705 eeepc_rfkill_hotplug();
706 if (eeepc
->hotplug_slot
)
707 pci_hp_deregister(eeepc
->hotplug_slot
);
709 if (eeepc
->bluetooth_rfkill
) {
710 rfkill_unregister(eeepc
->bluetooth_rfkill
);
711 rfkill_destroy(eeepc
->bluetooth_rfkill
);
712 eeepc
->bluetooth_rfkill
= NULL
;
714 if (eeepc
->wwan3g_rfkill
) {
715 rfkill_unregister(eeepc
->wwan3g_rfkill
);
716 rfkill_destroy(eeepc
->wwan3g_rfkill
);
717 eeepc
->wwan3g_rfkill
= NULL
;
719 if (eeepc
->wimax_rfkill
) {
720 rfkill_unregister(eeepc
->wimax_rfkill
);
721 rfkill_destroy(eeepc
->wimax_rfkill
);
722 eeepc
->wimax_rfkill
= NULL
;
726 static int eeepc_rfkill_init(struct device
*dev
)
730 mutex_init(&eeepc
->hotplug_lock
);
732 result
= eeepc_new_rfkill(&eeepc
->wlan_rfkill
,
734 RFKILL_TYPE_WLAN
, CM_ASL_WLAN
);
736 if (result
&& result
!= -ENODEV
)
739 result
= eeepc_new_rfkill(&eeepc
->bluetooth_rfkill
,
740 "eeepc-bluetooth", dev
,
741 RFKILL_TYPE_BLUETOOTH
, CM_ASL_BLUETOOTH
);
743 if (result
&& result
!= -ENODEV
)
746 result
= eeepc_new_rfkill(&eeepc
->wwan3g_rfkill
,
748 RFKILL_TYPE_WWAN
, CM_ASL_3G
);
750 if (result
&& result
!= -ENODEV
)
753 result
= eeepc_new_rfkill(&eeepc
->wimax_rfkill
,
755 RFKILL_TYPE_WIMAX
, CM_ASL_WIMAX
);
757 if (result
&& result
!= -ENODEV
)
760 result
= eeepc_setup_pci_hotplug();
762 * If we get -EBUSY then something else is handling the PCI hotplug -
763 * don't fail in this case
765 if (result
== -EBUSY
)
768 eeepc_register_rfkill_notifier("\\_SB.PCI0.P0P5");
769 eeepc_register_rfkill_notifier("\\_SB.PCI0.P0P6");
770 eeepc_register_rfkill_notifier("\\_SB.PCI0.P0P7");
772 * Refresh pci hotplug in case the rfkill state was changed during
775 eeepc_rfkill_hotplug();
778 if (result
&& result
!= -ENODEV
)
784 * Platform driver - hibernate/resume callbacks
786 static int eeepc_thaw(struct device
*device
)
788 if (eeepc
->wlan_rfkill
) {
792 * Work around bios bug - acpi _PTS turns off the wireless led
793 * during suspend. Normally it restores it on resume, but
794 * we should kick it ourselves in case hibernation is aborted.
796 wlan
= get_acpi(CM_ASL_WLAN
);
797 set_acpi(CM_ASL_WLAN
, wlan
);
803 static int eeepc_restore(struct device
*device
)
805 /* Refresh both wlan rfkill state and pci hotplug */
806 if (eeepc
->wlan_rfkill
)
807 eeepc_rfkill_hotplug();
809 if (eeepc
->bluetooth_rfkill
)
810 rfkill_set_sw_state(eeepc
->bluetooth_rfkill
,
811 get_acpi(CM_ASL_BLUETOOTH
) != 1);
812 if (eeepc
->wwan3g_rfkill
)
813 rfkill_set_sw_state(eeepc
->wwan3g_rfkill
,
814 get_acpi(CM_ASL_3G
) != 1);
815 if (eeepc
->wimax_rfkill
)
816 rfkill_set_sw_state(eeepc
->wimax_rfkill
,
817 get_acpi(CM_ASL_WIMAX
) != 1);
822 static struct dev_pm_ops eeepc_pm_ops
= {
824 .restore
= eeepc_restore
,
827 static struct platform_driver platform_driver
= {
829 .name
= EEEPC_LAPTOP_FILE
,
830 .owner
= THIS_MODULE
,
839 #define EEEPC_EC_SC00 0x61
840 #define EEEPC_EC_FAN_PWM (EEEPC_EC_SC00 + 2) /* Fan PWM duty cycle (%) */
841 #define EEEPC_EC_FAN_HRPM (EEEPC_EC_SC00 + 5) /* High byte, fan speed (RPM) */
842 #define EEEPC_EC_FAN_LRPM (EEEPC_EC_SC00 + 6) /* Low byte, fan speed (RPM) */
844 #define EEEPC_EC_SFB0 0xD0
845 #define EEEPC_EC_FAN_CTRL (EEEPC_EC_SFB0 + 3) /* Byte containing SF25 */
847 static int eeepc_get_fan_pwm(void)
851 ec_read(EEEPC_EC_FAN_PWM
, &value
);
852 return value
* 255 / 100;
855 static void eeepc_set_fan_pwm(int value
)
857 value
= SENSORS_LIMIT(value
, 0, 255);
858 value
= value
* 100 / 255;
859 ec_write(EEEPC_EC_FAN_PWM
, value
);
862 static int eeepc_get_fan_rpm(void)
867 ec_read(EEEPC_EC_FAN_HRPM
, &high
);
868 ec_read(EEEPC_EC_FAN_LRPM
, &low
);
869 return high
<< 8 | low
;
872 static int eeepc_get_fan_ctrl(void)
876 ec_read(EEEPC_EC_FAN_CTRL
, &value
);
878 return 1; /* manual */
880 return 2; /* automatic */
883 static void eeepc_set_fan_ctrl(int manual
)
887 ec_read(EEEPC_EC_FAN_CTRL
, &value
);
892 ec_write(EEEPC_EC_FAN_CTRL
, value
);
895 static ssize_t
store_sys_hwmon(void (*set
)(int), const char *buf
, size_t count
)
899 rv
= parse_arg(buf
, count
, &value
);
905 static ssize_t
show_sys_hwmon(int (*get
)(void), char *buf
)
907 return sprintf(buf
, "%d\n", get());
910 #define EEEPC_CREATE_SENSOR_ATTR(_name, _mode, _set, _get) \
911 static ssize_t show_##_name(struct device *dev, \
912 struct device_attribute *attr, \
915 return show_sys_hwmon(_set, buf); \
917 static ssize_t store_##_name(struct device *dev, \
918 struct device_attribute *attr, \
919 const char *buf, size_t count) \
921 return store_sys_hwmon(_get, buf, count); \
923 static SENSOR_DEVICE_ATTR(_name, _mode, show_##_name, store_##_name, 0);
925 EEEPC_CREATE_SENSOR_ATTR(fan1_input
, S_IRUGO
, eeepc_get_fan_rpm
, NULL
);
926 EEEPC_CREATE_SENSOR_ATTR(pwm1
, S_IRUGO
| S_IWUSR
,
927 eeepc_get_fan_pwm
, eeepc_set_fan_pwm
);
928 EEEPC_CREATE_SENSOR_ATTR(pwm1_enable
, S_IRUGO
| S_IWUSR
,
929 eeepc_get_fan_ctrl
, eeepc_set_fan_ctrl
);
932 show_name(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
934 return sprintf(buf
, "eeepc\n");
936 static SENSOR_DEVICE_ATTR(name
, S_IRUGO
, show_name
, NULL
, 0);
938 static struct attribute
*hwmon_attributes
[] = {
939 &sensor_dev_attr_pwm1
.dev_attr
.attr
,
940 &sensor_dev_attr_fan1_input
.dev_attr
.attr
,
941 &sensor_dev_attr_pwm1_enable
.dev_attr
.attr
,
942 &sensor_dev_attr_name
.dev_attr
.attr
,
946 static struct attribute_group hwmon_attribute_group
= {
947 .attrs
= hwmon_attributes
950 static void eeepc_hwmon_exit(void)
952 struct device
*hwmon
;
954 hwmon
= eeepc_hwmon_device
;
957 sysfs_remove_group(&hwmon
->kobj
,
958 &hwmon_attribute_group
);
959 hwmon_device_unregister(hwmon
);
960 eeepc_hwmon_device
= NULL
;
963 static int eeepc_hwmon_init(struct device
*dev
)
965 struct device
*hwmon
;
968 hwmon
= hwmon_device_register(dev
);
970 pr_err("Could not register eeepc hwmon device\n");
971 eeepc_hwmon_device
= NULL
;
972 return PTR_ERR(hwmon
);
974 eeepc_hwmon_device
= hwmon
;
975 result
= sysfs_create_group(&hwmon
->kobj
,
976 &hwmon_attribute_group
);
985 static int read_brightness(struct backlight_device
*bd
)
987 return get_acpi(CM_ASL_PANELBRIGHT
);
990 static int set_brightness(struct backlight_device
*bd
, int value
)
992 return set_acpi(CM_ASL_PANELBRIGHT
, value
);
995 static int update_bl_status(struct backlight_device
*bd
)
997 return set_brightness(bd
, bd
->props
.brightness
);
1000 static struct backlight_ops eeepcbl_ops
= {
1001 .get_brightness
= read_brightness
,
1002 .update_status
= update_bl_status
,
1005 static int eeepc_backlight_notify(void)
1007 struct backlight_device
*bd
= eeepc_backlight_device
;
1008 int old
= bd
->props
.brightness
;
1010 backlight_force_update(bd
, BACKLIGHT_UPDATE_HOTKEY
);
1015 static int eeepc_backlight_init(struct device
*dev
)
1017 struct backlight_device
*bd
;
1019 bd
= backlight_device_register(EEEPC_LAPTOP_FILE
, dev
,
1020 NULL
, &eeepcbl_ops
);
1022 pr_err("Could not register eeepc backlight device\n");
1023 eeepc_backlight_device
= NULL
;
1026 eeepc_backlight_device
= bd
;
1027 bd
->props
.max_brightness
= 15;
1028 bd
->props
.brightness
= read_brightness(NULL
);
1029 bd
->props
.power
= FB_BLANK_UNBLANK
;
1030 backlight_update_status(bd
);
1034 static void eeepc_backlight_exit(void)
1036 if (eeepc_backlight_device
)
1037 backlight_device_unregister(eeepc_backlight_device
);
1038 eeepc_backlight_device
= NULL
;
1043 * Input device (i.e. hotkeys)
1045 static struct key_entry
*eeepc_get_entry_by_scancode(int code
)
1047 struct key_entry
*key
;
1049 for (key
= eeepc_keymap
; key
->type
!= KE_END
; key
++)
1050 if (code
== key
->code
)
1056 static void eeepc_input_notify(int event
)
1058 static struct key_entry
*key
;
1060 key
= eeepc_get_entry_by_scancode(event
);
1062 switch (key
->type
) {
1064 input_report_key(eeepc
->inputdev
, key
->keycode
,
1066 input_sync(eeepc
->inputdev
);
1067 input_report_key(eeepc
->inputdev
, key
->keycode
,
1069 input_sync(eeepc
->inputdev
);
1075 static struct key_entry
*eepc_get_entry_by_keycode(int code
)
1077 struct key_entry
*key
;
1079 for (key
= eeepc_keymap
; key
->type
!= KE_END
; key
++)
1080 if (code
== key
->keycode
&& key
->type
== KE_KEY
)
1086 static int eeepc_getkeycode(struct input_dev
*dev
, int scancode
, int *keycode
)
1088 struct key_entry
*key
= eeepc_get_entry_by_scancode(scancode
);
1090 if (key
&& key
->type
== KE_KEY
) {
1091 *keycode
= key
->keycode
;
1098 static int eeepc_setkeycode(struct input_dev
*dev
, int scancode
, int keycode
)
1100 struct key_entry
*key
;
1103 if (keycode
< 0 || keycode
> KEY_MAX
)
1106 key
= eeepc_get_entry_by_scancode(scancode
);
1107 if (key
&& key
->type
== KE_KEY
) {
1108 old_keycode
= key
->keycode
;
1109 key
->keycode
= keycode
;
1110 set_bit(keycode
, dev
->keybit
);
1111 if (!eepc_get_entry_by_keycode(old_keycode
))
1112 clear_bit(old_keycode
, dev
->keybit
);
1119 static int eeepc_input_init(struct device
*dev
)
1121 const struct key_entry
*key
;
1124 eeepc
->inputdev
= input_allocate_device();
1125 if (!eeepc
->inputdev
) {
1126 pr_info("Unable to allocate input device\n");
1129 eeepc
->inputdev
->name
= "Asus EeePC extra buttons";
1130 eeepc
->inputdev
->dev
.parent
= dev
;
1131 eeepc
->inputdev
->phys
= EEEPC_LAPTOP_FILE
"/input0";
1132 eeepc
->inputdev
->id
.bustype
= BUS_HOST
;
1133 eeepc
->inputdev
->getkeycode
= eeepc_getkeycode
;
1134 eeepc
->inputdev
->setkeycode
= eeepc_setkeycode
;
1136 for (key
= eeepc_keymap
; key
->type
!= KE_END
; key
++) {
1137 switch (key
->type
) {
1139 set_bit(EV_KEY
, eeepc
->inputdev
->evbit
);
1140 set_bit(key
->keycode
, eeepc
->inputdev
->keybit
);
1144 result
= input_register_device(eeepc
->inputdev
);
1146 pr_info("Unable to register input device\n");
1147 input_free_device(eeepc
->inputdev
);
1153 static void eeepc_input_exit(void)
1155 if (eeepc
->inputdev
)
1156 input_unregister_device(eeepc
->inputdev
);
1162 static void eeepc_acpi_notify(struct acpi_device
*device
, u32 event
)
1166 if (event
> ACPI_MAX_SYS_NOTIFY
)
1168 count
= eeepc
->event_count
[event
% 128]++;
1169 acpi_bus_generate_proc_event(eeepc
->device
, event
, count
);
1170 acpi_bus_generate_netlink_event(eeepc
->device
->pnp
.device_class
,
1171 dev_name(&eeepc
->device
->dev
), event
,
1174 if (event
>= NOTIFY_BRN_MIN
&& event
<= NOTIFY_BRN_MAX
) {
1175 int old_brightness
, new_brightness
;
1177 /* Update backlight device. */
1178 old_brightness
= eeepc_backlight_notify();
1180 /* Convert brightness event to keypress (obsolescent hack). */
1181 new_brightness
= event
- NOTIFY_BRN_MIN
;
1183 if (new_brightness
< old_brightness
) {
1184 event
= NOTIFY_BRN_MIN
; /* brightness down */
1185 } else if (new_brightness
> old_brightness
) {
1186 event
= NOTIFY_BRN_MAX
; /* brightness up */
1189 * no change in brightness - already at min/max,
1190 * event will be desired value (or else ignored).
1194 eeepc_input_notify(event
);
1197 static void cmsg_quirk(int cm
, const char *name
)
1201 /* Some BIOSes do not report cm although it is avaliable.
1202 Check if cm_getv[cm] works and, if yes, assume cm should be set. */
1203 if (!(eeepc
->cm_supported
& (1 << cm
))
1204 && !read_acpi_int(eeepc
->handle
, cm_getv
[cm
], &dummy
)) {
1205 pr_info("%s (%x) not reported by BIOS,"
1206 " enabling anyway\n", name
, 1 << cm
);
1207 eeepc
->cm_supported
|= 1 << cm
;
1211 static void cmsg_quirks(void)
1213 cmsg_quirk(CM_ASL_LID
, "LID");
1214 cmsg_quirk(CM_ASL_TYPE
, "TYPE");
1215 cmsg_quirk(CM_ASL_PANELPOWER
, "PANELPOWER");
1216 cmsg_quirk(CM_ASL_TPD
, "TPD");
1219 static int eeepc_acpi_init(void)
1221 unsigned int init_flags
;
1224 result
= acpi_bus_get_status(eeepc
->device
);
1227 if (!eeepc
->device
->status
.present
) {
1228 pr_err("Hotkey device not present, aborting\n");
1232 init_flags
= DISABLE_ASL_WLAN
| DISABLE_ASL_DISPLAYSWITCH
;
1233 pr_notice("Hotkey init flags 0x%x\n", init_flags
);
1235 if (write_acpi_int(eeepc
->handle
, "INIT", init_flags
)) {
1236 pr_err("Hotkey initialization failed\n");
1240 /* get control methods supported */
1241 if (read_acpi_int(eeepc
->handle
, "CMSG", &eeepc
->cm_supported
)) {
1242 pr_err("Get control methods supported failed\n");
1246 pr_info("Get control methods supported: 0x%x\n", eeepc
->cm_supported
);
1251 static void __devinit
eeepc_enable_camera(void)
1254 * If the following call to set_acpi() fails, it's because there's no
1255 * camera so we can ignore the error.
1257 if (get_acpi(CM_ASL_CAMERA
) == 0)
1258 set_acpi(CM_ASL_CAMERA
, 1);
1261 static int __devinit
eeepc_acpi_add(struct acpi_device
*device
)
1266 pr_notice(EEEPC_LAPTOP_NAME
"\n");
1267 eeepc
= kzalloc(sizeof(struct eeepc_laptop
), GFP_KERNEL
);
1270 eeepc
->handle
= device
->handle
;
1271 strcpy(acpi_device_name(device
), EEEPC_ACPI_DEVICE_NAME
);
1272 strcpy(acpi_device_class(device
), EEEPC_ACPI_CLASS
);
1273 device
->driver_data
= eeepc
;
1274 eeepc
->device
= device
;
1276 result
= eeepc_acpi_init();
1279 eeepc_enable_camera();
1281 result
= eeepc_platform_init();
1284 dev
= &platform_device
->dev
;
1286 if (!acpi_video_backlight_support()) {
1287 result
= eeepc_backlight_init(dev
);
1289 goto fail_backlight
;
1291 pr_info("Backlight controlled by ACPI video driver\n");
1293 result
= eeepc_input_init(dev
);
1297 result
= eeepc_hwmon_init(dev
);
1301 result
= eeepc_led_init(dev
);
1305 result
= eeepc_rfkill_init(dev
);
1318 eeepc_backlight_exit();
1320 eeepc_platform_exit();
1327 static int eeepc_acpi_remove(struct acpi_device
*device
, int type
)
1329 eeepc_backlight_exit();
1330 eeepc_rfkill_exit();
1334 eeepc_platform_exit();
1341 static const struct acpi_device_id eeepc_device_ids
[] = {
1342 {EEEPC_ACPI_HID
, 0},
1345 MODULE_DEVICE_TABLE(acpi
, eeepc_device_ids
);
1347 static struct acpi_driver eeepc_acpi_driver
= {
1348 .name
= EEEPC_LAPTOP_NAME
,
1349 .class = EEEPC_ACPI_CLASS
,
1350 .owner
= THIS_MODULE
,
1351 .ids
= eeepc_device_ids
,
1352 .flags
= ACPI_DRIVER_ALL_NOTIFY_EVENTS
,
1354 .add
= eeepc_acpi_add
,
1355 .remove
= eeepc_acpi_remove
,
1356 .notify
= eeepc_acpi_notify
,
1361 static int __init
eeepc_laptop_init(void)
1365 result
= platform_driver_register(&platform_driver
);
1369 result
= acpi_bus_register_driver(&eeepc_acpi_driver
);
1371 goto fail_acpi_driver
;
1374 goto fail_no_device
;
1379 acpi_bus_unregister_driver(&eeepc_acpi_driver
);
1381 platform_driver_unregister(&platform_driver
);
1385 static void __exit
eeepc_laptop_exit(void)
1387 acpi_bus_unregister_driver(&eeepc_acpi_driver
);
1388 platform_driver_unregister(&platform_driver
);
1391 module_init(eeepc_laptop_init
);
1392 module_exit(eeepc_laptop_exit
);