2 * eepc-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"
41 #define EEEPC_HOTK_NAME "Eee PC Hotkey Driver"
42 #define EEEPC_HOTK_FILE "eeepc"
43 #define EEEPC_HOTK_CLASS "hotkey"
44 #define EEEPC_HOTK_DEVICE_NAME "Hotkey"
45 #define EEEPC_HOTK_HID "ASUS010"
47 MODULE_AUTHOR("Corentin Chary, Eric Cooper");
48 MODULE_DESCRIPTION(EEEPC_HOTK_NAME
);
49 MODULE_LICENSE("GPL");
52 * Definitions for Asus EeePC
54 #define NOTIFY_WLAN_ON 0x10
55 #define NOTIFY_BRN_MIN 0x20
56 #define NOTIFY_BRN_MAX 0x2f
59 DISABLE_ASL_WLAN
= 0x0001,
60 DISABLE_ASL_BLUETOOTH
= 0x0002,
61 DISABLE_ASL_IRDA
= 0x0004,
62 DISABLE_ASL_CAMERA
= 0x0008,
63 DISABLE_ASL_TV
= 0x0010,
64 DISABLE_ASL_GPS
= 0x0020,
65 DISABLE_ASL_DISPLAYSWITCH
= 0x0040,
66 DISABLE_ASL_MODEM
= 0x0080,
67 DISABLE_ASL_CARDREADER
= 0x0100,
68 DISABLE_ASL_3G
= 0x0200,
69 DISABLE_ASL_WIMAX
= 0x0400,
70 DISABLE_ASL_HWCF
= 0x0800
87 CM_ASL_CPUTEMPERATURE
,
100 CM_ASL_PANELPOWER
, /*P901*/
104 static const char *cm_getv
[] = {
105 "WLDG", "BTHG", NULL
, NULL
,
106 "CAMG", NULL
, NULL
, NULL
,
107 NULL
, "PBLG", NULL
, NULL
,
108 "CFVG", NULL
, NULL
, NULL
,
109 "USBG", NULL
, NULL
, "MODG",
110 "CRDG", "M3GG", "WIMG", "HWCF",
111 "LIDG", "TYPE", "PBPG", "TPDG"
114 static const char *cm_setv
[] = {
115 "WLDS", "BTHS", NULL
, NULL
,
116 "CAMS", NULL
, NULL
, NULL
,
117 "SDSP", "PBLS", "HDPS", NULL
,
118 "CFVS", NULL
, NULL
, NULL
,
119 "USBG", NULL
, NULL
, "MODS",
120 "CRDS", "M3GS", "WIMS", NULL
,
121 NULL
, NULL
, "PBPS", "TPDS"
130 enum { KE_KEY
, KE_END
};
132 static struct key_entry eeepc_keymap
[] = {
133 /* Sleep already handled via generic ACPI code */
134 {KE_KEY
, 0x10, KEY_WLAN
},
135 {KE_KEY
, 0x11, KEY_WLAN
},
136 {KE_KEY
, 0x12, KEY_PROG1
},
137 {KE_KEY
, 0x13, KEY_MUTE
},
138 {KE_KEY
, 0x14, KEY_VOLUMEDOWN
},
139 {KE_KEY
, 0x15, KEY_VOLUMEUP
},
140 {KE_KEY
, 0x1a, KEY_COFFEE
},
141 {KE_KEY
, 0x1b, KEY_ZOOM
},
142 {KE_KEY
, 0x1c, KEY_PROG2
},
143 {KE_KEY
, 0x1d, KEY_PROG3
},
144 {KE_KEY
, NOTIFY_BRN_MIN
, KEY_BRIGHTNESSDOWN
},
145 {KE_KEY
, NOTIFY_BRN_MAX
, KEY_BRIGHTNESSUP
},
146 {KE_KEY
, 0x30, KEY_SWITCHVIDEOMODE
},
147 {KE_KEY
, 0x31, KEY_SWITCHVIDEOMODE
},
148 {KE_KEY
, 0x32, KEY_SWITCHVIDEOMODE
},
154 * This is the main structure, we can use it to store useful information
155 * about the hotk device
158 struct acpi_device
*device
; /* the device we are in */
159 acpi_handle handle
; /* the handle of the hotk device */
160 u32 cm_supported
; /* the control methods supported
162 u16 event_count
[128]; /* count for each event */
163 struct input_dev
*inputdev
;
165 struct rfkill
*wlan_rfkill
;
166 struct rfkill
*bluetooth_rfkill
;
167 struct rfkill
*wwan3g_rfkill
;
168 struct rfkill
*wimax_rfkill
;
169 struct hotplug_slot
*hotplug_slot
;
170 struct mutex hotplug_lock
;
173 /* The actual device the driver binds to */
174 static struct eeepc_hotk
*ehotk
;
176 /* The platform device */
177 static struct platform_device
*platform_device
;
179 /* The backlight device /sys/class/backlight */
180 static struct backlight_device
*eeepc_backlight_device
;
182 /* The hwmon device */
183 static struct device
*eeepc_hwmon_device
;
189 static int write_acpi_int(acpi_handle handle
, const char *method
, int val
)
191 struct acpi_object_list params
;
192 union acpi_object in_obj
;
196 params
.pointer
= &in_obj
;
197 in_obj
.type
= ACPI_TYPE_INTEGER
;
198 in_obj
.integer
.value
= val
;
200 status
= acpi_evaluate_object(handle
, (char *)method
, ¶ms
, NULL
);
201 return (status
== AE_OK
? 0 : -1);
204 static int read_acpi_int(acpi_handle handle
, const char *method
, int *val
)
207 unsigned long long result
;
209 status
= acpi_evaluate_integer(handle
, (char *)method
, NULL
, &result
);
210 if (ACPI_FAILURE(status
)) {
219 static int set_acpi(int cm
, int value
)
221 const char *method
= cm_setv
[cm
];
225 if ((ehotk
->cm_supported
& (0x1 << cm
)) == 0)
228 if (write_acpi_int(ehotk
->handle
, method
, value
))
229 pr_warning("Error writing %s\n", method
);
233 static int get_acpi(int cm
)
235 const char *method
= cm_getv
[cm
];
240 if ((ehotk
->cm_supported
& (0x1 << cm
)) == 0)
243 if (read_acpi_int(ehotk
->handle
, method
, &value
))
244 pr_warning("Error reading %s\n", method
);
251 static int parse_arg(const char *buf
, unsigned long count
, int *val
)
255 if (sscanf(buf
, "%i", val
) != 1)
260 static ssize_t
store_sys_acpi(int cm
, const char *buf
, size_t count
)
264 rv
= parse_arg(buf
, count
, &value
);
266 value
= set_acpi(cm
, value
);
272 static ssize_t
show_sys_acpi(int cm
, char *buf
)
274 int value
= get_acpi(cm
);
278 return sprintf(buf
, "%d\n", value
);
281 #define EEEPC_CREATE_DEVICE_ATTR(_name, _mode, _cm) \
282 static ssize_t show_##_name(struct device *dev, \
283 struct device_attribute *attr, \
286 return show_sys_acpi(_cm, buf); \
288 static ssize_t store_##_name(struct device *dev, \
289 struct device_attribute *attr, \
290 const char *buf, size_t count) \
292 return store_sys_acpi(_cm, buf, count); \
294 static struct device_attribute dev_attr_##_name = { \
296 .name = __stringify(_name), \
298 .show = show_##_name, \
299 .store = store_##_name, \
302 EEEPC_CREATE_DEVICE_ATTR(camera
, 0644, CM_ASL_CAMERA
);
303 EEEPC_CREATE_DEVICE_ATTR(cardr
, 0644, CM_ASL_CARDREADER
);
304 EEEPC_CREATE_DEVICE_ATTR(disp
, 0200, CM_ASL_DISPLAYSWITCH
);
311 static int get_cpufv(struct eeepc_cpufv
*c
)
313 c
->cur
= get_acpi(CM_ASL_CPUFV
);
314 c
->num
= (c
->cur
>> 8) & 0xff;
316 if (c
->cur
< 0 || c
->num
<= 0 || c
->num
> 12)
321 static ssize_t
show_available_cpufv(struct device
*dev
,
322 struct device_attribute
*attr
,
325 struct eeepc_cpufv c
;
331 for (i
= 0; i
< c
.num
; i
++)
332 len
+= sprintf(buf
+ len
, "%d ", i
);
333 len
+= sprintf(buf
+ len
, "\n");
337 static ssize_t
show_cpufv(struct device
*dev
,
338 struct device_attribute
*attr
,
341 struct eeepc_cpufv c
;
345 return sprintf(buf
, "%#x\n", (c
.num
<< 8) | c
.cur
);
348 static ssize_t
store_cpufv(struct device
*dev
,
349 struct device_attribute
*attr
,
350 const char *buf
, size_t count
)
352 struct eeepc_cpufv c
;
357 rv
= parse_arg(buf
, count
, &value
);
360 if (!rv
|| value
< 0 || value
>= c
.num
)
362 set_acpi(CM_ASL_CPUFV
, value
);
366 static struct device_attribute dev_attr_cpufv
= {
374 static struct device_attribute dev_attr_available_cpufv
= {
376 .name
= "available_cpufv",
378 .show
= show_available_cpufv
381 static struct attribute
*platform_attributes
[] = {
382 &dev_attr_camera
.attr
,
383 &dev_attr_cardr
.attr
,
385 &dev_attr_cpufv
.attr
,
386 &dev_attr_available_cpufv
.attr
,
390 static struct attribute_group platform_attribute_group
= {
391 .attrs
= platform_attributes
394 static int eeepc_platform_init(void)
398 platform_device
= platform_device_alloc(EEEPC_HOTK_FILE
, -1);
399 if (!platform_device
)
402 result
= platform_device_add(platform_device
);
404 goto fail_platform_device
;
406 result
= sysfs_create_group(&platform_device
->dev
.kobj
,
407 &platform_attribute_group
);
413 platform_device_del(platform_device
);
414 fail_platform_device
:
415 platform_device_put(platform_device
);
419 static void eeepc_platform_exit(void)
421 sysfs_remove_group(&platform_device
->dev
.kobj
,
422 &platform_attribute_group
);
423 platform_device_unregister(platform_device
);
430 * These functions actually update the LED's, and are called from a
431 * workqueue. By doing this as separate work rather than when the LED
432 * subsystem asks, we avoid messing with the Asus ACPI stuff during a
433 * potentially bad time, such as a timer interrupt.
435 static int tpd_led_wk
;
437 static void tpd_led_update(struct work_struct
*ignored
)
439 int value
= tpd_led_wk
;
440 set_acpi(CM_ASL_TPD
, value
);
443 static struct workqueue_struct
*led_workqueue
;
444 static DECLARE_WORK(tpd_led_work
, tpd_led_update
);
446 static void tpd_led_set(struct led_classdev
*led_cdev
,
447 enum led_brightness value
)
449 tpd_led_wk
= (value
> 0) ? 1 : 0;
450 queue_work(led_workqueue
, &tpd_led_work
);
453 static struct led_classdev tpd_led
= {
454 .name
= "eeepc::touchpad",
455 .brightness_set
= tpd_led_set
,
459 static int eeepc_led_init(struct device
*dev
)
463 if (get_acpi(CM_ASL_TPD
) == -ENODEV
)
466 led_workqueue
= create_singlethread_workqueue("led_workqueue");
470 rv
= led_classdev_register(dev
, &tpd_led
);
472 destroy_workqueue(led_workqueue
);
479 static void eeepc_led_exit(void)
482 led_classdev_unregister(&tpd_led
);
484 destroy_workqueue(led_workqueue
);
489 * PCI hotplug (for wlan rfkill)
491 static bool eeepc_wlan_rfkill_blocked(void)
493 if (get_acpi(CM_ASL_WLAN
) == 1)
498 static void eeepc_rfkill_hotplug(void)
502 bool blocked
= eeepc_wlan_rfkill_blocked();
504 if (ehotk
->wlan_rfkill
)
505 rfkill_set_sw_state(ehotk
->wlan_rfkill
, blocked
);
507 mutex_lock(&ehotk
->hotplug_lock
);
509 if (ehotk
->hotplug_slot
) {
510 bus
= pci_find_bus(0, 1);
512 pr_warning("Unable to find PCI bus 1?\n");
517 dev
= pci_get_slot(bus
, 0);
519 /* Device already present */
523 dev
= pci_scan_single_device(bus
, 0);
525 pci_bus_assign_resources(bus
);
526 if (pci_bus_add_device(dev
))
527 pr_err("Unable to hotplug wifi\n");
530 dev
= pci_get_slot(bus
, 0);
532 pci_remove_bus_device(dev
);
539 mutex_unlock(&ehotk
->hotplug_lock
);
542 static void eeepc_rfkill_notify(acpi_handle handle
, u32 event
, void *data
)
544 if (event
!= ACPI_NOTIFY_BUS_CHECK
)
547 eeepc_rfkill_hotplug();
550 static int eeepc_register_rfkill_notifier(char *node
)
552 acpi_status status
= AE_OK
;
555 status
= acpi_get_handle(NULL
, node
, &handle
);
557 if (ACPI_SUCCESS(status
)) {
558 status
= acpi_install_notify_handler(handle
,
562 if (ACPI_FAILURE(status
))
563 pr_warning("Failed to register notify on %s\n", node
);
570 static void eeepc_unregister_rfkill_notifier(char *node
)
572 acpi_status status
= AE_OK
;
575 status
= acpi_get_handle(NULL
, node
, &handle
);
577 if (ACPI_SUCCESS(status
)) {
578 status
= acpi_remove_notify_handler(handle
,
580 eeepc_rfkill_notify
);
581 if (ACPI_FAILURE(status
))
582 pr_err("Error removing rfkill notify handler %s\n",
587 static int eeepc_get_adapter_status(struct hotplug_slot
*hotplug_slot
,
590 int val
= get_acpi(CM_ASL_WLAN
);
592 if (val
== 1 || val
== 0)
600 static void eeepc_cleanup_pci_hotplug(struct hotplug_slot
*hotplug_slot
)
602 kfree(hotplug_slot
->info
);
606 static struct hotplug_slot_ops eeepc_hotplug_slot_ops
= {
607 .owner
= THIS_MODULE
,
608 .get_adapter_status
= eeepc_get_adapter_status
,
609 .get_power_status
= eeepc_get_adapter_status
,
612 static int eeepc_setup_pci_hotplug(void)
615 struct pci_bus
*bus
= pci_find_bus(0, 1);
618 pr_err("Unable to find wifi PCI bus\n");
622 ehotk
->hotplug_slot
= kzalloc(sizeof(struct hotplug_slot
), GFP_KERNEL
);
623 if (!ehotk
->hotplug_slot
)
626 ehotk
->hotplug_slot
->info
= kzalloc(sizeof(struct hotplug_slot_info
),
628 if (!ehotk
->hotplug_slot
->info
)
631 ehotk
->hotplug_slot
->private = ehotk
;
632 ehotk
->hotplug_slot
->release
= &eeepc_cleanup_pci_hotplug
;
633 ehotk
->hotplug_slot
->ops
= &eeepc_hotplug_slot_ops
;
634 eeepc_get_adapter_status(ehotk
->hotplug_slot
,
635 &ehotk
->hotplug_slot
->info
->adapter_status
);
637 ret
= pci_hp_register(ehotk
->hotplug_slot
, bus
, 0, "eeepc-wifi");
639 pr_err("Unable to register hotplug slot - %d\n", ret
);
646 kfree(ehotk
->hotplug_slot
->info
);
648 kfree(ehotk
->hotplug_slot
);
649 ehotk
->hotplug_slot
= NULL
;
657 static int eeepc_rfkill_set(void *data
, bool blocked
)
659 unsigned long asl
= (unsigned long)data
;
660 return set_acpi(asl
, !blocked
);
663 static const struct rfkill_ops eeepc_rfkill_ops
= {
664 .set_block
= eeepc_rfkill_set
,
667 static int eeepc_new_rfkill(struct rfkill
**rfkill
,
668 const char *name
, struct device
*dev
,
669 enum rfkill_type type
, int cm
)
673 result
= get_acpi(cm
);
677 *rfkill
= rfkill_alloc(name
, dev
, type
,
678 &eeepc_rfkill_ops
, (void *)(unsigned long)cm
);
683 rfkill_init_sw_state(*rfkill
, get_acpi(cm
) != 1);
684 result
= rfkill_register(*rfkill
);
686 rfkill_destroy(*rfkill
);
693 static void eeepc_rfkill_exit(void)
695 eeepc_unregister_rfkill_notifier("\\_SB.PCI0.P0P5");
696 eeepc_unregister_rfkill_notifier("\\_SB.PCI0.P0P6");
697 eeepc_unregister_rfkill_notifier("\\_SB.PCI0.P0P7");
698 if (ehotk
->wlan_rfkill
) {
699 rfkill_unregister(ehotk
->wlan_rfkill
);
700 rfkill_destroy(ehotk
->wlan_rfkill
);
701 ehotk
->wlan_rfkill
= NULL
;
704 * Refresh pci hotplug in case the rfkill state was changed after
705 * eeepc_unregister_rfkill_notifier()
707 eeepc_rfkill_hotplug();
708 if (ehotk
->hotplug_slot
)
709 pci_hp_deregister(ehotk
->hotplug_slot
);
711 if (ehotk
->bluetooth_rfkill
) {
712 rfkill_unregister(ehotk
->bluetooth_rfkill
);
713 rfkill_destroy(ehotk
->bluetooth_rfkill
);
714 ehotk
->bluetooth_rfkill
= NULL
;
716 if (ehotk
->wwan3g_rfkill
) {
717 rfkill_unregister(ehotk
->wwan3g_rfkill
);
718 rfkill_destroy(ehotk
->wwan3g_rfkill
);
719 ehotk
->wwan3g_rfkill
= NULL
;
721 if (ehotk
->wimax_rfkill
) {
722 rfkill_unregister(ehotk
->wimax_rfkill
);
723 rfkill_destroy(ehotk
->wimax_rfkill
);
724 ehotk
->wimax_rfkill
= NULL
;
728 static int eeepc_rfkill_init(struct device
*dev
)
732 mutex_init(&ehotk
->hotplug_lock
);
734 result
= eeepc_new_rfkill(&ehotk
->wlan_rfkill
,
736 RFKILL_TYPE_WLAN
, CM_ASL_WLAN
);
738 if (result
&& result
!= -ENODEV
)
741 result
= eeepc_new_rfkill(&ehotk
->bluetooth_rfkill
,
742 "eeepc-bluetooth", dev
,
743 RFKILL_TYPE_BLUETOOTH
, CM_ASL_BLUETOOTH
);
745 if (result
&& result
!= -ENODEV
)
748 result
= eeepc_new_rfkill(&ehotk
->wwan3g_rfkill
,
750 RFKILL_TYPE_WWAN
, CM_ASL_3G
);
752 if (result
&& result
!= -ENODEV
)
755 result
= eeepc_new_rfkill(&ehotk
->wimax_rfkill
,
757 RFKILL_TYPE_WIMAX
, CM_ASL_WIMAX
);
759 if (result
&& result
!= -ENODEV
)
762 result
= eeepc_setup_pci_hotplug();
764 * If we get -EBUSY then something else is handling the PCI hotplug -
765 * don't fail in this case
767 if (result
== -EBUSY
)
770 eeepc_register_rfkill_notifier("\\_SB.PCI0.P0P5");
771 eeepc_register_rfkill_notifier("\\_SB.PCI0.P0P6");
772 eeepc_register_rfkill_notifier("\\_SB.PCI0.P0P7");
774 * Refresh pci hotplug in case the rfkill state was changed during
777 eeepc_rfkill_hotplug();
780 if (result
&& result
!= -ENODEV
)
786 * Platform driver - hibernate/resume callbacks
788 static int eeepc_hotk_thaw(struct device
*device
)
790 if (ehotk
->wlan_rfkill
) {
794 * Work around bios bug - acpi _PTS turns off the wireless led
795 * during suspend. Normally it restores it on resume, but
796 * we should kick it ourselves in case hibernation is aborted.
798 wlan
= get_acpi(CM_ASL_WLAN
);
799 set_acpi(CM_ASL_WLAN
, wlan
);
805 static int eeepc_hotk_restore(struct device
*device
)
807 /* Refresh both wlan rfkill state and pci hotplug */
808 if (ehotk
->wlan_rfkill
)
809 eeepc_rfkill_hotplug();
811 if (ehotk
->bluetooth_rfkill
)
812 rfkill_set_sw_state(ehotk
->bluetooth_rfkill
,
813 get_acpi(CM_ASL_BLUETOOTH
) != 1);
814 if (ehotk
->wwan3g_rfkill
)
815 rfkill_set_sw_state(ehotk
->wwan3g_rfkill
,
816 get_acpi(CM_ASL_3G
) != 1);
817 if (ehotk
->wimax_rfkill
)
818 rfkill_set_sw_state(ehotk
->wimax_rfkill
,
819 get_acpi(CM_ASL_WIMAX
) != 1);
824 static struct dev_pm_ops eeepc_pm_ops
= {
825 .thaw
= eeepc_hotk_thaw
,
826 .restore
= eeepc_hotk_restore
,
829 static struct platform_driver platform_driver
= {
831 .name
= EEEPC_HOTK_FILE
,
832 .owner
= THIS_MODULE
,
841 #define EEEPC_EC_SC00 0x61
842 #define EEEPC_EC_FAN_PWM (EEEPC_EC_SC00 + 2) /* Fan PWM duty cycle (%) */
843 #define EEEPC_EC_FAN_HRPM (EEEPC_EC_SC00 + 5) /* High byte, fan speed (RPM) */
844 #define EEEPC_EC_FAN_LRPM (EEEPC_EC_SC00 + 6) /* Low byte, fan speed (RPM) */
846 #define EEEPC_EC_SFB0 0xD0
847 #define EEEPC_EC_FAN_CTRL (EEEPC_EC_SFB0 + 3) /* Byte containing SF25 */
849 static int eeepc_get_fan_pwm(void)
853 ec_read(EEEPC_EC_FAN_PWM
, &value
);
854 return value
* 255 / 100;
857 static void eeepc_set_fan_pwm(int value
)
859 value
= SENSORS_LIMIT(value
, 0, 255);
860 value
= value
* 100 / 255;
861 ec_write(EEEPC_EC_FAN_PWM
, value
);
864 static int eeepc_get_fan_rpm(void)
869 ec_read(EEEPC_EC_FAN_HRPM
, &high
);
870 ec_read(EEEPC_EC_FAN_LRPM
, &low
);
871 return high
<< 8 | low
;
874 static int eeepc_get_fan_ctrl(void)
878 ec_read(EEEPC_EC_FAN_CTRL
, &value
);
880 return 1; /* manual */
882 return 2; /* automatic */
885 static void eeepc_set_fan_ctrl(int manual
)
889 ec_read(EEEPC_EC_FAN_CTRL
, &value
);
894 ec_write(EEEPC_EC_FAN_CTRL
, value
);
897 static ssize_t
store_sys_hwmon(void (*set
)(int), const char *buf
, size_t count
)
901 rv
= parse_arg(buf
, count
, &value
);
907 static ssize_t
show_sys_hwmon(int (*get
)(void), char *buf
)
909 return sprintf(buf
, "%d\n", get());
912 #define EEEPC_CREATE_SENSOR_ATTR(_name, _mode, _set, _get) \
913 static ssize_t show_##_name(struct device *dev, \
914 struct device_attribute *attr, \
917 return show_sys_hwmon(_set, buf); \
919 static ssize_t store_##_name(struct device *dev, \
920 struct device_attribute *attr, \
921 const char *buf, size_t count) \
923 return store_sys_hwmon(_get, buf, count); \
925 static SENSOR_DEVICE_ATTR(_name, _mode, show_##_name, store_##_name, 0);
927 EEEPC_CREATE_SENSOR_ATTR(fan1_input
, S_IRUGO
, eeepc_get_fan_rpm
, NULL
);
928 EEEPC_CREATE_SENSOR_ATTR(pwm1
, S_IRUGO
| S_IWUSR
,
929 eeepc_get_fan_pwm
, eeepc_set_fan_pwm
);
930 EEEPC_CREATE_SENSOR_ATTR(pwm1_enable
, S_IRUGO
| S_IWUSR
,
931 eeepc_get_fan_ctrl
, eeepc_set_fan_ctrl
);
934 show_name(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
936 return sprintf(buf
, "eeepc\n");
938 static SENSOR_DEVICE_ATTR(name
, S_IRUGO
, show_name
, NULL
, 0);
940 static struct attribute
*hwmon_attributes
[] = {
941 &sensor_dev_attr_pwm1
.dev_attr
.attr
,
942 &sensor_dev_attr_fan1_input
.dev_attr
.attr
,
943 &sensor_dev_attr_pwm1_enable
.dev_attr
.attr
,
944 &sensor_dev_attr_name
.dev_attr
.attr
,
948 static struct attribute_group hwmon_attribute_group
= {
949 .attrs
= hwmon_attributes
952 static void eeepc_hwmon_exit(void)
954 struct device
*hwmon
;
956 hwmon
= eeepc_hwmon_device
;
959 sysfs_remove_group(&hwmon
->kobj
,
960 &hwmon_attribute_group
);
961 hwmon_device_unregister(hwmon
);
962 eeepc_hwmon_device
= NULL
;
965 static int eeepc_hwmon_init(struct device
*dev
)
967 struct device
*hwmon
;
970 hwmon
= hwmon_device_register(dev
);
972 pr_err("Could not register eeepc hwmon device\n");
973 eeepc_hwmon_device
= NULL
;
974 return PTR_ERR(hwmon
);
976 eeepc_hwmon_device
= hwmon
;
977 result
= sysfs_create_group(&hwmon
->kobj
,
978 &hwmon_attribute_group
);
987 static int read_brightness(struct backlight_device
*bd
)
989 return get_acpi(CM_ASL_PANELBRIGHT
);
992 static int set_brightness(struct backlight_device
*bd
, int value
)
994 return set_acpi(CM_ASL_PANELBRIGHT
, value
);
997 static int update_bl_status(struct backlight_device
*bd
)
999 return set_brightness(bd
, bd
->props
.brightness
);
1002 static struct backlight_ops eeepcbl_ops
= {
1003 .get_brightness
= read_brightness
,
1004 .update_status
= update_bl_status
,
1007 static int eeepc_backlight_notify(void)
1009 struct backlight_device
*bd
= eeepc_backlight_device
;
1010 int old
= bd
->props
.brightness
;
1012 backlight_force_update(bd
, BACKLIGHT_UPDATE_HOTKEY
);
1017 static int eeepc_backlight_init(struct device
*dev
)
1019 struct backlight_device
*bd
;
1021 bd
= backlight_device_register(EEEPC_HOTK_FILE
, dev
,
1022 NULL
, &eeepcbl_ops
);
1024 pr_err("Could not register eeepc backlight device\n");
1025 eeepc_backlight_device
= NULL
;
1028 eeepc_backlight_device
= bd
;
1029 bd
->props
.max_brightness
= 15;
1030 bd
->props
.brightness
= read_brightness(NULL
);
1031 bd
->props
.power
= FB_BLANK_UNBLANK
;
1032 backlight_update_status(bd
);
1036 static void eeepc_backlight_exit(void)
1038 if (eeepc_backlight_device
)
1039 backlight_device_unregister(eeepc_backlight_device
);
1040 eeepc_backlight_device
= NULL
;
1045 * Input device (i.e. hotkeys)
1047 static struct key_entry
*eeepc_get_entry_by_scancode(int code
)
1049 struct key_entry
*key
;
1051 for (key
= eeepc_keymap
; key
->type
!= KE_END
; key
++)
1052 if (code
== key
->code
)
1058 static void eeepc_input_notify(int event
)
1060 static struct key_entry
*key
;
1062 key
= eeepc_get_entry_by_scancode(event
);
1064 switch (key
->type
) {
1066 input_report_key(ehotk
->inputdev
, key
->keycode
,
1068 input_sync(ehotk
->inputdev
);
1069 input_report_key(ehotk
->inputdev
, key
->keycode
,
1071 input_sync(ehotk
->inputdev
);
1077 static struct key_entry
*eepc_get_entry_by_keycode(int code
)
1079 struct key_entry
*key
;
1081 for (key
= eeepc_keymap
; key
->type
!= KE_END
; key
++)
1082 if (code
== key
->keycode
&& key
->type
== KE_KEY
)
1088 static int eeepc_getkeycode(struct input_dev
*dev
, int scancode
, int *keycode
)
1090 struct key_entry
*key
= eeepc_get_entry_by_scancode(scancode
);
1092 if (key
&& key
->type
== KE_KEY
) {
1093 *keycode
= key
->keycode
;
1100 static int eeepc_setkeycode(struct input_dev
*dev
, int scancode
, int keycode
)
1102 struct key_entry
*key
;
1105 if (keycode
< 0 || keycode
> KEY_MAX
)
1108 key
= eeepc_get_entry_by_scancode(scancode
);
1109 if (key
&& key
->type
== KE_KEY
) {
1110 old_keycode
= key
->keycode
;
1111 key
->keycode
= keycode
;
1112 set_bit(keycode
, dev
->keybit
);
1113 if (!eepc_get_entry_by_keycode(old_keycode
))
1114 clear_bit(old_keycode
, dev
->keybit
);
1121 static int eeepc_input_init(struct device
*dev
)
1123 const struct key_entry
*key
;
1126 ehotk
->inputdev
= input_allocate_device();
1127 if (!ehotk
->inputdev
) {
1128 pr_info("Unable to allocate input device\n");
1131 ehotk
->inputdev
->name
= "Asus EeePC extra buttons";
1132 ehotk
->inputdev
->dev
.parent
= dev
;
1133 ehotk
->inputdev
->phys
= EEEPC_HOTK_FILE
"/input0";
1134 ehotk
->inputdev
->id
.bustype
= BUS_HOST
;
1135 ehotk
->inputdev
->getkeycode
= eeepc_getkeycode
;
1136 ehotk
->inputdev
->setkeycode
= eeepc_setkeycode
;
1138 for (key
= eeepc_keymap
; key
->type
!= KE_END
; key
++) {
1139 switch (key
->type
) {
1141 set_bit(EV_KEY
, ehotk
->inputdev
->evbit
);
1142 set_bit(key
->keycode
, ehotk
->inputdev
->keybit
);
1146 result
= input_register_device(ehotk
->inputdev
);
1148 pr_info("Unable to register input device\n");
1149 input_free_device(ehotk
->inputdev
);
1155 static void eeepc_input_exit(void)
1157 if (ehotk
->inputdev
)
1158 input_unregister_device(ehotk
->inputdev
);
1164 static void eeepc_hotk_notify(struct acpi_device
*device
, u32 event
)
1168 if (event
> ACPI_MAX_SYS_NOTIFY
)
1170 count
= ehotk
->event_count
[event
% 128]++;
1171 acpi_bus_generate_proc_event(ehotk
->device
, event
, count
);
1172 acpi_bus_generate_netlink_event(ehotk
->device
->pnp
.device_class
,
1173 dev_name(&ehotk
->device
->dev
), event
,
1176 if (event
>= NOTIFY_BRN_MIN
&& event
<= NOTIFY_BRN_MAX
) {
1177 int old_brightness
, new_brightness
;
1179 /* Update backlight device. */
1180 old_brightness
= eeepc_backlight_notify();
1182 /* Convert brightness event to keypress (obsolescent hack). */
1183 new_brightness
= event
- NOTIFY_BRN_MIN
;
1185 if (new_brightness
< old_brightness
) {
1186 event
= NOTIFY_BRN_MIN
; /* brightness down */
1187 } else if (new_brightness
> old_brightness
) {
1188 event
= NOTIFY_BRN_MAX
; /* brightness up */
1191 * no change in brightness - already at min/max,
1192 * event will be desired value (or else ignored).
1196 eeepc_input_notify(event
);
1199 static void cmsg_quirk(int cm
, const char *name
)
1203 /* Some BIOSes do not report cm although it is avaliable.
1204 Check if cm_getv[cm] works and, if yes, assume cm should be set. */
1205 if (!(ehotk
->cm_supported
& (1 << cm
))
1206 && !read_acpi_int(ehotk
->handle
, cm_getv
[cm
], &dummy
)) {
1207 pr_info("%s (%x) not reported by BIOS,"
1208 " enabling anyway\n", name
, 1 << cm
);
1209 ehotk
->cm_supported
|= 1 << cm
;
1213 static void cmsg_quirks(void)
1215 cmsg_quirk(CM_ASL_LID
, "LID");
1216 cmsg_quirk(CM_ASL_TYPE
, "TYPE");
1217 cmsg_quirk(CM_ASL_PANELPOWER
, "PANELPOWER");
1218 cmsg_quirk(CM_ASL_TPD
, "TPD");
1221 static int eeepc_hotk_init(void)
1223 unsigned int init_flags
;
1226 result
= acpi_bus_get_status(ehotk
->device
);
1229 if (!ehotk
->device
->status
.present
) {
1230 pr_err("Hotkey device not present, aborting\n");
1234 init_flags
= DISABLE_ASL_WLAN
| DISABLE_ASL_DISPLAYSWITCH
;
1235 pr_notice("Hotkey init flags 0x%x\n", init_flags
);
1237 if (write_acpi_int(ehotk
->handle
, "INIT", init_flags
)) {
1238 pr_err("Hotkey initialization failed\n");
1242 /* get control methods supported */
1243 if (read_acpi_int(ehotk
->handle
, "CMSG", &ehotk
->cm_supported
)) {
1244 pr_err("Get control methods supported failed\n");
1248 pr_info("Get control methods supported: 0x%x\n", ehotk
->cm_supported
);
1253 static void __devinit
eeepc_enable_camera(void)
1256 * If the following call to set_acpi() fails, it's because there's no
1257 * camera so we can ignore the error.
1259 if (get_acpi(CM_ASL_CAMERA
) == 0)
1260 set_acpi(CM_ASL_CAMERA
, 1);
1263 static int __devinit
eeepc_hotk_add(struct acpi_device
*device
)
1268 pr_notice(EEEPC_HOTK_NAME
"\n");
1269 ehotk
= kzalloc(sizeof(struct eeepc_hotk
), GFP_KERNEL
);
1272 ehotk
->handle
= device
->handle
;
1273 strcpy(acpi_device_name(device
), EEEPC_HOTK_DEVICE_NAME
);
1274 strcpy(acpi_device_class(device
), EEEPC_HOTK_CLASS
);
1275 device
->driver_data
= ehotk
;
1276 ehotk
->device
= device
;
1278 result
= eeepc_hotk_init();
1281 eeepc_enable_camera();
1283 result
= eeepc_platform_init();
1287 dev
= &platform_device
->dev
;
1289 if (!acpi_video_backlight_support()) {
1290 result
= eeepc_backlight_init(dev
);
1292 goto fail_backlight
;
1294 pr_info("Backlight controlled by ACPI video driver\n");
1296 result
= eeepc_input_init(dev
);
1300 result
= eeepc_hwmon_init(dev
);
1304 result
= eeepc_led_init(dev
);
1308 result
= eeepc_rfkill_init(dev
);
1321 eeepc_backlight_exit();
1323 eeepc_platform_exit();
1330 static int eeepc_hotk_remove(struct acpi_device
*device
, int type
)
1332 eeepc_backlight_exit();
1333 eeepc_rfkill_exit();
1337 eeepc_platform_exit();
1344 static const struct acpi_device_id eeepc_device_ids
[] = {
1345 {EEEPC_HOTK_HID
, 0},
1348 MODULE_DEVICE_TABLE(acpi
, eeepc_device_ids
);
1350 static struct acpi_driver eeepc_hotk_driver
= {
1351 .name
= EEEPC_HOTK_NAME
,
1352 .class = EEEPC_HOTK_CLASS
,
1353 .owner
= THIS_MODULE
,
1354 .ids
= eeepc_device_ids
,
1355 .flags
= ACPI_DRIVER_ALL_NOTIFY_EVENTS
,
1357 .add
= eeepc_hotk_add
,
1358 .remove
= eeepc_hotk_remove
,
1359 .notify
= eeepc_hotk_notify
,
1364 static int __init
eeepc_laptop_init(void)
1368 result
= platform_driver_register(&platform_driver
);
1372 result
= acpi_bus_register_driver(&eeepc_hotk_driver
);
1374 goto fail_acpi_driver
;
1377 goto fail_no_device
;
1382 acpi_bus_unregister_driver(&eeepc_hotk_driver
);
1384 platform_driver_unregister(&platform_driver
);
1388 static void __exit
eeepc_laptop_exit(void)
1390 acpi_bus_unregister_driver(&eeepc_hotk_driver
);
1391 platform_driver_unregister(&platform_driver
);
1394 module_init(eeepc_laptop_init
);
1395 module_exit(eeepc_laptop_exit
);