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>
41 #define EEEPC_LAPTOP_VERSION "0.1"
42 #define EEEPC_LAPTOP_NAME "Eee PC Hotkey Driver"
43 #define EEEPC_LAPTOP_FILE "eeepc"
45 #define EEEPC_ACPI_CLASS "hotkey"
46 #define EEEPC_ACPI_DEVICE_NAME "Hotkey"
47 #define EEEPC_ACPI_HID "ASUS010"
49 MODULE_AUTHOR("Corentin Chary, Eric Cooper");
50 MODULE_DESCRIPTION(EEEPC_LAPTOP_NAME);
51 MODULE_LICENSE("GPL");
53 static bool hotplug_disabled;
55 module_param(hotplug_disabled, bool, 0444);
56 MODULE_PARM_DESC(hotplug_disabled,
57 "Disable hotplug for wireless device. "
58 "If your laptop need that, please report to "
59 "acpi4asus-user@lists.sourceforge.net.");
62 * Definitions for Asus EeePC
64 #define NOTIFY_BRN_MIN 0x20
65 #define NOTIFY_BRN_MAX 0x2f
68 DISABLE_ASL_WLAN = 0x0001,
69 DISABLE_ASL_BLUETOOTH = 0x0002,
70 DISABLE_ASL_IRDA = 0x0004,
71 DISABLE_ASL_CAMERA = 0x0008,
72 DISABLE_ASL_TV = 0x0010,
73 DISABLE_ASL_GPS = 0x0020,
74 DISABLE_ASL_DISPLAYSWITCH = 0x0040,
75 DISABLE_ASL_MODEM = 0x0080,
76 DISABLE_ASL_CARDREADER = 0x0100,
77 DISABLE_ASL_3G = 0x0200,
78 DISABLE_ASL_WIMAX = 0x0400,
79 DISABLE_ASL_HWCF = 0x0800
96 CM_ASL_CPUTEMPERATURE,
109 CM_ASL_PANELPOWER, /*P901*/
113 static const char *cm_getv[] = {
114 "WLDG", "BTHG", NULL, NULL,
115 "CAMG", NULL, NULL, NULL,
116 NULL, "PBLG", NULL, NULL,
117 "CFVG", NULL, NULL, NULL,
118 "USBG", NULL, NULL, "MODG",
119 "CRDG", "M3GG", "WIMG", "HWCF",
120 "LIDG", "TYPE", "PBPG", "TPDG"
123 static const char *cm_setv[] = {
124 "WLDS", "BTHS", NULL, NULL,
125 "CAMS", NULL, NULL, NULL,
126 "SDSP", "PBLS", "HDPS", NULL,
127 "CFVS", NULL, NULL, NULL,
128 "USBG", NULL, NULL, "MODS",
129 "CRDS", "M3GS", "WIMS", NULL,
130 NULL, NULL, "PBPS", "TPDS"
133 static const struct key_entry eeepc_keymap[] = {
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, 0x16, { KEY_DISPLAY_OFF } },
141 { KE_KEY, 0x1a, { KEY_COFFEE } },
142 { KE_KEY, 0x1b, { KEY_ZOOM } },
143 { KE_KEY, 0x1c, { KEY_PROG2 } },
144 { KE_KEY, 0x1d, { KEY_PROG3 } },
145 { KE_KEY, NOTIFY_BRN_MIN, { KEY_BRIGHTNESSDOWN } },
146 { KE_KEY, NOTIFY_BRN_MAX, { KEY_BRIGHTNESSUP } },
147 { KE_KEY, 0x30, { KEY_SWITCHVIDEOMODE } },
148 { KE_KEY, 0x31, { KEY_SWITCHVIDEOMODE } },
149 { KE_KEY, 0x32, { KEY_SWITCHVIDEOMODE } },
150 { KE_KEY, 0x37, { KEY_F13 } }, /* Disable Touchpad */
151 { KE_KEY, 0x38, { KEY_F14 } },
156 * This is the main structure, we can use it to store useful information
158 struct eeepc_laptop {
159 acpi_handle handle; /* the handle of the acpi device */
160 u32 cm_supported; /* the control methods supported
163 bool hotplug_disabled;
164 u16 event_count[128]; /* count for each event */
166 struct platform_device *platform_device;
167 struct acpi_device *device; /* the device we are in */
168 struct backlight_device *backlight_device;
170 struct input_dev *inputdev;
172 struct rfkill *wlan_rfkill;
173 struct rfkill *bluetooth_rfkill;
174 struct rfkill *wwan3g_rfkill;
175 struct rfkill *wimax_rfkill;
177 struct hotplug_slot *hotplug_slot;
178 struct mutex hotplug_lock;
180 struct led_classdev tpd_led;
182 struct workqueue_struct *led_workqueue;
183 struct work_struct tpd_led_work;
189 static int write_acpi_int(acpi_handle handle, const char *method, int val)
193 status = acpi_execute_simple_method(handle, (char *)method, val);
195 return (status == AE_OK ? 0 : -1);
198 static int read_acpi_int(acpi_handle handle, const char *method, int *val)
201 unsigned long long result;
203 status = acpi_evaluate_integer(handle, (char *)method, NULL, &result);
204 if (ACPI_FAILURE(status)) {
213 static int set_acpi(struct eeepc_laptop *eeepc, int cm, int value)
215 const char *method = cm_setv[cm];
219 if ((eeepc->cm_supported & (0x1 << cm)) == 0)
222 if (write_acpi_int(eeepc->handle, method, value))
223 pr_warn("Error writing %s\n", method);
227 static int get_acpi(struct eeepc_laptop *eeepc, int cm)
229 const char *method = cm_getv[cm];
234 if ((eeepc->cm_supported & (0x1 << cm)) == 0)
237 if (read_acpi_int(eeepc->handle, method, &value))
238 pr_warn("Error reading %s\n", method);
242 static int acpi_setter_handle(struct eeepc_laptop *eeepc, int cm,
245 const char *method = cm_setv[cm];
250 if ((eeepc->cm_supported & (0x1 << cm)) == 0)
253 status = acpi_get_handle(eeepc->handle, (char *)method,
255 if (status != AE_OK) {
256 pr_warn("Error finding %s\n", method);
266 static int parse_arg(const char *buf, int *val)
268 if (sscanf(buf, "%i", val) != 1)
273 static ssize_t store_sys_acpi(struct device *dev, int cm,
274 const char *buf, size_t count)
276 struct eeepc_laptop *eeepc = dev_get_drvdata(dev);
279 rv = parse_arg(buf, &value);
282 rv = set_acpi(eeepc, cm, value);
288 static ssize_t show_sys_acpi(struct device *dev, int cm, char *buf)
290 struct eeepc_laptop *eeepc = dev_get_drvdata(dev);
291 int value = get_acpi(eeepc, cm);
295 return sprintf(buf, "%d\n", value);
298 #define EEEPC_ACPI_SHOW_FUNC(_name, _cm) \
299 static ssize_t _name##_show(struct device *dev, \
300 struct device_attribute *attr, \
303 return show_sys_acpi(dev, _cm, buf); \
306 #define EEEPC_ACPI_STORE_FUNC(_name, _cm) \
307 static ssize_t _name##_store(struct device *dev, \
308 struct device_attribute *attr, \
309 const char *buf, size_t count) \
311 return store_sys_acpi(dev, _cm, buf, count); \
314 #define EEEPC_CREATE_DEVICE_ATTR_RW(_name, _cm) \
315 EEEPC_ACPI_SHOW_FUNC(_name, _cm) \
316 EEEPC_ACPI_STORE_FUNC(_name, _cm) \
317 static DEVICE_ATTR_RW(_name)
319 #define EEEPC_CREATE_DEVICE_ATTR_WO(_name, _cm) \
320 EEEPC_ACPI_STORE_FUNC(_name, _cm) \
321 static DEVICE_ATTR_WO(_name)
323 EEEPC_CREATE_DEVICE_ATTR_RW(camera, CM_ASL_CAMERA);
324 EEEPC_CREATE_DEVICE_ATTR_RW(cardr, CM_ASL_CARDREADER);
325 EEEPC_CREATE_DEVICE_ATTR_WO(disp, CM_ASL_DISPLAYSWITCH);
332 static int get_cpufv(struct eeepc_laptop *eeepc, struct eeepc_cpufv *c)
334 c->cur = get_acpi(eeepc, CM_ASL_CPUFV);
338 c->num = (c->cur >> 8) & 0xff;
340 if (c->num == 0 || c->num > 12)
345 static ssize_t available_cpufv_show(struct device *dev,
346 struct device_attribute *attr,
349 struct eeepc_laptop *eeepc = dev_get_drvdata(dev);
350 struct eeepc_cpufv c;
354 if (get_cpufv(eeepc, &c))
356 for (i = 0; i < c.num; i++)
357 len += sprintf(buf + len, "%d ", i);
358 len += sprintf(buf + len, "\n");
362 static ssize_t cpufv_show(struct device *dev,
363 struct device_attribute *attr,
366 struct eeepc_laptop *eeepc = dev_get_drvdata(dev);
367 struct eeepc_cpufv c;
369 if (get_cpufv(eeepc, &c))
371 return sprintf(buf, "%#x\n", (c.num << 8) | c.cur);
374 static ssize_t cpufv_store(struct device *dev,
375 struct device_attribute *attr,
376 const char *buf, size_t count)
378 struct eeepc_laptop *eeepc = dev_get_drvdata(dev);
379 struct eeepc_cpufv c;
382 if (eeepc->cpufv_disabled)
384 if (get_cpufv(eeepc, &c))
386 rv = parse_arg(buf, &value);
389 if (value < 0 || value >= c.num)
391 rv = set_acpi(eeepc, CM_ASL_CPUFV, value);
397 static ssize_t cpufv_disabled_show(struct device *dev,
398 struct device_attribute *attr,
401 struct eeepc_laptop *eeepc = dev_get_drvdata(dev);
403 return sprintf(buf, "%d\n", eeepc->cpufv_disabled);
406 static ssize_t cpufv_disabled_store(struct device *dev,
407 struct device_attribute *attr,
408 const char *buf, size_t count)
410 struct eeepc_laptop *eeepc = dev_get_drvdata(dev);
413 rv = parse_arg(buf, &value);
419 if (eeepc->cpufv_disabled)
420 pr_warn("cpufv enabled (not officially supported "
422 eeepc->cpufv_disabled = false;
432 static DEVICE_ATTR_RW(cpufv);
433 static DEVICE_ATTR_RO(available_cpufv);
434 static DEVICE_ATTR_RW(cpufv_disabled);
436 static struct attribute *platform_attributes[] = {
437 &dev_attr_camera.attr,
438 &dev_attr_cardr.attr,
440 &dev_attr_cpufv.attr,
441 &dev_attr_available_cpufv.attr,
442 &dev_attr_cpufv_disabled.attr,
446 static struct attribute_group platform_attribute_group = {
447 .attrs = platform_attributes
450 static int eeepc_platform_init(struct eeepc_laptop *eeepc)
454 eeepc->platform_device = platform_device_alloc(EEEPC_LAPTOP_FILE, -1);
455 if (!eeepc->platform_device)
457 platform_set_drvdata(eeepc->platform_device, eeepc);
459 result = platform_device_add(eeepc->platform_device);
461 goto fail_platform_device;
463 result = sysfs_create_group(&eeepc->platform_device->dev.kobj,
464 &platform_attribute_group);
470 platform_device_del(eeepc->platform_device);
471 fail_platform_device:
472 platform_device_put(eeepc->platform_device);
476 static void eeepc_platform_exit(struct eeepc_laptop *eeepc)
478 sysfs_remove_group(&eeepc->platform_device->dev.kobj,
479 &platform_attribute_group);
480 platform_device_unregister(eeepc->platform_device);
487 * These functions actually update the LED's, and are called from a
488 * workqueue. By doing this as separate work rather than when the LED
489 * subsystem asks, we avoid messing with the Asus ACPI stuff during a
490 * potentially bad time, such as a timer interrupt.
492 static void tpd_led_update(struct work_struct *work)
494 struct eeepc_laptop *eeepc;
496 eeepc = container_of(work, struct eeepc_laptop, tpd_led_work);
498 set_acpi(eeepc, CM_ASL_TPD, eeepc->tpd_led_wk);
501 static void tpd_led_set(struct led_classdev *led_cdev,
502 enum led_brightness value)
504 struct eeepc_laptop *eeepc;
506 eeepc = container_of(led_cdev, struct eeepc_laptop, tpd_led);
508 eeepc->tpd_led_wk = (value > 0) ? 1 : 0;
509 queue_work(eeepc->led_workqueue, &eeepc->tpd_led_work);
512 static enum led_brightness tpd_led_get(struct led_classdev *led_cdev)
514 struct eeepc_laptop *eeepc;
516 eeepc = container_of(led_cdev, struct eeepc_laptop, tpd_led);
518 return get_acpi(eeepc, CM_ASL_TPD);
521 static int eeepc_led_init(struct eeepc_laptop *eeepc)
525 if (get_acpi(eeepc, CM_ASL_TPD) == -ENODEV)
528 eeepc->led_workqueue = create_singlethread_workqueue("led_workqueue");
529 if (!eeepc->led_workqueue)
531 INIT_WORK(&eeepc->tpd_led_work, tpd_led_update);
533 eeepc->tpd_led.name = "eeepc::touchpad";
534 eeepc->tpd_led.brightness_set = tpd_led_set;
535 if (get_acpi(eeepc, CM_ASL_TPD) >= 0) /* if method is available */
536 eeepc->tpd_led.brightness_get = tpd_led_get;
537 eeepc->tpd_led.max_brightness = 1;
539 rv = led_classdev_register(&eeepc->platform_device->dev,
542 destroy_workqueue(eeepc->led_workqueue);
549 static void eeepc_led_exit(struct eeepc_laptop *eeepc)
551 if (!IS_ERR_OR_NULL(eeepc->tpd_led.dev))
552 led_classdev_unregister(&eeepc->tpd_led);
553 if (eeepc->led_workqueue)
554 destroy_workqueue(eeepc->led_workqueue);
559 * PCI hotplug (for wlan rfkill)
561 static bool eeepc_wlan_rfkill_blocked(struct eeepc_laptop *eeepc)
563 if (get_acpi(eeepc, CM_ASL_WLAN) == 1)
568 static void eeepc_rfkill_hotplug(struct eeepc_laptop *eeepc, acpi_handle handle)
570 struct pci_dev *port;
573 bool blocked = eeepc_wlan_rfkill_blocked(eeepc);
577 if (eeepc->wlan_rfkill)
578 rfkill_set_sw_state(eeepc->wlan_rfkill, blocked);
580 mutex_lock(&eeepc->hotplug_lock);
581 pci_lock_rescan_remove();
583 if (eeepc->hotplug_slot) {
584 port = acpi_get_pci_dev(handle);
586 pr_warning("Unable to find port\n");
590 bus = port->subordinate;
593 pr_warn("Unable to find PCI bus 1?\n");
597 if (pci_bus_read_config_dword(bus, 0, PCI_VENDOR_ID, &l)) {
598 pr_err("Unable to read PCI config space?\n");
602 absent = (l == 0xffffffff);
604 if (blocked != absent) {
605 pr_warn("BIOS says wireless lan is %s, "
606 "but the pci device is %s\n",
607 blocked ? "blocked" : "unblocked",
608 absent ? "absent" : "present");
609 pr_warn("skipped wireless hotplug as probably "
610 "inappropriate for this model\n");
615 dev = pci_get_slot(bus, 0);
617 /* Device already present */
621 dev = pci_scan_single_device(bus, 0);
623 pci_bus_assign_resources(bus);
624 pci_bus_add_device(dev);
627 dev = pci_get_slot(bus, 0);
629 pci_stop_and_remove_bus_device(dev);
638 pci_unlock_rescan_remove();
639 mutex_unlock(&eeepc->hotplug_lock);
642 static void eeepc_rfkill_hotplug_update(struct eeepc_laptop *eeepc, char *node)
644 acpi_status status = AE_OK;
647 status = acpi_get_handle(NULL, node, &handle);
649 if (ACPI_SUCCESS(status))
650 eeepc_rfkill_hotplug(eeepc, handle);
653 static void eeepc_rfkill_notify(acpi_handle handle, u32 event, void *data)
655 struct eeepc_laptop *eeepc = data;
657 if (event != ACPI_NOTIFY_BUS_CHECK)
660 eeepc_rfkill_hotplug(eeepc, handle);
663 static int eeepc_register_rfkill_notifier(struct eeepc_laptop *eeepc,
669 status = acpi_get_handle(NULL, node, &handle);
671 if (ACPI_FAILURE(status))
674 status = acpi_install_notify_handler(handle,
678 if (ACPI_FAILURE(status))
679 pr_warn("Failed to register notify on %s\n", node);
682 * Refresh pci hotplug in case the rfkill state was
683 * changed during setup.
685 eeepc_rfkill_hotplug(eeepc, handle);
689 static void eeepc_unregister_rfkill_notifier(struct eeepc_laptop *eeepc,
692 acpi_status status = AE_OK;
695 status = acpi_get_handle(NULL, node, &handle);
697 if (ACPI_FAILURE(status))
700 status = acpi_remove_notify_handler(handle,
702 eeepc_rfkill_notify);
703 if (ACPI_FAILURE(status))
704 pr_err("Error removing rfkill notify handler %s\n",
707 * Refresh pci hotplug in case the rfkill
708 * state was changed after
709 * eeepc_unregister_rfkill_notifier()
711 eeepc_rfkill_hotplug(eeepc, handle);
714 static int eeepc_get_adapter_status(struct hotplug_slot *hotplug_slot,
717 struct eeepc_laptop *eeepc = hotplug_slot->private;
718 int val = get_acpi(eeepc, CM_ASL_WLAN);
720 if (val == 1 || val == 0)
728 static void eeepc_cleanup_pci_hotplug(struct hotplug_slot *hotplug_slot)
730 kfree(hotplug_slot->info);
734 static struct hotplug_slot_ops eeepc_hotplug_slot_ops = {
735 .owner = THIS_MODULE,
736 .get_adapter_status = eeepc_get_adapter_status,
737 .get_power_status = eeepc_get_adapter_status,
740 static int eeepc_setup_pci_hotplug(struct eeepc_laptop *eeepc)
743 struct pci_bus *bus = pci_find_bus(0, 1);
746 pr_err("Unable to find wifi PCI bus\n");
750 eeepc->hotplug_slot = kzalloc(sizeof(struct hotplug_slot), GFP_KERNEL);
751 if (!eeepc->hotplug_slot)
754 eeepc->hotplug_slot->info = kzalloc(sizeof(struct hotplug_slot_info),
756 if (!eeepc->hotplug_slot->info)
759 eeepc->hotplug_slot->private = eeepc;
760 eeepc->hotplug_slot->release = &eeepc_cleanup_pci_hotplug;
761 eeepc->hotplug_slot->ops = &eeepc_hotplug_slot_ops;
762 eeepc_get_adapter_status(eeepc->hotplug_slot,
763 &eeepc->hotplug_slot->info->adapter_status);
765 ret = pci_hp_register(eeepc->hotplug_slot, bus, 0, "eeepc-wifi");
767 pr_err("Unable to register hotplug slot - %d\n", ret);
774 kfree(eeepc->hotplug_slot->info);
776 kfree(eeepc->hotplug_slot);
777 eeepc->hotplug_slot = NULL;
785 static int eeepc_rfkill_set(void *data, bool blocked)
787 acpi_handle handle = data;
789 return write_acpi_int(handle, NULL, !blocked);
792 static const struct rfkill_ops eeepc_rfkill_ops = {
793 .set_block = eeepc_rfkill_set,
796 static int eeepc_new_rfkill(struct eeepc_laptop *eeepc,
797 struct rfkill **rfkill,
799 enum rfkill_type type, int cm)
804 result = acpi_setter_handle(eeepc, cm, &handle);
808 *rfkill = rfkill_alloc(name, &eeepc->platform_device->dev, type,
809 &eeepc_rfkill_ops, handle);
814 rfkill_init_sw_state(*rfkill, get_acpi(eeepc, cm) != 1);
815 result = rfkill_register(*rfkill);
817 rfkill_destroy(*rfkill);
824 static void eeepc_rfkill_exit(struct eeepc_laptop *eeepc)
826 eeepc_unregister_rfkill_notifier(eeepc, "\\_SB.PCI0.P0P5");
827 eeepc_unregister_rfkill_notifier(eeepc, "\\_SB.PCI0.P0P6");
828 eeepc_unregister_rfkill_notifier(eeepc, "\\_SB.PCI0.P0P7");
829 if (eeepc->wlan_rfkill) {
830 rfkill_unregister(eeepc->wlan_rfkill);
831 rfkill_destroy(eeepc->wlan_rfkill);
832 eeepc->wlan_rfkill = NULL;
835 if (eeepc->hotplug_slot)
836 pci_hp_deregister(eeepc->hotplug_slot);
838 if (eeepc->bluetooth_rfkill) {
839 rfkill_unregister(eeepc->bluetooth_rfkill);
840 rfkill_destroy(eeepc->bluetooth_rfkill);
841 eeepc->bluetooth_rfkill = NULL;
843 if (eeepc->wwan3g_rfkill) {
844 rfkill_unregister(eeepc->wwan3g_rfkill);
845 rfkill_destroy(eeepc->wwan3g_rfkill);
846 eeepc->wwan3g_rfkill = NULL;
848 if (eeepc->wimax_rfkill) {
849 rfkill_unregister(eeepc->wimax_rfkill);
850 rfkill_destroy(eeepc->wimax_rfkill);
851 eeepc->wimax_rfkill = NULL;
855 static int eeepc_rfkill_init(struct eeepc_laptop *eeepc)
859 mutex_init(&eeepc->hotplug_lock);
861 result = eeepc_new_rfkill(eeepc, &eeepc->wlan_rfkill,
862 "eeepc-wlan", RFKILL_TYPE_WLAN,
865 if (result && result != -ENODEV)
868 result = eeepc_new_rfkill(eeepc, &eeepc->bluetooth_rfkill,
869 "eeepc-bluetooth", RFKILL_TYPE_BLUETOOTH,
872 if (result && result != -ENODEV)
875 result = eeepc_new_rfkill(eeepc, &eeepc->wwan3g_rfkill,
876 "eeepc-wwan3g", RFKILL_TYPE_WWAN,
879 if (result && result != -ENODEV)
882 result = eeepc_new_rfkill(eeepc, &eeepc->wimax_rfkill,
883 "eeepc-wimax", RFKILL_TYPE_WIMAX,
886 if (result && result != -ENODEV)
889 if (eeepc->hotplug_disabled)
892 result = eeepc_setup_pci_hotplug(eeepc);
894 * If we get -EBUSY then something else is handling the PCI hotplug -
895 * don't fail in this case
897 if (result == -EBUSY)
900 eeepc_register_rfkill_notifier(eeepc, "\\_SB.PCI0.P0P5");
901 eeepc_register_rfkill_notifier(eeepc, "\\_SB.PCI0.P0P6");
902 eeepc_register_rfkill_notifier(eeepc, "\\_SB.PCI0.P0P7");
905 if (result && result != -ENODEV)
906 eeepc_rfkill_exit(eeepc);
911 * Platform driver - hibernate/resume callbacks
913 static int eeepc_hotk_thaw(struct device *device)
915 struct eeepc_laptop *eeepc = dev_get_drvdata(device);
917 if (eeepc->wlan_rfkill) {
921 * Work around bios bug - acpi _PTS turns off the wireless led
922 * during suspend. Normally it restores it on resume, but
923 * we should kick it ourselves in case hibernation is aborted.
925 wlan = get_acpi(eeepc, CM_ASL_WLAN);
926 set_acpi(eeepc, CM_ASL_WLAN, wlan);
932 static int eeepc_hotk_restore(struct device *device)
934 struct eeepc_laptop *eeepc = dev_get_drvdata(device);
936 /* Refresh both wlan rfkill state and pci hotplug */
937 if (eeepc->wlan_rfkill) {
938 eeepc_rfkill_hotplug_update(eeepc, "\\_SB.PCI0.P0P5");
939 eeepc_rfkill_hotplug_update(eeepc, "\\_SB.PCI0.P0P6");
940 eeepc_rfkill_hotplug_update(eeepc, "\\_SB.PCI0.P0P7");
943 if (eeepc->bluetooth_rfkill)
944 rfkill_set_sw_state(eeepc->bluetooth_rfkill,
945 get_acpi(eeepc, CM_ASL_BLUETOOTH) != 1);
946 if (eeepc->wwan3g_rfkill)
947 rfkill_set_sw_state(eeepc->wwan3g_rfkill,
948 get_acpi(eeepc, CM_ASL_3G) != 1);
949 if (eeepc->wimax_rfkill)
950 rfkill_set_sw_state(eeepc->wimax_rfkill,
951 get_acpi(eeepc, CM_ASL_WIMAX) != 1);
956 static const struct dev_pm_ops eeepc_pm_ops = {
957 .thaw = eeepc_hotk_thaw,
958 .restore = eeepc_hotk_restore,
961 static struct platform_driver platform_driver = {
963 .name = EEEPC_LAPTOP_FILE,
972 #define EEEPC_EC_SC00 0x61
973 #define EEEPC_EC_FAN_PWM (EEEPC_EC_SC00 + 2) /* Fan PWM duty cycle (%) */
974 #define EEEPC_EC_FAN_HRPM (EEEPC_EC_SC00 + 5) /* High byte, fan speed (RPM) */
975 #define EEEPC_EC_FAN_LRPM (EEEPC_EC_SC00 + 6) /* Low byte, fan speed (RPM) */
977 #define EEEPC_EC_SFB0 0xD0
978 #define EEEPC_EC_FAN_CTRL (EEEPC_EC_SFB0 + 3) /* Byte containing SF25 */
980 static int eeepc_get_fan_pwm(void)
984 ec_read(EEEPC_EC_FAN_PWM, &value);
985 return value * 255 / 100;
988 static void eeepc_set_fan_pwm(int value)
990 value = clamp_val(value, 0, 255);
991 value = value * 100 / 255;
992 ec_write(EEEPC_EC_FAN_PWM, value);
995 static int eeepc_get_fan_rpm(void)
1000 ec_read(EEEPC_EC_FAN_HRPM, &high);
1001 ec_read(EEEPC_EC_FAN_LRPM, &low);
1002 return high << 8 | low;
1005 static int eeepc_get_fan_ctrl(void)
1009 ec_read(EEEPC_EC_FAN_CTRL, &value);
1011 return 1; /* manual */
1013 return 2; /* automatic */
1016 static void eeepc_set_fan_ctrl(int manual)
1020 ec_read(EEEPC_EC_FAN_CTRL, &value);
1025 ec_write(EEEPC_EC_FAN_CTRL, value);
1028 static ssize_t store_sys_hwmon(void (*set)(int), const char *buf, size_t count)
1032 rv = parse_arg(buf, &value);
1039 static ssize_t show_sys_hwmon(int (*get)(void), char *buf)
1041 return sprintf(buf, "%d\n", get());
1044 #define EEEPC_SENSOR_SHOW_FUNC(_name, _get) \
1045 static ssize_t _name##_show(struct device *dev, \
1046 struct device_attribute *attr, \
1049 return show_sys_hwmon(_get, buf); \
1052 #define EEEPC_SENSOR_STORE_FUNC(_name, _set) \
1053 static ssize_t _name##_store(struct device *dev, \
1054 struct device_attribute *attr, \
1055 const char *buf, size_t count) \
1057 return store_sys_hwmon(_set, buf, count); \
1060 #define EEEPC_CREATE_SENSOR_ATTR_RW(_name, _get, _set) \
1061 EEEPC_SENSOR_SHOW_FUNC(_name, _get) \
1062 EEEPC_SENSOR_STORE_FUNC(_name, _set) \
1063 static DEVICE_ATTR_RW(_name)
1065 #define EEEPC_CREATE_SENSOR_ATTR_RO(_name, _get) \
1066 EEEPC_SENSOR_SHOW_FUNC(_name, _get) \
1067 static DEVICE_ATTR_RO(_name)
1069 EEEPC_CREATE_SENSOR_ATTR_RO(fan1_input, eeepc_get_fan_rpm);
1070 EEEPC_CREATE_SENSOR_ATTR_RW(pwm1, eeepc_get_fan_pwm,
1072 EEEPC_CREATE_SENSOR_ATTR_RW(pwm1_enable, eeepc_get_fan_ctrl,
1073 eeepc_set_fan_ctrl);
1075 static struct attribute *hwmon_attrs[] = {
1076 &dev_attr_pwm1.attr,
1077 &dev_attr_fan1_input.attr,
1078 &dev_attr_pwm1_enable.attr,
1081 ATTRIBUTE_GROUPS(hwmon);
1083 static int eeepc_hwmon_init(struct eeepc_laptop *eeepc)
1085 struct device *dev = &eeepc->platform_device->dev;
1086 struct device *hwmon;
1088 hwmon = devm_hwmon_device_register_with_groups(dev, "eeepc", NULL,
1090 if (IS_ERR(hwmon)) {
1091 pr_err("Could not register eeepc hwmon device\n");
1092 return PTR_ERR(hwmon);
1100 static int read_brightness(struct backlight_device *bd)
1102 struct eeepc_laptop *eeepc = bl_get_data(bd);
1104 return get_acpi(eeepc, CM_ASL_PANELBRIGHT);
1107 static int set_brightness(struct backlight_device *bd, int value)
1109 struct eeepc_laptop *eeepc = bl_get_data(bd);
1111 return set_acpi(eeepc, CM_ASL_PANELBRIGHT, value);
1114 static int update_bl_status(struct backlight_device *bd)
1116 return set_brightness(bd, bd->props.brightness);
1119 static const struct backlight_ops eeepcbl_ops = {
1120 .get_brightness = read_brightness,
1121 .update_status = update_bl_status,
1124 static int eeepc_backlight_notify(struct eeepc_laptop *eeepc)
1126 struct backlight_device *bd = eeepc->backlight_device;
1127 int old = bd->props.brightness;
1129 backlight_force_update(bd, BACKLIGHT_UPDATE_HOTKEY);
1134 static int eeepc_backlight_init(struct eeepc_laptop *eeepc)
1136 struct backlight_properties props;
1137 struct backlight_device *bd;
1139 memset(&props, 0, sizeof(struct backlight_properties));
1140 props.type = BACKLIGHT_PLATFORM;
1141 props.max_brightness = 15;
1142 bd = backlight_device_register(EEEPC_LAPTOP_FILE,
1143 &eeepc->platform_device->dev, eeepc,
1144 &eeepcbl_ops, &props);
1146 pr_err("Could not register eeepc backlight device\n");
1147 eeepc->backlight_device = NULL;
1150 eeepc->backlight_device = bd;
1151 bd->props.brightness = read_brightness(bd);
1152 bd->props.power = FB_BLANK_UNBLANK;
1153 backlight_update_status(bd);
1157 static void eeepc_backlight_exit(struct eeepc_laptop *eeepc)
1159 if (eeepc->backlight_device)
1160 backlight_device_unregister(eeepc->backlight_device);
1161 eeepc->backlight_device = NULL;
1166 * Input device (i.e. hotkeys)
1168 static int eeepc_input_init(struct eeepc_laptop *eeepc)
1170 struct input_dev *input;
1173 input = input_allocate_device();
1177 input->name = "Asus EeePC extra buttons";
1178 input->phys = EEEPC_LAPTOP_FILE "/input0";
1179 input->id.bustype = BUS_HOST;
1180 input->dev.parent = &eeepc->platform_device->dev;
1182 error = sparse_keymap_setup(input, eeepc_keymap, NULL);
1184 pr_err("Unable to setup input device keymap\n");
1188 error = input_register_device(input);
1190 pr_err("Unable to register input device\n");
1191 goto err_free_keymap;
1194 eeepc->inputdev = input;
1198 sparse_keymap_free(input);
1200 input_free_device(input);
1204 static void eeepc_input_exit(struct eeepc_laptop *eeepc)
1206 if (eeepc->inputdev) {
1207 sparse_keymap_free(eeepc->inputdev);
1208 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);
1229 if (event > ACPI_MAX_SYS_NOTIFY)
1231 count = eeepc->event_count[event % 128]++;
1232 acpi_bus_generate_netlink_event(device->pnp.device_class,
1233 dev_name(&device->dev), event,
1236 /* Brightness events are special */
1237 if (event >= NOTIFY_BRN_MIN && event <= NOTIFY_BRN_MAX) {
1239 /* Ignore them completely if the acpi video driver is used */
1240 if (eeepc->backlight_device != NULL) {
1241 int old_brightness, new_brightness;
1243 /* Update the backlight device. */
1244 old_brightness = eeepc_backlight_notify(eeepc);
1246 /* Convert event to keypress (obsolescent hack) */
1247 new_brightness = event - NOTIFY_BRN_MIN;
1249 if (new_brightness < old_brightness) {
1250 event = NOTIFY_BRN_MIN; /* brightness down */
1251 } else if (new_brightness > old_brightness) {
1252 event = NOTIFY_BRN_MAX; /* brightness up */
1255 * no change in brightness - already at min/max,
1256 * event will be desired value (or else ignored)
1259 eeepc_input_notify(eeepc, event);
1262 /* Everything else is a bona-fide keypress event */
1263 eeepc_input_notify(eeepc, event);
1267 static void eeepc_dmi_check(struct eeepc_laptop *eeepc)
1271 model = dmi_get_system_info(DMI_PRODUCT_NAME);
1276 * Blacklist for setting cpufv (cpu speed).
1278 * EeePC 4G ("701") implements CFVS, but it is not supported
1279 * by the pre-installed OS, and the original option to change it
1280 * in the BIOS setup screen was removed in later versions.
1282 * Judging by the lack of "Super Hybrid Engine" on Asus product pages,
1283 * this applies to all "701" models (4G/4G Surf/2G Surf).
1285 * So Asus made a deliberate decision not to support it on this model.
1286 * We have several reports that using it can cause the system to hang
1288 * The hang has also been reported on a "702" (Model name "8G"?).
1290 * We avoid dmi_check_system() / dmi_match(), because they use
1291 * substring matching. We don't want to affect the "701SD"
1292 * and "701SDX" models, because they do support S.H.E.
1294 if (strcmp(model, "701") == 0 || strcmp(model, "702") == 0) {
1295 eeepc->cpufv_disabled = true;
1296 pr_info("model %s does not officially support setting cpu "
1298 pr_info("cpufv disabled to avoid instability\n");
1302 * Blacklist for wlan hotplug
1304 * Eeepc 1005HA doesn't work like others models and don't need the
1305 * hotplug code. In fact, current hotplug code seems to unplug another
1308 if (strcmp(model, "1005HA") == 0 || strcmp(model, "1201N") == 0 ||
1309 strcmp(model, "1005PE") == 0) {
1310 eeepc->hotplug_disabled = true;
1311 pr_info("wlan hotplug disabled\n");
1315 static void cmsg_quirk(struct eeepc_laptop *eeepc, int cm, const char *name)
1319 /* Some BIOSes do not report cm although it is available.
1320 Check if cm_getv[cm] works and, if yes, assume cm should be set. */
1321 if (!(eeepc->cm_supported & (1 << cm))
1322 && !read_acpi_int(eeepc->handle, cm_getv[cm], &dummy)) {
1323 pr_info("%s (%x) not reported by BIOS,"
1324 " enabling anyway\n", name, 1 << cm);
1325 eeepc->cm_supported |= 1 << cm;
1329 static void cmsg_quirks(struct eeepc_laptop *eeepc)
1331 cmsg_quirk(eeepc, CM_ASL_LID, "LID");
1332 cmsg_quirk(eeepc, CM_ASL_TYPE, "TYPE");
1333 cmsg_quirk(eeepc, CM_ASL_PANELPOWER, "PANELPOWER");
1334 cmsg_quirk(eeepc, CM_ASL_TPD, "TPD");
1337 static int eeepc_acpi_init(struct eeepc_laptop *eeepc)
1339 unsigned int init_flags;
1342 result = acpi_bus_get_status(eeepc->device);
1345 if (!eeepc->device->status.present) {
1346 pr_err("Hotkey device not present, aborting\n");
1350 init_flags = DISABLE_ASL_WLAN | DISABLE_ASL_DISPLAYSWITCH;
1351 pr_notice("Hotkey init flags 0x%x\n", init_flags);
1353 if (write_acpi_int(eeepc->handle, "INIT", init_flags)) {
1354 pr_err("Hotkey initialization failed\n");
1358 /* get control methods supported */
1359 if (read_acpi_int(eeepc->handle, "CMSG", &eeepc->cm_supported)) {
1360 pr_err("Get control methods supported failed\n");
1364 pr_info("Get control methods supported: 0x%x\n", eeepc->cm_supported);
1369 static void eeepc_enable_camera(struct eeepc_laptop *eeepc)
1372 * If the following call to set_acpi() fails, it's because there's no
1373 * camera so we can ignore the error.
1375 if (get_acpi(eeepc, CM_ASL_CAMERA) == 0)
1376 set_acpi(eeepc, CM_ASL_CAMERA, 1);
1379 static bool eeepc_device_present;
1381 static int eeepc_acpi_add(struct acpi_device *device)
1383 struct eeepc_laptop *eeepc;
1386 pr_notice(EEEPC_LAPTOP_NAME "\n");
1387 eeepc = kzalloc(sizeof(struct eeepc_laptop), GFP_KERNEL);
1390 eeepc->handle = device->handle;
1391 strcpy(acpi_device_name(device), EEEPC_ACPI_DEVICE_NAME);
1392 strcpy(acpi_device_class(device), EEEPC_ACPI_CLASS);
1393 device->driver_data = eeepc;
1394 eeepc->device = device;
1396 eeepc->hotplug_disabled = hotplug_disabled;
1398 eeepc_dmi_check(eeepc);
1400 result = eeepc_acpi_init(eeepc);
1403 eeepc_enable_camera(eeepc);
1406 * Register the platform device first. It is used as a parent for the
1407 * sub-devices below.
1409 * Note that if there are multiple instances of this ACPI device it
1410 * will bail out, because the platform device is registered with a
1411 * fixed name. Of course it doesn't make sense to have more than one,
1412 * and machine-specific scripts find the fixed name convenient. But
1413 * It's also good for us to exclude multiple instances because both
1414 * our hwmon and our wlan rfkill subdevice use global ACPI objects
1415 * (the EC and the wlan PCI slot respectively).
1417 result = eeepc_platform_init(eeepc);
1421 if (!acpi_video_backlight_support()) {
1422 result = eeepc_backlight_init(eeepc);
1424 goto fail_backlight;
1426 pr_info("Backlight controlled by ACPI video driver\n");
1429 result = eeepc_input_init(eeepc);
1433 result = eeepc_hwmon_init(eeepc);
1437 result = eeepc_led_init(eeepc);
1441 result = eeepc_rfkill_init(eeepc);
1445 eeepc_device_present = true;
1449 eeepc_led_exit(eeepc);
1452 eeepc_input_exit(eeepc);
1454 eeepc_backlight_exit(eeepc);
1456 eeepc_platform_exit(eeepc);
1463 static int eeepc_acpi_remove(struct acpi_device *device)
1465 struct eeepc_laptop *eeepc = acpi_driver_data(device);
1467 eeepc_backlight_exit(eeepc);
1468 eeepc_rfkill_exit(eeepc);
1469 eeepc_input_exit(eeepc);
1470 eeepc_led_exit(eeepc);
1471 eeepc_platform_exit(eeepc);
1478 static const struct acpi_device_id eeepc_device_ids[] = {
1479 {EEEPC_ACPI_HID, 0},
1482 MODULE_DEVICE_TABLE(acpi, eeepc_device_ids);
1484 static struct acpi_driver eeepc_acpi_driver = {
1485 .name = EEEPC_LAPTOP_NAME,
1486 .class = EEEPC_ACPI_CLASS,
1487 .owner = THIS_MODULE,
1488 .ids = eeepc_device_ids,
1489 .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS,
1491 .add = eeepc_acpi_add,
1492 .remove = eeepc_acpi_remove,
1493 .notify = eeepc_acpi_notify,
1498 static int __init eeepc_laptop_init(void)
1502 result = platform_driver_register(&platform_driver);
1506 result = acpi_bus_register_driver(&eeepc_acpi_driver);
1508 goto fail_acpi_driver;
1510 if (!eeepc_device_present) {
1512 goto fail_no_device;
1518 acpi_bus_unregister_driver(&eeepc_acpi_driver);
1520 platform_driver_unregister(&platform_driver);
1524 static void __exit eeepc_laptop_exit(void)
1526 acpi_bus_unregister_driver(&eeepc_acpi_driver);
1527 platform_driver_unregister(&platform_driver);
1530 module_init(eeepc_laptop_init);
1531 module_exit(eeepc_laptop_exit);