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 <linux/slab.h>
31 #include <linux/acpi.h>
32 #include <linux/uaccess.h>
33 #include <linux/input.h>
34 #include <linux/input/sparse-keymap.h>
35 #include <linux/rfkill.h>
36 #include <linux/pci.h>
37 #include <linux/pci_hotplug.h>
38 #include <linux/leds.h>
39 #include <linux/dmi.h>
40 #include <acpi/video.h>
42 #define EEEPC_LAPTOP_VERSION "0.1"
43 #define EEEPC_LAPTOP_NAME "Eee PC Hotkey Driver"
44 #define EEEPC_LAPTOP_FILE "eeepc"
46 #define EEEPC_ACPI_CLASS "hotkey"
47 #define EEEPC_ACPI_DEVICE_NAME "Hotkey"
48 #define EEEPC_ACPI_HID "ASUS010"
50 MODULE_AUTHOR("Corentin Chary, Eric Cooper");
51 MODULE_DESCRIPTION(EEEPC_LAPTOP_NAME
);
52 MODULE_LICENSE("GPL");
54 static bool hotplug_disabled
;
56 module_param(hotplug_disabled
, bool, 0444);
57 MODULE_PARM_DESC(hotplug_disabled
,
58 "Disable hotplug for wireless device. "
59 "If your laptop need that, please report to "
60 "acpi4asus-user@lists.sourceforge.net.");
63 * Definitions for Asus EeePC
65 #define NOTIFY_BRN_MIN 0x20
66 #define NOTIFY_BRN_MAX 0x2f
69 DISABLE_ASL_WLAN
= 0x0001,
70 DISABLE_ASL_BLUETOOTH
= 0x0002,
71 DISABLE_ASL_IRDA
= 0x0004,
72 DISABLE_ASL_CAMERA
= 0x0008,
73 DISABLE_ASL_TV
= 0x0010,
74 DISABLE_ASL_GPS
= 0x0020,
75 DISABLE_ASL_DISPLAYSWITCH
= 0x0040,
76 DISABLE_ASL_MODEM
= 0x0080,
77 DISABLE_ASL_CARDREADER
= 0x0100,
78 DISABLE_ASL_3G
= 0x0200,
79 DISABLE_ASL_WIMAX
= 0x0400,
80 DISABLE_ASL_HWCF
= 0x0800
97 CM_ASL_CPUTEMPERATURE
,
110 CM_ASL_PANELPOWER
, /*P901*/
114 static const char *cm_getv
[] = {
115 "WLDG", "BTHG", NULL
, NULL
,
116 "CAMG", NULL
, NULL
, NULL
,
117 NULL
, "PBLG", NULL
, NULL
,
118 "CFVG", NULL
, NULL
, NULL
,
119 "USBG", NULL
, NULL
, "MODG",
120 "CRDG", "M3GG", "WIMG", "HWCF",
121 "LIDG", "TYPE", "PBPG", "TPDG"
124 static const char *cm_setv
[] = {
125 "WLDS", "BTHS", NULL
, NULL
,
126 "CAMS", NULL
, NULL
, NULL
,
127 "SDSP", "PBLS", "HDPS", NULL
,
128 "CFVS", NULL
, NULL
, NULL
,
129 "USBG", NULL
, NULL
, "MODS",
130 "CRDS", "M3GS", "WIMS", NULL
,
131 NULL
, NULL
, "PBPS", "TPDS"
134 static const struct key_entry eeepc_keymap
[] = {
135 { KE_KEY
, 0x10, { KEY_WLAN
} },
136 { KE_KEY
, 0x11, { KEY_WLAN
} },
137 { KE_KEY
, 0x12, { KEY_PROG1
} },
138 { KE_KEY
, 0x13, { KEY_MUTE
} },
139 { KE_KEY
, 0x14, { KEY_VOLUMEDOWN
} },
140 { KE_KEY
, 0x15, { KEY_VOLUMEUP
} },
141 { KE_KEY
, 0x16, { KEY_DISPLAY_OFF
} },
142 { KE_KEY
, 0x1a, { KEY_COFFEE
} },
143 { KE_KEY
, 0x1b, { KEY_ZOOM
} },
144 { KE_KEY
, 0x1c, { KEY_PROG2
} },
145 { KE_KEY
, 0x1d, { KEY_PROG3
} },
146 { KE_KEY
, NOTIFY_BRN_MIN
, { KEY_BRIGHTNESSDOWN
} },
147 { KE_KEY
, NOTIFY_BRN_MAX
, { KEY_BRIGHTNESSUP
} },
148 { KE_KEY
, 0x30, { KEY_SWITCHVIDEOMODE
} },
149 { KE_KEY
, 0x31, { KEY_SWITCHVIDEOMODE
} },
150 { KE_KEY
, 0x32, { KEY_SWITCHVIDEOMODE
} },
151 { KE_KEY
, 0x37, { KEY_F13
} }, /* Disable Touchpad */
152 { KE_KEY
, 0x38, { KEY_F14
} },
153 { KE_IGNORE
, 0x50, { KEY_RESERVED
} }, /* AC plugged */
154 { KE_IGNORE
, 0x51, { KEY_RESERVED
} }, /* AC unplugged */
159 * This is the main structure, we can use it to store useful information
161 struct eeepc_laptop
{
162 acpi_handle handle
; /* the handle of the acpi device */
163 u32 cm_supported
; /* the control methods supported
166 bool hotplug_disabled
;
167 u16 event_count
[128]; /* count for each event */
169 struct platform_device
*platform_device
;
170 struct acpi_device
*device
; /* the device we are in */
171 struct backlight_device
*backlight_device
;
173 struct input_dev
*inputdev
;
175 struct rfkill
*wlan_rfkill
;
176 struct rfkill
*bluetooth_rfkill
;
177 struct rfkill
*wwan3g_rfkill
;
178 struct rfkill
*wimax_rfkill
;
180 struct hotplug_slot
*hotplug_slot
;
181 struct mutex hotplug_lock
;
183 struct led_classdev tpd_led
;
185 struct workqueue_struct
*led_workqueue
;
186 struct work_struct tpd_led_work
;
192 static int write_acpi_int(acpi_handle handle
, const char *method
, int val
)
196 status
= acpi_execute_simple_method(handle
, (char *)method
, val
);
198 return (status
== AE_OK
? 0 : -1);
201 static int read_acpi_int(acpi_handle handle
, const char *method
, int *val
)
204 unsigned long long result
;
206 status
= acpi_evaluate_integer(handle
, (char *)method
, NULL
, &result
);
207 if (ACPI_FAILURE(status
)) {
216 static int set_acpi(struct eeepc_laptop
*eeepc
, int cm
, int value
)
218 const char *method
= cm_setv
[cm
];
222 if ((eeepc
->cm_supported
& (0x1 << cm
)) == 0)
225 if (write_acpi_int(eeepc
->handle
, method
, value
))
226 pr_warn("Error writing %s\n", method
);
230 static int get_acpi(struct eeepc_laptop
*eeepc
, int cm
)
232 const char *method
= cm_getv
[cm
];
237 if ((eeepc
->cm_supported
& (0x1 << cm
)) == 0)
240 if (read_acpi_int(eeepc
->handle
, method
, &value
))
241 pr_warn("Error reading %s\n", method
);
245 static int acpi_setter_handle(struct eeepc_laptop
*eeepc
, int cm
,
248 const char *method
= cm_setv
[cm
];
253 if ((eeepc
->cm_supported
& (0x1 << cm
)) == 0)
256 status
= acpi_get_handle(eeepc
->handle
, (char *)method
,
258 if (status
!= AE_OK
) {
259 pr_warn("Error finding %s\n", method
);
269 static int parse_arg(const char *buf
, int *val
)
271 if (sscanf(buf
, "%i", val
) != 1)
276 static ssize_t
store_sys_acpi(struct device
*dev
, int cm
,
277 const char *buf
, size_t count
)
279 struct eeepc_laptop
*eeepc
= dev_get_drvdata(dev
);
282 rv
= parse_arg(buf
, &value
);
285 rv
= set_acpi(eeepc
, cm
, value
);
291 static ssize_t
show_sys_acpi(struct device
*dev
, int cm
, char *buf
)
293 struct eeepc_laptop
*eeepc
= dev_get_drvdata(dev
);
294 int value
= get_acpi(eeepc
, cm
);
298 return sprintf(buf
, "%d\n", value
);
301 #define EEEPC_ACPI_SHOW_FUNC(_name, _cm) \
302 static ssize_t _name##_show(struct device *dev, \
303 struct device_attribute *attr, \
306 return show_sys_acpi(dev, _cm, buf); \
309 #define EEEPC_ACPI_STORE_FUNC(_name, _cm) \
310 static ssize_t _name##_store(struct device *dev, \
311 struct device_attribute *attr, \
312 const char *buf, size_t count) \
314 return store_sys_acpi(dev, _cm, buf, count); \
317 #define EEEPC_CREATE_DEVICE_ATTR_RW(_name, _cm) \
318 EEEPC_ACPI_SHOW_FUNC(_name, _cm) \
319 EEEPC_ACPI_STORE_FUNC(_name, _cm) \
320 static DEVICE_ATTR_RW(_name)
322 #define EEEPC_CREATE_DEVICE_ATTR_WO(_name, _cm) \
323 EEEPC_ACPI_STORE_FUNC(_name, _cm) \
324 static DEVICE_ATTR_WO(_name)
326 EEEPC_CREATE_DEVICE_ATTR_RW(camera
, CM_ASL_CAMERA
);
327 EEEPC_CREATE_DEVICE_ATTR_RW(cardr
, CM_ASL_CARDREADER
);
328 EEEPC_CREATE_DEVICE_ATTR_WO(disp
, CM_ASL_DISPLAYSWITCH
);
335 static int get_cpufv(struct eeepc_laptop
*eeepc
, struct eeepc_cpufv
*c
)
337 c
->cur
= get_acpi(eeepc
, CM_ASL_CPUFV
);
341 c
->num
= (c
->cur
>> 8) & 0xff;
343 if (c
->num
== 0 || c
->num
> 12)
348 static ssize_t
available_cpufv_show(struct device
*dev
,
349 struct device_attribute
*attr
,
352 struct eeepc_laptop
*eeepc
= dev_get_drvdata(dev
);
353 struct eeepc_cpufv c
;
357 if (get_cpufv(eeepc
, &c
))
359 for (i
= 0; i
< c
.num
; i
++)
360 len
+= sprintf(buf
+ len
, "%d ", i
);
361 len
+= sprintf(buf
+ len
, "\n");
365 static ssize_t
cpufv_show(struct device
*dev
,
366 struct device_attribute
*attr
,
369 struct eeepc_laptop
*eeepc
= dev_get_drvdata(dev
);
370 struct eeepc_cpufv c
;
372 if (get_cpufv(eeepc
, &c
))
374 return sprintf(buf
, "%#x\n", (c
.num
<< 8) | c
.cur
);
377 static ssize_t
cpufv_store(struct device
*dev
,
378 struct device_attribute
*attr
,
379 const char *buf
, size_t count
)
381 struct eeepc_laptop
*eeepc
= dev_get_drvdata(dev
);
382 struct eeepc_cpufv c
;
385 if (eeepc
->cpufv_disabled
)
387 if (get_cpufv(eeepc
, &c
))
389 rv
= parse_arg(buf
, &value
);
392 if (value
< 0 || value
>= c
.num
)
394 rv
= set_acpi(eeepc
, CM_ASL_CPUFV
, value
);
400 static ssize_t
cpufv_disabled_show(struct device
*dev
,
401 struct device_attribute
*attr
,
404 struct eeepc_laptop
*eeepc
= dev_get_drvdata(dev
);
406 return sprintf(buf
, "%d\n", eeepc
->cpufv_disabled
);
409 static ssize_t
cpufv_disabled_store(struct device
*dev
,
410 struct device_attribute
*attr
,
411 const char *buf
, size_t count
)
413 struct eeepc_laptop
*eeepc
= dev_get_drvdata(dev
);
416 rv
= parse_arg(buf
, &value
);
422 if (eeepc
->cpufv_disabled
)
423 pr_warn("cpufv enabled (not officially supported on this model)\n");
424 eeepc
->cpufv_disabled
= false;
434 static DEVICE_ATTR_RW(cpufv
);
435 static DEVICE_ATTR_RO(available_cpufv
);
436 static DEVICE_ATTR_RW(cpufv_disabled
);
438 static struct attribute
*platform_attributes
[] = {
439 &dev_attr_camera
.attr
,
440 &dev_attr_cardr
.attr
,
442 &dev_attr_cpufv
.attr
,
443 &dev_attr_available_cpufv
.attr
,
444 &dev_attr_cpufv_disabled
.attr
,
448 static const struct attribute_group platform_attribute_group
= {
449 .attrs
= platform_attributes
452 static int eeepc_platform_init(struct eeepc_laptop
*eeepc
)
456 eeepc
->platform_device
= platform_device_alloc(EEEPC_LAPTOP_FILE
, -1);
457 if (!eeepc
->platform_device
)
459 platform_set_drvdata(eeepc
->platform_device
, eeepc
);
461 result
= platform_device_add(eeepc
->platform_device
);
463 goto fail_platform_device
;
465 result
= sysfs_create_group(&eeepc
->platform_device
->dev
.kobj
,
466 &platform_attribute_group
);
472 platform_device_del(eeepc
->platform_device
);
473 fail_platform_device
:
474 platform_device_put(eeepc
->platform_device
);
478 static void eeepc_platform_exit(struct eeepc_laptop
*eeepc
)
480 sysfs_remove_group(&eeepc
->platform_device
->dev
.kobj
,
481 &platform_attribute_group
);
482 platform_device_unregister(eeepc
->platform_device
);
489 * These functions actually update the LED's, and are called from a
490 * workqueue. By doing this as separate work rather than when the LED
491 * subsystem asks, we avoid messing with the Asus ACPI stuff during a
492 * potentially bad time, such as a timer interrupt.
494 static void tpd_led_update(struct work_struct
*work
)
496 struct eeepc_laptop
*eeepc
;
498 eeepc
= container_of(work
, struct eeepc_laptop
, tpd_led_work
);
500 set_acpi(eeepc
, CM_ASL_TPD
, eeepc
->tpd_led_wk
);
503 static void tpd_led_set(struct led_classdev
*led_cdev
,
504 enum led_brightness value
)
506 struct eeepc_laptop
*eeepc
;
508 eeepc
= container_of(led_cdev
, struct eeepc_laptop
, tpd_led
);
510 eeepc
->tpd_led_wk
= (value
> 0) ? 1 : 0;
511 queue_work(eeepc
->led_workqueue
, &eeepc
->tpd_led_work
);
514 static enum led_brightness
tpd_led_get(struct led_classdev
*led_cdev
)
516 struct eeepc_laptop
*eeepc
;
518 eeepc
= container_of(led_cdev
, struct eeepc_laptop
, tpd_led
);
520 return get_acpi(eeepc
, CM_ASL_TPD
);
523 static int eeepc_led_init(struct eeepc_laptop
*eeepc
)
527 if (get_acpi(eeepc
, CM_ASL_TPD
) == -ENODEV
)
530 eeepc
->led_workqueue
= create_singlethread_workqueue("led_workqueue");
531 if (!eeepc
->led_workqueue
)
533 INIT_WORK(&eeepc
->tpd_led_work
, tpd_led_update
);
535 eeepc
->tpd_led
.name
= "eeepc::touchpad";
536 eeepc
->tpd_led
.brightness_set
= tpd_led_set
;
537 if (get_acpi(eeepc
, CM_ASL_TPD
) >= 0) /* if method is available */
538 eeepc
->tpd_led
.brightness_get
= tpd_led_get
;
539 eeepc
->tpd_led
.max_brightness
= 1;
541 rv
= led_classdev_register(&eeepc
->platform_device
->dev
,
544 destroy_workqueue(eeepc
->led_workqueue
);
551 static void eeepc_led_exit(struct eeepc_laptop
*eeepc
)
553 if (!IS_ERR_OR_NULL(eeepc
->tpd_led
.dev
))
554 led_classdev_unregister(&eeepc
->tpd_led
);
555 if (eeepc
->led_workqueue
)
556 destroy_workqueue(eeepc
->led_workqueue
);
561 * PCI hotplug (for wlan rfkill)
563 static bool eeepc_wlan_rfkill_blocked(struct eeepc_laptop
*eeepc
)
565 if (get_acpi(eeepc
, CM_ASL_WLAN
) == 1)
570 static void eeepc_rfkill_hotplug(struct eeepc_laptop
*eeepc
, acpi_handle handle
)
572 struct pci_dev
*port
;
575 bool blocked
= eeepc_wlan_rfkill_blocked(eeepc
);
579 if (eeepc
->wlan_rfkill
)
580 rfkill_set_sw_state(eeepc
->wlan_rfkill
, blocked
);
582 mutex_lock(&eeepc
->hotplug_lock
);
583 pci_lock_rescan_remove();
585 if (!eeepc
->hotplug_slot
)
588 port
= acpi_get_pci_dev(handle
);
590 pr_warning("Unable to find port\n");
594 bus
= port
->subordinate
;
597 pr_warn("Unable to find PCI bus 1?\n");
601 if (pci_bus_read_config_dword(bus
, 0, PCI_VENDOR_ID
, &l
)) {
602 pr_err("Unable to read PCI config space?\n");
606 absent
= (l
== 0xffffffff);
608 if (blocked
!= absent
) {
609 pr_warn("BIOS says wireless lan is %s, but the pci device is %s\n",
610 blocked
? "blocked" : "unblocked",
611 absent
? "absent" : "present");
612 pr_warn("skipped wireless hotplug as probably inappropriate for this model\n");
617 dev
= pci_get_slot(bus
, 0);
619 /* Device already present */
623 dev
= pci_scan_single_device(bus
, 0);
625 pci_bus_assign_resources(bus
);
626 pci_bus_add_device(dev
);
629 dev
= pci_get_slot(bus
, 0);
631 pci_stop_and_remove_bus_device(dev
);
639 pci_unlock_rescan_remove();
640 mutex_unlock(&eeepc
->hotplug_lock
);
643 static void eeepc_rfkill_hotplug_update(struct eeepc_laptop
*eeepc
, char *node
)
645 acpi_status status
= AE_OK
;
648 status
= acpi_get_handle(NULL
, node
, &handle
);
650 if (ACPI_SUCCESS(status
))
651 eeepc_rfkill_hotplug(eeepc
, handle
);
654 static void eeepc_rfkill_notify(acpi_handle handle
, u32 event
, void *data
)
656 struct eeepc_laptop
*eeepc
= data
;
658 if (event
!= ACPI_NOTIFY_BUS_CHECK
)
661 eeepc_rfkill_hotplug(eeepc
, handle
);
664 static int eeepc_register_rfkill_notifier(struct eeepc_laptop
*eeepc
,
670 status
= acpi_get_handle(NULL
, node
, &handle
);
672 if (ACPI_FAILURE(status
))
675 status
= acpi_install_notify_handler(handle
,
679 if (ACPI_FAILURE(status
))
680 pr_warn("Failed to register notify on %s\n", node
);
683 * Refresh pci hotplug in case the rfkill state was
684 * changed during setup.
686 eeepc_rfkill_hotplug(eeepc
, handle
);
690 static void eeepc_unregister_rfkill_notifier(struct eeepc_laptop
*eeepc
,
693 acpi_status status
= AE_OK
;
696 status
= acpi_get_handle(NULL
, node
, &handle
);
698 if (ACPI_FAILURE(status
))
701 status
= acpi_remove_notify_handler(handle
,
703 eeepc_rfkill_notify
);
704 if (ACPI_FAILURE(status
))
705 pr_err("Error removing rfkill notify handler %s\n",
708 * Refresh pci hotplug in case the rfkill
709 * state was changed after
710 * eeepc_unregister_rfkill_notifier()
712 eeepc_rfkill_hotplug(eeepc
, handle
);
715 static int eeepc_get_adapter_status(struct hotplug_slot
*hotplug_slot
,
718 struct eeepc_laptop
*eeepc
= hotplug_slot
->private;
719 int val
= get_acpi(eeepc
, CM_ASL_WLAN
);
721 if (val
== 1 || val
== 0)
729 static const struct hotplug_slot_ops eeepc_hotplug_slot_ops
= {
730 .get_adapter_status
= eeepc_get_adapter_status
,
731 .get_power_status
= eeepc_get_adapter_status
,
734 static int eeepc_setup_pci_hotplug(struct eeepc_laptop
*eeepc
)
737 struct pci_bus
*bus
= pci_find_bus(0, 1);
740 pr_err("Unable to find wifi PCI bus\n");
744 eeepc
->hotplug_slot
= kzalloc(sizeof(struct hotplug_slot
), GFP_KERNEL
);
745 if (!eeepc
->hotplug_slot
)
748 eeepc
->hotplug_slot
->private = eeepc
;
749 eeepc
->hotplug_slot
->ops
= &eeepc_hotplug_slot_ops
;
751 ret
= pci_hp_register(eeepc
->hotplug_slot
, bus
, 0, "eeepc-wifi");
753 pr_err("Unable to register hotplug slot - %d\n", ret
);
760 kfree(eeepc
->hotplug_slot
);
761 eeepc
->hotplug_slot
= NULL
;
769 static int eeepc_rfkill_set(void *data
, bool blocked
)
771 acpi_handle handle
= data
;
773 return write_acpi_int(handle
, NULL
, !blocked
);
776 static const struct rfkill_ops eeepc_rfkill_ops
= {
777 .set_block
= eeepc_rfkill_set
,
780 static int eeepc_new_rfkill(struct eeepc_laptop
*eeepc
,
781 struct rfkill
**rfkill
,
783 enum rfkill_type type
, int cm
)
788 result
= acpi_setter_handle(eeepc
, cm
, &handle
);
792 *rfkill
= rfkill_alloc(name
, &eeepc
->platform_device
->dev
, type
,
793 &eeepc_rfkill_ops
, handle
);
798 rfkill_init_sw_state(*rfkill
, get_acpi(eeepc
, cm
) != 1);
799 result
= rfkill_register(*rfkill
);
801 rfkill_destroy(*rfkill
);
808 static char EEEPC_RFKILL_NODE_1
[] = "\\_SB.PCI0.P0P5";
809 static char EEEPC_RFKILL_NODE_2
[] = "\\_SB.PCI0.P0P6";
810 static char EEEPC_RFKILL_NODE_3
[] = "\\_SB.PCI0.P0P7";
812 static void eeepc_rfkill_exit(struct eeepc_laptop
*eeepc
)
814 eeepc_unregister_rfkill_notifier(eeepc
, EEEPC_RFKILL_NODE_1
);
815 eeepc_unregister_rfkill_notifier(eeepc
, EEEPC_RFKILL_NODE_2
);
816 eeepc_unregister_rfkill_notifier(eeepc
, EEEPC_RFKILL_NODE_3
);
817 if (eeepc
->wlan_rfkill
) {
818 rfkill_unregister(eeepc
->wlan_rfkill
);
819 rfkill_destroy(eeepc
->wlan_rfkill
);
820 eeepc
->wlan_rfkill
= NULL
;
823 if (eeepc
->hotplug_slot
) {
824 pci_hp_deregister(eeepc
->hotplug_slot
);
825 kfree(eeepc
->hotplug_slot
);
828 if (eeepc
->bluetooth_rfkill
) {
829 rfkill_unregister(eeepc
->bluetooth_rfkill
);
830 rfkill_destroy(eeepc
->bluetooth_rfkill
);
831 eeepc
->bluetooth_rfkill
= NULL
;
833 if (eeepc
->wwan3g_rfkill
) {
834 rfkill_unregister(eeepc
->wwan3g_rfkill
);
835 rfkill_destroy(eeepc
->wwan3g_rfkill
);
836 eeepc
->wwan3g_rfkill
= NULL
;
838 if (eeepc
->wimax_rfkill
) {
839 rfkill_unregister(eeepc
->wimax_rfkill
);
840 rfkill_destroy(eeepc
->wimax_rfkill
);
841 eeepc
->wimax_rfkill
= NULL
;
845 static int eeepc_rfkill_init(struct eeepc_laptop
*eeepc
)
849 mutex_init(&eeepc
->hotplug_lock
);
851 result
= eeepc_new_rfkill(eeepc
, &eeepc
->wlan_rfkill
,
852 "eeepc-wlan", RFKILL_TYPE_WLAN
,
855 if (result
&& result
!= -ENODEV
)
858 result
= eeepc_new_rfkill(eeepc
, &eeepc
->bluetooth_rfkill
,
859 "eeepc-bluetooth", RFKILL_TYPE_BLUETOOTH
,
862 if (result
&& result
!= -ENODEV
)
865 result
= eeepc_new_rfkill(eeepc
, &eeepc
->wwan3g_rfkill
,
866 "eeepc-wwan3g", RFKILL_TYPE_WWAN
,
869 if (result
&& result
!= -ENODEV
)
872 result
= eeepc_new_rfkill(eeepc
, &eeepc
->wimax_rfkill
,
873 "eeepc-wimax", RFKILL_TYPE_WIMAX
,
876 if (result
&& result
!= -ENODEV
)
879 if (eeepc
->hotplug_disabled
)
882 result
= eeepc_setup_pci_hotplug(eeepc
);
884 * If we get -EBUSY then something else is handling the PCI hotplug -
885 * don't fail in this case
887 if (result
== -EBUSY
)
890 eeepc_register_rfkill_notifier(eeepc
, EEEPC_RFKILL_NODE_1
);
891 eeepc_register_rfkill_notifier(eeepc
, EEEPC_RFKILL_NODE_2
);
892 eeepc_register_rfkill_notifier(eeepc
, EEEPC_RFKILL_NODE_3
);
895 if (result
&& result
!= -ENODEV
)
896 eeepc_rfkill_exit(eeepc
);
901 * Platform driver - hibernate/resume callbacks
903 static int eeepc_hotk_thaw(struct device
*device
)
905 struct eeepc_laptop
*eeepc
= dev_get_drvdata(device
);
907 if (eeepc
->wlan_rfkill
) {
911 * Work around bios bug - acpi _PTS turns off the wireless led
912 * during suspend. Normally it restores it on resume, but
913 * we should kick it ourselves in case hibernation is aborted.
915 wlan
= get_acpi(eeepc
, CM_ASL_WLAN
);
917 set_acpi(eeepc
, CM_ASL_WLAN
, wlan
);
923 static int eeepc_hotk_restore(struct device
*device
)
925 struct eeepc_laptop
*eeepc
= dev_get_drvdata(device
);
927 /* Refresh both wlan rfkill state and pci hotplug */
928 if (eeepc
->wlan_rfkill
) {
929 eeepc_rfkill_hotplug_update(eeepc
, EEEPC_RFKILL_NODE_1
);
930 eeepc_rfkill_hotplug_update(eeepc
, EEEPC_RFKILL_NODE_2
);
931 eeepc_rfkill_hotplug_update(eeepc
, EEEPC_RFKILL_NODE_3
);
934 if (eeepc
->bluetooth_rfkill
)
935 rfkill_set_sw_state(eeepc
->bluetooth_rfkill
,
936 get_acpi(eeepc
, CM_ASL_BLUETOOTH
) != 1);
937 if (eeepc
->wwan3g_rfkill
)
938 rfkill_set_sw_state(eeepc
->wwan3g_rfkill
,
939 get_acpi(eeepc
, CM_ASL_3G
) != 1);
940 if (eeepc
->wimax_rfkill
)
941 rfkill_set_sw_state(eeepc
->wimax_rfkill
,
942 get_acpi(eeepc
, CM_ASL_WIMAX
) != 1);
947 static const struct dev_pm_ops eeepc_pm_ops
= {
948 .thaw
= eeepc_hotk_thaw
,
949 .restore
= eeepc_hotk_restore
,
952 static struct platform_driver platform_driver
= {
954 .name
= EEEPC_LAPTOP_FILE
,
963 #define EEEPC_EC_SC00 0x61
964 #define EEEPC_EC_FAN_PWM (EEEPC_EC_SC00 + 2) /* Fan PWM duty cycle (%) */
965 #define EEEPC_EC_FAN_HRPM (EEEPC_EC_SC00 + 5) /* High byte, fan speed (RPM) */
966 #define EEEPC_EC_FAN_LRPM (EEEPC_EC_SC00 + 6) /* Low byte, fan speed (RPM) */
968 #define EEEPC_EC_SFB0 0xD0
969 #define EEEPC_EC_FAN_CTRL (EEEPC_EC_SFB0 + 3) /* Byte containing SF25 */
971 static inline int eeepc_pwm_to_lmsensors(int value
)
973 return value
* 255 / 100;
976 static inline int eeepc_lmsensors_to_pwm(int value
)
978 value
= clamp_val(value
, 0, 255);
979 return value
* 100 / 255;
982 static int eeepc_get_fan_pwm(void)
986 ec_read(EEEPC_EC_FAN_PWM
, &value
);
987 return eeepc_pwm_to_lmsensors(value
);
990 static void eeepc_set_fan_pwm(int value
)
992 value
= eeepc_lmsensors_to_pwm(value
);
993 ec_write(EEEPC_EC_FAN_PWM
, value
);
996 static int eeepc_get_fan_rpm(void)
1001 ec_read(EEEPC_EC_FAN_HRPM
, &high
);
1002 ec_read(EEEPC_EC_FAN_LRPM
, &low
);
1003 return high
<< 8 | low
;
1006 #define EEEPC_EC_FAN_CTRL_BIT 0x02
1007 #define EEEPC_FAN_CTRL_MANUAL 1
1008 #define EEEPC_FAN_CTRL_AUTO 2
1010 static int eeepc_get_fan_ctrl(void)
1014 ec_read(EEEPC_EC_FAN_CTRL
, &value
);
1015 if (value
& EEEPC_EC_FAN_CTRL_BIT
)
1016 return EEEPC_FAN_CTRL_MANUAL
;
1018 return EEEPC_FAN_CTRL_AUTO
;
1021 static void eeepc_set_fan_ctrl(int manual
)
1025 ec_read(EEEPC_EC_FAN_CTRL
, &value
);
1026 if (manual
== EEEPC_FAN_CTRL_MANUAL
)
1027 value
|= EEEPC_EC_FAN_CTRL_BIT
;
1029 value
&= ~EEEPC_EC_FAN_CTRL_BIT
;
1030 ec_write(EEEPC_EC_FAN_CTRL
, value
);
1033 static ssize_t
store_sys_hwmon(void (*set
)(int), const char *buf
, size_t count
)
1037 rv
= parse_arg(buf
, &value
);
1044 static ssize_t
show_sys_hwmon(int (*get
)(void), char *buf
)
1046 return sprintf(buf
, "%d\n", get());
1049 #define EEEPC_SENSOR_SHOW_FUNC(_name, _get) \
1050 static ssize_t _name##_show(struct device *dev, \
1051 struct device_attribute *attr, \
1054 return show_sys_hwmon(_get, buf); \
1057 #define EEEPC_SENSOR_STORE_FUNC(_name, _set) \
1058 static ssize_t _name##_store(struct device *dev, \
1059 struct device_attribute *attr, \
1060 const char *buf, size_t count) \
1062 return store_sys_hwmon(_set, buf, count); \
1065 #define EEEPC_CREATE_SENSOR_ATTR_RW(_name, _get, _set) \
1066 EEEPC_SENSOR_SHOW_FUNC(_name, _get) \
1067 EEEPC_SENSOR_STORE_FUNC(_name, _set) \
1068 static DEVICE_ATTR_RW(_name)
1070 #define EEEPC_CREATE_SENSOR_ATTR_RO(_name, _get) \
1071 EEEPC_SENSOR_SHOW_FUNC(_name, _get) \
1072 static DEVICE_ATTR_RO(_name)
1074 EEEPC_CREATE_SENSOR_ATTR_RO(fan1_input
, eeepc_get_fan_rpm
);
1075 EEEPC_CREATE_SENSOR_ATTR_RW(pwm1
, eeepc_get_fan_pwm
,
1077 EEEPC_CREATE_SENSOR_ATTR_RW(pwm1_enable
, eeepc_get_fan_ctrl
,
1078 eeepc_set_fan_ctrl
);
1080 static struct attribute
*hwmon_attrs
[] = {
1081 &dev_attr_pwm1
.attr
,
1082 &dev_attr_fan1_input
.attr
,
1083 &dev_attr_pwm1_enable
.attr
,
1086 ATTRIBUTE_GROUPS(hwmon
);
1088 static int eeepc_hwmon_init(struct eeepc_laptop
*eeepc
)
1090 struct device
*dev
= &eeepc
->platform_device
->dev
;
1091 struct device
*hwmon
;
1093 hwmon
= devm_hwmon_device_register_with_groups(dev
, "eeepc", NULL
,
1095 if (IS_ERR(hwmon
)) {
1096 pr_err("Could not register eeepc hwmon device\n");
1097 return PTR_ERR(hwmon
);
1105 static int read_brightness(struct backlight_device
*bd
)
1107 struct eeepc_laptop
*eeepc
= bl_get_data(bd
);
1109 return get_acpi(eeepc
, CM_ASL_PANELBRIGHT
);
1112 static int set_brightness(struct backlight_device
*bd
, int value
)
1114 struct eeepc_laptop
*eeepc
= bl_get_data(bd
);
1116 return set_acpi(eeepc
, CM_ASL_PANELBRIGHT
, value
);
1119 static int update_bl_status(struct backlight_device
*bd
)
1121 return set_brightness(bd
, bd
->props
.brightness
);
1124 static const struct backlight_ops eeepcbl_ops
= {
1125 .get_brightness
= read_brightness
,
1126 .update_status
= update_bl_status
,
1129 static int eeepc_backlight_notify(struct eeepc_laptop
*eeepc
)
1131 struct backlight_device
*bd
= eeepc
->backlight_device
;
1132 int old
= bd
->props
.brightness
;
1134 backlight_force_update(bd
, BACKLIGHT_UPDATE_HOTKEY
);
1139 static int eeepc_backlight_init(struct eeepc_laptop
*eeepc
)
1141 struct backlight_properties props
;
1142 struct backlight_device
*bd
;
1144 memset(&props
, 0, sizeof(struct backlight_properties
));
1145 props
.type
= BACKLIGHT_PLATFORM
;
1146 props
.max_brightness
= 15;
1147 bd
= backlight_device_register(EEEPC_LAPTOP_FILE
,
1148 &eeepc
->platform_device
->dev
, eeepc
,
1149 &eeepcbl_ops
, &props
);
1151 pr_err("Could not register eeepc backlight device\n");
1152 eeepc
->backlight_device
= NULL
;
1155 eeepc
->backlight_device
= bd
;
1156 bd
->props
.brightness
= read_brightness(bd
);
1157 bd
->props
.power
= FB_BLANK_UNBLANK
;
1158 backlight_update_status(bd
);
1162 static void eeepc_backlight_exit(struct eeepc_laptop
*eeepc
)
1164 backlight_device_unregister(eeepc
->backlight_device
);
1165 eeepc
->backlight_device
= NULL
;
1170 * Input device (i.e. hotkeys)
1172 static int eeepc_input_init(struct eeepc_laptop
*eeepc
)
1174 struct input_dev
*input
;
1177 input
= input_allocate_device();
1181 input
->name
= "Asus EeePC extra buttons";
1182 input
->phys
= EEEPC_LAPTOP_FILE
"/input0";
1183 input
->id
.bustype
= BUS_HOST
;
1184 input
->dev
.parent
= &eeepc
->platform_device
->dev
;
1186 error
= sparse_keymap_setup(input
, eeepc_keymap
, NULL
);
1188 pr_err("Unable to setup input device keymap\n");
1192 error
= input_register_device(input
);
1194 pr_err("Unable to register input device\n");
1198 eeepc
->inputdev
= input
;
1202 input_free_device(input
);
1206 static void eeepc_input_exit(struct eeepc_laptop
*eeepc
)
1208 if (eeepc
->inputdev
)
1209 input_unregister_device(eeepc
->inputdev
);
1210 eeepc
->inputdev
= NULL
;
1216 static void eeepc_input_notify(struct eeepc_laptop
*eeepc
, int event
)
1218 if (!eeepc
->inputdev
)
1220 if (!sparse_keymap_report_event(eeepc
->inputdev
, event
, 1, true))
1221 pr_info("Unknown key %x pressed\n", event
);
1224 static void eeepc_acpi_notify(struct acpi_device
*device
, u32 event
)
1226 struct eeepc_laptop
*eeepc
= acpi_driver_data(device
);
1227 int old_brightness
, new_brightness
;
1230 if (event
> ACPI_MAX_SYS_NOTIFY
)
1232 count
= eeepc
->event_count
[event
% 128]++;
1233 acpi_bus_generate_netlink_event(device
->pnp
.device_class
,
1234 dev_name(&device
->dev
), event
,
1237 /* Brightness events are special */
1238 if (event
< NOTIFY_BRN_MIN
|| event
> NOTIFY_BRN_MAX
) {
1239 eeepc_input_notify(eeepc
, event
);
1243 /* Ignore them completely if the acpi video driver is used */
1244 if (!eeepc
->backlight_device
)
1247 /* Update the backlight device. */
1248 old_brightness
= eeepc_backlight_notify(eeepc
);
1250 /* Convert event to keypress (obsolescent hack) */
1251 new_brightness
= event
- NOTIFY_BRN_MIN
;
1253 if (new_brightness
< old_brightness
) {
1254 event
= NOTIFY_BRN_MIN
; /* brightness down */
1255 } else if (new_brightness
> old_brightness
) {
1256 event
= NOTIFY_BRN_MAX
; /* brightness up */
1259 * no change in brightness - already at min/max,
1260 * event will be desired value (or else ignored)
1263 eeepc_input_notify(eeepc
, event
);
1266 static void eeepc_dmi_check(struct eeepc_laptop
*eeepc
)
1270 model
= dmi_get_system_info(DMI_PRODUCT_NAME
);
1275 * Blacklist for setting cpufv (cpu speed).
1277 * EeePC 4G ("701") implements CFVS, but it is not supported
1278 * by the pre-installed OS, and the original option to change it
1279 * in the BIOS setup screen was removed in later versions.
1281 * Judging by the lack of "Super Hybrid Engine" on Asus product pages,
1282 * this applies to all "701" models (4G/4G Surf/2G Surf).
1284 * So Asus made a deliberate decision not to support it on this model.
1285 * We have several reports that using it can cause the system to hang
1287 * The hang has also been reported on a "702" (Model name "8G"?).
1289 * We avoid dmi_check_system() / dmi_match(), because they use
1290 * substring matching. We don't want to affect the "701SD"
1291 * and "701SDX" models, because they do support S.H.E.
1293 if (strcmp(model
, "701") == 0 || strcmp(model
, "702") == 0) {
1294 eeepc
->cpufv_disabled
= true;
1295 pr_info("model %s does not officially support setting cpu speed\n",
1297 pr_info("cpufv disabled to avoid instability\n");
1301 * Blacklist for wlan hotplug
1303 * Eeepc 1005HA doesn't work like others models and don't need the
1304 * hotplug code. In fact, current hotplug code seems to unplug another
1307 if (strcmp(model
, "1005HA") == 0 || strcmp(model
, "1201N") == 0 ||
1308 strcmp(model
, "1005PE") == 0) {
1309 eeepc
->hotplug_disabled
= true;
1310 pr_info("wlan hotplug disabled\n");
1314 static void cmsg_quirk(struct eeepc_laptop
*eeepc
, int cm
, const char *name
)
1318 /* Some BIOSes do not report cm although it is available.
1319 Check if cm_getv[cm] works and, if yes, assume cm should be set. */
1320 if (!(eeepc
->cm_supported
& (1 << cm
))
1321 && !read_acpi_int(eeepc
->handle
, cm_getv
[cm
], &dummy
)) {
1322 pr_info("%s (%x) not reported by BIOS, enabling anyway\n",
1324 eeepc
->cm_supported
|= 1 << cm
;
1328 static void cmsg_quirks(struct eeepc_laptop
*eeepc
)
1330 cmsg_quirk(eeepc
, CM_ASL_LID
, "LID");
1331 cmsg_quirk(eeepc
, CM_ASL_TYPE
, "TYPE");
1332 cmsg_quirk(eeepc
, CM_ASL_PANELPOWER
, "PANELPOWER");
1333 cmsg_quirk(eeepc
, CM_ASL_TPD
, "TPD");
1336 static int eeepc_acpi_init(struct eeepc_laptop
*eeepc
)
1338 unsigned int init_flags
;
1341 result
= acpi_bus_get_status(eeepc
->device
);
1344 if (!eeepc
->device
->status
.present
) {
1345 pr_err("Hotkey device not present, aborting\n");
1349 init_flags
= DISABLE_ASL_WLAN
| DISABLE_ASL_DISPLAYSWITCH
;
1350 pr_notice("Hotkey init flags 0x%x\n", init_flags
);
1352 if (write_acpi_int(eeepc
->handle
, "INIT", init_flags
)) {
1353 pr_err("Hotkey initialization failed\n");
1357 /* get control methods supported */
1358 if (read_acpi_int(eeepc
->handle
, "CMSG", &eeepc
->cm_supported
)) {
1359 pr_err("Get control methods supported failed\n");
1363 pr_info("Get control methods supported: 0x%x\n", eeepc
->cm_supported
);
1368 static void eeepc_enable_camera(struct eeepc_laptop
*eeepc
)
1371 * If the following call to set_acpi() fails, it's because there's no
1372 * camera so we can ignore the error.
1374 if (get_acpi(eeepc
, CM_ASL_CAMERA
) == 0)
1375 set_acpi(eeepc
, CM_ASL_CAMERA
, 1);
1378 static bool eeepc_device_present
;
1380 static int eeepc_acpi_add(struct acpi_device
*device
)
1382 struct eeepc_laptop
*eeepc
;
1385 pr_notice(EEEPC_LAPTOP_NAME
"\n");
1386 eeepc
= kzalloc(sizeof(struct eeepc_laptop
), GFP_KERNEL
);
1389 eeepc
->handle
= device
->handle
;
1390 strcpy(acpi_device_name(device
), EEEPC_ACPI_DEVICE_NAME
);
1391 strcpy(acpi_device_class(device
), EEEPC_ACPI_CLASS
);
1392 device
->driver_data
= eeepc
;
1393 eeepc
->device
= device
;
1395 eeepc
->hotplug_disabled
= hotplug_disabled
;
1397 eeepc_dmi_check(eeepc
);
1399 result
= eeepc_acpi_init(eeepc
);
1402 eeepc_enable_camera(eeepc
);
1405 * Register the platform device first. It is used as a parent for the
1406 * sub-devices below.
1408 * Note that if there are multiple instances of this ACPI device it
1409 * will bail out, because the platform device is registered with a
1410 * fixed name. Of course it doesn't make sense to have more than one,
1411 * and machine-specific scripts find the fixed name convenient. But
1412 * It's also good for us to exclude multiple instances because both
1413 * our hwmon and our wlan rfkill subdevice use global ACPI objects
1414 * (the EC and the wlan PCI slot respectively).
1416 result
= eeepc_platform_init(eeepc
);
1420 if (acpi_video_get_backlight_type() == acpi_backlight_vendor
) {
1421 result
= eeepc_backlight_init(eeepc
);
1423 goto fail_backlight
;
1426 result
= eeepc_input_init(eeepc
);
1430 result
= eeepc_hwmon_init(eeepc
);
1434 result
= eeepc_led_init(eeepc
);
1438 result
= eeepc_rfkill_init(eeepc
);
1442 eeepc_device_present
= true;
1446 eeepc_led_exit(eeepc
);
1449 eeepc_input_exit(eeepc
);
1451 eeepc_backlight_exit(eeepc
);
1453 eeepc_platform_exit(eeepc
);
1460 static int eeepc_acpi_remove(struct acpi_device
*device
)
1462 struct eeepc_laptop
*eeepc
= acpi_driver_data(device
);
1464 eeepc_backlight_exit(eeepc
);
1465 eeepc_rfkill_exit(eeepc
);
1466 eeepc_input_exit(eeepc
);
1467 eeepc_led_exit(eeepc
);
1468 eeepc_platform_exit(eeepc
);
1475 static const struct acpi_device_id eeepc_device_ids
[] = {
1476 {EEEPC_ACPI_HID
, 0},
1479 MODULE_DEVICE_TABLE(acpi
, eeepc_device_ids
);
1481 static struct acpi_driver eeepc_acpi_driver
= {
1482 .name
= EEEPC_LAPTOP_NAME
,
1483 .class = EEEPC_ACPI_CLASS
,
1484 .owner
= THIS_MODULE
,
1485 .ids
= eeepc_device_ids
,
1486 .flags
= ACPI_DRIVER_ALL_NOTIFY_EVENTS
,
1488 .add
= eeepc_acpi_add
,
1489 .remove
= eeepc_acpi_remove
,
1490 .notify
= eeepc_acpi_notify
,
1495 static int __init
eeepc_laptop_init(void)
1499 result
= platform_driver_register(&platform_driver
);
1503 result
= acpi_bus_register_driver(&eeepc_acpi_driver
);
1505 goto fail_acpi_driver
;
1507 if (!eeepc_device_present
) {
1509 goto fail_no_device
;
1515 acpi_bus_unregister_driver(&eeepc_acpi_driver
);
1517 platform_driver_unregister(&platform_driver
);
1521 static void __exit
eeepc_laptop_exit(void)
1523 acpi_bus_unregister_driver(&eeepc_acpi_driver
);
1524 platform_driver_unregister(&platform_driver
);
1527 module_init(eeepc_laptop_init
);
1528 module_exit(eeepc_laptop_exit
);