* [PATCH 01/14] asus-wmi: move generic code to asus-wmi
2011-02-26 9:20 [PATCH 00/14] Support Asus WMI capable Notebooks (asus-wmi, asus-nb-wmi and eeepc-wmi) Corentin Chary
@ 2011-02-26 9:20 ` Corentin Chary
2011-02-26 9:20 ` [PATCH 02/14] eeepc-wmi: asus generic asus-wmi.ko module Corentin Chary
` (13 subsequent siblings)
14 siblings, 0 replies; 16+ messages in thread
From: Corentin Chary @ 2011-02-26 9:20 UTC (permalink / raw)
To: Matthew Garrett
Cc: Dmitry Torokhov, Corentin Chary, open list,
open list:X86 PLATFORM DRIVERS, open list:ASUS NOTEBOOKS AN...
New Asus notebooks are using a WMI device similar to
the one used in Eee PCs. Since we don't want to load
a module named eeepc-laptop on Asus Notebooks, start by
copying all the code to asus-wmi.c.
Signed-off-by: Corentin Chary <corentincj@iksaif.net>
---
drivers/platform/x86/Makefile | 2 +-
drivers/platform/x86/asus-wmi.c | 1454 ++++++++++++++++++++++++++++++++++++++
drivers/platform/x86/eeepc-wmi.c | 1454 --------------------------------------
3 files changed, 1455 insertions(+), 1455 deletions(-)
create mode 100644 drivers/platform/x86/asus-wmi.c
delete mode 100644 drivers/platform/x86/eeepc-wmi.c
diff --git a/drivers/platform/x86/Makefile b/drivers/platform/x86/Makefile
index 951b516..3672b04 100644
--- a/drivers/platform/x86/Makefile
+++ b/drivers/platform/x86/Makefile
@@ -4,7 +4,7 @@
#
obj-$(CONFIG_ASUS_LAPTOP) += asus-laptop.o
obj-$(CONFIG_EEEPC_LAPTOP) += eeepc-laptop.o
-obj-$(CONFIG_EEEPC_WMI) += eeepc-wmi.o
+obj-$(CONFIG_EEEPC_WMI) += asus-wmi.o eeepc-wmi.o
obj-$(CONFIG_MSI_LAPTOP) += msi-laptop.o
obj-$(CONFIG_ACPI_CMPC) += classmate-laptop.o
obj-$(CONFIG_COMPAL_LAPTOP) += compal-laptop.o
diff --git a/drivers/platform/x86/asus-wmi.c b/drivers/platform/x86/asus-wmi.c
new file mode 100644
index 0000000..d399775
--- /dev/null
+++ b/drivers/platform/x86/asus-wmi.c
@@ -0,0 +1,1454 @@
+/*
+ * Eee PC WMI hotkey driver
+ *
+ * Copyright(C) 2010 Intel Corporation.
+ * Copyright(C) 2010 Corentin Chary <corentin.chary@gmail.com>
+ *
+ * Portions based on wistron_btns.c:
+ * Copyright (C) 2005 Miloslav Trmac <mitr@volny.cz>
+ * Copyright (C) 2005 Bernhard Rosenkraenzer <bero@arklinux.org>
+ * Copyright (C) 2005 Dmitry Torokhov <dtor@mail.ru>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/types.h>
+#include <linux/slab.h>
+#include <linux/input.h>
+#include <linux/input/sparse-keymap.h>
+#include <linux/fb.h>
+#include <linux/backlight.h>
+#include <linux/leds.h>
+#include <linux/rfkill.h>
+#include <linux/pci.h>
+#include <linux/pci_hotplug.h>
+#include <linux/debugfs.h>
+#include <linux/seq_file.h>
+#include <linux/platform_device.h>
+#include <linux/dmi.h>
+#include <acpi/acpi_bus.h>
+#include <acpi/acpi_drivers.h>
+
+#define EEEPC_WMI_FILE "eeepc-wmi"
+
+MODULE_AUTHOR("Yong Wang <yong.y.wang@intel.com>");
+MODULE_DESCRIPTION("Eee PC WMI Hotkey Driver");
+MODULE_LICENSE("GPL");
+
+#define EEEPC_ACPI_HID "ASUS010" /* old _HID used in eeepc-laptop */
+
+#define EEEPC_WMI_EVENT_GUID "ABBC0F72-8EA1-11D1-00A0-C90629100000"
+#define EEEPC_WMI_MGMT_GUID "97845ED0-4E6D-11DE-8A39-0800200C9A66"
+
+MODULE_ALIAS("wmi:"EEEPC_WMI_EVENT_GUID);
+MODULE_ALIAS("wmi:"EEEPC_WMI_MGMT_GUID);
+
+#define NOTIFY_BRNUP_MIN 0x11
+#define NOTIFY_BRNUP_MAX 0x1f
+#define NOTIFY_BRNDOWN_MIN 0x20
+#define NOTIFY_BRNDOWN_MAX 0x2e
+
+/* WMI Methods */
+#define EEEPC_WMI_METHODID_DSTS 0x53544344
+#define EEEPC_WMI_METHODID_DEVS 0x53564544
+#define EEEPC_WMI_METHODID_CFVS 0x53564643
+
+/* Wireless */
+#define EEEPC_WMI_DEVID_WLAN 0x00010011
+#define EEEPC_WMI_DEVID_BLUETOOTH 0x00010013
+#define EEEPC_WMI_DEVID_WIMAX 0x00010017
+#define EEEPC_WMI_DEVID_WWAN3G 0x00010019
+
+/* Backlight and Brightness */
+#define EEEPC_WMI_DEVID_BACKLIGHT 0x00050011
+#define EEEPC_WMI_DEVID_BRIGHTNESS 0x00050012
+
+/* Misc */
+#define EEEPC_WMI_DEVID_CAMERA 0x00060013
+
+/* Storage */
+#define EEEPC_WMI_DEVID_CARDREADER 0x00080013
+
+/* Input */
+#define EEEPC_WMI_DEVID_TOUCHPAD 0x00100011
+#define EEEPC_WMI_DEVID_TOUCHPAD_LED 0x00100012
+
+/* DSTS masks */
+#define EEEPC_WMI_DSTS_STATUS_BIT 0x00000001
+#define EEEPC_WMI_DSTS_PRESENCE_BIT 0x00010000
+#define EEEPC_WMI_DSTS_BRIGHTNESS_MASK 0x000000FF
+#define EEEPC_WMI_DSTS_MAX_BRIGTH_MASK 0x0000FF00
+
+static bool hotplug_wireless;
+
+module_param(hotplug_wireless, bool, 0444);
+MODULE_PARM_DESC(hotplug_wireless,
+ "Enable hotplug for wireless device. "
+ "If your laptop needs that, please report to "
+ "acpi4asus-user@lists.sourceforge.net.");
+
+static const struct key_entry eeepc_wmi_keymap[] = {
+ /* Sleep already handled via generic ACPI code */
+ { KE_IGNORE, NOTIFY_BRNDOWN_MIN, { KEY_BRIGHTNESSDOWN } },
+ { KE_IGNORE, NOTIFY_BRNUP_MIN, { KEY_BRIGHTNESSUP } },
+ { KE_KEY, 0x30, { KEY_VOLUMEUP } },
+ { KE_KEY, 0x31, { KEY_VOLUMEDOWN } },
+ { KE_KEY, 0x32, { KEY_MUTE } },
+ { KE_KEY, 0x5c, { KEY_F15 } }, /* Power Gear key */
+ { KE_KEY, 0x5d, { KEY_WLAN } },
+ { KE_KEY, 0x6b, { KEY_F13 } }, /* Disable Touchpad */
+ { KE_KEY, 0x82, { KEY_CAMERA } },
+ { KE_KEY, 0x83, { KEY_CAMERA_ZOOMIN } },
+ { KE_KEY, 0x88, { KEY_WLAN } },
+ { KE_KEY, 0xcc, { KEY_SWITCHVIDEOMODE } },
+ { KE_KEY, 0xe0, { KEY_PROG1 } }, /* Task Manager */
+ { KE_KEY, 0xe1, { KEY_F14 } }, /* Change Resolution */
+ { KE_KEY, 0xe9, { KEY_BRIGHTNESS_ZERO } },
+ { KE_KEY, 0xeb, { KEY_CAMERA_ZOOMOUT } },
+ { KE_KEY, 0xec, { KEY_CAMERA_UP } },
+ { KE_KEY, 0xed, { KEY_CAMERA_DOWN } },
+ { KE_KEY, 0xee, { KEY_CAMERA_LEFT } },
+ { KE_KEY, 0xef, { KEY_CAMERA_RIGHT } },
+ { KE_END, 0},
+};
+
+struct bios_args {
+ u32 dev_id;
+ u32 ctrl_param;
+};
+
+/*
+ * eeepc-wmi/ - debugfs root directory
+ * dev_id - current dev_id
+ * ctrl_param - current ctrl_param
+ * devs - call DEVS(dev_id, ctrl_param) and print result
+ * dsts - call DSTS(dev_id) and print result
+ */
+struct eeepc_wmi_debug {
+ struct dentry *root;
+ u32 dev_id;
+ u32 ctrl_param;
+};
+
+struct eeepc_wmi {
+ bool hotplug_wireless;
+
+ struct input_dev *inputdev;
+ struct backlight_device *backlight_device;
+ struct platform_device *platform_device;
+
+ struct led_classdev tpd_led;
+ int tpd_led_wk;
+ struct workqueue_struct *led_workqueue;
+ struct work_struct tpd_led_work;
+
+ struct rfkill *wlan_rfkill;
+ struct rfkill *bluetooth_rfkill;
+ struct rfkill *wimax_rfkill;
+ struct rfkill *wwan3g_rfkill;
+
+ struct hotplug_slot *hotplug_slot;
+ struct mutex hotplug_lock;
+ struct mutex wmi_lock;
+ struct workqueue_struct *hotplug_workqueue;
+ struct work_struct hotplug_work;
+
+ struct eeepc_wmi_debug debug;
+};
+
+static int eeepc_wmi_input_init(struct eeepc_wmi *eeepc)
+{
+ int err;
+
+ eeepc->inputdev = input_allocate_device();
+ if (!eeepc->inputdev)
+ return -ENOMEM;
+
+ eeepc->inputdev->name = "Eee PC WMI hotkeys";
+ eeepc->inputdev->phys = EEEPC_WMI_FILE "/input0";
+ eeepc->inputdev->id.bustype = BUS_HOST;
+ eeepc->inputdev->dev.parent = &eeepc->platform_device->dev;
+
+ err = sparse_keymap_setup(eeepc->inputdev, eeepc_wmi_keymap, NULL);
+ if (err)
+ goto err_free_dev;
+
+ err = input_register_device(eeepc->inputdev);
+ if (err)
+ goto err_free_keymap;
+
+ return 0;
+
+err_free_keymap:
+ sparse_keymap_free(eeepc->inputdev);
+err_free_dev:
+ input_free_device(eeepc->inputdev);
+ return err;
+}
+
+static void eeepc_wmi_input_exit(struct eeepc_wmi *eeepc)
+{
+ if (eeepc->inputdev) {
+ sparse_keymap_free(eeepc->inputdev);
+ input_unregister_device(eeepc->inputdev);
+ }
+
+ eeepc->inputdev = NULL;
+}
+
+static acpi_status eeepc_wmi_get_devstate(u32 dev_id, u32 *retval)
+{
+ struct acpi_buffer input = { (acpi_size)sizeof(u32), &dev_id };
+ struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
+ union acpi_object *obj;
+ acpi_status status;
+ u32 tmp;
+
+ status = wmi_evaluate_method(EEEPC_WMI_MGMT_GUID,
+ 1, EEEPC_WMI_METHODID_DSTS,
+ &input, &output);
+
+ if (ACPI_FAILURE(status))
+ return status;
+
+ obj = (union acpi_object *)output.pointer;
+ if (obj && obj->type == ACPI_TYPE_INTEGER)
+ tmp = (u32)obj->integer.value;
+ else
+ tmp = 0;
+
+ if (retval)
+ *retval = tmp;
+
+ kfree(obj);
+
+ return status;
+
+}
+
+static acpi_status eeepc_wmi_set_devstate(u32 dev_id, u32 ctrl_param,
+ u32 *retval)
+{
+ struct bios_args args = {
+ .dev_id = dev_id,
+ .ctrl_param = ctrl_param,
+ };
+ struct acpi_buffer input = { (acpi_size)sizeof(args), &args };
+ acpi_status status;
+
+ if (!retval) {
+ status = wmi_evaluate_method(EEEPC_WMI_MGMT_GUID, 1,
+ EEEPC_WMI_METHODID_DEVS,
+ &input, NULL);
+ } else {
+ struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
+ union acpi_object *obj;
+ u32 tmp;
+
+ status = wmi_evaluate_method(EEEPC_WMI_MGMT_GUID, 1,
+ EEEPC_WMI_METHODID_DEVS,
+ &input, &output);
+
+ if (ACPI_FAILURE(status))
+ return status;
+
+ obj = (union acpi_object *)output.pointer;
+ if (obj && obj->type == ACPI_TYPE_INTEGER)
+ tmp = (u32)obj->integer.value;
+ else
+ tmp = 0;
+
+ *retval = tmp;
+
+ kfree(obj);
+ }
+
+ return status;
+}
+
+/* Helper for special devices with magic return codes */
+static int eeepc_wmi_get_devstate_bits(u32 dev_id, u32 mask)
+{
+ u32 retval = 0;
+ acpi_status status;
+
+ status = eeepc_wmi_get_devstate(dev_id, &retval);
+
+ if (ACPI_FAILURE(status))
+ return -EINVAL;
+
+ if (!(retval & EEEPC_WMI_DSTS_PRESENCE_BIT))
+ return -ENODEV;
+
+ return retval & mask;
+}
+
+static int eeepc_wmi_get_devstate_simple(u32 dev_id)
+{
+ return eeepc_wmi_get_devstate_bits(dev_id, EEEPC_WMI_DSTS_STATUS_BIT);
+}
+
+/*
+ * LEDs
+ */
+/*
+ * These functions actually update the LED's, and are called from a
+ * workqueue. By doing this as separate work rather than when the LED
+ * subsystem asks, we avoid messing with the Eeepc ACPI stuff during a
+ * potentially bad time, such as a timer interrupt.
+ */
+static void tpd_led_update(struct work_struct *work)
+{
+ int ctrl_param;
+ struct eeepc_wmi *eeepc;
+
+ eeepc = container_of(work, struct eeepc_wmi, tpd_led_work);
+
+ ctrl_param = eeepc->tpd_led_wk;
+ eeepc_wmi_set_devstate(EEEPC_WMI_DEVID_TOUCHPAD_LED, ctrl_param, NULL);
+}
+
+static void tpd_led_set(struct led_classdev *led_cdev,
+ enum led_brightness value)
+{
+ struct eeepc_wmi *eeepc;
+
+ eeepc = container_of(led_cdev, struct eeepc_wmi, tpd_led);
+
+ eeepc->tpd_led_wk = !!value;
+ queue_work(eeepc->led_workqueue, &eeepc->tpd_led_work);
+}
+
+static int read_tpd_led_state(struct eeepc_wmi *eeepc)
+{
+ return eeepc_wmi_get_devstate_simple(EEEPC_WMI_DEVID_TOUCHPAD_LED);
+}
+
+static enum led_brightness tpd_led_get(struct led_classdev *led_cdev)
+{
+ struct eeepc_wmi *eeepc;
+
+ eeepc = container_of(led_cdev, struct eeepc_wmi, tpd_led);
+
+ return read_tpd_led_state(eeepc);
+}
+
+static int eeepc_wmi_led_init(struct eeepc_wmi *eeepc)
+{
+ int rv;
+
+ if (read_tpd_led_state(eeepc) < 0)
+ return 0;
+
+ eeepc->led_workqueue = create_singlethread_workqueue("led_workqueue");
+ if (!eeepc->led_workqueue)
+ return -ENOMEM;
+ INIT_WORK(&eeepc->tpd_led_work, tpd_led_update);
+
+ eeepc->tpd_led.name = "eeepc::touchpad";
+ eeepc->tpd_led.brightness_set = tpd_led_set;
+ eeepc->tpd_led.brightness_get = tpd_led_get;
+ eeepc->tpd_led.max_brightness = 1;
+
+ rv = led_classdev_register(&eeepc->platform_device->dev,
+ &eeepc->tpd_led);
+ if (rv) {
+ destroy_workqueue(eeepc->led_workqueue);
+ return rv;
+ }
+
+ return 0;
+}
+
+static void eeepc_wmi_led_exit(struct eeepc_wmi *eeepc)
+{
+ if (eeepc->tpd_led.dev)
+ led_classdev_unregister(&eeepc->tpd_led);
+ if (eeepc->led_workqueue)
+ destroy_workqueue(eeepc->led_workqueue);
+}
+
+/*
+ * PCI hotplug (for wlan rfkill)
+ */
+static bool eeepc_wlan_rfkill_blocked(struct eeepc_wmi *eeepc)
+{
+ int result = eeepc_wmi_get_devstate_simple(EEEPC_WMI_DEVID_WLAN);
+
+ if (result < 0)
+ return false;
+ return !result;
+}
+
+static void eeepc_rfkill_hotplug(struct eeepc_wmi *eeepc)
+{
+ struct pci_dev *dev;
+ struct pci_bus *bus;
+ bool blocked;
+ bool absent;
+ u32 l;
+
+ mutex_lock(&eeepc->wmi_lock);
+ blocked = eeepc_wlan_rfkill_blocked(eeepc);
+ mutex_unlock(&eeepc->wmi_lock);
+
+ mutex_lock(&eeepc->hotplug_lock);
+
+ if (eeepc->wlan_rfkill)
+ rfkill_set_sw_state(eeepc->wlan_rfkill, blocked);
+
+ if (eeepc->hotplug_slot) {
+ bus = pci_find_bus(0, 1);
+ if (!bus) {
+ pr_warning("Unable to find PCI bus 1?\n");
+ goto out_unlock;
+ }
+
+ if (pci_bus_read_config_dword(bus, 0, PCI_VENDOR_ID, &l)) {
+ pr_err("Unable to read PCI config space?\n");
+ goto out_unlock;
+ }
+ absent = (l == 0xffffffff);
+
+ if (blocked != absent) {
+ pr_warning("BIOS says wireless lan is %s, "
+ "but the pci device is %s\n",
+ blocked ? "blocked" : "unblocked",
+ absent ? "absent" : "present");
+ pr_warning("skipped wireless hotplug as probably "
+ "inappropriate for this model\n");
+ goto out_unlock;
+ }
+
+ if (!blocked) {
+ dev = pci_get_slot(bus, 0);
+ if (dev) {
+ /* Device already present */
+ pci_dev_put(dev);
+ goto out_unlock;
+ }
+ dev = pci_scan_single_device(bus, 0);
+ if (dev) {
+ pci_bus_assign_resources(bus);
+ if (pci_bus_add_device(dev))
+ pr_err("Unable to hotplug wifi\n");
+ }
+ } else {
+ dev = pci_get_slot(bus, 0);
+ if (dev) {
+ pci_remove_bus_device(dev);
+ pci_dev_put(dev);
+ }
+ }
+ }
+
+out_unlock:
+ mutex_unlock(&eeepc->hotplug_lock);
+}
+
+static void eeepc_rfkill_notify(acpi_handle handle, u32 event, void *data)
+{
+ struct eeepc_wmi *eeepc = data;
+
+ if (event != ACPI_NOTIFY_BUS_CHECK)
+ return;
+
+ /*
+ * We can't call directly eeepc_rfkill_hotplug because most
+ * of the time WMBC is still being executed and not reetrant.
+ * There is currently no way to tell ACPICA that we want this
+ * method to be serialized, we schedule a eeepc_rfkill_hotplug
+ * call later, in a safer context.
+ */
+ queue_work(eeepc->hotplug_workqueue, &eeepc->hotplug_work);
+}
+
+static int eeepc_register_rfkill_notifier(struct eeepc_wmi *eeepc,
+ char *node)
+{
+ acpi_status status;
+ acpi_handle handle;
+
+ status = acpi_get_handle(NULL, node, &handle);
+
+ if (ACPI_SUCCESS(status)) {
+ status = acpi_install_notify_handler(handle,
+ ACPI_SYSTEM_NOTIFY,
+ eeepc_rfkill_notify,
+ eeepc);
+ if (ACPI_FAILURE(status))
+ pr_warning("Failed to register notify on %s\n", node);
+ } else
+ return -ENODEV;
+
+ return 0;
+}
+
+static void eeepc_unregister_rfkill_notifier(struct eeepc_wmi *eeepc,
+ char *node)
+{
+ acpi_status status = AE_OK;
+ acpi_handle handle;
+
+ status = acpi_get_handle(NULL, node, &handle);
+
+ if (ACPI_SUCCESS(status)) {
+ status = acpi_remove_notify_handler(handle,
+ ACPI_SYSTEM_NOTIFY,
+ eeepc_rfkill_notify);
+ if (ACPI_FAILURE(status))
+ pr_err("Error removing rfkill notify handler %s\n",
+ node);
+ }
+}
+
+static int eeepc_get_adapter_status(struct hotplug_slot *hotplug_slot,
+ u8 *value)
+{
+ int result = eeepc_wmi_get_devstate_simple(EEEPC_WMI_DEVID_WLAN);
+
+ if (result < 0)
+ return result;
+
+ *value = !!result;
+ return 0;
+}
+
+static void eeepc_cleanup_pci_hotplug(struct hotplug_slot *hotplug_slot)
+{
+ kfree(hotplug_slot->info);
+ kfree(hotplug_slot);
+}
+
+static struct hotplug_slot_ops eeepc_hotplug_slot_ops = {
+ .owner = THIS_MODULE,
+ .get_adapter_status = eeepc_get_adapter_status,
+ .get_power_status = eeepc_get_adapter_status,
+};
+
+static void eeepc_hotplug_work(struct work_struct *work)
+{
+ struct eeepc_wmi *eeepc;
+
+ eeepc = container_of(work, struct eeepc_wmi, hotplug_work);
+ eeepc_rfkill_hotplug(eeepc);
+}
+
+static int eeepc_setup_pci_hotplug(struct eeepc_wmi *eeepc)
+{
+ int ret = -ENOMEM;
+ struct pci_bus *bus = pci_find_bus(0, 1);
+
+ if (!bus) {
+ pr_err("Unable to find wifi PCI bus\n");
+ return -ENODEV;
+ }
+
+ eeepc->hotplug_workqueue =
+ create_singlethread_workqueue("hotplug_workqueue");
+ if (!eeepc->hotplug_workqueue)
+ goto error_workqueue;
+
+ INIT_WORK(&eeepc->hotplug_work, eeepc_hotplug_work);
+
+ eeepc->hotplug_slot = kzalloc(sizeof(struct hotplug_slot), GFP_KERNEL);
+ if (!eeepc->hotplug_slot)
+ goto error_slot;
+
+ eeepc->hotplug_slot->info = kzalloc(sizeof(struct hotplug_slot_info),
+ GFP_KERNEL);
+ if (!eeepc->hotplug_slot->info)
+ goto error_info;
+
+ eeepc->hotplug_slot->private = eeepc;
+ eeepc->hotplug_slot->release = &eeepc_cleanup_pci_hotplug;
+ eeepc->hotplug_slot->ops = &eeepc_hotplug_slot_ops;
+ eeepc_get_adapter_status(eeepc->hotplug_slot,
+ &eeepc->hotplug_slot->info->adapter_status);
+
+ ret = pci_hp_register(eeepc->hotplug_slot, bus, 0, "eeepc-wifi");
+ if (ret) {
+ pr_err("Unable to register hotplug slot - %d\n", ret);
+ goto error_register;
+ }
+
+ return 0;
+
+error_register:
+ kfree(eeepc->hotplug_slot->info);
+error_info:
+ kfree(eeepc->hotplug_slot);
+ eeepc->hotplug_slot = NULL;
+error_slot:
+ destroy_workqueue(eeepc->hotplug_workqueue);
+error_workqueue:
+ return ret;
+}
+
+/*
+ * Rfkill devices
+ */
+static int eeepc_rfkill_set(void *data, bool blocked)
+{
+ int dev_id = (unsigned long)data;
+ u32 ctrl_param = !blocked;
+ acpi_status status;
+
+ status = eeepc_wmi_set_devstate(dev_id, ctrl_param, NULL);
+
+ if (ACPI_FAILURE(status))
+ return -EIO;
+
+ return 0;
+}
+
+static void eeepc_rfkill_query(struct rfkill *rfkill, void *data)
+{
+ int dev_id = (unsigned long)data;
+ int result;
+
+ result = eeepc_wmi_get_devstate_simple(dev_id);
+
+ if (result < 0)
+ return ;
+
+ rfkill_set_sw_state(rfkill, !result);
+}
+
+static int eeepc_rfkill_wlan_set(void *data, bool blocked)
+{
+ struct eeepc_wmi *eeepc = data;
+ int ret;
+
+ /*
+ * This handler is enabled only if hotplug is enabled.
+ * In this case, the eeepc_wmi_set_devstate() will
+ * trigger a wmi notification and we need to wait
+ * this call to finish before being able to call
+ * any wmi method
+ */
+ mutex_lock(&eeepc->wmi_lock);
+ ret = eeepc_rfkill_set((void *)(long)EEEPC_WMI_DEVID_WLAN, blocked);
+ mutex_unlock(&eeepc->wmi_lock);
+ return ret;
+}
+
+static void eeepc_rfkill_wlan_query(struct rfkill *rfkill, void *data)
+{
+ eeepc_rfkill_query(rfkill, (void *)(long)EEEPC_WMI_DEVID_WLAN);
+}
+
+static const struct rfkill_ops eeepc_rfkill_wlan_ops = {
+ .set_block = eeepc_rfkill_wlan_set,
+ .query = eeepc_rfkill_wlan_query,
+};
+
+static const struct rfkill_ops eeepc_rfkill_ops = {
+ .set_block = eeepc_rfkill_set,
+ .query = eeepc_rfkill_query,
+};
+
+static int eeepc_new_rfkill(struct eeepc_wmi *eeepc,
+ struct rfkill **rfkill,
+ const char *name,
+ enum rfkill_type type, int dev_id)
+{
+ int result = eeepc_wmi_get_devstate_simple(dev_id);
+
+ if (result < 0)
+ return result;
+
+ if (dev_id == EEEPC_WMI_DEVID_WLAN && eeepc->hotplug_wireless)
+ *rfkill = rfkill_alloc(name, &eeepc->platform_device->dev, type,
+ &eeepc_rfkill_wlan_ops, eeepc);
+ else
+ *rfkill = rfkill_alloc(name, &eeepc->platform_device->dev, type,
+ &eeepc_rfkill_ops, (void *)(long)dev_id);
+
+ if (!*rfkill)
+ return -EINVAL;
+
+ rfkill_init_sw_state(*rfkill, !result);
+ result = rfkill_register(*rfkill);
+ if (result) {
+ rfkill_destroy(*rfkill);
+ *rfkill = NULL;
+ return result;
+ }
+ return 0;
+}
+
+static void eeepc_wmi_rfkill_exit(struct eeepc_wmi *eeepc)
+{
+ eeepc_unregister_rfkill_notifier(eeepc, "\\_SB.PCI0.P0P5");
+ eeepc_unregister_rfkill_notifier(eeepc, "\\_SB.PCI0.P0P6");
+ eeepc_unregister_rfkill_notifier(eeepc, "\\_SB.PCI0.P0P7");
+ if (eeepc->wlan_rfkill) {
+ rfkill_unregister(eeepc->wlan_rfkill);
+ rfkill_destroy(eeepc->wlan_rfkill);
+ eeepc->wlan_rfkill = NULL;
+ }
+ /*
+ * Refresh pci hotplug in case the rfkill state was changed after
+ * eeepc_unregister_rfkill_notifier()
+ */
+ eeepc_rfkill_hotplug(eeepc);
+ if (eeepc->hotplug_slot)
+ pci_hp_deregister(eeepc->hotplug_slot);
+ if (eeepc->hotplug_workqueue)
+ destroy_workqueue(eeepc->hotplug_workqueue);
+
+ if (eeepc->bluetooth_rfkill) {
+ rfkill_unregister(eeepc->bluetooth_rfkill);
+ rfkill_destroy(eeepc->bluetooth_rfkill);
+ eeepc->bluetooth_rfkill = NULL;
+ }
+ if (eeepc->wimax_rfkill) {
+ rfkill_unregister(eeepc->wimax_rfkill);
+ rfkill_destroy(eeepc->wimax_rfkill);
+ eeepc->wimax_rfkill = NULL;
+ }
+ if (eeepc->wwan3g_rfkill) {
+ rfkill_unregister(eeepc->wwan3g_rfkill);
+ rfkill_destroy(eeepc->wwan3g_rfkill);
+ eeepc->wwan3g_rfkill = NULL;
+ }
+}
+
+static int eeepc_wmi_rfkill_init(struct eeepc_wmi *eeepc)
+{
+ int result = 0;
+
+ mutex_init(&eeepc->hotplug_lock);
+ mutex_init(&eeepc->wmi_lock);
+
+ result = eeepc_new_rfkill(eeepc, &eeepc->wlan_rfkill,
+ "eeepc-wlan", RFKILL_TYPE_WLAN,
+ EEEPC_WMI_DEVID_WLAN);
+
+ if (result && result != -ENODEV)
+ goto exit;
+
+ result = eeepc_new_rfkill(eeepc, &eeepc->bluetooth_rfkill,
+ "eeepc-bluetooth", RFKILL_TYPE_BLUETOOTH,
+ EEEPC_WMI_DEVID_BLUETOOTH);
+
+ if (result && result != -ENODEV)
+ goto exit;
+
+ result = eeepc_new_rfkill(eeepc, &eeepc->wimax_rfkill,
+ "eeepc-wimax", RFKILL_TYPE_WIMAX,
+ EEEPC_WMI_DEVID_WIMAX);
+
+ if (result && result != -ENODEV)
+ goto exit;
+
+ result = eeepc_new_rfkill(eeepc, &eeepc->wwan3g_rfkill,
+ "eeepc-wwan3g", RFKILL_TYPE_WWAN,
+ EEEPC_WMI_DEVID_WWAN3G);
+
+ if (result && result != -ENODEV)
+ goto exit;
+
+ if (!eeepc->hotplug_wireless)
+ goto exit;
+
+ result = eeepc_setup_pci_hotplug(eeepc);
+ /*
+ * If we get -EBUSY then something else is handling the PCI hotplug -
+ * don't fail in this case
+ */
+ if (result == -EBUSY)
+ result = 0;
+
+ eeepc_register_rfkill_notifier(eeepc, "\\_SB.PCI0.P0P5");
+ eeepc_register_rfkill_notifier(eeepc, "\\_SB.PCI0.P0P6");
+ eeepc_register_rfkill_notifier(eeepc, "\\_SB.PCI0.P0P7");
+ /*
+ * Refresh pci hotplug in case the rfkill state was changed during
+ * setup.
+ */
+ eeepc_rfkill_hotplug(eeepc);
+
+exit:
+ if (result && result != -ENODEV)
+ eeepc_wmi_rfkill_exit(eeepc);
+
+ if (result == -ENODEV)
+ result = 0;
+
+ return result;
+}
+
+/*
+ * Backlight
+ */
+static int read_backlight_power(void)
+{
+ int ret = eeepc_wmi_get_devstate_simple(EEEPC_WMI_DEVID_BACKLIGHT);
+
+ if (ret < 0)
+ return ret;
+
+ return ret ? FB_BLANK_UNBLANK : FB_BLANK_POWERDOWN;
+}
+
+static int read_brightness(struct backlight_device *bd)
+{
+ u32 retval;
+ acpi_status status;
+
+ status = eeepc_wmi_get_devstate(EEEPC_WMI_DEVID_BRIGHTNESS, &retval);
+
+ if (ACPI_FAILURE(status))
+ return -EIO;
+ else
+ return retval & EEEPC_WMI_DSTS_BRIGHTNESS_MASK;
+}
+
+static int update_bl_status(struct backlight_device *bd)
+{
+ u32 ctrl_param;
+ acpi_status status;
+ int power;
+
+ ctrl_param = bd->props.brightness;
+
+ status = eeepc_wmi_set_devstate(EEEPC_WMI_DEVID_BRIGHTNESS,
+ ctrl_param, NULL);
+
+ if (ACPI_FAILURE(status))
+ return -EIO;
+
+ power = read_backlight_power();
+ if (power != -ENODEV && bd->props.power != power) {
+ ctrl_param = !!(bd->props.power == FB_BLANK_UNBLANK);
+ status = eeepc_wmi_set_devstate(EEEPC_WMI_DEVID_BACKLIGHT,
+ ctrl_param, NULL);
+
+ if (ACPI_FAILURE(status))
+ return -EIO;
+ }
+ return 0;
+}
+
+static const struct backlight_ops eeepc_wmi_bl_ops = {
+ .get_brightness = read_brightness,
+ .update_status = update_bl_status,
+};
+
+static int eeepc_wmi_backlight_notify(struct eeepc_wmi *eeepc, int code)
+{
+ struct backlight_device *bd = eeepc->backlight_device;
+ int old = bd->props.brightness;
+ int new = old;
+
+ if (code >= NOTIFY_BRNUP_MIN && code <= NOTIFY_BRNUP_MAX)
+ new = code - NOTIFY_BRNUP_MIN + 1;
+ else if (code >= NOTIFY_BRNDOWN_MIN && code <= NOTIFY_BRNDOWN_MAX)
+ new = code - NOTIFY_BRNDOWN_MIN;
+
+ bd->props.brightness = new;
+ backlight_update_status(bd);
+ backlight_force_update(bd, BACKLIGHT_UPDATE_HOTKEY);
+
+ return old;
+}
+
+static int eeepc_wmi_backlight_init(struct eeepc_wmi *eeepc)
+{
+ struct backlight_device *bd;
+ struct backlight_properties props;
+ int max;
+ int power;
+
+ max = eeepc_wmi_get_devstate_bits(EEEPC_WMI_DEVID_BRIGHTNESS,
+ EEEPC_WMI_DSTS_MAX_BRIGTH_MASK);
+ power = read_backlight_power();
+
+ if (max < 0 && power < 0) {
+ /* Try to keep the original error */
+ if (max == -ENODEV && power == -ENODEV)
+ return -ENODEV;
+ if (max != -ENODEV)
+ return max;
+ else
+ return power;
+ }
+ if (max == -ENODEV)
+ max = 0;
+ if (power == -ENODEV)
+ power = FB_BLANK_UNBLANK;
+
+ memset(&props, 0, sizeof(struct backlight_properties));
+ props.max_brightness = max;
+ bd = backlight_device_register(EEEPC_WMI_FILE,
+ &eeepc->platform_device->dev, eeepc,
+ &eeepc_wmi_bl_ops, &props);
+ if (IS_ERR(bd)) {
+ pr_err("Could not register backlight device\n");
+ return PTR_ERR(bd);
+ }
+
+ eeepc->backlight_device = bd;
+
+ bd->props.brightness = read_brightness(bd);
+ bd->props.power = power;
+ backlight_update_status(bd);
+
+ return 0;
+}
+
+static void eeepc_wmi_backlight_exit(struct eeepc_wmi *eeepc)
+{
+ if (eeepc->backlight_device)
+ backlight_device_unregister(eeepc->backlight_device);
+
+ eeepc->backlight_device = NULL;
+}
+
+static void eeepc_wmi_notify(u32 value, void *context)
+{
+ struct eeepc_wmi *eeepc = context;
+ struct acpi_buffer response = { ACPI_ALLOCATE_BUFFER, NULL };
+ union acpi_object *obj;
+ acpi_status status;
+ int code;
+ int orig_code;
+
+ status = wmi_get_event_data(value, &response);
+ if (status != AE_OK) {
+ pr_err("bad event status 0x%x\n", status);
+ return;
+ }
+
+ obj = (union acpi_object *)response.pointer;
+
+ if (obj && obj->type == ACPI_TYPE_INTEGER) {
+ code = obj->integer.value;
+ orig_code = code;
+
+ if (code >= NOTIFY_BRNUP_MIN && code <= NOTIFY_BRNUP_MAX)
+ code = NOTIFY_BRNUP_MIN;
+ else if (code >= NOTIFY_BRNDOWN_MIN &&
+ code <= NOTIFY_BRNDOWN_MAX)
+ code = NOTIFY_BRNDOWN_MIN;
+
+ if (code == NOTIFY_BRNUP_MIN || code == NOTIFY_BRNDOWN_MIN) {
+ if (!acpi_video_backlight_support())
+ eeepc_wmi_backlight_notify(eeepc, orig_code);
+ }
+
+ if (!sparse_keymap_report_event(eeepc->inputdev,
+ code, 1, true))
+ pr_info("Unknown key %x pressed\n", code);
+ }
+
+ kfree(obj);
+}
+
+/*
+ * Sys helpers
+ */
+static int parse_arg(const char *buf, unsigned long count, int *val)
+{
+ if (!count)
+ return 0;
+ if (sscanf(buf, "%i", val) != 1)
+ return -EINVAL;
+ return count;
+}
+
+static ssize_t store_sys_wmi(int devid, const char *buf, size_t count)
+{
+ acpi_status status;
+ u32 retval;
+ int rv, value;
+
+ value = eeepc_wmi_get_devstate_simple(devid);
+ if (value == -ENODEV) /* Check device presence */
+ return value;
+
+ rv = parse_arg(buf, count, &value);
+ status = eeepc_wmi_set_devstate(devid, value, &retval);
+
+ if (ACPI_FAILURE(status))
+ return -EIO;
+ return rv;
+}
+
+static ssize_t show_sys_wmi(int devid, char *buf)
+{
+ int value = eeepc_wmi_get_devstate_simple(devid);
+
+ if (value < 0)
+ return value;
+
+ return sprintf(buf, "%d\n", value);
+}
+
+#define EEEPC_WMI_CREATE_DEVICE_ATTR(_name, _mode, _cm) \
+ static ssize_t show_##_name(struct device *dev, \
+ struct device_attribute *attr, \
+ char *buf) \
+ { \
+ return show_sys_wmi(_cm, buf); \
+ } \
+ static ssize_t store_##_name(struct device *dev, \
+ struct device_attribute *attr, \
+ const char *buf, size_t count) \
+ { \
+ return store_sys_wmi(_cm, buf, count); \
+ } \
+ static struct device_attribute dev_attr_##_name = { \
+ .attr = { \
+ .name = __stringify(_name), \
+ .mode = _mode }, \
+ .show = show_##_name, \
+ .store = store_##_name, \
+ }
+
+EEEPC_WMI_CREATE_DEVICE_ATTR(touchpad, 0644, EEEPC_WMI_DEVID_TOUCHPAD);
+EEEPC_WMI_CREATE_DEVICE_ATTR(camera, 0644, EEEPC_WMI_DEVID_CAMERA);
+EEEPC_WMI_CREATE_DEVICE_ATTR(cardr, 0644, EEEPC_WMI_DEVID_CARDREADER);
+
+static ssize_t store_cpufv(struct device *dev, struct device_attribute *attr,
+ const char *buf, size_t count)
+{
+ int value;
+ struct acpi_buffer input = { (acpi_size)sizeof(value), &value };
+ acpi_status status;
+
+ if (!count || sscanf(buf, "%i", &value) != 1)
+ return -EINVAL;
+ if (value < 0 || value > 2)
+ return -EINVAL;
+
+ status = wmi_evaluate_method(EEEPC_WMI_MGMT_GUID,
+ 1, EEEPC_WMI_METHODID_CFVS, &input, NULL);
+
+ if (ACPI_FAILURE(status))
+ return -EIO;
+ else
+ return count;
+}
+
+static DEVICE_ATTR(cpufv, S_IRUGO | S_IWUSR, NULL, store_cpufv);
+
+static struct attribute *platform_attributes[] = {
+ &dev_attr_cpufv.attr,
+ &dev_attr_camera.attr,
+ &dev_attr_cardr.attr,
+ &dev_attr_touchpad.attr,
+ NULL
+};
+
+static mode_t eeepc_sysfs_is_visible(struct kobject *kobj,
+ struct attribute *attr,
+ int idx)
+{
+ bool supported = true;
+ int devid = -1;
+
+ if (attr == &dev_attr_camera.attr)
+ devid = EEEPC_WMI_DEVID_CAMERA;
+ else if (attr == &dev_attr_cardr.attr)
+ devid = EEEPC_WMI_DEVID_CARDREADER;
+ else if (attr == &dev_attr_touchpad.attr)
+ devid = EEEPC_WMI_DEVID_TOUCHPAD;
+
+ if (devid != -1)
+ supported = eeepc_wmi_get_devstate_simple(devid) != -ENODEV;
+
+ return supported ? attr->mode : 0;
+}
+
+static struct attribute_group platform_attribute_group = {
+ .is_visible = eeepc_sysfs_is_visible,
+ .attrs = platform_attributes
+};
+
+static void eeepc_wmi_sysfs_exit(struct platform_device *device)
+{
+ sysfs_remove_group(&device->dev.kobj, &platform_attribute_group);
+}
+
+static int eeepc_wmi_sysfs_init(struct platform_device *device)
+{
+ return sysfs_create_group(&device->dev.kobj, &platform_attribute_group);
+}
+
+/*
+ * Platform device
+ */
+static int __init eeepc_wmi_platform_init(struct eeepc_wmi *eeepc)
+{
+ return eeepc_wmi_sysfs_init(eeepc->platform_device);
+}
+
+static void eeepc_wmi_platform_exit(struct eeepc_wmi *eeepc)
+{
+ eeepc_wmi_sysfs_exit(eeepc->platform_device);
+}
+
+/*
+ * debugfs
+ */
+struct eeepc_wmi_debugfs_node {
+ struct eeepc_wmi *eeepc;
+ char *name;
+ int (*show)(struct seq_file *m, void *data);
+};
+
+static int show_dsts(struct seq_file *m, void *data)
+{
+ struct eeepc_wmi *eeepc = m->private;
+ acpi_status status;
+ u32 retval = -1;
+
+ status = eeepc_wmi_get_devstate(eeepc->debug.dev_id, &retval);
+
+ if (ACPI_FAILURE(status))
+ return -EIO;
+
+ seq_printf(m, "DSTS(%x) = %x\n", eeepc->debug.dev_id, retval);
+
+ return 0;
+}
+
+static int show_devs(struct seq_file *m, void *data)
+{
+ struct eeepc_wmi *eeepc = m->private;
+ acpi_status status;
+ u32 retval = -1;
+
+ status = eeepc_wmi_set_devstate(eeepc->debug.dev_id,
+ eeepc->debug.ctrl_param, &retval);
+ if (ACPI_FAILURE(status))
+ return -EIO;
+
+ seq_printf(m, "DEVS(%x, %x) = %x\n", eeepc->debug.dev_id,
+ eeepc->debug.ctrl_param, retval);
+
+ return 0;
+}
+
+static struct eeepc_wmi_debugfs_node eeepc_wmi_debug_files[] = {
+ { NULL, "devs", show_devs },
+ { NULL, "dsts", show_dsts },
+};
+
+static int eeepc_wmi_debugfs_open(struct inode *inode, struct file *file)
+{
+ struct eeepc_wmi_debugfs_node *node = inode->i_private;
+
+ return single_open(file, node->show, node->eeepc);
+}
+
+static const struct file_operations eeepc_wmi_debugfs_io_ops = {
+ .owner = THIS_MODULE,
+ .open = eeepc_wmi_debugfs_open,
+ .read = seq_read,
+ .llseek = seq_lseek,
+ .release = single_release,
+};
+
+static void eeepc_wmi_debugfs_exit(struct eeepc_wmi *eeepc)
+{
+ debugfs_remove_recursive(eeepc->debug.root);
+}
+
+static int eeepc_wmi_debugfs_init(struct eeepc_wmi *eeepc)
+{
+ struct dentry *dent;
+ int i;
+
+ eeepc->debug.root = debugfs_create_dir(EEEPC_WMI_FILE, NULL);
+ if (!eeepc->debug.root) {
+ pr_err("failed to create debugfs directory");
+ goto error_debugfs;
+ }
+
+ dent = debugfs_create_x32("dev_id", S_IRUGO|S_IWUSR,
+ eeepc->debug.root, &eeepc->debug.dev_id);
+ if (!dent)
+ goto error_debugfs;
+
+ dent = debugfs_create_x32("ctrl_param", S_IRUGO|S_IWUSR,
+ eeepc->debug.root, &eeepc->debug.ctrl_param);
+ if (!dent)
+ goto error_debugfs;
+
+ for (i = 0; i < ARRAY_SIZE(eeepc_wmi_debug_files); i++) {
+ struct eeepc_wmi_debugfs_node *node = &eeepc_wmi_debug_files[i];
+
+ node->eeepc = eeepc;
+ dent = debugfs_create_file(node->name, S_IFREG | S_IRUGO,
+ eeepc->debug.root, node,
+ &eeepc_wmi_debugfs_io_ops);
+ if (!dent) {
+ pr_err("failed to create debug file: %s\n", node->name);
+ goto error_debugfs;
+ }
+ }
+
+ return 0;
+
+error_debugfs:
+ eeepc_wmi_debugfs_exit(eeepc);
+ return -ENOMEM;
+}
+
+/*
+ * WMI Driver
+ */
+static void eeepc_dmi_check(struct eeepc_wmi *eeepc)
+{
+ const char *model;
+
+ model = dmi_get_system_info(DMI_PRODUCT_NAME);
+ if (!model)
+ return;
+
+ /*
+ * Whitelist for wlan hotplug
+ *
+ * Eeepc 1000H needs the current hotplug code to handle
+ * Fn+F2 correctly. We may add other Eeepc here later, but
+ * it seems that most of the laptops supported by eeepc-wmi
+ * don't need to be on this list
+ */
+ if (strcmp(model, "1000H") == 0) {
+ eeepc->hotplug_wireless = true;
+ pr_info("wlan hotplug enabled\n");
+ }
+}
+
+static int __init eeepc_wmi_add(struct platform_device *pdev)
+{
+ struct eeepc_wmi *eeepc;
+ acpi_status status;
+ int err;
+
+ eeepc = kzalloc(sizeof(struct eeepc_wmi), GFP_KERNEL);
+ if (!eeepc)
+ return -ENOMEM;
+
+ eeepc->platform_device = pdev;
+ platform_set_drvdata(eeepc->platform_device, eeepc);
+
+ eeepc->hotplug_wireless = hotplug_wireless;
+ eeepc_dmi_check(eeepc);
+
+ err = eeepc_wmi_platform_init(eeepc);
+ if (err)
+ goto fail_platform;
+
+ err = eeepc_wmi_input_init(eeepc);
+ if (err)
+ goto fail_input;
+
+ err = eeepc_wmi_led_init(eeepc);
+ if (err)
+ goto fail_leds;
+
+ err = eeepc_wmi_rfkill_init(eeepc);
+ if (err)
+ goto fail_rfkill;
+
+ if (!acpi_video_backlight_support()) {
+ err = eeepc_wmi_backlight_init(eeepc);
+ if (err && err != -ENODEV)
+ goto fail_backlight;
+ } else
+ pr_info("Backlight controlled by ACPI video driver\n");
+
+ status = wmi_install_notify_handler(EEEPC_WMI_EVENT_GUID,
+ eeepc_wmi_notify, eeepc);
+ if (ACPI_FAILURE(status)) {
+ pr_err("Unable to register notify handler - %d\n",
+ status);
+ err = -ENODEV;
+ goto fail_wmi_handler;
+ }
+
+ err = eeepc_wmi_debugfs_init(eeepc);
+ if (err)
+ goto fail_debugfs;
+
+ return 0;
+
+fail_debugfs:
+ wmi_remove_notify_handler(EEEPC_WMI_EVENT_GUID);
+fail_wmi_handler:
+ eeepc_wmi_backlight_exit(eeepc);
+fail_backlight:
+ eeepc_wmi_rfkill_exit(eeepc);
+fail_rfkill:
+ eeepc_wmi_led_exit(eeepc);
+fail_leds:
+ eeepc_wmi_input_exit(eeepc);
+fail_input:
+ eeepc_wmi_platform_exit(eeepc);
+fail_platform:
+ kfree(eeepc);
+ return err;
+}
+
+static int __exit eeepc_wmi_remove(struct platform_device *device)
+{
+ struct eeepc_wmi *eeepc;
+
+ eeepc = platform_get_drvdata(device);
+ wmi_remove_notify_handler(EEEPC_WMI_EVENT_GUID);
+ eeepc_wmi_backlight_exit(eeepc);
+ eeepc_wmi_input_exit(eeepc);
+ eeepc_wmi_led_exit(eeepc);
+ eeepc_wmi_rfkill_exit(eeepc);
+ eeepc_wmi_debugfs_exit(eeepc);
+ eeepc_wmi_platform_exit(eeepc);
+
+ kfree(eeepc);
+ return 0;
+}
+
+/*
+ * Platform driver - hibernate/resume callbacks
+ */
+static int eeepc_hotk_thaw(struct device *device)
+{
+ struct eeepc_wmi *eeepc = dev_get_drvdata(device);
+
+ if (eeepc->wlan_rfkill) {
+ bool wlan;
+
+ /*
+ * Work around bios bug - acpi _PTS turns off the wireless led
+ * during suspend. Normally it restores it on resume, but
+ * we should kick it ourselves in case hibernation is aborted.
+ */
+ wlan = eeepc_wmi_get_devstate_simple(EEEPC_WMI_DEVID_WLAN);
+ eeepc_wmi_set_devstate(EEEPC_WMI_DEVID_WLAN, wlan, NULL);
+ }
+
+ return 0;
+}
+
+static int eeepc_hotk_restore(struct device *device)
+{
+ struct eeepc_wmi *eeepc = dev_get_drvdata(device);
+ int bl;
+
+ /* Refresh both wlan rfkill state and pci hotplug */
+ if (eeepc->wlan_rfkill)
+ eeepc_rfkill_hotplug(eeepc);
+
+ if (eeepc->bluetooth_rfkill) {
+ bl = !eeepc_wmi_get_devstate_simple(EEEPC_WMI_DEVID_BLUETOOTH);
+ rfkill_set_sw_state(eeepc->bluetooth_rfkill, bl);
+ }
+ if (eeepc->wimax_rfkill) {
+ bl = !eeepc_wmi_get_devstate_simple(EEEPC_WMI_DEVID_WIMAX);
+ rfkill_set_sw_state(eeepc->wimax_rfkill, bl);
+ }
+ if (eeepc->wwan3g_rfkill) {
+ bl = !eeepc_wmi_get_devstate_simple(EEEPC_WMI_DEVID_WWAN3G);
+ rfkill_set_sw_state(eeepc->wwan3g_rfkill, bl);
+ }
+
+ return 0;
+}
+
+static const struct dev_pm_ops eeepc_pm_ops = {
+ .thaw = eeepc_hotk_thaw,
+ .restore = eeepc_hotk_restore,
+};
+
+static struct platform_driver platform_driver = {
+ .remove = __exit_p(eeepc_wmi_remove),
+ .driver = {
+ .name = EEEPC_WMI_FILE,
+ .owner = THIS_MODULE,
+ .pm = &eeepc_pm_ops,
+ },
+};
+
+static acpi_status __init eeepc_wmi_parse_device(acpi_handle handle, u32 level,
+ void *context, void **retval)
+{
+ pr_warning("Found legacy ATKD device (%s)", EEEPC_ACPI_HID);
+ *(bool *)context = true;
+ return AE_CTRL_TERMINATE;
+}
+
+static int __init eeepc_wmi_check_atkd(void)
+{
+ acpi_status status;
+ bool found = false;
+
+ status = acpi_get_devices(EEEPC_ACPI_HID, eeepc_wmi_parse_device,
+ &found, NULL);
+
+ if (ACPI_FAILURE(status) || !found)
+ return 0;
+ return -1;
+}
+
+static int __init eeepc_wmi_probe(struct platform_device *pdev)
+{
+ if (!wmi_has_guid(EEEPC_WMI_EVENT_GUID) ||
+ !wmi_has_guid(EEEPC_WMI_MGMT_GUID)) {
+ pr_warning("No known WMI GUID found\n");
+ return -ENODEV;
+ }
+
+ if (eeepc_wmi_check_atkd()) {
+ pr_warning("WMI device present, but legacy ATKD device is also "
+ "present and enabled.");
+ pr_warning("You probably booted with acpi_osi=\"Linux\" or "
+ "acpi_osi=\"!Windows 2009\"");
+ pr_warning("Can't load eeepc-wmi, use default acpi_osi "
+ "(preferred) or eeepc-laptop");
+ return -ENODEV;
+ }
+
+ return eeepc_wmi_add(pdev);
+}
+
+static struct platform_device *platform_device;
+
+static int __init eeepc_wmi_init(void)
+{
+ platform_device = platform_create_bundle(&platform_driver,
+ eeepc_wmi_probe,
+ NULL, 0, NULL, 0);
+ if (IS_ERR(platform_device))
+ return PTR_ERR(platform_device);
+ return 0;
+}
+
+static void __exit eeepc_wmi_exit(void)
+{
+ platform_device_unregister(platform_device);
+ platform_driver_unregister(&platform_driver);
+}
+
+module_init(eeepc_wmi_init);
+module_exit(eeepc_wmi_exit);
diff --git a/drivers/platform/x86/eeepc-wmi.c b/drivers/platform/x86/eeepc-wmi.c
deleted file mode 100644
index d399775..0000000
--- a/drivers/platform/x86/eeepc-wmi.c
+++ /dev/null
@@ -1,1454 +0,0 @@
-/*
- * Eee PC WMI hotkey driver
- *
- * Copyright(C) 2010 Intel Corporation.
- * Copyright(C) 2010 Corentin Chary <corentin.chary@gmail.com>
- *
- * Portions based on wistron_btns.c:
- * Copyright (C) 2005 Miloslav Trmac <mitr@volny.cz>
- * Copyright (C) 2005 Bernhard Rosenkraenzer <bero@arklinux.org>
- * Copyright (C) 2005 Dmitry Torokhov <dtor@mail.ru>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
- */
-
-#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
-
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/init.h>
-#include <linux/types.h>
-#include <linux/slab.h>
-#include <linux/input.h>
-#include <linux/input/sparse-keymap.h>
-#include <linux/fb.h>
-#include <linux/backlight.h>
-#include <linux/leds.h>
-#include <linux/rfkill.h>
-#include <linux/pci.h>
-#include <linux/pci_hotplug.h>
-#include <linux/debugfs.h>
-#include <linux/seq_file.h>
-#include <linux/platform_device.h>
-#include <linux/dmi.h>
-#include <acpi/acpi_bus.h>
-#include <acpi/acpi_drivers.h>
-
-#define EEEPC_WMI_FILE "eeepc-wmi"
-
-MODULE_AUTHOR("Yong Wang <yong.y.wang@intel.com>");
-MODULE_DESCRIPTION("Eee PC WMI Hotkey Driver");
-MODULE_LICENSE("GPL");
-
-#define EEEPC_ACPI_HID "ASUS010" /* old _HID used in eeepc-laptop */
-
-#define EEEPC_WMI_EVENT_GUID "ABBC0F72-8EA1-11D1-00A0-C90629100000"
-#define EEEPC_WMI_MGMT_GUID "97845ED0-4E6D-11DE-8A39-0800200C9A66"
-
-MODULE_ALIAS("wmi:"EEEPC_WMI_EVENT_GUID);
-MODULE_ALIAS("wmi:"EEEPC_WMI_MGMT_GUID);
-
-#define NOTIFY_BRNUP_MIN 0x11
-#define NOTIFY_BRNUP_MAX 0x1f
-#define NOTIFY_BRNDOWN_MIN 0x20
-#define NOTIFY_BRNDOWN_MAX 0x2e
-
-/* WMI Methods */
-#define EEEPC_WMI_METHODID_DSTS 0x53544344
-#define EEEPC_WMI_METHODID_DEVS 0x53564544
-#define EEEPC_WMI_METHODID_CFVS 0x53564643
-
-/* Wireless */
-#define EEEPC_WMI_DEVID_WLAN 0x00010011
-#define EEEPC_WMI_DEVID_BLUETOOTH 0x00010013
-#define EEEPC_WMI_DEVID_WIMAX 0x00010017
-#define EEEPC_WMI_DEVID_WWAN3G 0x00010019
-
-/* Backlight and Brightness */
-#define EEEPC_WMI_DEVID_BACKLIGHT 0x00050011
-#define EEEPC_WMI_DEVID_BRIGHTNESS 0x00050012
-
-/* Misc */
-#define EEEPC_WMI_DEVID_CAMERA 0x00060013
-
-/* Storage */
-#define EEEPC_WMI_DEVID_CARDREADER 0x00080013
-
-/* Input */
-#define EEEPC_WMI_DEVID_TOUCHPAD 0x00100011
-#define EEEPC_WMI_DEVID_TOUCHPAD_LED 0x00100012
-
-/* DSTS masks */
-#define EEEPC_WMI_DSTS_STATUS_BIT 0x00000001
-#define EEEPC_WMI_DSTS_PRESENCE_BIT 0x00010000
-#define EEEPC_WMI_DSTS_BRIGHTNESS_MASK 0x000000FF
-#define EEEPC_WMI_DSTS_MAX_BRIGTH_MASK 0x0000FF00
-
-static bool hotplug_wireless;
-
-module_param(hotplug_wireless, bool, 0444);
-MODULE_PARM_DESC(hotplug_wireless,
- "Enable hotplug for wireless device. "
- "If your laptop needs that, please report to "
- "acpi4asus-user@lists.sourceforge.net.");
-
-static const struct key_entry eeepc_wmi_keymap[] = {
- /* Sleep already handled via generic ACPI code */
- { KE_IGNORE, NOTIFY_BRNDOWN_MIN, { KEY_BRIGHTNESSDOWN } },
- { KE_IGNORE, NOTIFY_BRNUP_MIN, { KEY_BRIGHTNESSUP } },
- { KE_KEY, 0x30, { KEY_VOLUMEUP } },
- { KE_KEY, 0x31, { KEY_VOLUMEDOWN } },
- { KE_KEY, 0x32, { KEY_MUTE } },
- { KE_KEY, 0x5c, { KEY_F15 } }, /* Power Gear key */
- { KE_KEY, 0x5d, { KEY_WLAN } },
- { KE_KEY, 0x6b, { KEY_F13 } }, /* Disable Touchpad */
- { KE_KEY, 0x82, { KEY_CAMERA } },
- { KE_KEY, 0x83, { KEY_CAMERA_ZOOMIN } },
- { KE_KEY, 0x88, { KEY_WLAN } },
- { KE_KEY, 0xcc, { KEY_SWITCHVIDEOMODE } },
- { KE_KEY, 0xe0, { KEY_PROG1 } }, /* Task Manager */
- { KE_KEY, 0xe1, { KEY_F14 } }, /* Change Resolution */
- { KE_KEY, 0xe9, { KEY_BRIGHTNESS_ZERO } },
- { KE_KEY, 0xeb, { KEY_CAMERA_ZOOMOUT } },
- { KE_KEY, 0xec, { KEY_CAMERA_UP } },
- { KE_KEY, 0xed, { KEY_CAMERA_DOWN } },
- { KE_KEY, 0xee, { KEY_CAMERA_LEFT } },
- { KE_KEY, 0xef, { KEY_CAMERA_RIGHT } },
- { KE_END, 0},
-};
-
-struct bios_args {
- u32 dev_id;
- u32 ctrl_param;
-};
-
-/*
- * eeepc-wmi/ - debugfs root directory
- * dev_id - current dev_id
- * ctrl_param - current ctrl_param
- * devs - call DEVS(dev_id, ctrl_param) and print result
- * dsts - call DSTS(dev_id) and print result
- */
-struct eeepc_wmi_debug {
- struct dentry *root;
- u32 dev_id;
- u32 ctrl_param;
-};
-
-struct eeepc_wmi {
- bool hotplug_wireless;
-
- struct input_dev *inputdev;
- struct backlight_device *backlight_device;
- struct platform_device *platform_device;
-
- struct led_classdev tpd_led;
- int tpd_led_wk;
- struct workqueue_struct *led_workqueue;
- struct work_struct tpd_led_work;
-
- struct rfkill *wlan_rfkill;
- struct rfkill *bluetooth_rfkill;
- struct rfkill *wimax_rfkill;
- struct rfkill *wwan3g_rfkill;
-
- struct hotplug_slot *hotplug_slot;
- struct mutex hotplug_lock;
- struct mutex wmi_lock;
- struct workqueue_struct *hotplug_workqueue;
- struct work_struct hotplug_work;
-
- struct eeepc_wmi_debug debug;
-};
-
-static int eeepc_wmi_input_init(struct eeepc_wmi *eeepc)
-{
- int err;
-
- eeepc->inputdev = input_allocate_device();
- if (!eeepc->inputdev)
- return -ENOMEM;
-
- eeepc->inputdev->name = "Eee PC WMI hotkeys";
- eeepc->inputdev->phys = EEEPC_WMI_FILE "/input0";
- eeepc->inputdev->id.bustype = BUS_HOST;
- eeepc->inputdev->dev.parent = &eeepc->platform_device->dev;
-
- err = sparse_keymap_setup(eeepc->inputdev, eeepc_wmi_keymap, NULL);
- if (err)
- goto err_free_dev;
-
- err = input_register_device(eeepc->inputdev);
- if (err)
- goto err_free_keymap;
-
- return 0;
-
-err_free_keymap:
- sparse_keymap_free(eeepc->inputdev);
-err_free_dev:
- input_free_device(eeepc->inputdev);
- return err;
-}
-
-static void eeepc_wmi_input_exit(struct eeepc_wmi *eeepc)
-{
- if (eeepc->inputdev) {
- sparse_keymap_free(eeepc->inputdev);
- input_unregister_device(eeepc->inputdev);
- }
-
- eeepc->inputdev = NULL;
-}
-
-static acpi_status eeepc_wmi_get_devstate(u32 dev_id, u32 *retval)
-{
- struct acpi_buffer input = { (acpi_size)sizeof(u32), &dev_id };
- struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
- union acpi_object *obj;
- acpi_status status;
- u32 tmp;
-
- status = wmi_evaluate_method(EEEPC_WMI_MGMT_GUID,
- 1, EEEPC_WMI_METHODID_DSTS,
- &input, &output);
-
- if (ACPI_FAILURE(status))
- return status;
-
- obj = (union acpi_object *)output.pointer;
- if (obj && obj->type == ACPI_TYPE_INTEGER)
- tmp = (u32)obj->integer.value;
- else
- tmp = 0;
-
- if (retval)
- *retval = tmp;
-
- kfree(obj);
-
- return status;
-
-}
-
-static acpi_status eeepc_wmi_set_devstate(u32 dev_id, u32 ctrl_param,
- u32 *retval)
-{
- struct bios_args args = {
- .dev_id = dev_id,
- .ctrl_param = ctrl_param,
- };
- struct acpi_buffer input = { (acpi_size)sizeof(args), &args };
- acpi_status status;
-
- if (!retval) {
- status = wmi_evaluate_method(EEEPC_WMI_MGMT_GUID, 1,
- EEEPC_WMI_METHODID_DEVS,
- &input, NULL);
- } else {
- struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
- union acpi_object *obj;
- u32 tmp;
-
- status = wmi_evaluate_method(EEEPC_WMI_MGMT_GUID, 1,
- EEEPC_WMI_METHODID_DEVS,
- &input, &output);
-
- if (ACPI_FAILURE(status))
- return status;
-
- obj = (union acpi_object *)output.pointer;
- if (obj && obj->type == ACPI_TYPE_INTEGER)
- tmp = (u32)obj->integer.value;
- else
- tmp = 0;
-
- *retval = tmp;
-
- kfree(obj);
- }
-
- return status;
-}
-
-/* Helper for special devices with magic return codes */
-static int eeepc_wmi_get_devstate_bits(u32 dev_id, u32 mask)
-{
- u32 retval = 0;
- acpi_status status;
-
- status = eeepc_wmi_get_devstate(dev_id, &retval);
-
- if (ACPI_FAILURE(status))
- return -EINVAL;
-
- if (!(retval & EEEPC_WMI_DSTS_PRESENCE_BIT))
- return -ENODEV;
-
- return retval & mask;
-}
-
-static int eeepc_wmi_get_devstate_simple(u32 dev_id)
-{
- return eeepc_wmi_get_devstate_bits(dev_id, EEEPC_WMI_DSTS_STATUS_BIT);
-}
-
-/*
- * LEDs
- */
-/*
- * These functions actually update the LED's, and are called from a
- * workqueue. By doing this as separate work rather than when the LED
- * subsystem asks, we avoid messing with the Eeepc ACPI stuff during a
- * potentially bad time, such as a timer interrupt.
- */
-static void tpd_led_update(struct work_struct *work)
-{
- int ctrl_param;
- struct eeepc_wmi *eeepc;
-
- eeepc = container_of(work, struct eeepc_wmi, tpd_led_work);
-
- ctrl_param = eeepc->tpd_led_wk;
- eeepc_wmi_set_devstate(EEEPC_WMI_DEVID_TOUCHPAD_LED, ctrl_param, NULL);
-}
-
-static void tpd_led_set(struct led_classdev *led_cdev,
- enum led_brightness value)
-{
- struct eeepc_wmi *eeepc;
-
- eeepc = container_of(led_cdev, struct eeepc_wmi, tpd_led);
-
- eeepc->tpd_led_wk = !!value;
- queue_work(eeepc->led_workqueue, &eeepc->tpd_led_work);
-}
-
-static int read_tpd_led_state(struct eeepc_wmi *eeepc)
-{
- return eeepc_wmi_get_devstate_simple(EEEPC_WMI_DEVID_TOUCHPAD_LED);
-}
-
-static enum led_brightness tpd_led_get(struct led_classdev *led_cdev)
-{
- struct eeepc_wmi *eeepc;
-
- eeepc = container_of(led_cdev, struct eeepc_wmi, tpd_led);
-
- return read_tpd_led_state(eeepc);
-}
-
-static int eeepc_wmi_led_init(struct eeepc_wmi *eeepc)
-{
- int rv;
-
- if (read_tpd_led_state(eeepc) < 0)
- return 0;
-
- eeepc->led_workqueue = create_singlethread_workqueue("led_workqueue");
- if (!eeepc->led_workqueue)
- return -ENOMEM;
- INIT_WORK(&eeepc->tpd_led_work, tpd_led_update);
-
- eeepc->tpd_led.name = "eeepc::touchpad";
- eeepc->tpd_led.brightness_set = tpd_led_set;
- eeepc->tpd_led.brightness_get = tpd_led_get;
- eeepc->tpd_led.max_brightness = 1;
-
- rv = led_classdev_register(&eeepc->platform_device->dev,
- &eeepc->tpd_led);
- if (rv) {
- destroy_workqueue(eeepc->led_workqueue);
- return rv;
- }
-
- return 0;
-}
-
-static void eeepc_wmi_led_exit(struct eeepc_wmi *eeepc)
-{
- if (eeepc->tpd_led.dev)
- led_classdev_unregister(&eeepc->tpd_led);
- if (eeepc->led_workqueue)
- destroy_workqueue(eeepc->led_workqueue);
-}
-
-/*
- * PCI hotplug (for wlan rfkill)
- */
-static bool eeepc_wlan_rfkill_blocked(struct eeepc_wmi *eeepc)
-{
- int result = eeepc_wmi_get_devstate_simple(EEEPC_WMI_DEVID_WLAN);
-
- if (result < 0)
- return false;
- return !result;
-}
-
-static void eeepc_rfkill_hotplug(struct eeepc_wmi *eeepc)
-{
- struct pci_dev *dev;
- struct pci_bus *bus;
- bool blocked;
- bool absent;
- u32 l;
-
- mutex_lock(&eeepc->wmi_lock);
- blocked = eeepc_wlan_rfkill_blocked(eeepc);
- mutex_unlock(&eeepc->wmi_lock);
-
- mutex_lock(&eeepc->hotplug_lock);
-
- if (eeepc->wlan_rfkill)
- rfkill_set_sw_state(eeepc->wlan_rfkill, blocked);
-
- if (eeepc->hotplug_slot) {
- bus = pci_find_bus(0, 1);
- if (!bus) {
- pr_warning("Unable to find PCI bus 1?\n");
- goto out_unlock;
- }
-
- if (pci_bus_read_config_dword(bus, 0, PCI_VENDOR_ID, &l)) {
- pr_err("Unable to read PCI config space?\n");
- goto out_unlock;
- }
- absent = (l == 0xffffffff);
-
- if (blocked != absent) {
- pr_warning("BIOS says wireless lan is %s, "
- "but the pci device is %s\n",
- blocked ? "blocked" : "unblocked",
- absent ? "absent" : "present");
- pr_warning("skipped wireless hotplug as probably "
- "inappropriate for this model\n");
- goto out_unlock;
- }
-
- if (!blocked) {
- dev = pci_get_slot(bus, 0);
- if (dev) {
- /* Device already present */
- pci_dev_put(dev);
- goto out_unlock;
- }
- dev = pci_scan_single_device(bus, 0);
- if (dev) {
- pci_bus_assign_resources(bus);
- if (pci_bus_add_device(dev))
- pr_err("Unable to hotplug wifi\n");
- }
- } else {
- dev = pci_get_slot(bus, 0);
- if (dev) {
- pci_remove_bus_device(dev);
- pci_dev_put(dev);
- }
- }
- }
-
-out_unlock:
- mutex_unlock(&eeepc->hotplug_lock);
-}
-
-static void eeepc_rfkill_notify(acpi_handle handle, u32 event, void *data)
-{
- struct eeepc_wmi *eeepc = data;
-
- if (event != ACPI_NOTIFY_BUS_CHECK)
- return;
-
- /*
- * We can't call directly eeepc_rfkill_hotplug because most
- * of the time WMBC is still being executed and not reetrant.
- * There is currently no way to tell ACPICA that we want this
- * method to be serialized, we schedule a eeepc_rfkill_hotplug
- * call later, in a safer context.
- */
- queue_work(eeepc->hotplug_workqueue, &eeepc->hotplug_work);
-}
-
-static int eeepc_register_rfkill_notifier(struct eeepc_wmi *eeepc,
- char *node)
-{
- acpi_status status;
- acpi_handle handle;
-
- status = acpi_get_handle(NULL, node, &handle);
-
- if (ACPI_SUCCESS(status)) {
- status = acpi_install_notify_handler(handle,
- ACPI_SYSTEM_NOTIFY,
- eeepc_rfkill_notify,
- eeepc);
- if (ACPI_FAILURE(status))
- pr_warning("Failed to register notify on %s\n", node);
- } else
- return -ENODEV;
-
- return 0;
-}
-
-static void eeepc_unregister_rfkill_notifier(struct eeepc_wmi *eeepc,
- char *node)
-{
- acpi_status status = AE_OK;
- acpi_handle handle;
-
- status = acpi_get_handle(NULL, node, &handle);
-
- if (ACPI_SUCCESS(status)) {
- status = acpi_remove_notify_handler(handle,
- ACPI_SYSTEM_NOTIFY,
- eeepc_rfkill_notify);
- if (ACPI_FAILURE(status))
- pr_err("Error removing rfkill notify handler %s\n",
- node);
- }
-}
-
-static int eeepc_get_adapter_status(struct hotplug_slot *hotplug_slot,
- u8 *value)
-{
- int result = eeepc_wmi_get_devstate_simple(EEEPC_WMI_DEVID_WLAN);
-
- if (result < 0)
- return result;
-
- *value = !!result;
- return 0;
-}
-
-static void eeepc_cleanup_pci_hotplug(struct hotplug_slot *hotplug_slot)
-{
- kfree(hotplug_slot->info);
- kfree(hotplug_slot);
-}
-
-static struct hotplug_slot_ops eeepc_hotplug_slot_ops = {
- .owner = THIS_MODULE,
- .get_adapter_status = eeepc_get_adapter_status,
- .get_power_status = eeepc_get_adapter_status,
-};
-
-static void eeepc_hotplug_work(struct work_struct *work)
-{
- struct eeepc_wmi *eeepc;
-
- eeepc = container_of(work, struct eeepc_wmi, hotplug_work);
- eeepc_rfkill_hotplug(eeepc);
-}
-
-static int eeepc_setup_pci_hotplug(struct eeepc_wmi *eeepc)
-{
- int ret = -ENOMEM;
- struct pci_bus *bus = pci_find_bus(0, 1);
-
- if (!bus) {
- pr_err("Unable to find wifi PCI bus\n");
- return -ENODEV;
- }
-
- eeepc->hotplug_workqueue =
- create_singlethread_workqueue("hotplug_workqueue");
- if (!eeepc->hotplug_workqueue)
- goto error_workqueue;
-
- INIT_WORK(&eeepc->hotplug_work, eeepc_hotplug_work);
-
- eeepc->hotplug_slot = kzalloc(sizeof(struct hotplug_slot), GFP_KERNEL);
- if (!eeepc->hotplug_slot)
- goto error_slot;
-
- eeepc->hotplug_slot->info = kzalloc(sizeof(struct hotplug_slot_info),
- GFP_KERNEL);
- if (!eeepc->hotplug_slot->info)
- goto error_info;
-
- eeepc->hotplug_slot->private = eeepc;
- eeepc->hotplug_slot->release = &eeepc_cleanup_pci_hotplug;
- eeepc->hotplug_slot->ops = &eeepc_hotplug_slot_ops;
- eeepc_get_adapter_status(eeepc->hotplug_slot,
- &eeepc->hotplug_slot->info->adapter_status);
-
- ret = pci_hp_register(eeepc->hotplug_slot, bus, 0, "eeepc-wifi");
- if (ret) {
- pr_err("Unable to register hotplug slot - %d\n", ret);
- goto error_register;
- }
-
- return 0;
-
-error_register:
- kfree(eeepc->hotplug_slot->info);
-error_info:
- kfree(eeepc->hotplug_slot);
- eeepc->hotplug_slot = NULL;
-error_slot:
- destroy_workqueue(eeepc->hotplug_workqueue);
-error_workqueue:
- return ret;
-}
-
-/*
- * Rfkill devices
- */
-static int eeepc_rfkill_set(void *data, bool blocked)
-{
- int dev_id = (unsigned long)data;
- u32 ctrl_param = !blocked;
- acpi_status status;
-
- status = eeepc_wmi_set_devstate(dev_id, ctrl_param, NULL);
-
- if (ACPI_FAILURE(status))
- return -EIO;
-
- return 0;
-}
-
-static void eeepc_rfkill_query(struct rfkill *rfkill, void *data)
-{
- int dev_id = (unsigned long)data;
- int result;
-
- result = eeepc_wmi_get_devstate_simple(dev_id);
-
- if (result < 0)
- return ;
-
- rfkill_set_sw_state(rfkill, !result);
-}
-
-static int eeepc_rfkill_wlan_set(void *data, bool blocked)
-{
- struct eeepc_wmi *eeepc = data;
- int ret;
-
- /*
- * This handler is enabled only if hotplug is enabled.
- * In this case, the eeepc_wmi_set_devstate() will
- * trigger a wmi notification and we need to wait
- * this call to finish before being able to call
- * any wmi method
- */
- mutex_lock(&eeepc->wmi_lock);
- ret = eeepc_rfkill_set((void *)(long)EEEPC_WMI_DEVID_WLAN, blocked);
- mutex_unlock(&eeepc->wmi_lock);
- return ret;
-}
-
-static void eeepc_rfkill_wlan_query(struct rfkill *rfkill, void *data)
-{
- eeepc_rfkill_query(rfkill, (void *)(long)EEEPC_WMI_DEVID_WLAN);
-}
-
-static const struct rfkill_ops eeepc_rfkill_wlan_ops = {
- .set_block = eeepc_rfkill_wlan_set,
- .query = eeepc_rfkill_wlan_query,
-};
-
-static const struct rfkill_ops eeepc_rfkill_ops = {
- .set_block = eeepc_rfkill_set,
- .query = eeepc_rfkill_query,
-};
-
-static int eeepc_new_rfkill(struct eeepc_wmi *eeepc,
- struct rfkill **rfkill,
- const char *name,
- enum rfkill_type type, int dev_id)
-{
- int result = eeepc_wmi_get_devstate_simple(dev_id);
-
- if (result < 0)
- return result;
-
- if (dev_id == EEEPC_WMI_DEVID_WLAN && eeepc->hotplug_wireless)
- *rfkill = rfkill_alloc(name, &eeepc->platform_device->dev, type,
- &eeepc_rfkill_wlan_ops, eeepc);
- else
- *rfkill = rfkill_alloc(name, &eeepc->platform_device->dev, type,
- &eeepc_rfkill_ops, (void *)(long)dev_id);
-
- if (!*rfkill)
- return -EINVAL;
-
- rfkill_init_sw_state(*rfkill, !result);
- result = rfkill_register(*rfkill);
- if (result) {
- rfkill_destroy(*rfkill);
- *rfkill = NULL;
- return result;
- }
- return 0;
-}
-
-static void eeepc_wmi_rfkill_exit(struct eeepc_wmi *eeepc)
-{
- eeepc_unregister_rfkill_notifier(eeepc, "\\_SB.PCI0.P0P5");
- eeepc_unregister_rfkill_notifier(eeepc, "\\_SB.PCI0.P0P6");
- eeepc_unregister_rfkill_notifier(eeepc, "\\_SB.PCI0.P0P7");
- if (eeepc->wlan_rfkill) {
- rfkill_unregister(eeepc->wlan_rfkill);
- rfkill_destroy(eeepc->wlan_rfkill);
- eeepc->wlan_rfkill = NULL;
- }
- /*
- * Refresh pci hotplug in case the rfkill state was changed after
- * eeepc_unregister_rfkill_notifier()
- */
- eeepc_rfkill_hotplug(eeepc);
- if (eeepc->hotplug_slot)
- pci_hp_deregister(eeepc->hotplug_slot);
- if (eeepc->hotplug_workqueue)
- destroy_workqueue(eeepc->hotplug_workqueue);
-
- if (eeepc->bluetooth_rfkill) {
- rfkill_unregister(eeepc->bluetooth_rfkill);
- rfkill_destroy(eeepc->bluetooth_rfkill);
- eeepc->bluetooth_rfkill = NULL;
- }
- if (eeepc->wimax_rfkill) {
- rfkill_unregister(eeepc->wimax_rfkill);
- rfkill_destroy(eeepc->wimax_rfkill);
- eeepc->wimax_rfkill = NULL;
- }
- if (eeepc->wwan3g_rfkill) {
- rfkill_unregister(eeepc->wwan3g_rfkill);
- rfkill_destroy(eeepc->wwan3g_rfkill);
- eeepc->wwan3g_rfkill = NULL;
- }
-}
-
-static int eeepc_wmi_rfkill_init(struct eeepc_wmi *eeepc)
-{
- int result = 0;
-
- mutex_init(&eeepc->hotplug_lock);
- mutex_init(&eeepc->wmi_lock);
-
- result = eeepc_new_rfkill(eeepc, &eeepc->wlan_rfkill,
- "eeepc-wlan", RFKILL_TYPE_WLAN,
- EEEPC_WMI_DEVID_WLAN);
-
- if (result && result != -ENODEV)
- goto exit;
-
- result = eeepc_new_rfkill(eeepc, &eeepc->bluetooth_rfkill,
- "eeepc-bluetooth", RFKILL_TYPE_BLUETOOTH,
- EEEPC_WMI_DEVID_BLUETOOTH);
-
- if (result && result != -ENODEV)
- goto exit;
-
- result = eeepc_new_rfkill(eeepc, &eeepc->wimax_rfkill,
- "eeepc-wimax", RFKILL_TYPE_WIMAX,
- EEEPC_WMI_DEVID_WIMAX);
-
- if (result && result != -ENODEV)
- goto exit;
-
- result = eeepc_new_rfkill(eeepc, &eeepc->wwan3g_rfkill,
- "eeepc-wwan3g", RFKILL_TYPE_WWAN,
- EEEPC_WMI_DEVID_WWAN3G);
-
- if (result && result != -ENODEV)
- goto exit;
-
- if (!eeepc->hotplug_wireless)
- goto exit;
-
- result = eeepc_setup_pci_hotplug(eeepc);
- /*
- * If we get -EBUSY then something else is handling the PCI hotplug -
- * don't fail in this case
- */
- if (result == -EBUSY)
- result = 0;
-
- eeepc_register_rfkill_notifier(eeepc, "\\_SB.PCI0.P0P5");
- eeepc_register_rfkill_notifier(eeepc, "\\_SB.PCI0.P0P6");
- eeepc_register_rfkill_notifier(eeepc, "\\_SB.PCI0.P0P7");
- /*
- * Refresh pci hotplug in case the rfkill state was changed during
- * setup.
- */
- eeepc_rfkill_hotplug(eeepc);
-
-exit:
- if (result && result != -ENODEV)
- eeepc_wmi_rfkill_exit(eeepc);
-
- if (result == -ENODEV)
- result = 0;
-
- return result;
-}
-
-/*
- * Backlight
- */
-static int read_backlight_power(void)
-{
- int ret = eeepc_wmi_get_devstate_simple(EEEPC_WMI_DEVID_BACKLIGHT);
-
- if (ret < 0)
- return ret;
-
- return ret ? FB_BLANK_UNBLANK : FB_BLANK_POWERDOWN;
-}
-
-static int read_brightness(struct backlight_device *bd)
-{
- u32 retval;
- acpi_status status;
-
- status = eeepc_wmi_get_devstate(EEEPC_WMI_DEVID_BRIGHTNESS, &retval);
-
- if (ACPI_FAILURE(status))
- return -EIO;
- else
- return retval & EEEPC_WMI_DSTS_BRIGHTNESS_MASK;
-}
-
-static int update_bl_status(struct backlight_device *bd)
-{
- u32 ctrl_param;
- acpi_status status;
- int power;
-
- ctrl_param = bd->props.brightness;
-
- status = eeepc_wmi_set_devstate(EEEPC_WMI_DEVID_BRIGHTNESS,
- ctrl_param, NULL);
-
- if (ACPI_FAILURE(status))
- return -EIO;
-
- power = read_backlight_power();
- if (power != -ENODEV && bd->props.power != power) {
- ctrl_param = !!(bd->props.power == FB_BLANK_UNBLANK);
- status = eeepc_wmi_set_devstate(EEEPC_WMI_DEVID_BACKLIGHT,
- ctrl_param, NULL);
-
- if (ACPI_FAILURE(status))
- return -EIO;
- }
- return 0;
-}
-
-static const struct backlight_ops eeepc_wmi_bl_ops = {
- .get_brightness = read_brightness,
- .update_status = update_bl_status,
-};
-
-static int eeepc_wmi_backlight_notify(struct eeepc_wmi *eeepc, int code)
-{
- struct backlight_device *bd = eeepc->backlight_device;
- int old = bd->props.brightness;
- int new = old;
-
- if (code >= NOTIFY_BRNUP_MIN && code <= NOTIFY_BRNUP_MAX)
- new = code - NOTIFY_BRNUP_MIN + 1;
- else if (code >= NOTIFY_BRNDOWN_MIN && code <= NOTIFY_BRNDOWN_MAX)
- new = code - NOTIFY_BRNDOWN_MIN;
-
- bd->props.brightness = new;
- backlight_update_status(bd);
- backlight_force_update(bd, BACKLIGHT_UPDATE_HOTKEY);
-
- return old;
-}
-
-static int eeepc_wmi_backlight_init(struct eeepc_wmi *eeepc)
-{
- struct backlight_device *bd;
- struct backlight_properties props;
- int max;
- int power;
-
- max = eeepc_wmi_get_devstate_bits(EEEPC_WMI_DEVID_BRIGHTNESS,
- EEEPC_WMI_DSTS_MAX_BRIGTH_MASK);
- power = read_backlight_power();
-
- if (max < 0 && power < 0) {
- /* Try to keep the original error */
- if (max == -ENODEV && power == -ENODEV)
- return -ENODEV;
- if (max != -ENODEV)
- return max;
- else
- return power;
- }
- if (max == -ENODEV)
- max = 0;
- if (power == -ENODEV)
- power = FB_BLANK_UNBLANK;
-
- memset(&props, 0, sizeof(struct backlight_properties));
- props.max_brightness = max;
- bd = backlight_device_register(EEEPC_WMI_FILE,
- &eeepc->platform_device->dev, eeepc,
- &eeepc_wmi_bl_ops, &props);
- if (IS_ERR(bd)) {
- pr_err("Could not register backlight device\n");
- return PTR_ERR(bd);
- }
-
- eeepc->backlight_device = bd;
-
- bd->props.brightness = read_brightness(bd);
- bd->props.power = power;
- backlight_update_status(bd);
-
- return 0;
-}
-
-static void eeepc_wmi_backlight_exit(struct eeepc_wmi *eeepc)
-{
- if (eeepc->backlight_device)
- backlight_device_unregister(eeepc->backlight_device);
-
- eeepc->backlight_device = NULL;
-}
-
-static void eeepc_wmi_notify(u32 value, void *context)
-{
- struct eeepc_wmi *eeepc = context;
- struct acpi_buffer response = { ACPI_ALLOCATE_BUFFER, NULL };
- union acpi_object *obj;
- acpi_status status;
- int code;
- int orig_code;
-
- status = wmi_get_event_data(value, &response);
- if (status != AE_OK) {
- pr_err("bad event status 0x%x\n", status);
- return;
- }
-
- obj = (union acpi_object *)response.pointer;
-
- if (obj && obj->type == ACPI_TYPE_INTEGER) {
- code = obj->integer.value;
- orig_code = code;
-
- if (code >= NOTIFY_BRNUP_MIN && code <= NOTIFY_BRNUP_MAX)
- code = NOTIFY_BRNUP_MIN;
- else if (code >= NOTIFY_BRNDOWN_MIN &&
- code <= NOTIFY_BRNDOWN_MAX)
- code = NOTIFY_BRNDOWN_MIN;
-
- if (code == NOTIFY_BRNUP_MIN || code == NOTIFY_BRNDOWN_MIN) {
- if (!acpi_video_backlight_support())
- eeepc_wmi_backlight_notify(eeepc, orig_code);
- }
-
- if (!sparse_keymap_report_event(eeepc->inputdev,
- code, 1, true))
- pr_info("Unknown key %x pressed\n", code);
- }
-
- kfree(obj);
-}
-
-/*
- * Sys helpers
- */
-static int parse_arg(const char *buf, unsigned long count, int *val)
-{
- if (!count)
- return 0;
- if (sscanf(buf, "%i", val) != 1)
- return -EINVAL;
- return count;
-}
-
-static ssize_t store_sys_wmi(int devid, const char *buf, size_t count)
-{
- acpi_status status;
- u32 retval;
- int rv, value;
-
- value = eeepc_wmi_get_devstate_simple(devid);
- if (value == -ENODEV) /* Check device presence */
- return value;
-
- rv = parse_arg(buf, count, &value);
- status = eeepc_wmi_set_devstate(devid, value, &retval);
-
- if (ACPI_FAILURE(status))
- return -EIO;
- return rv;
-}
-
-static ssize_t show_sys_wmi(int devid, char *buf)
-{
- int value = eeepc_wmi_get_devstate_simple(devid);
-
- if (value < 0)
- return value;
-
- return sprintf(buf, "%d\n", value);
-}
-
-#define EEEPC_WMI_CREATE_DEVICE_ATTR(_name, _mode, _cm) \
- static ssize_t show_##_name(struct device *dev, \
- struct device_attribute *attr, \
- char *buf) \
- { \
- return show_sys_wmi(_cm, buf); \
- } \
- static ssize_t store_##_name(struct device *dev, \
- struct device_attribute *attr, \
- const char *buf, size_t count) \
- { \
- return store_sys_wmi(_cm, buf, count); \
- } \
- static struct device_attribute dev_attr_##_name = { \
- .attr = { \
- .name = __stringify(_name), \
- .mode = _mode }, \
- .show = show_##_name, \
- .store = store_##_name, \
- }
-
-EEEPC_WMI_CREATE_DEVICE_ATTR(touchpad, 0644, EEEPC_WMI_DEVID_TOUCHPAD);
-EEEPC_WMI_CREATE_DEVICE_ATTR(camera, 0644, EEEPC_WMI_DEVID_CAMERA);
-EEEPC_WMI_CREATE_DEVICE_ATTR(cardr, 0644, EEEPC_WMI_DEVID_CARDREADER);
-
-static ssize_t store_cpufv(struct device *dev, struct device_attribute *attr,
- const char *buf, size_t count)
-{
- int value;
- struct acpi_buffer input = { (acpi_size)sizeof(value), &value };
- acpi_status status;
-
- if (!count || sscanf(buf, "%i", &value) != 1)
- return -EINVAL;
- if (value < 0 || value > 2)
- return -EINVAL;
-
- status = wmi_evaluate_method(EEEPC_WMI_MGMT_GUID,
- 1, EEEPC_WMI_METHODID_CFVS, &input, NULL);
-
- if (ACPI_FAILURE(status))
- return -EIO;
- else
- return count;
-}
-
-static DEVICE_ATTR(cpufv, S_IRUGO | S_IWUSR, NULL, store_cpufv);
-
-static struct attribute *platform_attributes[] = {
- &dev_attr_cpufv.attr,
- &dev_attr_camera.attr,
- &dev_attr_cardr.attr,
- &dev_attr_touchpad.attr,
- NULL
-};
-
-static mode_t eeepc_sysfs_is_visible(struct kobject *kobj,
- struct attribute *attr,
- int idx)
-{
- bool supported = true;
- int devid = -1;
-
- if (attr == &dev_attr_camera.attr)
- devid = EEEPC_WMI_DEVID_CAMERA;
- else if (attr == &dev_attr_cardr.attr)
- devid = EEEPC_WMI_DEVID_CARDREADER;
- else if (attr == &dev_attr_touchpad.attr)
- devid = EEEPC_WMI_DEVID_TOUCHPAD;
-
- if (devid != -1)
- supported = eeepc_wmi_get_devstate_simple(devid) != -ENODEV;
-
- return supported ? attr->mode : 0;
-}
-
-static struct attribute_group platform_attribute_group = {
- .is_visible = eeepc_sysfs_is_visible,
- .attrs = platform_attributes
-};
-
-static void eeepc_wmi_sysfs_exit(struct platform_device *device)
-{
- sysfs_remove_group(&device->dev.kobj, &platform_attribute_group);
-}
-
-static int eeepc_wmi_sysfs_init(struct platform_device *device)
-{
- return sysfs_create_group(&device->dev.kobj, &platform_attribute_group);
-}
-
-/*
- * Platform device
- */
-static int __init eeepc_wmi_platform_init(struct eeepc_wmi *eeepc)
-{
- return eeepc_wmi_sysfs_init(eeepc->platform_device);
-}
-
-static void eeepc_wmi_platform_exit(struct eeepc_wmi *eeepc)
-{
- eeepc_wmi_sysfs_exit(eeepc->platform_device);
-}
-
-/*
- * debugfs
- */
-struct eeepc_wmi_debugfs_node {
- struct eeepc_wmi *eeepc;
- char *name;
- int (*show)(struct seq_file *m, void *data);
-};
-
-static int show_dsts(struct seq_file *m, void *data)
-{
- struct eeepc_wmi *eeepc = m->private;
- acpi_status status;
- u32 retval = -1;
-
- status = eeepc_wmi_get_devstate(eeepc->debug.dev_id, &retval);
-
- if (ACPI_FAILURE(status))
- return -EIO;
-
- seq_printf(m, "DSTS(%x) = %x\n", eeepc->debug.dev_id, retval);
-
- return 0;
-}
-
-static int show_devs(struct seq_file *m, void *data)
-{
- struct eeepc_wmi *eeepc = m->private;
- acpi_status status;
- u32 retval = -1;
-
- status = eeepc_wmi_set_devstate(eeepc->debug.dev_id,
- eeepc->debug.ctrl_param, &retval);
- if (ACPI_FAILURE(status))
- return -EIO;
-
- seq_printf(m, "DEVS(%x, %x) = %x\n", eeepc->debug.dev_id,
- eeepc->debug.ctrl_param, retval);
-
- return 0;
-}
-
-static struct eeepc_wmi_debugfs_node eeepc_wmi_debug_files[] = {
- { NULL, "devs", show_devs },
- { NULL, "dsts", show_dsts },
-};
-
-static int eeepc_wmi_debugfs_open(struct inode *inode, struct file *file)
-{
- struct eeepc_wmi_debugfs_node *node = inode->i_private;
-
- return single_open(file, node->show, node->eeepc);
-}
-
-static const struct file_operations eeepc_wmi_debugfs_io_ops = {
- .owner = THIS_MODULE,
- .open = eeepc_wmi_debugfs_open,
- .read = seq_read,
- .llseek = seq_lseek,
- .release = single_release,
-};
-
-static void eeepc_wmi_debugfs_exit(struct eeepc_wmi *eeepc)
-{
- debugfs_remove_recursive(eeepc->debug.root);
-}
-
-static int eeepc_wmi_debugfs_init(struct eeepc_wmi *eeepc)
-{
- struct dentry *dent;
- int i;
-
- eeepc->debug.root = debugfs_create_dir(EEEPC_WMI_FILE, NULL);
- if (!eeepc->debug.root) {
- pr_err("failed to create debugfs directory");
- goto error_debugfs;
- }
-
- dent = debugfs_create_x32("dev_id", S_IRUGO|S_IWUSR,
- eeepc->debug.root, &eeepc->debug.dev_id);
- if (!dent)
- goto error_debugfs;
-
- dent = debugfs_create_x32("ctrl_param", S_IRUGO|S_IWUSR,
- eeepc->debug.root, &eeepc->debug.ctrl_param);
- if (!dent)
- goto error_debugfs;
-
- for (i = 0; i < ARRAY_SIZE(eeepc_wmi_debug_files); i++) {
- struct eeepc_wmi_debugfs_node *node = &eeepc_wmi_debug_files[i];
-
- node->eeepc = eeepc;
- dent = debugfs_create_file(node->name, S_IFREG | S_IRUGO,
- eeepc->debug.root, node,
- &eeepc_wmi_debugfs_io_ops);
- if (!dent) {
- pr_err("failed to create debug file: %s\n", node->name);
- goto error_debugfs;
- }
- }
-
- return 0;
-
-error_debugfs:
- eeepc_wmi_debugfs_exit(eeepc);
- return -ENOMEM;
-}
-
-/*
- * WMI Driver
- */
-static void eeepc_dmi_check(struct eeepc_wmi *eeepc)
-{
- const char *model;
-
- model = dmi_get_system_info(DMI_PRODUCT_NAME);
- if (!model)
- return;
-
- /*
- * Whitelist for wlan hotplug
- *
- * Eeepc 1000H needs the current hotplug code to handle
- * Fn+F2 correctly. We may add other Eeepc here later, but
- * it seems that most of the laptops supported by eeepc-wmi
- * don't need to be on this list
- */
- if (strcmp(model, "1000H") == 0) {
- eeepc->hotplug_wireless = true;
- pr_info("wlan hotplug enabled\n");
- }
-}
-
-static int __init eeepc_wmi_add(struct platform_device *pdev)
-{
- struct eeepc_wmi *eeepc;
- acpi_status status;
- int err;
-
- eeepc = kzalloc(sizeof(struct eeepc_wmi), GFP_KERNEL);
- if (!eeepc)
- return -ENOMEM;
-
- eeepc->platform_device = pdev;
- platform_set_drvdata(eeepc->platform_device, eeepc);
-
- eeepc->hotplug_wireless = hotplug_wireless;
- eeepc_dmi_check(eeepc);
-
- err = eeepc_wmi_platform_init(eeepc);
- if (err)
- goto fail_platform;
-
- err = eeepc_wmi_input_init(eeepc);
- if (err)
- goto fail_input;
-
- err = eeepc_wmi_led_init(eeepc);
- if (err)
- goto fail_leds;
-
- err = eeepc_wmi_rfkill_init(eeepc);
- if (err)
- goto fail_rfkill;
-
- if (!acpi_video_backlight_support()) {
- err = eeepc_wmi_backlight_init(eeepc);
- if (err && err != -ENODEV)
- goto fail_backlight;
- } else
- pr_info("Backlight controlled by ACPI video driver\n");
-
- status = wmi_install_notify_handler(EEEPC_WMI_EVENT_GUID,
- eeepc_wmi_notify, eeepc);
- if (ACPI_FAILURE(status)) {
- pr_err("Unable to register notify handler - %d\n",
- status);
- err = -ENODEV;
- goto fail_wmi_handler;
- }
-
- err = eeepc_wmi_debugfs_init(eeepc);
- if (err)
- goto fail_debugfs;
-
- return 0;
-
-fail_debugfs:
- wmi_remove_notify_handler(EEEPC_WMI_EVENT_GUID);
-fail_wmi_handler:
- eeepc_wmi_backlight_exit(eeepc);
-fail_backlight:
- eeepc_wmi_rfkill_exit(eeepc);
-fail_rfkill:
- eeepc_wmi_led_exit(eeepc);
-fail_leds:
- eeepc_wmi_input_exit(eeepc);
-fail_input:
- eeepc_wmi_platform_exit(eeepc);
-fail_platform:
- kfree(eeepc);
- return err;
-}
-
-static int __exit eeepc_wmi_remove(struct platform_device *device)
-{
- struct eeepc_wmi *eeepc;
-
- eeepc = platform_get_drvdata(device);
- wmi_remove_notify_handler(EEEPC_WMI_EVENT_GUID);
- eeepc_wmi_backlight_exit(eeepc);
- eeepc_wmi_input_exit(eeepc);
- eeepc_wmi_led_exit(eeepc);
- eeepc_wmi_rfkill_exit(eeepc);
- eeepc_wmi_debugfs_exit(eeepc);
- eeepc_wmi_platform_exit(eeepc);
-
- kfree(eeepc);
- return 0;
-}
-
-/*
- * Platform driver - hibernate/resume callbacks
- */
-static int eeepc_hotk_thaw(struct device *device)
-{
- struct eeepc_wmi *eeepc = dev_get_drvdata(device);
-
- if (eeepc->wlan_rfkill) {
- bool wlan;
-
- /*
- * Work around bios bug - acpi _PTS turns off the wireless led
- * during suspend. Normally it restores it on resume, but
- * we should kick it ourselves in case hibernation is aborted.
- */
- wlan = eeepc_wmi_get_devstate_simple(EEEPC_WMI_DEVID_WLAN);
- eeepc_wmi_set_devstate(EEEPC_WMI_DEVID_WLAN, wlan, NULL);
- }
-
- return 0;
-}
-
-static int eeepc_hotk_restore(struct device *device)
-{
- struct eeepc_wmi *eeepc = dev_get_drvdata(device);
- int bl;
-
- /* Refresh both wlan rfkill state and pci hotplug */
- if (eeepc->wlan_rfkill)
- eeepc_rfkill_hotplug(eeepc);
-
- if (eeepc->bluetooth_rfkill) {
- bl = !eeepc_wmi_get_devstate_simple(EEEPC_WMI_DEVID_BLUETOOTH);
- rfkill_set_sw_state(eeepc->bluetooth_rfkill, bl);
- }
- if (eeepc->wimax_rfkill) {
- bl = !eeepc_wmi_get_devstate_simple(EEEPC_WMI_DEVID_WIMAX);
- rfkill_set_sw_state(eeepc->wimax_rfkill, bl);
- }
- if (eeepc->wwan3g_rfkill) {
- bl = !eeepc_wmi_get_devstate_simple(EEEPC_WMI_DEVID_WWAN3G);
- rfkill_set_sw_state(eeepc->wwan3g_rfkill, bl);
- }
-
- return 0;
-}
-
-static const struct dev_pm_ops eeepc_pm_ops = {
- .thaw = eeepc_hotk_thaw,
- .restore = eeepc_hotk_restore,
-};
-
-static struct platform_driver platform_driver = {
- .remove = __exit_p(eeepc_wmi_remove),
- .driver = {
- .name = EEEPC_WMI_FILE,
- .owner = THIS_MODULE,
- .pm = &eeepc_pm_ops,
- },
-};
-
-static acpi_status __init eeepc_wmi_parse_device(acpi_handle handle, u32 level,
- void *context, void **retval)
-{
- pr_warning("Found legacy ATKD device (%s)", EEEPC_ACPI_HID);
- *(bool *)context = true;
- return AE_CTRL_TERMINATE;
-}
-
-static int __init eeepc_wmi_check_atkd(void)
-{
- acpi_status status;
- bool found = false;
-
- status = acpi_get_devices(EEEPC_ACPI_HID, eeepc_wmi_parse_device,
- &found, NULL);
-
- if (ACPI_FAILURE(status) || !found)
- return 0;
- return -1;
-}
-
-static int __init eeepc_wmi_probe(struct platform_device *pdev)
-{
- if (!wmi_has_guid(EEEPC_WMI_EVENT_GUID) ||
- !wmi_has_guid(EEEPC_WMI_MGMT_GUID)) {
- pr_warning("No known WMI GUID found\n");
- return -ENODEV;
- }
-
- if (eeepc_wmi_check_atkd()) {
- pr_warning("WMI device present, but legacy ATKD device is also "
- "present and enabled.");
- pr_warning("You probably booted with acpi_osi=\"Linux\" or "
- "acpi_osi=\"!Windows 2009\"");
- pr_warning("Can't load eeepc-wmi, use default acpi_osi "
- "(preferred) or eeepc-laptop");
- return -ENODEV;
- }
-
- return eeepc_wmi_add(pdev);
-}
-
-static struct platform_device *platform_device;
-
-static int __init eeepc_wmi_init(void)
-{
- platform_device = platform_create_bundle(&platform_driver,
- eeepc_wmi_probe,
- NULL, 0, NULL, 0);
- if (IS_ERR(platform_device))
- return PTR_ERR(platform_device);
- return 0;
-}
-
-static void __exit eeepc_wmi_exit(void)
-{
- platform_device_unregister(platform_device);
- platform_driver_unregister(&platform_driver);
-}
-
-module_init(eeepc_wmi_init);
-module_exit(eeepc_wmi_exit);
--
1.7.4
^ permalink raw reply [flat|nested] 16+ messages in thread* [PATCH 02/14] eeepc-wmi: asus generic asus-wmi.ko module
2011-02-26 9:20 [PATCH 00/14] Support Asus WMI capable Notebooks (asus-wmi, asus-nb-wmi and eeepc-wmi) Corentin Chary
2011-02-26 9:20 ` [PATCH 01/14] asus-wmi: move generic code to asus-wmi Corentin Chary
@ 2011-02-26 9:20 ` Corentin Chary
2011-02-26 9:20 ` [PATCH 03/14] asus-wmi: minor cleanups Corentin Chary
` (12 subsequent siblings)
14 siblings, 0 replies; 16+ messages in thread
From: Corentin Chary @ 2011-02-26 9:20 UTC (permalink / raw)
To: Matthew Garrett
Cc: Dmitry Torokhov, Corentin Chary, Randy Dunlap,
open list:DOCUMENTATION, open list,
open list:X86 PLATFORM DRIVERS, open list:ASUS NOTEBOOKS AN...
New Asus notebooks are using a WMI device similar to
the one used in Eee PCs. Since we don't want to load
eeepc-wmi module on Asus notebooks, and we want to
keep the eeepc-wmi module for backward compatibility,
this patch introduce a new module, named asus-wmi, that
will be used by eeepc-wmi and the new Asus Notebook WMI
Driver.
eeepc-wmi's input device strings (device name and phys)
are kept, but rfkill and led names are changed (s/eeepc/asus/).
This should not break anything since rfkill are used by type or
index, not by name, and the eeepc::touchpad led wasn't working
correctly before 2.6.39 anyway.
Signed-off-by: Corentin Chary <corentincj@iksaif.net>
---
Documentation/ABI/testing/sysfs-platform-asus-wmi | 31 +
Documentation/ABI/testing/sysfs-platform-eeepc-wmi | 31 -
drivers/platform/x86/Kconfig | 24 +-
drivers/platform/x86/Makefile | 3 +-
drivers/platform/x86/asus-wmi.c | 924 +++++++++-----------
drivers/platform/x86/asus-wmi.h | 58 ++
drivers/platform/x86/eeepc-wmi.c | 162 ++++
7 files changed, 708 insertions(+), 525 deletions(-)
create mode 100644 Documentation/ABI/testing/sysfs-platform-asus-wmi
delete mode 100644 Documentation/ABI/testing/sysfs-platform-eeepc-wmi
create mode 100644 drivers/platform/x86/asus-wmi.h
create mode 100644 drivers/platform/x86/eeepc-wmi.c
diff --git a/Documentation/ABI/testing/sysfs-platform-asus-wmi b/Documentation/ABI/testing/sysfs-platform-asus-wmi
new file mode 100644
index 0000000..2e7df91
--- /dev/null
+++ b/Documentation/ABI/testing/sysfs-platform-asus-wmi
@@ -0,0 +1,31 @@
+What: /sys/devices/platform/<platform>/cpufv
+Date: Oct 2010
+KernelVersion: 2.6.37
+Contact: "Corentin Chary" <corentincj@iksaif.net>
+Description:
+ Change CPU clock configuration (write-only).
+ There are three available clock configuration:
+ * 0 -> Super Performance Mode
+ * 1 -> High Performance Mode
+ * 2 -> Power Saving Mode
+
+What: /sys/devices/platform/<platform>/camera
+Date: Jan 2010
+KernelVersion: 2.6.39
+Contact: "Corentin Chary" <corentincj@iksaif.net>
+Description:
+ Control the camera. 1 means on, 0 means off.
+
+What: /sys/devices/platform/<platform>/cardr
+Date: Jan 2010
+KernelVersion: 2.6.39
+Contact: "Corentin Chary" <corentincj@iksaif.net>
+Description:
+ Control the card reader. 1 means on, 0 means off.
+
+What: /sys/devices/platform/<platform>/touchpad
+Date: Jan 2010
+KernelVersion: 2.6.39
+Contact: "Corentin Chary" <corentincj@iksaif.net>
+Description:
+ Control the card touchpad. 1 means on, 0 means off.
diff --git a/Documentation/ABI/testing/sysfs-platform-eeepc-wmi b/Documentation/ABI/testing/sysfs-platform-eeepc-wmi
deleted file mode 100644
index 26acb68..0000000
--- a/Documentation/ABI/testing/sysfs-platform-eeepc-wmi
+++ /dev/null
@@ -1,31 +0,0 @@
-What: /sys/devices/platform/eeepc-wmi/cpufv
-Date: Oct 2010
-KernelVersion: 2.6.37
-Contact: "Corentin Chary" <corentincj@iksaif.net>
-Description:
- Change CPU clock configuration (write-only).
- There are three available clock configuration:
- * 0 -> Super Performance Mode
- * 1 -> High Performance Mode
- * 2 -> Power Saving Mode
-
-What: /sys/devices/platform/eeepc-wmi/camera
-Date: Jan 2010
-KernelVersion: 2.6.39
-Contact: "Corentin Chary" <corentincj@iksaif.net>
-Description:
- Control the camera. 1 means on, 0 means off.
-
-What: /sys/devices/platform/eeepc-wmi/cardr
-Date: Jan 2010
-KernelVersion: 2.6.39
-Contact: "Corentin Chary" <corentincj@iksaif.net>
-Description:
- Control the card reader. 1 means on, 0 means off.
-
-What: /sys/devices/platform/eeepc-wmi/touchpad
-Date: Jan 2010
-KernelVersion: 2.6.39
-Contact: "Corentin Chary" <corentincj@iksaif.net>
-Description:
- Control the card touchpad. 1 means on, 0 means off.
diff --git a/drivers/platform/x86/Kconfig b/drivers/platform/x86/Kconfig
index 906e1fb..22e5225 100644
--- a/drivers/platform/x86/Kconfig
+++ b/drivers/platform/x86/Kconfig
@@ -433,10 +433,11 @@ config EEEPC_LAPTOP
Bluetooth, backlight and allows powering on/off some other
devices.
- If you have an Eee PC laptop, say Y or M here.
+ If you have an Eee PC laptop, say Y or M here. If this driver
+ doesn't work on your Eee PC, try eeepc-wmi instead.
-config EEEPC_WMI
- tristate "Eee PC WMI Hotkey Driver (EXPERIMENTAL)"
+config ASUS_WMI
+ tristate "ASUS WMI Driver (EXPERIMENTAL)"
depends on ACPI_WMI
depends on INPUT
depends on EXPERIMENTAL
@@ -446,10 +447,23 @@ config EEEPC_WMI
select LEDS_CLASS
select NEW_LEDS
---help---
- Say Y here if you want to support WMI-based hotkeys on Eee PC laptops.
+ Say Y here if you have a WMI aware Asus laptop (like Eee PCs).
To compile this driver as a module, choose M here: the module will
- be called eeepc-wmi.
+ be called asus-wmi.
+
+config EEEPC_WMI
+ tristate "Eee PC WMI Driver (EXPERIMENTAL)"
+ depends on ASUS_WMI
+ ---help---
+ This is a driver for newer Eee PC laptops. It adds extra features
+ like wireless radio and bluetooth control, leds, hotkeys, backlight...
+
+ For more informations, see
+ <file:Documentation/ABI/testing/sysfs-platform-asus-wmi>
+
+ If you have an ACPI-WMI compatible Eee PC laptop (>= 1000), say Y or M
+ here.
config ACPI_WMI
tristate "WMI"
diff --git a/drivers/platform/x86/Makefile b/drivers/platform/x86/Makefile
index 3672b04..f8d35f1 100644
--- a/drivers/platform/x86/Makefile
+++ b/drivers/platform/x86/Makefile
@@ -3,8 +3,9 @@
# x86 Platform-Specific Drivers
#
obj-$(CONFIG_ASUS_LAPTOP) += asus-laptop.o
+obj-$(CONFIG_ASUS_WMI) += asus-wmi.o
obj-$(CONFIG_EEEPC_LAPTOP) += eeepc-laptop.o
-obj-$(CONFIG_EEEPC_WMI) += asus-wmi.o eeepc-wmi.o
+obj-$(CONFIG_EEEPC_WMI) += eeepc-wmi.o
obj-$(CONFIG_MSI_LAPTOP) += msi-laptop.o
obj-$(CONFIG_ACPI_CMPC) += classmate-laptop.o
obj-$(CONFIG_COMPAL_LAPTOP) += compal-laptop.o
diff --git a/drivers/platform/x86/asus-wmi.c b/drivers/platform/x86/asus-wmi.c
index d399775..35e6bb6 100644
--- a/drivers/platform/x86/asus-wmi.c
+++ b/drivers/platform/x86/asus-wmi.c
@@ -1,5 +1,5 @@
/*
- * Eee PC WMI hotkey driver
+ * Asus PC WMI hotkey driver
*
* Copyright(C) 2010 Intel Corporation.
* Copyright(C) 2010 Corentin Chary <corentin.chary@gmail.com>
@@ -42,23 +42,23 @@
#include <linux/debugfs.h>
#include <linux/seq_file.h>
#include <linux/platform_device.h>
-#include <linux/dmi.h>
#include <acpi/acpi_bus.h>
#include <acpi/acpi_drivers.h>
-#define EEEPC_WMI_FILE "eeepc-wmi"
+#include "asus-wmi.h"
-MODULE_AUTHOR("Yong Wang <yong.y.wang@intel.com>");
-MODULE_DESCRIPTION("Eee PC WMI Hotkey Driver");
+MODULE_AUTHOR("Corentin Chary <corentincj@iksaif.net>, "
+ "Yong Wang <yong.y.wang@intel.com>");
+MODULE_DESCRIPTION("Asus Generic WMI Driver");
MODULE_LICENSE("GPL");
-#define EEEPC_ACPI_HID "ASUS010" /* old _HID used in eeepc-laptop */
+#define to_platform_driver(drv) \
+ (container_of((drv), struct platform_driver, driver))
-#define EEEPC_WMI_EVENT_GUID "ABBC0F72-8EA1-11D1-00A0-C90629100000"
-#define EEEPC_WMI_MGMT_GUID "97845ED0-4E6D-11DE-8A39-0800200C9A66"
+#define to_asus_wmi_driver(pdrv) \
+ (container_of((pdrv), struct asus_wmi_driver, platform_driver))
-MODULE_ALIAS("wmi:"EEEPC_WMI_EVENT_GUID);
-MODULE_ALIAS("wmi:"EEEPC_WMI_MGMT_GUID);
+#define ASUS_WMI_MGMT_GUID "97845ED0-4E6D-11DE-8A39-0800200C9A66"
#define NOTIFY_BRNUP_MIN 0x11
#define NOTIFY_BRNUP_MAX 0x1f
@@ -66,90 +66,55 @@ MODULE_ALIAS("wmi:"EEEPC_WMI_MGMT_GUID);
#define NOTIFY_BRNDOWN_MAX 0x2e
/* WMI Methods */
-#define EEEPC_WMI_METHODID_DSTS 0x53544344
-#define EEEPC_WMI_METHODID_DEVS 0x53564544
-#define EEEPC_WMI_METHODID_CFVS 0x53564643
+#define ASUS_WMI_METHODID_DSTS 0x53544344
+#define ASUS_WMI_METHODID_DEVS 0x53564544
+#define ASUS_WMI_METHODID_CFVS 0x53564643
/* Wireless */
-#define EEEPC_WMI_DEVID_WLAN 0x00010011
-#define EEEPC_WMI_DEVID_BLUETOOTH 0x00010013
-#define EEEPC_WMI_DEVID_WIMAX 0x00010017
-#define EEEPC_WMI_DEVID_WWAN3G 0x00010019
+#define ASUS_WMI_DEVID_WLAN 0x00010011
+#define ASUS_WMI_DEVID_BLUETOOTH 0x00010013
+#define ASUS_WMI_DEVID_WIMAX 0x00010017
+#define ASUS_WMI_DEVID_WWAN3G 0x00010019
/* Backlight and Brightness */
-#define EEEPC_WMI_DEVID_BACKLIGHT 0x00050011
-#define EEEPC_WMI_DEVID_BRIGHTNESS 0x00050012
+#define ASUS_WMI_DEVID_BACKLIGHT 0x00050011
+#define ASUS_WMI_DEVID_BRIGHTNESS 0x00050012
/* Misc */
-#define EEEPC_WMI_DEVID_CAMERA 0x00060013
+#define ASUS_WMI_DEVID_CAMERA 0x00060013
/* Storage */
-#define EEEPC_WMI_DEVID_CARDREADER 0x00080013
+#define ASUS_WMI_DEVID_CARDREADER 0x00080013
/* Input */
-#define EEEPC_WMI_DEVID_TOUCHPAD 0x00100011
-#define EEEPC_WMI_DEVID_TOUCHPAD_LED 0x00100012
+#define ASUS_WMI_DEVID_TOUCHPAD 0x00100011
+#define ASUS_WMI_DEVID_TOUCHPAD_LED 0x00100012
/* DSTS masks */
-#define EEEPC_WMI_DSTS_STATUS_BIT 0x00000001
-#define EEEPC_WMI_DSTS_PRESENCE_BIT 0x00010000
-#define EEEPC_WMI_DSTS_BRIGHTNESS_MASK 0x000000FF
-#define EEEPC_WMI_DSTS_MAX_BRIGTH_MASK 0x0000FF00
-
-static bool hotplug_wireless;
-
-module_param(hotplug_wireless, bool, 0444);
-MODULE_PARM_DESC(hotplug_wireless,
- "Enable hotplug for wireless device. "
- "If your laptop needs that, please report to "
- "acpi4asus-user@lists.sourceforge.net.");
-
-static const struct key_entry eeepc_wmi_keymap[] = {
- /* Sleep already handled via generic ACPI code */
- { KE_IGNORE, NOTIFY_BRNDOWN_MIN, { KEY_BRIGHTNESSDOWN } },
- { KE_IGNORE, NOTIFY_BRNUP_MIN, { KEY_BRIGHTNESSUP } },
- { KE_KEY, 0x30, { KEY_VOLUMEUP } },
- { KE_KEY, 0x31, { KEY_VOLUMEDOWN } },
- { KE_KEY, 0x32, { KEY_MUTE } },
- { KE_KEY, 0x5c, { KEY_F15 } }, /* Power Gear key */
- { KE_KEY, 0x5d, { KEY_WLAN } },
- { KE_KEY, 0x6b, { KEY_F13 } }, /* Disable Touchpad */
- { KE_KEY, 0x82, { KEY_CAMERA } },
- { KE_KEY, 0x83, { KEY_CAMERA_ZOOMIN } },
- { KE_KEY, 0x88, { KEY_WLAN } },
- { KE_KEY, 0xcc, { KEY_SWITCHVIDEOMODE } },
- { KE_KEY, 0xe0, { KEY_PROG1 } }, /* Task Manager */
- { KE_KEY, 0xe1, { KEY_F14 } }, /* Change Resolution */
- { KE_KEY, 0xe9, { KEY_BRIGHTNESS_ZERO } },
- { KE_KEY, 0xeb, { KEY_CAMERA_ZOOMOUT } },
- { KE_KEY, 0xec, { KEY_CAMERA_UP } },
- { KE_KEY, 0xed, { KEY_CAMERA_DOWN } },
- { KE_KEY, 0xee, { KEY_CAMERA_LEFT } },
- { KE_KEY, 0xef, { KEY_CAMERA_RIGHT } },
- { KE_END, 0},
-};
+#define ASUS_WMI_DSTS_STATUS_BIT 0x00000001
+#define ASUS_WMI_DSTS_PRESENCE_BIT 0x00010000
+#define ASUS_WMI_DSTS_BRIGHTNESS_MASK 0x000000FF
+#define ASUS_WMI_DSTS_MAX_BRIGTH_MASK 0x0000FF00
struct bios_args {
- u32 dev_id;
- u32 ctrl_param;
+ u32 dev_id;
+ u32 ctrl_param;
};
/*
- * eeepc-wmi/ - debugfs root directory
+ * <platform>/ - debugfs root directory
* dev_id - current dev_id
* ctrl_param - current ctrl_param
* devs - call DEVS(dev_id, ctrl_param) and print result
* dsts - call DSTS(dev_id) and print result
*/
-struct eeepc_wmi_debug {
+struct asus_wmi_debug {
struct dentry *root;
u32 dev_id;
u32 ctrl_param;
};
-struct eeepc_wmi {
- bool hotplug_wireless;
-
+struct asus_wmi {
struct input_dev *inputdev;
struct backlight_device *backlight_device;
struct platform_device *platform_device;
@@ -170,59 +135,61 @@ struct eeepc_wmi {
struct workqueue_struct *hotplug_workqueue;
struct work_struct hotplug_work;
- struct eeepc_wmi_debug debug;
+ struct asus_wmi_debug debug;
+
+ struct asus_wmi_driver *driver;
};
-static int eeepc_wmi_input_init(struct eeepc_wmi *eeepc)
+static int asus_wmi_input_init(struct asus_wmi *asus)
{
int err;
- eeepc->inputdev = input_allocate_device();
- if (!eeepc->inputdev)
+ asus->inputdev = input_allocate_device();
+ if (!asus->inputdev)
return -ENOMEM;
- eeepc->inputdev->name = "Eee PC WMI hotkeys";
- eeepc->inputdev->phys = EEEPC_WMI_FILE "/input0";
- eeepc->inputdev->id.bustype = BUS_HOST;
- eeepc->inputdev->dev.parent = &eeepc->platform_device->dev;
+ asus->inputdev->name = asus->driver->input_phys;
+ asus->inputdev->phys = asus->driver->input_name;
+ asus->inputdev->id.bustype = BUS_HOST;
+ asus->inputdev->dev.parent = &asus->platform_device->dev;
- err = sparse_keymap_setup(eeepc->inputdev, eeepc_wmi_keymap, NULL);
+ err = sparse_keymap_setup(asus->inputdev, asus->driver->keymap, NULL);
if (err)
goto err_free_dev;
- err = input_register_device(eeepc->inputdev);
+ err = input_register_device(asus->inputdev);
if (err)
goto err_free_keymap;
return 0;
err_free_keymap:
- sparse_keymap_free(eeepc->inputdev);
+ sparse_keymap_free(asus->inputdev);
err_free_dev:
- input_free_device(eeepc->inputdev);
+ input_free_device(asus->inputdev);
return err;
}
-static void eeepc_wmi_input_exit(struct eeepc_wmi *eeepc)
+static void asus_wmi_input_exit(struct asus_wmi *asus)
{
- if (eeepc->inputdev) {
- sparse_keymap_free(eeepc->inputdev);
- input_unregister_device(eeepc->inputdev);
+ if (asus->inputdev) {
+ sparse_keymap_free(asus->inputdev);
+ input_unregister_device(asus->inputdev);
}
- eeepc->inputdev = NULL;
+ asus->inputdev = NULL;
}
-static acpi_status eeepc_wmi_get_devstate(u32 dev_id, u32 *retval)
+static acpi_status asus_wmi_get_devstate(u32 dev_id, u32 *retval)
{
- struct acpi_buffer input = { (acpi_size)sizeof(u32), &dev_id };
+ struct acpi_buffer input = { (acpi_size) sizeof(u32), &dev_id };
struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
union acpi_object *obj;
acpi_status status;
u32 tmp;
- status = wmi_evaluate_method(EEEPC_WMI_MGMT_GUID,
- 1, EEEPC_WMI_METHODID_DSTS,
+ status = wmi_evaluate_method(ASUS_WMI_MGMT_GUID,
+ 1, ASUS_WMI_METHODID_DSTS,
&input, &output);
if (ACPI_FAILURE(status))
@@ -230,7 +197,7 @@ static acpi_status eeepc_wmi_get_devstate(u32 dev_id, u32 *retval)
obj = (union acpi_object *)output.pointer;
if (obj && obj->type == ACPI_TYPE_INTEGER)
- tmp = (u32)obj->integer.value;
+ tmp = (u32) obj->integer.value;
else
tmp = 0;
@@ -243,27 +210,27 @@ static acpi_status eeepc_wmi_get_devstate(u32 dev_id, u32 *retval)
}
-static acpi_status eeepc_wmi_set_devstate(u32 dev_id, u32 ctrl_param,
- u32 *retval)
+static acpi_status asus_wmi_set_devstate(u32 dev_id, u32 ctrl_param,
+ u32 *retval)
{
struct bios_args args = {
.dev_id = dev_id,
.ctrl_param = ctrl_param,
};
- struct acpi_buffer input = { (acpi_size)sizeof(args), &args };
+ struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
acpi_status status;
if (!retval) {
- status = wmi_evaluate_method(EEEPC_WMI_MGMT_GUID, 1,
- EEEPC_WMI_METHODID_DEVS,
+ status = wmi_evaluate_method(ASUS_WMI_MGMT_GUID, 1,
+ ASUS_WMI_METHODID_DEVS,
&input, NULL);
} else {
struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
union acpi_object *obj;
u32 tmp;
- status = wmi_evaluate_method(EEEPC_WMI_MGMT_GUID, 1,
- EEEPC_WMI_METHODID_DEVS,
+ status = wmi_evaluate_method(ASUS_WMI_MGMT_GUID, 1,
+ ASUS_WMI_METHODID_DEVS,
&input, &output);
if (ACPI_FAILURE(status))
@@ -271,7 +238,7 @@ static acpi_status eeepc_wmi_set_devstate(u32 dev_id, u32 ctrl_param,
obj = (union acpi_object *)output.pointer;
if (obj && obj->type == ACPI_TYPE_INTEGER)
- tmp = (u32)obj->integer.value;
+ tmp = (u32) obj->integer.value;
else
tmp = 0;
@@ -284,25 +251,25 @@ static acpi_status eeepc_wmi_set_devstate(u32 dev_id, u32 ctrl_param,
}
/* Helper for special devices with magic return codes */
-static int eeepc_wmi_get_devstate_bits(u32 dev_id, u32 mask)
+static int asus_wmi_get_devstate_bits(u32 dev_id, u32 mask)
{
u32 retval = 0;
acpi_status status;
- status = eeepc_wmi_get_devstate(dev_id, &retval);
+ status = asus_wmi_get_devstate(dev_id, &retval);
if (ACPI_FAILURE(status))
return -EINVAL;
- if (!(retval & EEEPC_WMI_DSTS_PRESENCE_BIT))
+ if (!(retval & ASUS_WMI_DSTS_PRESENCE_BIT))
return -ENODEV;
return retval & mask;
}
-static int eeepc_wmi_get_devstate_simple(u32 dev_id)
+static int asus_wmi_get_devstate_simple(u32 dev_id)
{
- return eeepc_wmi_get_devstate_bits(dev_id, EEEPC_WMI_DSTS_STATUS_BIT);
+ return asus_wmi_get_devstate_bits(dev_id, ASUS_WMI_DSTS_STATUS_BIT);
}
/*
@@ -311,93 +278,92 @@ static int eeepc_wmi_get_devstate_simple(u32 dev_id)
/*
* These functions actually update the LED's, and are called from a
* workqueue. By doing this as separate work rather than when the LED
- * subsystem asks, we avoid messing with the Eeepc ACPI stuff during a
+ * subsystem asks, we avoid messing with the Asus ACPI stuff during a
* potentially bad time, such as a timer interrupt.
*/
static void tpd_led_update(struct work_struct *work)
{
int ctrl_param;
- struct eeepc_wmi *eeepc;
+ struct asus_wmi *asus;
- eeepc = container_of(work, struct eeepc_wmi, tpd_led_work);
+ asus = container_of(work, struct asus_wmi, tpd_led_work);
- ctrl_param = eeepc->tpd_led_wk;
- eeepc_wmi_set_devstate(EEEPC_WMI_DEVID_TOUCHPAD_LED, ctrl_param, NULL);
+ ctrl_param = asus->tpd_led_wk;
+ asus_wmi_set_devstate(ASUS_WMI_DEVID_TOUCHPAD_LED, ctrl_param, NULL);
}
static void tpd_led_set(struct led_classdev *led_cdev,
enum led_brightness value)
{
- struct eeepc_wmi *eeepc;
+ struct asus_wmi *asus;
- eeepc = container_of(led_cdev, struct eeepc_wmi, tpd_led);
+ asus = container_of(led_cdev, struct asus_wmi, tpd_led);
- eeepc->tpd_led_wk = !!value;
- queue_work(eeepc->led_workqueue, &eeepc->tpd_led_work);
+ asus->tpd_led_wk = !!value;
+ queue_work(asus->led_workqueue, &asus->tpd_led_work);
}
-static int read_tpd_led_state(struct eeepc_wmi *eeepc)
+static int read_tpd_led_state(struct asus_wmi *asus)
{
- return eeepc_wmi_get_devstate_simple(EEEPC_WMI_DEVID_TOUCHPAD_LED);
+ return asus_wmi_get_devstate_simple(ASUS_WMI_DEVID_TOUCHPAD_LED);
}
static enum led_brightness tpd_led_get(struct led_classdev *led_cdev)
{
- struct eeepc_wmi *eeepc;
+ struct asus_wmi *asus;
- eeepc = container_of(led_cdev, struct eeepc_wmi, tpd_led);
+ asus = container_of(led_cdev, struct asus_wmi, tpd_led);
- return read_tpd_led_state(eeepc);
+ return read_tpd_led_state(asus);
}
-static int eeepc_wmi_led_init(struct eeepc_wmi *eeepc)
+static int asus_wmi_led_init(struct asus_wmi *asus)
{
int rv;
- if (read_tpd_led_state(eeepc) < 0)
+ if (read_tpd_led_state(asus) < 0)
return 0;
- eeepc->led_workqueue = create_singlethread_workqueue("led_workqueue");
- if (!eeepc->led_workqueue)
+ asus->led_workqueue = create_singlethread_workqueue("led_workqueue");
+ if (!asus->led_workqueue)
return -ENOMEM;
- INIT_WORK(&eeepc->tpd_led_work, tpd_led_update);
+ INIT_WORK(&asus->tpd_led_work, tpd_led_update);
- eeepc->tpd_led.name = "eeepc::touchpad";
- eeepc->tpd_led.brightness_set = tpd_led_set;
- eeepc->tpd_led.brightness_get = tpd_led_get;
- eeepc->tpd_led.max_brightness = 1;
+ asus->tpd_led.name = "asus::touchpad";
+ asus->tpd_led.brightness_set = tpd_led_set;
+ asus->tpd_led.brightness_get = tpd_led_get;
+ asus->tpd_led.max_brightness = 1;
- rv = led_classdev_register(&eeepc->platform_device->dev,
- &eeepc->tpd_led);
+ rv = led_classdev_register(&asus->platform_device->dev, &asus->tpd_led);
if (rv) {
- destroy_workqueue(eeepc->led_workqueue);
+ destroy_workqueue(asus->led_workqueue);
return rv;
}
return 0;
}
-static void eeepc_wmi_led_exit(struct eeepc_wmi *eeepc)
+static void asus_wmi_led_exit(struct asus_wmi *asus)
{
- if (eeepc->tpd_led.dev)
- led_classdev_unregister(&eeepc->tpd_led);
- if (eeepc->led_workqueue)
- destroy_workqueue(eeepc->led_workqueue);
+ if (asus->tpd_led.dev)
+ led_classdev_unregister(&asus->tpd_led);
+ if (asus->led_workqueue)
+ destroy_workqueue(asus->led_workqueue);
}
/*
* PCI hotplug (for wlan rfkill)
*/
-static bool eeepc_wlan_rfkill_blocked(struct eeepc_wmi *eeepc)
+static bool asus_wlan_rfkill_blocked(struct asus_wmi *asus)
{
- int result = eeepc_wmi_get_devstate_simple(EEEPC_WMI_DEVID_WLAN);
+ int result = asus_wmi_get_devstate_simple(ASUS_WMI_DEVID_WLAN);
if (result < 0)
return false;
return !result;
}
-static void eeepc_rfkill_hotplug(struct eeepc_wmi *eeepc)
+static void asus_rfkill_hotplug(struct asus_wmi *asus)
{
struct pci_dev *dev;
struct pci_bus *bus;
@@ -405,16 +371,16 @@ static void eeepc_rfkill_hotplug(struct eeepc_wmi *eeepc)
bool absent;
u32 l;
- mutex_lock(&eeepc->wmi_lock);
- blocked = eeepc_wlan_rfkill_blocked(eeepc);
- mutex_unlock(&eeepc->wmi_lock);
+ mutex_lock(&asus->wmi_lock);
+ blocked = asus_wlan_rfkill_blocked(asus);
+ mutex_unlock(&asus->wmi_lock);
- mutex_lock(&eeepc->hotplug_lock);
+ mutex_lock(&asus->hotplug_lock);
- if (eeepc->wlan_rfkill)
- rfkill_set_sw_state(eeepc->wlan_rfkill, blocked);
+ if (asus->wlan_rfkill)
+ rfkill_set_sw_state(asus->wlan_rfkill, blocked);
- if (eeepc->hotplug_slot) {
+ if (asus->hotplug_slot) {
bus = pci_find_bus(0, 1);
if (!bus) {
pr_warning("Unable to find PCI bus 1?\n");
@@ -429,11 +395,11 @@ static void eeepc_rfkill_hotplug(struct eeepc_wmi *eeepc)
if (blocked != absent) {
pr_warning("BIOS says wireless lan is %s, "
- "but the pci device is %s\n",
- blocked ? "blocked" : "unblocked",
- absent ? "absent" : "present");
+ "but the pci device is %s\n",
+ blocked ? "blocked" : "unblocked",
+ absent ? "absent" : "present");
pr_warning("skipped wireless hotplug as probably "
- "inappropriate for this model\n");
+ "inappropriate for this model\n");
goto out_unlock;
}
@@ -460,28 +426,27 @@ static void eeepc_rfkill_hotplug(struct eeepc_wmi *eeepc)
}
out_unlock:
- mutex_unlock(&eeepc->hotplug_lock);
+ mutex_unlock(&asus->hotplug_lock);
}
-static void eeepc_rfkill_notify(acpi_handle handle, u32 event, void *data)
+static void asus_rfkill_notify(acpi_handle handle, u32 event, void *data)
{
- struct eeepc_wmi *eeepc = data;
+ struct asus_wmi *asus = data;
if (event != ACPI_NOTIFY_BUS_CHECK)
return;
/*
- * We can't call directly eeepc_rfkill_hotplug because most
+ * We can't call directly asus_rfkill_hotplug because most
* of the time WMBC is still being executed and not reetrant.
* There is currently no way to tell ACPICA that we want this
- * method to be serialized, we schedule a eeepc_rfkill_hotplug
+ * method to be serialized, we schedule a asus_rfkill_hotplug
* call later, in a safer context.
*/
- queue_work(eeepc->hotplug_workqueue, &eeepc->hotplug_work);
+ queue_work(asus->hotplug_workqueue, &asus->hotplug_work);
}
-static int eeepc_register_rfkill_notifier(struct eeepc_wmi *eeepc,
- char *node)
+static int asus_register_rfkill_notifier(struct asus_wmi *asus, char *node)
{
acpi_status status;
acpi_handle handle;
@@ -491,8 +456,7 @@ static int eeepc_register_rfkill_notifier(struct eeepc_wmi *eeepc,
if (ACPI_SUCCESS(status)) {
status = acpi_install_notify_handler(handle,
ACPI_SYSTEM_NOTIFY,
- eeepc_rfkill_notify,
- eeepc);
+ asus_rfkill_notify, asus);
if (ACPI_FAILURE(status))
pr_warning("Failed to register notify on %s\n", node);
} else
@@ -501,8 +465,7 @@ static int eeepc_register_rfkill_notifier(struct eeepc_wmi *eeepc,
return 0;
}
-static void eeepc_unregister_rfkill_notifier(struct eeepc_wmi *eeepc,
- char *node)
+static void asus_unregister_rfkill_notifier(struct asus_wmi *asus, char *node)
{
acpi_status status = AE_OK;
acpi_handle handle;
@@ -511,18 +474,18 @@ static void eeepc_unregister_rfkill_notifier(struct eeepc_wmi *eeepc,
if (ACPI_SUCCESS(status)) {
status = acpi_remove_notify_handler(handle,
- ACPI_SYSTEM_NOTIFY,
- eeepc_rfkill_notify);
+ ACPI_SYSTEM_NOTIFY,
+ asus_rfkill_notify);
if (ACPI_FAILURE(status))
pr_err("Error removing rfkill notify handler %s\n",
- node);
+ node);
}
}
-static int eeepc_get_adapter_status(struct hotplug_slot *hotplug_slot,
- u8 *value)
+static int asus_get_adapter_status(struct hotplug_slot *hotplug_slot,
+ u8 *value)
{
- int result = eeepc_wmi_get_devstate_simple(EEEPC_WMI_DEVID_WLAN);
+ int result = asus_wmi_get_devstate_simple(ASUS_WMI_DEVID_WLAN);
if (result < 0)
return result;
@@ -531,27 +494,27 @@ static int eeepc_get_adapter_status(struct hotplug_slot *hotplug_slot,
return 0;
}
-static void eeepc_cleanup_pci_hotplug(struct hotplug_slot *hotplug_slot)
+static void asus_cleanup_pci_hotplug(struct hotplug_slot *hotplug_slot)
{
kfree(hotplug_slot->info);
kfree(hotplug_slot);
}
-static struct hotplug_slot_ops eeepc_hotplug_slot_ops = {
+static struct hotplug_slot_ops asus_hotplug_slot_ops = {
.owner = THIS_MODULE,
- .get_adapter_status = eeepc_get_adapter_status,
- .get_power_status = eeepc_get_adapter_status,
+ .get_adapter_status = asus_get_adapter_status,
+ .get_power_status = asus_get_adapter_status,
};
-static void eeepc_hotplug_work(struct work_struct *work)
+static void asus_hotplug_work(struct work_struct *work)
{
- struct eeepc_wmi *eeepc;
+ struct asus_wmi *asus;
- eeepc = container_of(work, struct eeepc_wmi, hotplug_work);
- eeepc_rfkill_hotplug(eeepc);
+ asus = container_of(work, struct asus_wmi, hotplug_work);
+ asus_rfkill_hotplug(asus);
}
-static int eeepc_setup_pci_hotplug(struct eeepc_wmi *eeepc)
+static int asus_setup_pci_hotplug(struct asus_wmi *asus)
{
int ret = -ENOMEM;
struct pci_bus *bus = pci_find_bus(0, 1);
@@ -561,29 +524,29 @@ static int eeepc_setup_pci_hotplug(struct eeepc_wmi *eeepc)
return -ENODEV;
}
- eeepc->hotplug_workqueue =
- create_singlethread_workqueue("hotplug_workqueue");
- if (!eeepc->hotplug_workqueue)
+ asus->hotplug_workqueue =
+ create_singlethread_workqueue("hotplug_workqueue");
+ if (!asus->hotplug_workqueue)
goto error_workqueue;
- INIT_WORK(&eeepc->hotplug_work, eeepc_hotplug_work);
+ INIT_WORK(&asus->hotplug_work, asus_hotplug_work);
- eeepc->hotplug_slot = kzalloc(sizeof(struct hotplug_slot), GFP_KERNEL);
- if (!eeepc->hotplug_slot)
+ asus->hotplug_slot = kzalloc(sizeof(struct hotplug_slot), GFP_KERNEL);
+ if (!asus->hotplug_slot)
goto error_slot;
- eeepc->hotplug_slot->info = kzalloc(sizeof(struct hotplug_slot_info),
- GFP_KERNEL);
- if (!eeepc->hotplug_slot->info)
+ asus->hotplug_slot->info = kzalloc(sizeof(struct hotplug_slot_info),
+ GFP_KERNEL);
+ if (!asus->hotplug_slot->info)
goto error_info;
- eeepc->hotplug_slot->private = eeepc;
- eeepc->hotplug_slot->release = &eeepc_cleanup_pci_hotplug;
- eeepc->hotplug_slot->ops = &eeepc_hotplug_slot_ops;
- eeepc_get_adapter_status(eeepc->hotplug_slot,
- &eeepc->hotplug_slot->info->adapter_status);
+ asus->hotplug_slot->private = asus;
+ asus->hotplug_slot->release = &asus_cleanup_pci_hotplug;
+ asus->hotplug_slot->ops = &asus_hotplug_slot_ops;
+ asus_get_adapter_status(asus->hotplug_slot,
+ &asus->hotplug_slot->info->adapter_status);
- ret = pci_hp_register(eeepc->hotplug_slot, bus, 0, "eeepc-wifi");
+ ret = pci_hp_register(asus->hotplug_slot, bus, 0, "asus-wifi");
if (ret) {
pr_err("Unable to register hotplug slot - %d\n", ret);
goto error_register;
@@ -592,12 +555,12 @@ static int eeepc_setup_pci_hotplug(struct eeepc_wmi *eeepc)
return 0;
error_register:
- kfree(eeepc->hotplug_slot->info);
+ kfree(asus->hotplug_slot->info);
error_info:
- kfree(eeepc->hotplug_slot);
- eeepc->hotplug_slot = NULL;
+ kfree(asus->hotplug_slot);
+ asus->hotplug_slot = NULL;
error_slot:
- destroy_workqueue(eeepc->hotplug_workqueue);
+ destroy_workqueue(asus->hotplug_workqueue);
error_workqueue:
return ret;
}
@@ -605,13 +568,13 @@ error_workqueue:
/*
* Rfkill devices
*/
-static int eeepc_rfkill_set(void *data, bool blocked)
+static int asus_rfkill_set(void *data, bool blocked)
{
int dev_id = (unsigned long)data;
u32 ctrl_param = !blocked;
acpi_status status;
- status = eeepc_wmi_set_devstate(dev_id, ctrl_param, NULL);
+ status = asus_wmi_set_devstate(dev_id, ctrl_param, NULL);
if (ACPI_FAILURE(status))
return -EIO;
@@ -619,68 +582,67 @@ static int eeepc_rfkill_set(void *data, bool blocked)
return 0;
}
-static void eeepc_rfkill_query(struct rfkill *rfkill, void *data)
+static void asus_rfkill_query(struct rfkill *rfkill, void *data)
{
int dev_id = (unsigned long)data;
int result;
- result = eeepc_wmi_get_devstate_simple(dev_id);
+ result = asus_wmi_get_devstate_simple(dev_id);
if (result < 0)
- return ;
+ return;
rfkill_set_sw_state(rfkill, !result);
}
-static int eeepc_rfkill_wlan_set(void *data, bool blocked)
+static int asus_rfkill_wlan_set(void *data, bool blocked)
{
- struct eeepc_wmi *eeepc = data;
+ struct asus_wmi *asus = data;
int ret;
/*
* This handler is enabled only if hotplug is enabled.
- * In this case, the eeepc_wmi_set_devstate() will
+ * In this case, the asus_wmi_set_devstate() will
* trigger a wmi notification and we need to wait
* this call to finish before being able to call
* any wmi method
*/
- mutex_lock(&eeepc->wmi_lock);
- ret = eeepc_rfkill_set((void *)(long)EEEPC_WMI_DEVID_WLAN, blocked);
- mutex_unlock(&eeepc->wmi_lock);
+ mutex_lock(&asus->wmi_lock);
+ ret = asus_rfkill_set((void *)(long)ASUS_WMI_DEVID_WLAN, blocked);
+ mutex_unlock(&asus->wmi_lock);
return ret;
}
-static void eeepc_rfkill_wlan_query(struct rfkill *rfkill, void *data)
+static void asus_rfkill_wlan_query(struct rfkill *rfkill, void *data)
{
- eeepc_rfkill_query(rfkill, (void *)(long)EEEPC_WMI_DEVID_WLAN);
+ asus_rfkill_query(rfkill, (void *)(long)ASUS_WMI_DEVID_WLAN);
}
-static const struct rfkill_ops eeepc_rfkill_wlan_ops = {
- .set_block = eeepc_rfkill_wlan_set,
- .query = eeepc_rfkill_wlan_query,
+static const struct rfkill_ops asus_rfkill_wlan_ops = {
+ .set_block = asus_rfkill_wlan_set,
+ .query = asus_rfkill_wlan_query,
};
-static const struct rfkill_ops eeepc_rfkill_ops = {
- .set_block = eeepc_rfkill_set,
- .query = eeepc_rfkill_query,
+static const struct rfkill_ops asus_rfkill_ops = {
+ .set_block = asus_rfkill_set,
+ .query = asus_rfkill_query,
};
-static int eeepc_new_rfkill(struct eeepc_wmi *eeepc,
- struct rfkill **rfkill,
- const char *name,
- enum rfkill_type type, int dev_id)
+static int asus_new_rfkill(struct asus_wmi *asus,
+ struct rfkill **rfkill,
+ const char *name, enum rfkill_type type, int dev_id)
{
- int result = eeepc_wmi_get_devstate_simple(dev_id);
+ int result = asus_wmi_get_devstate_simple(dev_id);
if (result < 0)
return result;
- if (dev_id == EEEPC_WMI_DEVID_WLAN && eeepc->hotplug_wireless)
- *rfkill = rfkill_alloc(name, &eeepc->platform_device->dev, type,
- &eeepc_rfkill_wlan_ops, eeepc);
+ if (dev_id == ASUS_WMI_DEVID_WLAN && asus->driver->hotplug_wireless)
+ *rfkill = rfkill_alloc(name, &asus->platform_device->dev, type,
+ &asus_rfkill_wlan_ops, asus);
else
- *rfkill = rfkill_alloc(name, &eeepc->platform_device->dev, type,
- &eeepc_rfkill_ops, (void *)(long)dev_id);
+ *rfkill = rfkill_alloc(name, &asus->platform_device->dev, type,
+ &asus_rfkill_ops, (void *)(long)dev_id);
if (!*rfkill)
return -EINVAL;
@@ -695,82 +657,82 @@ static int eeepc_new_rfkill(struct eeepc_wmi *eeepc,
return 0;
}
-static void eeepc_wmi_rfkill_exit(struct eeepc_wmi *eeepc)
+static void asus_wmi_rfkill_exit(struct asus_wmi *asus)
{
- eeepc_unregister_rfkill_notifier(eeepc, "\\_SB.PCI0.P0P5");
- eeepc_unregister_rfkill_notifier(eeepc, "\\_SB.PCI0.P0P6");
- eeepc_unregister_rfkill_notifier(eeepc, "\\_SB.PCI0.P0P7");
- if (eeepc->wlan_rfkill) {
- rfkill_unregister(eeepc->wlan_rfkill);
- rfkill_destroy(eeepc->wlan_rfkill);
- eeepc->wlan_rfkill = NULL;
+ asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P5");
+ asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P6");
+ asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P7");
+ if (asus->wlan_rfkill) {
+ rfkill_unregister(asus->wlan_rfkill);
+ rfkill_destroy(asus->wlan_rfkill);
+ asus->wlan_rfkill = NULL;
}
/*
* Refresh pci hotplug in case the rfkill state was changed after
- * eeepc_unregister_rfkill_notifier()
+ * asus_unregister_rfkill_notifier()
*/
- eeepc_rfkill_hotplug(eeepc);
- if (eeepc->hotplug_slot)
- pci_hp_deregister(eeepc->hotplug_slot);
- if (eeepc->hotplug_workqueue)
- destroy_workqueue(eeepc->hotplug_workqueue);
-
- if (eeepc->bluetooth_rfkill) {
- rfkill_unregister(eeepc->bluetooth_rfkill);
- rfkill_destroy(eeepc->bluetooth_rfkill);
- eeepc->bluetooth_rfkill = NULL;
+ asus_rfkill_hotplug(asus);
+ if (asus->hotplug_slot)
+ pci_hp_deregister(asus->hotplug_slot);
+ if (asus->hotplug_workqueue)
+ destroy_workqueue(asus->hotplug_workqueue);
+
+ if (asus->bluetooth_rfkill) {
+ rfkill_unregister(asus->bluetooth_rfkill);
+ rfkill_destroy(asus->bluetooth_rfkill);
+ asus->bluetooth_rfkill = NULL;
}
- if (eeepc->wimax_rfkill) {
- rfkill_unregister(eeepc->wimax_rfkill);
- rfkill_destroy(eeepc->wimax_rfkill);
- eeepc->wimax_rfkill = NULL;
+ if (asus->wimax_rfkill) {
+ rfkill_unregister(asus->wimax_rfkill);
+ rfkill_destroy(asus->wimax_rfkill);
+ asus->wimax_rfkill = NULL;
}
- if (eeepc->wwan3g_rfkill) {
- rfkill_unregister(eeepc->wwan3g_rfkill);
- rfkill_destroy(eeepc->wwan3g_rfkill);
- eeepc->wwan3g_rfkill = NULL;
+ if (asus->wwan3g_rfkill) {
+ rfkill_unregister(asus->wwan3g_rfkill);
+ rfkill_destroy(asus->wwan3g_rfkill);
+ asus->wwan3g_rfkill = NULL;
}
}
-static int eeepc_wmi_rfkill_init(struct eeepc_wmi *eeepc)
+static int asus_wmi_rfkill_init(struct asus_wmi *asus)
{
int result = 0;
- mutex_init(&eeepc->hotplug_lock);
- mutex_init(&eeepc->wmi_lock);
+ mutex_init(&asus->hotplug_lock);
+ mutex_init(&asus->wmi_lock);
- result = eeepc_new_rfkill(eeepc, &eeepc->wlan_rfkill,
- "eeepc-wlan", RFKILL_TYPE_WLAN,
- EEEPC_WMI_DEVID_WLAN);
+ result = asus_new_rfkill(asus, &asus->wlan_rfkill,
+ "asus-wlan", RFKILL_TYPE_WLAN,
+ ASUS_WMI_DEVID_WLAN);
if (result && result != -ENODEV)
goto exit;
- result = eeepc_new_rfkill(eeepc, &eeepc->bluetooth_rfkill,
- "eeepc-bluetooth", RFKILL_TYPE_BLUETOOTH,
- EEEPC_WMI_DEVID_BLUETOOTH);
+ result = asus_new_rfkill(asus, &asus->bluetooth_rfkill,
+ "asus-bluetooth", RFKILL_TYPE_BLUETOOTH,
+ ASUS_WMI_DEVID_BLUETOOTH);
if (result && result != -ENODEV)
goto exit;
- result = eeepc_new_rfkill(eeepc, &eeepc->wimax_rfkill,
- "eeepc-wimax", RFKILL_TYPE_WIMAX,
- EEEPC_WMI_DEVID_WIMAX);
+ result = asus_new_rfkill(asus, &asus->wimax_rfkill,
+ "asus-wimax", RFKILL_TYPE_WIMAX,
+ ASUS_WMI_DEVID_WIMAX);
if (result && result != -ENODEV)
goto exit;
- result = eeepc_new_rfkill(eeepc, &eeepc->wwan3g_rfkill,
- "eeepc-wwan3g", RFKILL_TYPE_WWAN,
- EEEPC_WMI_DEVID_WWAN3G);
+ result = asus_new_rfkill(asus, &asus->wwan3g_rfkill,
+ "asus-wwan3g", RFKILL_TYPE_WWAN,
+ ASUS_WMI_DEVID_WWAN3G);
if (result && result != -ENODEV)
goto exit;
- if (!eeepc->hotplug_wireless)
+ if (!asus->driver->hotplug_wireless)
goto exit;
- result = eeepc_setup_pci_hotplug(eeepc);
+ result = asus_setup_pci_hotplug(asus);
/*
* If we get -EBUSY then something else is handling the PCI hotplug -
* don't fail in this case
@@ -778,18 +740,18 @@ static int eeepc_wmi_rfkill_init(struct eeepc_wmi *eeepc)
if (result == -EBUSY)
result = 0;
- eeepc_register_rfkill_notifier(eeepc, "\\_SB.PCI0.P0P5");
- eeepc_register_rfkill_notifier(eeepc, "\\_SB.PCI0.P0P6");
- eeepc_register_rfkill_notifier(eeepc, "\\_SB.PCI0.P0P7");
+ asus_register_rfkill_notifier(asus, "\\_SB.PCI0.P0P5");
+ asus_register_rfkill_notifier(asus, "\\_SB.PCI0.P0P6");
+ asus_register_rfkill_notifier(asus, "\\_SB.PCI0.P0P7");
/*
* Refresh pci hotplug in case the rfkill state was changed during
* setup.
*/
- eeepc_rfkill_hotplug(eeepc);
+ asus_rfkill_hotplug(asus);
exit:
if (result && result != -ENODEV)
- eeepc_wmi_rfkill_exit(eeepc);
+ asus_wmi_rfkill_exit(asus);
if (result == -ENODEV)
result = 0;
@@ -802,7 +764,7 @@ exit:
*/
static int read_backlight_power(void)
{
- int ret = eeepc_wmi_get_devstate_simple(EEEPC_WMI_DEVID_BACKLIGHT);
+ int ret = asus_wmi_get_devstate_simple(ASUS_WMI_DEVID_BACKLIGHT);
if (ret < 0)
return ret;
@@ -815,12 +777,12 @@ static int read_brightness(struct backlight_device *bd)
u32 retval;
acpi_status status;
- status = eeepc_wmi_get_devstate(EEEPC_WMI_DEVID_BRIGHTNESS, &retval);
+ status = asus_wmi_get_devstate(ASUS_WMI_DEVID_BRIGHTNESS, &retval);
if (ACPI_FAILURE(status))
return -EIO;
else
- return retval & EEEPC_WMI_DSTS_BRIGHTNESS_MASK;
+ return retval & ASUS_WMI_DSTS_BRIGHTNESS_MASK;
}
static int update_bl_status(struct backlight_device *bd)
@@ -831,8 +793,8 @@ static int update_bl_status(struct backlight_device *bd)
ctrl_param = bd->props.brightness;
- status = eeepc_wmi_set_devstate(EEEPC_WMI_DEVID_BRIGHTNESS,
- ctrl_param, NULL);
+ status = asus_wmi_set_devstate(ASUS_WMI_DEVID_BRIGHTNESS,
+ ctrl_param, NULL);
if (ACPI_FAILURE(status))
return -EIO;
@@ -840,8 +802,8 @@ static int update_bl_status(struct backlight_device *bd)
power = read_backlight_power();
if (power != -ENODEV && bd->props.power != power) {
ctrl_param = !!(bd->props.power == FB_BLANK_UNBLANK);
- status = eeepc_wmi_set_devstate(EEEPC_WMI_DEVID_BACKLIGHT,
- ctrl_param, NULL);
+ status = asus_wmi_set_devstate(ASUS_WMI_DEVID_BACKLIGHT,
+ ctrl_param, NULL);
if (ACPI_FAILURE(status))
return -EIO;
@@ -849,14 +811,14 @@ static int update_bl_status(struct backlight_device *bd)
return 0;
}
-static const struct backlight_ops eeepc_wmi_bl_ops = {
+static const struct backlight_ops asus_wmi_bl_ops = {
.get_brightness = read_brightness,
.update_status = update_bl_status,
};
-static int eeepc_wmi_backlight_notify(struct eeepc_wmi *eeepc, int code)
+static int asus_wmi_backlight_notify(struct asus_wmi *asus, int code)
{
- struct backlight_device *bd = eeepc->backlight_device;
+ struct backlight_device *bd = asus->backlight_device;
int old = bd->props.brightness;
int new = old;
@@ -872,15 +834,15 @@ static int eeepc_wmi_backlight_notify(struct eeepc_wmi *eeepc, int code)
return old;
}
-static int eeepc_wmi_backlight_init(struct eeepc_wmi *eeepc)
+static int asus_wmi_backlight_init(struct asus_wmi *asus)
{
struct backlight_device *bd;
struct backlight_properties props;
int max;
int power;
- max = eeepc_wmi_get_devstate_bits(EEEPC_WMI_DEVID_BRIGHTNESS,
- EEEPC_WMI_DSTS_MAX_BRIGTH_MASK);
+ max = asus_wmi_get_devstate_bits(ASUS_WMI_DEVID_BRIGHTNESS,
+ ASUS_WMI_DSTS_MAX_BRIGTH_MASK);
power = read_backlight_power();
if (max < 0 && power < 0) {
@@ -899,15 +861,15 @@ static int eeepc_wmi_backlight_init(struct eeepc_wmi *eeepc)
memset(&props, 0, sizeof(struct backlight_properties));
props.max_brightness = max;
- bd = backlight_device_register(EEEPC_WMI_FILE,
- &eeepc->platform_device->dev, eeepc,
- &eeepc_wmi_bl_ops, &props);
+ bd = backlight_device_register(asus->driver->name,
+ &asus->platform_device->dev, asus,
+ &asus_wmi_bl_ops, &props);
if (IS_ERR(bd)) {
pr_err("Could not register backlight device\n");
return PTR_ERR(bd);
}
- eeepc->backlight_device = bd;
+ asus->backlight_device = bd;
bd->props.brightness = read_brightness(bd);
bd->props.power = power;
@@ -916,17 +878,17 @@ static int eeepc_wmi_backlight_init(struct eeepc_wmi *eeepc)
return 0;
}
-static void eeepc_wmi_backlight_exit(struct eeepc_wmi *eeepc)
+static void asus_wmi_backlight_exit(struct asus_wmi *asus)
{
- if (eeepc->backlight_device)
- backlight_device_unregister(eeepc->backlight_device);
+ if (asus->backlight_device)
+ backlight_device_unregister(asus->backlight_device);
- eeepc->backlight_device = NULL;
+ asus->backlight_device = NULL;
}
-static void eeepc_wmi_notify(u32 value, void *context)
+static void asus_wmi_notify(u32 value, void *context)
{
- struct eeepc_wmi *eeepc = context;
+ struct asus_wmi *asus = context;
struct acpi_buffer response = { ACPI_ALLOCATE_BUFFER, NULL };
union acpi_object *obj;
acpi_status status;
@@ -953,11 +915,10 @@ static void eeepc_wmi_notify(u32 value, void *context)
if (code == NOTIFY_BRNUP_MIN || code == NOTIFY_BRNDOWN_MIN) {
if (!acpi_video_backlight_support())
- eeepc_wmi_backlight_notify(eeepc, orig_code);
+ asus_wmi_backlight_notify(asus, orig_code);
}
- if (!sparse_keymap_report_event(eeepc->inputdev,
- code, 1, true))
+ if (!sparse_keymap_report_event(asus->inputdev, code, 1, true))
pr_info("Unknown key %x pressed\n", code);
}
@@ -982,12 +943,12 @@ static ssize_t store_sys_wmi(int devid, const char *buf, size_t count)
u32 retval;
int rv, value;
- value = eeepc_wmi_get_devstate_simple(devid);
- if (value == -ENODEV) /* Check device presence */
+ value = asus_wmi_get_devstate_simple(devid);
+ if (value == -ENODEV) /* Check device presence */
return value;
rv = parse_arg(buf, count, &value);
- status = eeepc_wmi_set_devstate(devid, value, &retval);
+ status = asus_wmi_set_devstate(devid, value, &retval);
if (ACPI_FAILURE(status))
return -EIO;
@@ -996,7 +957,7 @@ static ssize_t store_sys_wmi(int devid, const char *buf, size_t count)
static ssize_t show_sys_wmi(int devid, char *buf)
{
- int value = eeepc_wmi_get_devstate_simple(devid);
+ int value = asus_wmi_get_devstate_simple(devid);
if (value < 0)
return value;
@@ -1004,7 +965,7 @@ static ssize_t show_sys_wmi(int devid, char *buf)
return sprintf(buf, "%d\n", value);
}
-#define EEEPC_WMI_CREATE_DEVICE_ATTR(_name, _mode, _cm) \
+#define ASUS_WMI_CREATE_DEVICE_ATTR(_name, _mode, _cm) \
static ssize_t show_##_name(struct device *dev, \
struct device_attribute *attr, \
char *buf) \
@@ -1025,15 +986,15 @@ static ssize_t show_sys_wmi(int devid, char *buf)
.store = store_##_name, \
}
-EEEPC_WMI_CREATE_DEVICE_ATTR(touchpad, 0644, EEEPC_WMI_DEVID_TOUCHPAD);
-EEEPC_WMI_CREATE_DEVICE_ATTR(camera, 0644, EEEPC_WMI_DEVID_CAMERA);
-EEEPC_WMI_CREATE_DEVICE_ATTR(cardr, 0644, EEEPC_WMI_DEVID_CARDREADER);
+ASUS_WMI_CREATE_DEVICE_ATTR(touchpad, 0644, ASUS_WMI_DEVID_TOUCHPAD);
+ASUS_WMI_CREATE_DEVICE_ATTR(camera, 0644, ASUS_WMI_DEVID_CAMERA);
+ASUS_WMI_CREATE_DEVICE_ATTR(cardr, 0644, ASUS_WMI_DEVID_CARDREADER);
static ssize_t store_cpufv(struct device *dev, struct device_attribute *attr,
const char *buf, size_t count)
{
int value;
- struct acpi_buffer input = { (acpi_size)sizeof(value), &value };
+ struct acpi_buffer input = { (acpi_size) sizeof(value), &value };
acpi_status status;
if (!count || sscanf(buf, "%i", &value) != 1)
@@ -1041,8 +1002,8 @@ static ssize_t store_cpufv(struct device *dev, struct device_attribute *attr,
if (value < 0 || value > 2)
return -EINVAL;
- status = wmi_evaluate_method(EEEPC_WMI_MGMT_GUID,
- 1, EEEPC_WMI_METHODID_CFVS, &input, NULL);
+ status = wmi_evaluate_method(ASUS_WMI_MGMT_GUID,
+ 1, ASUS_WMI_METHODID_CFVS, &input, NULL);
if (ACPI_FAILURE(status))
return -EIO;
@@ -1060,37 +1021,36 @@ static struct attribute *platform_attributes[] = {
NULL
};
-static mode_t eeepc_sysfs_is_visible(struct kobject *kobj,
- struct attribute *attr,
- int idx)
+static mode_t asus_sysfs_is_visible(struct kobject *kobj,
+ struct attribute *attr, int idx)
{
bool supported = true;
int devid = -1;
if (attr == &dev_attr_camera.attr)
- devid = EEEPC_WMI_DEVID_CAMERA;
+ devid = ASUS_WMI_DEVID_CAMERA;
else if (attr == &dev_attr_cardr.attr)
- devid = EEEPC_WMI_DEVID_CARDREADER;
+ devid = ASUS_WMI_DEVID_CARDREADER;
else if (attr == &dev_attr_touchpad.attr)
- devid = EEEPC_WMI_DEVID_TOUCHPAD;
+ devid = ASUS_WMI_DEVID_TOUCHPAD;
if (devid != -1)
- supported = eeepc_wmi_get_devstate_simple(devid) != -ENODEV;
+ supported = asus_wmi_get_devstate_simple(devid) != -ENODEV;
return supported ? attr->mode : 0;
}
static struct attribute_group platform_attribute_group = {
- .is_visible = eeepc_sysfs_is_visible,
- .attrs = platform_attributes
+ .is_visible = asus_sysfs_is_visible,
+ .attrs = platform_attributes
};
-static void eeepc_wmi_sysfs_exit(struct platform_device *device)
+static void asus_wmi_sysfs_exit(struct platform_device *device)
{
sysfs_remove_group(&device->dev.kobj, &platform_attribute_group);
}
-static int eeepc_wmi_sysfs_init(struct platform_device *device)
+static int asus_wmi_sysfs_init(struct platform_device *device)
{
return sysfs_create_group(&device->dev.kobj, &platform_attribute_group);
}
@@ -1098,111 +1058,111 @@ static int eeepc_wmi_sysfs_init(struct platform_device *device)
/*
* Platform device
*/
-static int __init eeepc_wmi_platform_init(struct eeepc_wmi *eeepc)
+static int __init asus_wmi_platform_init(struct asus_wmi *asus)
{
- return eeepc_wmi_sysfs_init(eeepc->platform_device);
+ return asus_wmi_sysfs_init(asus->platform_device);
}
-static void eeepc_wmi_platform_exit(struct eeepc_wmi *eeepc)
+static void asus_wmi_platform_exit(struct asus_wmi *asus)
{
- eeepc_wmi_sysfs_exit(eeepc->platform_device);
+ asus_wmi_sysfs_exit(asus->platform_device);
}
/*
* debugfs
*/
-struct eeepc_wmi_debugfs_node {
- struct eeepc_wmi *eeepc;
+struct asus_wmi_debugfs_node {
+ struct asus_wmi *asus;
char *name;
- int (*show)(struct seq_file *m, void *data);
+ int (*show) (struct seq_file *m, void *data);
};
static int show_dsts(struct seq_file *m, void *data)
{
- struct eeepc_wmi *eeepc = m->private;
+ struct asus_wmi *asus = m->private;
acpi_status status;
u32 retval = -1;
- status = eeepc_wmi_get_devstate(eeepc->debug.dev_id, &retval);
+ status = asus_wmi_get_devstate(asus->debug.dev_id, &retval);
if (ACPI_FAILURE(status))
return -EIO;
- seq_printf(m, "DSTS(%x) = %x\n", eeepc->debug.dev_id, retval);
+ seq_printf(m, "DSTS(%x) = %x\n", asus->debug.dev_id, retval);
return 0;
}
static int show_devs(struct seq_file *m, void *data)
{
- struct eeepc_wmi *eeepc = m->private;
+ struct asus_wmi *asus = m->private;
acpi_status status;
u32 retval = -1;
- status = eeepc_wmi_set_devstate(eeepc->debug.dev_id,
- eeepc->debug.ctrl_param, &retval);
+ status = asus_wmi_set_devstate(asus->debug.dev_id,
+ asus->debug.ctrl_param, &retval);
if (ACPI_FAILURE(status))
return -EIO;
- seq_printf(m, "DEVS(%x, %x) = %x\n", eeepc->debug.dev_id,
- eeepc->debug.ctrl_param, retval);
+ seq_printf(m, "DEVS(%x, %x) = %x\n", asus->debug.dev_id,
+ asus->debug.ctrl_param, retval);
return 0;
}
-static struct eeepc_wmi_debugfs_node eeepc_wmi_debug_files[] = {
- { NULL, "devs", show_devs },
- { NULL, "dsts", show_dsts },
+static struct asus_wmi_debugfs_node asus_wmi_debug_files[] = {
+ {NULL, "devs", show_devs},
+ {NULL, "dsts", show_dsts},
};
-static int eeepc_wmi_debugfs_open(struct inode *inode, struct file *file)
+static int asus_wmi_debugfs_open(struct inode *inode, struct file *file)
{
- struct eeepc_wmi_debugfs_node *node = inode->i_private;
+ struct asus_wmi_debugfs_node *node = inode->i_private;
- return single_open(file, node->show, node->eeepc);
+ return single_open(file, node->show, node->asus);
}
-static const struct file_operations eeepc_wmi_debugfs_io_ops = {
+static const struct file_operations asus_wmi_debugfs_io_ops = {
.owner = THIS_MODULE,
- .open = eeepc_wmi_debugfs_open,
+ .open = asus_wmi_debugfs_open,
.read = seq_read,
.llseek = seq_lseek,
.release = single_release,
};
-static void eeepc_wmi_debugfs_exit(struct eeepc_wmi *eeepc)
+static void asus_wmi_debugfs_exit(struct asus_wmi *asus)
{
- debugfs_remove_recursive(eeepc->debug.root);
+ debugfs_remove_recursive(asus->debug.root);
}
-static int eeepc_wmi_debugfs_init(struct eeepc_wmi *eeepc)
+static int asus_wmi_debugfs_init(struct asus_wmi *asus)
{
struct dentry *dent;
int i;
- eeepc->debug.root = debugfs_create_dir(EEEPC_WMI_FILE, NULL);
- if (!eeepc->debug.root) {
+ asus->debug.root = debugfs_create_dir(asus->driver->name, NULL);
+ if (!asus->debug.root) {
pr_err("failed to create debugfs directory");
goto error_debugfs;
}
- dent = debugfs_create_x32("dev_id", S_IRUGO|S_IWUSR,
- eeepc->debug.root, &eeepc->debug.dev_id);
+ dent = debugfs_create_x32("dev_id", S_IRUGO | S_IWUSR,
+ asus->debug.root, &asus->debug.dev_id);
if (!dent)
goto error_debugfs;
- dent = debugfs_create_x32("ctrl_param", S_IRUGO|S_IWUSR,
- eeepc->debug.root, &eeepc->debug.ctrl_param);
+ dent = debugfs_create_x32("ctrl_param", S_IRUGO | S_IWUSR,
+ asus->debug.root, &asus->debug.ctrl_param);
if (!dent)
goto error_debugfs;
- for (i = 0; i < ARRAY_SIZE(eeepc_wmi_debug_files); i++) {
- struct eeepc_wmi_debugfs_node *node = &eeepc_wmi_debug_files[i];
+ for (i = 0; i < ARRAY_SIZE(asus_wmi_debug_files); i++) {
+ struct asus_wmi_debugfs_node *node = &asus_wmi_debug_files[i];
- node->eeepc = eeepc;
+ node->asus = asus;
dent = debugfs_create_file(node->name, S_IFREG | S_IRUGO,
- eeepc->debug.root, node,
- &eeepc_wmi_debugfs_io_ops);
+ asus->debug.root, node,
+ &asus_wmi_debugfs_io_ops);
if (!dent) {
pr_err("failed to create debug file: %s\n", node->name);
goto error_debugfs;
@@ -1212,131 +1172,112 @@ static int eeepc_wmi_debugfs_init(struct eeepc_wmi *eeepc)
return 0;
error_debugfs:
- eeepc_wmi_debugfs_exit(eeepc);
+ asus_wmi_debugfs_exit(asus);
return -ENOMEM;
}
/*
* WMI Driver
*/
-static void eeepc_dmi_check(struct eeepc_wmi *eeepc)
+static int asus_wmi_add(struct platform_device *pdev)
{
- const char *model;
-
- model = dmi_get_system_info(DMI_PRODUCT_NAME);
- if (!model)
- return;
-
- /*
- * Whitelist for wlan hotplug
- *
- * Eeepc 1000H needs the current hotplug code to handle
- * Fn+F2 correctly. We may add other Eeepc here later, but
- * it seems that most of the laptops supported by eeepc-wmi
- * don't need to be on this list
- */
- if (strcmp(model, "1000H") == 0) {
- eeepc->hotplug_wireless = true;
- pr_info("wlan hotplug enabled\n");
- }
-}
-
-static int __init eeepc_wmi_add(struct platform_device *pdev)
-{
- struct eeepc_wmi *eeepc;
+ struct platform_driver *pdrv = to_platform_driver(pdev->dev.driver);
+ struct asus_wmi_driver *wdrv = to_asus_wmi_driver(pdrv);
+ struct asus_wmi *asus;
acpi_status status;
int err;
- eeepc = kzalloc(sizeof(struct eeepc_wmi), GFP_KERNEL);
- if (!eeepc)
+ asus = kzalloc(sizeof(struct asus_wmi), GFP_KERNEL);
+ if (!asus)
return -ENOMEM;
- eeepc->platform_device = pdev;
- platform_set_drvdata(eeepc->platform_device, eeepc);
+ asus->driver = wdrv;
+ asus->platform_device = pdev;
+ wdrv->platform_device = pdev;
+ platform_set_drvdata(asus->platform_device, asus);
- eeepc->hotplug_wireless = hotplug_wireless;
- eeepc_dmi_check(eeepc);
+ if (wdrv->quirks)
+ wdrv->quirks(asus->driver);
- err = eeepc_wmi_platform_init(eeepc);
+ err = asus_wmi_platform_init(asus);
if (err)
goto fail_platform;
- err = eeepc_wmi_input_init(eeepc);
+ err = asus_wmi_input_init(asus);
if (err)
goto fail_input;
- err = eeepc_wmi_led_init(eeepc);
+ err = asus_wmi_led_init(asus);
if (err)
goto fail_leds;
- err = eeepc_wmi_rfkill_init(eeepc);
+ err = asus_wmi_rfkill_init(asus);
if (err)
goto fail_rfkill;
if (!acpi_video_backlight_support()) {
- err = eeepc_wmi_backlight_init(eeepc);
+ err = asus_wmi_backlight_init(asus);
if (err && err != -ENODEV)
goto fail_backlight;
} else
pr_info("Backlight controlled by ACPI video driver\n");
- status = wmi_install_notify_handler(EEEPC_WMI_EVENT_GUID,
- eeepc_wmi_notify, eeepc);
+ status = wmi_install_notify_handler(asus->driver->event_guid,
+ asus_wmi_notify, asus);
if (ACPI_FAILURE(status)) {
- pr_err("Unable to register notify handler - %d\n",
- status);
+ pr_err("Unable to register notify handler - %d\n", status);
err = -ENODEV;
goto fail_wmi_handler;
}
- err = eeepc_wmi_debugfs_init(eeepc);
+ err = asus_wmi_debugfs_init(asus);
if (err)
goto fail_debugfs;
return 0;
fail_debugfs:
- wmi_remove_notify_handler(EEEPC_WMI_EVENT_GUID);
+ wmi_remove_notify_handler(asus->driver->event_guid);
fail_wmi_handler:
- eeepc_wmi_backlight_exit(eeepc);
+ asus_wmi_backlight_exit(asus);
fail_backlight:
- eeepc_wmi_rfkill_exit(eeepc);
+ asus_wmi_rfkill_exit(asus);
fail_rfkill:
- eeepc_wmi_led_exit(eeepc);
+ asus_wmi_led_exit(asus);
fail_leds:
- eeepc_wmi_input_exit(eeepc);
+ asus_wmi_input_exit(asus);
fail_input:
- eeepc_wmi_platform_exit(eeepc);
+ asus_wmi_platform_exit(asus);
fail_platform:
- kfree(eeepc);
+ kfree(asus);
return err;
}
-static int __exit eeepc_wmi_remove(struct platform_device *device)
+static int asus_wmi_remove(struct platform_device *device)
{
- struct eeepc_wmi *eeepc;
-
- eeepc = platform_get_drvdata(device);
- wmi_remove_notify_handler(EEEPC_WMI_EVENT_GUID);
- eeepc_wmi_backlight_exit(eeepc);
- eeepc_wmi_input_exit(eeepc);
- eeepc_wmi_led_exit(eeepc);
- eeepc_wmi_rfkill_exit(eeepc);
- eeepc_wmi_debugfs_exit(eeepc);
- eeepc_wmi_platform_exit(eeepc);
-
- kfree(eeepc);
+ struct asus_wmi *asus;
+
+ asus = platform_get_drvdata(device);
+ wmi_remove_notify_handler(asus->driver->event_guid);
+ asus_wmi_backlight_exit(asus);
+ asus_wmi_input_exit(asus);
+ asus_wmi_led_exit(asus);
+ asus_wmi_rfkill_exit(asus);
+ asus_wmi_debugfs_exit(asus);
+ asus_wmi_platform_exit(asus);
+
+ kfree(asus);
return 0;
}
/*
* Platform driver - hibernate/resume callbacks
*/
-static int eeepc_hotk_thaw(struct device *device)
+static int asus_hotk_thaw(struct device *device)
{
- struct eeepc_wmi *eeepc = dev_get_drvdata(device);
+ struct asus_wmi *asus = dev_get_drvdata(device);
- if (eeepc->wlan_rfkill) {
+ if (asus->wlan_rfkill) {
bool wlan;
/*
@@ -1344,111 +1285,118 @@ static int eeepc_hotk_thaw(struct device *device)
* during suspend. Normally it restores it on resume, but
* we should kick it ourselves in case hibernation is aborted.
*/
- wlan = eeepc_wmi_get_devstate_simple(EEEPC_WMI_DEVID_WLAN);
- eeepc_wmi_set_devstate(EEEPC_WMI_DEVID_WLAN, wlan, NULL);
+ wlan = asus_wmi_get_devstate_simple(ASUS_WMI_DEVID_WLAN);
+ asus_wmi_set_devstate(ASUS_WMI_DEVID_WLAN, wlan, NULL);
}
return 0;
}
-static int eeepc_hotk_restore(struct device *device)
+static int asus_hotk_restore(struct device *device)
{
- struct eeepc_wmi *eeepc = dev_get_drvdata(device);
+ struct asus_wmi *asus = dev_get_drvdata(device);
int bl;
/* Refresh both wlan rfkill state and pci hotplug */
- if (eeepc->wlan_rfkill)
- eeepc_rfkill_hotplug(eeepc);
+ if (asus->wlan_rfkill)
+ asus_rfkill_hotplug(asus);
- if (eeepc->bluetooth_rfkill) {
- bl = !eeepc_wmi_get_devstate_simple(EEEPC_WMI_DEVID_BLUETOOTH);
- rfkill_set_sw_state(eeepc->bluetooth_rfkill, bl);
+ if (asus->bluetooth_rfkill) {
+ bl = !asus_wmi_get_devstate_simple(ASUS_WMI_DEVID_BLUETOOTH);
+ rfkill_set_sw_state(asus->bluetooth_rfkill, bl);
}
- if (eeepc->wimax_rfkill) {
- bl = !eeepc_wmi_get_devstate_simple(EEEPC_WMI_DEVID_WIMAX);
- rfkill_set_sw_state(eeepc->wimax_rfkill, bl);
+ if (asus->wimax_rfkill) {
+ bl = !asus_wmi_get_devstate_simple(ASUS_WMI_DEVID_WIMAX);
+ rfkill_set_sw_state(asus->wimax_rfkill, bl);
}
- if (eeepc->wwan3g_rfkill) {
- bl = !eeepc_wmi_get_devstate_simple(EEEPC_WMI_DEVID_WWAN3G);
- rfkill_set_sw_state(eeepc->wwan3g_rfkill, bl);
+ if (asus->wwan3g_rfkill) {
+ bl = !asus_wmi_get_devstate_simple(ASUS_WMI_DEVID_WWAN3G);
+ rfkill_set_sw_state(asus->wwan3g_rfkill, bl);
}
return 0;
}
-static const struct dev_pm_ops eeepc_pm_ops = {
- .thaw = eeepc_hotk_thaw,
- .restore = eeepc_hotk_restore,
-};
-
-static struct platform_driver platform_driver = {
- .remove = __exit_p(eeepc_wmi_remove),
- .driver = {
- .name = EEEPC_WMI_FILE,
- .owner = THIS_MODULE,
- .pm = &eeepc_pm_ops,
- },
+static const struct dev_pm_ops asus_pm_ops = {
+ .thaw = asus_hotk_thaw,
+ .restore = asus_hotk_restore,
};
-static acpi_status __init eeepc_wmi_parse_device(acpi_handle handle, u32 level,
- void *context, void **retval)
+static int asus_wmi_probe(struct platform_device *pdev)
{
- pr_warning("Found legacy ATKD device (%s)", EEEPC_ACPI_HID);
- *(bool *)context = true;
- return AE_CTRL_TERMINATE;
-}
-
-static int __init eeepc_wmi_check_atkd(void)
-{
- acpi_status status;
- bool found = false;
-
- status = acpi_get_devices(EEEPC_ACPI_HID, eeepc_wmi_parse_device,
- &found, NULL);
-
- if (ACPI_FAILURE(status) || !found)
- return 0;
- return -1;
-}
+ struct platform_driver *pdrv = to_platform_driver(pdev->dev.driver);
+ struct asus_wmi_driver *wdrv = to_asus_wmi_driver(pdrv);
+ int ret;
-static int __init eeepc_wmi_probe(struct platform_device *pdev)
-{
- if (!wmi_has_guid(EEEPC_WMI_EVENT_GUID) ||
- !wmi_has_guid(EEEPC_WMI_MGMT_GUID)) {
- pr_warning("No known WMI GUID found\n");
+ if (!wmi_has_guid(ASUS_WMI_MGMT_GUID)) {
+ pr_warning("Management GUID not found\n");
return -ENODEV;
}
- if (eeepc_wmi_check_atkd()) {
- pr_warning("WMI device present, but legacy ATKD device is also "
- "present and enabled.");
- pr_warning("You probably booted with acpi_osi=\"Linux\" or "
- "acpi_osi=\"!Windows 2009\"");
- pr_warning("Can't load eeepc-wmi, use default acpi_osi "
- "(preferred) or eeepc-laptop");
+ if (wdrv->event_guid && !wmi_has_guid(wdrv->event_guid)) {
+ pr_warning("Event GUID not found\n");
return -ENODEV;
}
- return eeepc_wmi_add(pdev);
+ if (wdrv->probe) {
+ ret = wdrv->probe(pdev);
+ if (ret)
+ return ret;
+ }
+
+ return asus_wmi_add(pdev);
}
-static struct platform_device *platform_device;
+static bool used;
-static int __init eeepc_wmi_init(void)
+int asus_wmi_register_driver(struct asus_wmi_driver *driver)
{
- platform_device = platform_create_bundle(&platform_driver,
- eeepc_wmi_probe,
+ struct platform_driver *platform_driver;
+ struct platform_device *platform_device;
+
+ if (used)
+ return -EBUSY;
+
+ platform_driver = &driver->platform_driver;
+ platform_driver->remove = asus_wmi_remove;
+ platform_driver->driver.owner = driver->owner;
+ platform_driver->driver.name = driver->name;
+ platform_driver->driver.pm = &asus_pm_ops;
+
+ platform_device = platform_create_bundle(platform_driver,
+ asus_wmi_probe,
NULL, 0, NULL, 0);
if (IS_ERR(platform_device))
return PTR_ERR(platform_device);
+
+ used = true;
+ return 0;
+}
+EXPORT_SYMBOL_GPL(asus_wmi_register_driver);
+
+void asus_wmi_unregister_driver(struct asus_wmi_driver *driver)
+{
+ platform_device_unregister(driver->platform_device);
+ platform_driver_unregister(&driver->platform_driver);
+ used = false;
+}
+EXPORT_SYMBOL_GPL(asus_wmi_unregister_driver);
+
+static int __init asus_wmi_init(void)
+{
+ if (!wmi_has_guid(ASUS_WMI_MGMT_GUID)) {
+ pr_info("Asus Management GUID not found");
+ return -ENODEV;
+ }
+
+ pr_info("ASUS WMI generic driver loaded");
return 0;
}
-static void __exit eeepc_wmi_exit(void)
+static void __exit asus_wmi_exit(void)
{
- platform_device_unregister(platform_device);
- platform_driver_unregister(&platform_driver);
+ pr_info("ASUS WMI generic driver unloaded");
}
-module_init(eeepc_wmi_init);
-module_exit(eeepc_wmi_exit);
+module_init(asus_wmi_init);
+module_exit(asus_wmi_exit);
diff --git a/drivers/platform/x86/asus-wmi.h b/drivers/platform/x86/asus-wmi.h
new file mode 100644
index 0000000..c044522
--- /dev/null
+++ b/drivers/platform/x86/asus-wmi.h
@@ -0,0 +1,58 @@
+/*
+ * Asus PC WMI hotkey driver
+ *
+ * Copyright(C) 2010 Intel Corporation.
+ * Copyright(C) 2010-2011 Corentin Chary <corentin.chary@gmail.com>
+ *
+ * Portions based on wistron_btns.c:
+ * Copyright (C) 2005 Miloslav Trmac <mitr@volny.cz>
+ * Copyright (C) 2005 Bernhard Rosenkraenzer <bero@arklinux.org>
+ * Copyright (C) 2005 Dmitry Torokhov <dtor@mail.ru>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#ifndef _ASUS_WMI_H_
+#define _ASUS_WMI_H_
+
+#include <linux/platform_device.h>
+
+struct module;
+struct key_entry;
+struct asus_wmi;
+
+struct asus_wmi_driver {
+ bool hotplug_wireless;
+
+ const char *name;
+ struct module *owner;
+
+ const char *event_guid;
+
+ const struct key_entry *keymap;
+ const char *input_name;
+ const char *input_phys;
+
+ int (*probe) (struct platform_device *device);
+ void (*quirks) (struct asus_wmi_driver *driver);
+
+ struct platform_driver platform_driver;
+ struct platform_device *platform_device;
+};
+
+int asus_wmi_register_driver(struct asus_wmi_driver *driver);
+void asus_wmi_unregister_driver(struct asus_wmi_driver *driver);
+
+#endif /* !_ASUS_WMI_H_ */
diff --git a/drivers/platform/x86/eeepc-wmi.c b/drivers/platform/x86/eeepc-wmi.c
new file mode 100644
index 0000000..3a060ae
--- /dev/null
+++ b/drivers/platform/x86/eeepc-wmi.c
@@ -0,0 +1,162 @@
+/*
+ * Eee PC WMI hotkey driver
+ *
+ * Copyright(C) 2010 Intel Corporation.
+ * Copyright(C) 2010 Corentin Chary <corentin.chary@gmail.com>
+ *
+ * Portions based on wistron_btns.c:
+ * Copyright (C) 2005 Miloslav Trmac <mitr@volny.cz>
+ * Copyright (C) 2005 Bernhard Rosenkraenzer <bero@arklinux.org>
+ * Copyright (C) 2005 Dmitry Torokhov <dtor@mail.ru>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/input.h>
+#include <linux/input/sparse-keymap.h>
+#include <linux/dmi.h>
+#include <acpi/acpi_bus.h>
+
+#include "asus-wmi.h"
+
+#define EEEPC_WMI_FILE "eeepc-wmi"
+
+MODULE_AUTHOR("Corentin Chary <corentincj@iksaif.net>");
+MODULE_DESCRIPTION("Eee PC WMI Hotkey Driver");
+MODULE_LICENSE("GPL");
+
+#define EEEPC_ACPI_HID "ASUS010" /* old _HID used in eeepc-laptop */
+
+#define EEEPC_WMI_EVENT_GUID "ABBC0F72-8EA1-11D1-00A0-C90629100000"
+
+MODULE_ALIAS("wmi:"EEEPC_WMI_EVENT_GUID);
+
+static bool hotplug_wireless;
+
+module_param(hotplug_wireless, bool, 0444);
+MODULE_PARM_DESC(hotplug_wireless,
+ "Enable hotplug for wireless device. "
+ "If your laptop needs that, please report to "
+ "acpi4asus-user@lists.sourceforge.net.");
+
+static const struct key_entry eeepc_wmi_keymap[] = {
+ /* Sleep already handled via generic ACPI code */
+ { KE_KEY, 0x30, { KEY_VOLUMEUP } },
+ { KE_KEY, 0x31, { KEY_VOLUMEDOWN } },
+ { KE_KEY, 0x32, { KEY_MUTE } },
+ { KE_KEY, 0x5c, { KEY_F15 } }, /* Power Gear key */
+ { KE_KEY, 0x5d, { KEY_WLAN } },
+ { KE_KEY, 0x6b, { KEY_F13 } }, /* Disable Touchpad */
+ { KE_KEY, 0x82, { KEY_CAMERA } },
+ { KE_KEY, 0x88, { KEY_WLAN } },
+ { KE_KEY, 0xcc, { KEY_SWITCHVIDEOMODE } },
+ { KE_KEY, 0xe0, { KEY_PROG1 } }, /* Task Manager */
+ { KE_KEY, 0xe1, { KEY_F14 } }, /* Change Resolution */
+ { KE_KEY, 0xe9, { KEY_BRIGHTNESS_ZERO } },
+ { KE_END, 0},
+};
+
+static acpi_status eeepc_wmi_parse_device(acpi_handle handle, u32 level,
+ void *context, void **retval)
+{
+ pr_warning("Found legacy ATKD device (%s)", EEEPC_ACPI_HID);
+ *(bool *)context = true;
+ return AE_CTRL_TERMINATE;
+}
+
+static int eeepc_wmi_check_atkd(void)
+{
+ acpi_status status;
+ bool found = false;
+
+ status = acpi_get_devices(EEEPC_ACPI_HID, eeepc_wmi_parse_device,
+ &found, NULL);
+
+ if (ACPI_FAILURE(status) || !found)
+ return 0;
+ return -1;
+}
+
+static int eeepc_wmi_probe(struct platform_device *pdev)
+{
+ if (eeepc_wmi_check_atkd()) {
+ pr_warning("WMI device present, but legacy ATKD device is also "
+ "present and enabled.");
+ pr_warning("You probably booted with acpi_osi=\"Linux\" or "
+ "acpi_osi=\"!Windows 2009\"");
+ pr_warning("Can't load eeepc-wmi, use default acpi_osi "
+ "(preferred) or eeepc-laptop");
+ return -EBUSY;
+ }
+ return 0;
+}
+
+static void eeepc_dmi_check(struct asus_wmi_driver *driver)
+{
+ const char *model;
+
+ model = dmi_get_system_info(DMI_PRODUCT_NAME);
+ if (!model)
+ return;
+
+ /*
+ * Whitelist for wlan hotplug
+ *
+ * Asus 1000H needs the current hotplug code to handle
+ * Fn+F2 correctly. We may add other Asus here later, but
+ * it seems that most of the laptops supported by asus-wmi
+ * don't need to be on this list
+ */
+ if (strcmp(model, "1000H") == 0) {
+ driver->hotplug_wireless = true;
+ pr_info("wlan hotplug enabled\n");
+ }
+}
+
+static void eeepc_wmi_quirks(struct asus_wmi_driver *driver)
+{
+ driver->hotplug_wireless = hotplug_wireless;
+ eeepc_dmi_check(driver);
+}
+
+static struct asus_wmi_driver asus_wmi_driver = {
+ .name = EEEPC_WMI_FILE,
+ .owner = THIS_MODULE,
+ .event_guid = EEEPC_WMI_EVENT_GUID,
+ .keymap = eeepc_wmi_keymap,
+ .input_name = "Eee PC WMI hotkeys",
+ .input_phys = EEEPC_WMI_FILE "/input0",
+ .probe = eeepc_wmi_probe,
+ .quirks = eeepc_wmi_quirks,
+};
+
+
+static int __init eeepc_wmi_init(void)
+{
+ return asus_wmi_register_driver(&asus_wmi_driver);
+}
+
+static void __exit eeepc_wmi_exit(void)
+{
+ asus_wmi_unregister_driver(&asus_wmi_driver);
+}
+
+module_init(eeepc_wmi_init);
+module_exit(eeepc_wmi_exit);
--
1.7.4
^ permalink raw reply [flat|nested] 16+ messages in thread* [PATCH 03/14] asus-wmi: minor cleanups
2011-02-26 9:20 [PATCH 00/14] Support Asus WMI capable Notebooks (asus-wmi, asus-nb-wmi and eeepc-wmi) Corentin Chary
2011-02-26 9:20 ` [PATCH 01/14] asus-wmi: move generic code to asus-wmi Corentin Chary
2011-02-26 9:20 ` [PATCH 02/14] eeepc-wmi: asus generic asus-wmi.ko module Corentin Chary
@ 2011-02-26 9:20 ` Corentin Chary
2011-02-26 9:20 ` [PATCH 04/14] asus-wmi: introduce struct asus_rfkill Corentin Chary
` (11 subsequent siblings)
14 siblings, 0 replies; 16+ messages in thread
From: Corentin Chary @ 2011-02-26 9:20 UTC (permalink / raw)
To: Matthew Garrett
Cc: Dmitry Torokhov, Corentin Chary, open list:ASUS NOTEBOOKS AN...,
open list:ASUS NOTEBOOKS AN...,
open list
Signed-off-by: Corentin Chary <corentincj@iksaif.net>
---
drivers/platform/x86/asus-wmi.c | 34 +++++++++++++++++-----------------
drivers/platform/x86/eeepc-wmi.c | 2 +-
2 files changed, 18 insertions(+), 18 deletions(-)
diff --git a/drivers/platform/x86/asus-wmi.c b/drivers/platform/x86/asus-wmi.c
index 35e6bb6..4c3f68a 100644
--- a/drivers/platform/x86/asus-wmi.c
+++ b/drivers/platform/x86/asus-wmi.c
@@ -2,7 +2,7 @@
* Asus PC WMI hotkey driver
*
* Copyright(C) 2010 Intel Corporation.
- * Copyright(C) 2010 Corentin Chary <corentin.chary@gmail.com>
+ * Copyright(C) 2010-2011 Corentin Chary <corentin.chary@gmail.com>
*
* Portions based on wistron_btns.c:
* Copyright (C) 2005 Miloslav Trmac <mitr@volny.cz>
@@ -87,7 +87,7 @@ MODULE_LICENSE("GPL");
#define ASUS_WMI_DEVID_CARDREADER 0x00080013
/* Input */
-#define ASUS_WMI_DEVID_TOUCHPAD 0x00100011
+#define ASUS_WMI_DEVID_TOUCHPAD 0x00100011
#define ASUS_WMI_DEVID_TOUCHPAD_LED 0x00100012
/* DSTS masks */
@@ -903,25 +903,25 @@ static void asus_wmi_notify(u32 value, void *context)
obj = (union acpi_object *)response.pointer;
- if (obj && obj->type == ACPI_TYPE_INTEGER) {
- code = obj->integer.value;
- orig_code = code;
+ if (!obj || obj->type != ACPI_TYPE_INTEGER)
+ goto exit;
- if (code >= NOTIFY_BRNUP_MIN && code <= NOTIFY_BRNUP_MAX)
- code = NOTIFY_BRNUP_MIN;
- else if (code >= NOTIFY_BRNDOWN_MIN &&
- code <= NOTIFY_BRNDOWN_MAX)
- code = NOTIFY_BRNDOWN_MIN;
+ code = obj->integer.value;
+ orig_code = code;
- if (code == NOTIFY_BRNUP_MIN || code == NOTIFY_BRNDOWN_MIN) {
- if (!acpi_video_backlight_support())
- asus_wmi_backlight_notify(asus, orig_code);
- }
+ if (code >= NOTIFY_BRNUP_MIN && code <= NOTIFY_BRNUP_MAX)
+ code = NOTIFY_BRNUP_MIN;
+ else if (code >= NOTIFY_BRNDOWN_MIN &&
+ code <= NOTIFY_BRNDOWN_MAX)
+ code = NOTIFY_BRNDOWN_MIN;
- if (!sparse_keymap_report_event(asus->inputdev, code, 1, true))
- pr_info("Unknown key %x pressed\n", code);
- }
+ if (code == NOTIFY_BRNUP_MIN || code == NOTIFY_BRNDOWN_MIN) {
+ if (!acpi_video_backlight_support())
+ asus_wmi_backlight_notify(asus, orig_code);
+ } else if (!sparse_keymap_report_event(asus->inputdev, code, 1, true))
+ pr_info("Unknown key %x pressed\n", code);
+exit:
kfree(obj);
}
diff --git a/drivers/platform/x86/eeepc-wmi.c b/drivers/platform/x86/eeepc-wmi.c
index 3a060ae..e69701f 100644
--- a/drivers/platform/x86/eeepc-wmi.c
+++ b/drivers/platform/x86/eeepc-wmi.c
@@ -2,7 +2,7 @@
* Eee PC WMI hotkey driver
*
* Copyright(C) 2010 Intel Corporation.
- * Copyright(C) 2010 Corentin Chary <corentin.chary@gmail.com>
+ * Copyright(C) 2010-2011 Corentin Chary <corentin.chary@gmail.com>
*
* Portions based on wistron_btns.c:
* Copyright (C) 2005 Miloslav Trmac <mitr@volny.cz>
--
1.7.4
^ permalink raw reply [flat|nested] 16+ messages in thread* [PATCH 04/14] asus-wmi: introduce struct asus_rfkill
2011-02-26 9:20 [PATCH 00/14] Support Asus WMI capable Notebooks (asus-wmi, asus-nb-wmi and eeepc-wmi) Corentin Chary
` (2 preceding siblings ...)
2011-02-26 9:20 ` [PATCH 03/14] asus-wmi: minor cleanups Corentin Chary
@ 2011-02-26 9:20 ` Corentin Chary
2011-02-26 9:20 ` [PATCH 05/14] asus-wmi: handle "unknown status" bit Corentin Chary
` (10 subsequent siblings)
14 siblings, 0 replies; 16+ messages in thread
From: Corentin Chary @ 2011-02-26 9:20 UTC (permalink / raw)
To: Matthew Garrett
Cc: Dmitry Torokhov, Corentin Chary, open list:ASUS NOTEBOOKS AN...,
open list:ASUS NOTEBOOKS AN...,
open list
First, this allow use to remove the custom asusrfkill_wlan_query,
but this will also allow us to give struct asus_wmi * to
get_devstate/set_devstate later.
Signed-off-by: Corentin Chary <corentincj@iksaif.net>
---
drivers/platform/x86/asus-wmi.c | 115 ++++++++++++++++++++-------------------
1 files changed, 59 insertions(+), 56 deletions(-)
diff --git a/drivers/platform/x86/asus-wmi.c b/drivers/platform/x86/asus-wmi.c
index 4c3f68a..d0f0931 100644
--- a/drivers/platform/x86/asus-wmi.c
+++ b/drivers/platform/x86/asus-wmi.c
@@ -114,6 +114,12 @@ struct asus_wmi_debug {
u32 ctrl_param;
};
+struct asus_rfkill {
+ struct asus_wmi *asus;
+ struct rfkill *rfkill;
+ u32 dev_id;
+};
+
struct asus_wmi {
struct input_dev *inputdev;
struct backlight_device *backlight_device;
@@ -124,10 +130,10 @@ struct asus_wmi {
struct workqueue_struct *led_workqueue;
struct work_struct tpd_led_work;
- struct rfkill *wlan_rfkill;
- struct rfkill *bluetooth_rfkill;
- struct rfkill *wimax_rfkill;
- struct rfkill *wwan3g_rfkill;
+ struct asus_rfkill wlan;
+ struct asus_rfkill bluetooth;
+ struct asus_rfkill wimax;
+ struct asus_rfkill wwan3g;
struct hotplug_slot *hotplug_slot;
struct mutex hotplug_lock;
@@ -377,8 +383,8 @@ static void asus_rfkill_hotplug(struct asus_wmi *asus)
mutex_lock(&asus->hotplug_lock);
- if (asus->wlan_rfkill)
- rfkill_set_sw_state(asus->wlan_rfkill, blocked);
+ if (asus->wlan.rfkill)
+ rfkill_set_sw_state(asus->wlan.rfkill, blocked);
if (asus->hotplug_slot) {
bus = pci_find_bus(0, 1);
@@ -570,11 +576,11 @@ error_workqueue:
*/
static int asus_rfkill_set(void *data, bool blocked)
{
- int dev_id = (unsigned long)data;
+ struct asus_rfkill *priv = data;
u32 ctrl_param = !blocked;
acpi_status status;
- status = asus_wmi_set_devstate(dev_id, ctrl_param, NULL);
+ status = asus_wmi_set_devstate(priv->dev_id, ctrl_param, NULL);
if (ACPI_FAILURE(status))
return -EIO;
@@ -584,20 +590,21 @@ static int asus_rfkill_set(void *data, bool blocked)
static void asus_rfkill_query(struct rfkill *rfkill, void *data)
{
- int dev_id = (unsigned long)data;
+ struct asus_rfkill *priv = data;
int result;
- result = asus_wmi_get_devstate_simple(dev_id);
+ result = asus_wmi_get_devstate_simple(priv->dev_id);
if (result < 0)
return;
- rfkill_set_sw_state(rfkill, !result);
+ rfkill_set_sw_state(priv->rfkill, !result);
}
static int asus_rfkill_wlan_set(void *data, bool blocked)
{
- struct asus_wmi *asus = data;
+ struct asus_rfkill *priv = data;
+ struct asus_wmi *asus = priv->asus;
int ret;
/*
@@ -608,19 +615,14 @@ static int asus_rfkill_wlan_set(void *data, bool blocked)
* any wmi method
*/
mutex_lock(&asus->wmi_lock);
- ret = asus_rfkill_set((void *)(long)ASUS_WMI_DEVID_WLAN, blocked);
+ ret = asus_rfkill_set(data, blocked);
mutex_unlock(&asus->wmi_lock);
return ret;
}
-static void asus_rfkill_wlan_query(struct rfkill *rfkill, void *data)
-{
- asus_rfkill_query(rfkill, (void *)(long)ASUS_WMI_DEVID_WLAN);
-}
-
static const struct rfkill_ops asus_rfkill_wlan_ops = {
.set_block = asus_rfkill_wlan_set,
- .query = asus_rfkill_wlan_query,
+ .query = asus_rfkill_query,
};
static const struct rfkill_ops asus_rfkill_ops = {
@@ -629,20 +631,24 @@ static const struct rfkill_ops asus_rfkill_ops = {
};
static int asus_new_rfkill(struct asus_wmi *asus,
- struct rfkill **rfkill,
+ struct asus_rfkill *arfkill,
const char *name, enum rfkill_type type, int dev_id)
{
int result = asus_wmi_get_devstate_simple(dev_id);
+ struct rfkill **rfkill = &arfkill->rfkill;
if (result < 0)
return result;
+ arfkill->dev_id = dev_id;
+ arfkill->asus = asus;
+
if (dev_id == ASUS_WMI_DEVID_WLAN && asus->driver->hotplug_wireless)
*rfkill = rfkill_alloc(name, &asus->platform_device->dev, type,
- &asus_rfkill_wlan_ops, asus);
+ &asus_rfkill_wlan_ops, arfkill);
else
*rfkill = rfkill_alloc(name, &asus->platform_device->dev, type,
- &asus_rfkill_ops, (void *)(long)dev_id);
+ &asus_rfkill_ops, arfkill);
if (!*rfkill)
return -EINVAL;
@@ -662,10 +668,10 @@ static void asus_wmi_rfkill_exit(struct asus_wmi *asus)
asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P5");
asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P6");
asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P7");
- if (asus->wlan_rfkill) {
- rfkill_unregister(asus->wlan_rfkill);
- rfkill_destroy(asus->wlan_rfkill);
- asus->wlan_rfkill = NULL;
+ if (asus->wlan.rfkill) {
+ rfkill_unregister(asus->wlan.rfkill);
+ rfkill_destroy(asus->wlan.rfkill);
+ asus->wlan.rfkill = NULL;
}
/*
* Refresh pci hotplug in case the rfkill state was changed after
@@ -677,20 +683,20 @@ static void asus_wmi_rfkill_exit(struct asus_wmi *asus)
if (asus->hotplug_workqueue)
destroy_workqueue(asus->hotplug_workqueue);
- if (asus->bluetooth_rfkill) {
- rfkill_unregister(asus->bluetooth_rfkill);
- rfkill_destroy(asus->bluetooth_rfkill);
- asus->bluetooth_rfkill = NULL;
+ if (asus->bluetooth.rfkill) {
+ rfkill_unregister(asus->bluetooth.rfkill);
+ rfkill_destroy(asus->bluetooth.rfkill);
+ asus->bluetooth.rfkill = NULL;
}
- if (asus->wimax_rfkill) {
- rfkill_unregister(asus->wimax_rfkill);
- rfkill_destroy(asus->wimax_rfkill);
- asus->wimax_rfkill = NULL;
+ if (asus->wimax.rfkill) {
+ rfkill_unregister(asus->wimax.rfkill);
+ rfkill_destroy(asus->wimax.rfkill);
+ asus->wimax.rfkill = NULL;
}
- if (asus->wwan3g_rfkill) {
- rfkill_unregister(asus->wwan3g_rfkill);
- rfkill_destroy(asus->wwan3g_rfkill);
- asus->wwan3g_rfkill = NULL;
+ if (asus->wwan3g.rfkill) {
+ rfkill_unregister(asus->wwan3g.rfkill);
+ rfkill_destroy(asus->wwan3g.rfkill);
+ asus->wwan3g.rfkill = NULL;
}
}
@@ -701,30 +707,27 @@ static int asus_wmi_rfkill_init(struct asus_wmi *asus)
mutex_init(&asus->hotplug_lock);
mutex_init(&asus->wmi_lock);
- result = asus_new_rfkill(asus, &asus->wlan_rfkill,
- "asus-wlan", RFKILL_TYPE_WLAN,
- ASUS_WMI_DEVID_WLAN);
+ result = asus_new_rfkill(asus, &asus->wlan, "asus-wlan",
+ RFKILL_TYPE_WLAN, ASUS_WMI_DEVID_WLAN);
if (result && result != -ENODEV)
goto exit;
- result = asus_new_rfkill(asus, &asus->bluetooth_rfkill,
+ result = asus_new_rfkill(asus, &asus->bluetooth,
"asus-bluetooth", RFKILL_TYPE_BLUETOOTH,
ASUS_WMI_DEVID_BLUETOOTH);
if (result && result != -ENODEV)
goto exit;
- result = asus_new_rfkill(asus, &asus->wimax_rfkill,
- "asus-wimax", RFKILL_TYPE_WIMAX,
- ASUS_WMI_DEVID_WIMAX);
+ result = asus_new_rfkill(asus, &asus->wimax, "asus-wimax",
+ RFKILL_TYPE_WIMAX, ASUS_WMI_DEVID_WIMAX);
if (result && result != -ENODEV)
goto exit;
- result = asus_new_rfkill(asus, &asus->wwan3g_rfkill,
- "asus-wwan3g", RFKILL_TYPE_WWAN,
- ASUS_WMI_DEVID_WWAN3G);
+ result = asus_new_rfkill(asus, &asus->wwan3g, "asus-wwan3g",
+ RFKILL_TYPE_WWAN, ASUS_WMI_DEVID_WWAN3G);
if (result && result != -ENODEV)
goto exit;
@@ -1277,7 +1280,7 @@ static int asus_hotk_thaw(struct device *device)
{
struct asus_wmi *asus = dev_get_drvdata(device);
- if (asus->wlan_rfkill) {
+ if (asus->wlan.rfkill) {
bool wlan;
/*
@@ -1298,20 +1301,20 @@ static int asus_hotk_restore(struct device *device)
int bl;
/* Refresh both wlan rfkill state and pci hotplug */
- if (asus->wlan_rfkill)
+ if (asus->wlan.rfkill)
asus_rfkill_hotplug(asus);
- if (asus->bluetooth_rfkill) {
+ if (asus->bluetooth.rfkill) {
bl = !asus_wmi_get_devstate_simple(ASUS_WMI_DEVID_BLUETOOTH);
- rfkill_set_sw_state(asus->bluetooth_rfkill, bl);
+ rfkill_set_sw_state(asus->bluetooth.rfkill, bl);
}
- if (asus->wimax_rfkill) {
+ if (asus->wimax.rfkill) {
bl = !asus_wmi_get_devstate_simple(ASUS_WMI_DEVID_WIMAX);
- rfkill_set_sw_state(asus->wimax_rfkill, bl);
+ rfkill_set_sw_state(asus->wimax.rfkill, bl);
}
- if (asus->wwan3g_rfkill) {
+ if (asus->wwan3g.rfkill) {
bl = !asus_wmi_get_devstate_simple(ASUS_WMI_DEVID_WWAN3G);
- rfkill_set_sw_state(asus->wwan3g_rfkill, bl);
+ rfkill_set_sw_state(asus->wwan3g.rfkill, bl);
}
return 0;
--
1.7.4
^ permalink raw reply [flat|nested] 16+ messages in thread* [PATCH 05/14] asus-wmi: handle "unknown status" bit
2011-02-26 9:20 [PATCH 00/14] Support Asus WMI capable Notebooks (asus-wmi, asus-nb-wmi and eeepc-wmi) Corentin Chary
` (3 preceding siblings ...)
2011-02-26 9:20 ` [PATCH 04/14] asus-wmi: introduce struct asus_rfkill Corentin Chary
@ 2011-02-26 9:20 ` Corentin Chary
2011-02-26 9:20 ` [PATCH 06/14] asus-wmi: factorise wmi_evaluate_method call Corentin Chary
` (9 subsequent siblings)
14 siblings, 0 replies; 16+ messages in thread
From: Corentin Chary @ 2011-02-26 9:20 UTC (permalink / raw)
To: Matthew Garrett
Cc: Dmitry Torokhov, Corentin Chary, open list:ASUS NOTEBOOKS AN...,
open list:ASUS NOTEBOOKS AN...,
open list
Signed-off-by: Corentin Chary <corentincj@iksaif.net>
---
drivers/platform/x86/asus-wmi.c | 6 ++++++
1 files changed, 6 insertions(+), 0 deletions(-)
diff --git a/drivers/platform/x86/asus-wmi.c b/drivers/platform/x86/asus-wmi.c
index d0f0931..39ce3c1 100644
--- a/drivers/platform/x86/asus-wmi.c
+++ b/drivers/platform/x86/asus-wmi.c
@@ -92,6 +92,7 @@ MODULE_LICENSE("GPL");
/* DSTS masks */
#define ASUS_WMI_DSTS_STATUS_BIT 0x00000001
+#define ASUS_WMI_DSTS_UNKNOWN_BIT 0x00000002
#define ASUS_WMI_DSTS_PRESENCE_BIT 0x00010000
#define ASUS_WMI_DSTS_BRIGHTNESS_MASK 0x000000FF
#define ASUS_WMI_DSTS_MAX_BRIGTH_MASK 0x0000FF00
@@ -270,6 +271,11 @@ static int asus_wmi_get_devstate_bits(u32 dev_id, u32 mask)
if (!(retval & ASUS_WMI_DSTS_PRESENCE_BIT))
return -ENODEV;
+ if (mask == ASUS_WMI_DSTS_STATUS_BIT) {
+ if (retval & ASUS_WMI_DSTS_UNKNOWN_BIT)
+ return -ENODEV;
+ }
+
return retval & mask;
}
--
1.7.4
^ permalink raw reply [flat|nested] 16+ messages in thread* [PATCH 06/14] asus-wmi: factorise wmi_evaluate_method call
2011-02-26 9:20 [PATCH 00/14] Support Asus WMI capable Notebooks (asus-wmi, asus-nb-wmi and eeepc-wmi) Corentin Chary
` (4 preceding siblings ...)
2011-02-26 9:20 ` [PATCH 05/14] asus-wmi: handle "unknown status" bit Corentin Chary
@ 2011-02-26 9:20 ` Corentin Chary
2011-02-26 9:20 ` [PATCH 07/14] asus-wmi: try to guess the right DSTS methods Corentin Chary
` (8 subsequent siblings)
14 siblings, 0 replies; 16+ messages in thread
From: Corentin Chary @ 2011-02-26 9:20 UTC (permalink / raw)
To: Matthew Garrett
Cc: Dmitry Torokhov, Corentin Chary, open list:ASUS NOTEBOOKS AN...,
open list:ASUS NOTEBOOKS AN...,
open list
This patch create a single function to call the
WMI methods. This function handle inexistent methods (when
implemented by the WMI devices, and this is not the case on
Eee PCs), ACPI errors, etc..
Also pack struct bios_arg, and make sure that we always send
a 64bit buffer when calling a WMI method, because this is
needed on Asus notebooks.
Signed-off-by: Corentin Chary <corentincj@iksaif.net>
---
drivers/platform/x86/asus-wmi.c | 162 ++++++++++++++++-----------------------
1 files changed, 65 insertions(+), 97 deletions(-)
diff --git a/drivers/platform/x86/asus-wmi.c b/drivers/platform/x86/asus-wmi.c
index 39ce3c1..34e6b4d 100644
--- a/drivers/platform/x86/asus-wmi.c
+++ b/drivers/platform/x86/asus-wmi.c
@@ -70,6 +70,8 @@ MODULE_LICENSE("GPL");
#define ASUS_WMI_METHODID_DEVS 0x53564544
#define ASUS_WMI_METHODID_CFVS 0x53564643
+#define ASUS_WMI_UNSUPPORTED_METHOD 0xFFFFFFFE
+
/* Wireless */
#define ASUS_WMI_DEVID_WLAN 0x00010011
#define ASUS_WMI_DEVID_BLUETOOTH 0x00010013
@@ -98,9 +100,9 @@ MODULE_LICENSE("GPL");
#define ASUS_WMI_DSTS_MAX_BRIGTH_MASK 0x0000FF00
struct bios_args {
- u32 dev_id;
- u32 ctrl_param;
-};
+ u32 arg0;
+ u32 arg1;
+} __packed;
/*
* <platform>/ - debugfs root directory
@@ -187,20 +189,24 @@ static void asus_wmi_input_exit(struct asus_wmi *asus)
asus->inputdev = NULL;
}
-static acpi_status asus_wmi_get_devstate(u32 dev_id, u32 *retval)
+static int asus_wmi_evaluate_method(u32 method_id, u32 arg0, u32 arg1,
+ u32 *retval)
{
- struct acpi_buffer input = { (acpi_size) sizeof(u32), &dev_id };
+ struct bios_args args = {
+ .arg0 = arg0,
+ .arg1 = arg1,
+ };
+ struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
- union acpi_object *obj;
acpi_status status;
+ union acpi_object *obj;
u32 tmp;
- status = wmi_evaluate_method(ASUS_WMI_MGMT_GUID,
- 1, ASUS_WMI_METHODID_DSTS,
+ status = wmi_evaluate_method(ASUS_WMI_MGMT_GUID, 1, method_id,
&input, &output);
if (ACPI_FAILURE(status))
- return status;
+ goto exit;
obj = (union acpi_object *)output.pointer;
if (obj && obj->type == ACPI_TYPE_INTEGER)
@@ -213,60 +219,39 @@ static acpi_status asus_wmi_get_devstate(u32 dev_id, u32 *retval)
kfree(obj);
- return status;
+exit:
+ if (ACPI_FAILURE(status))
+ return -EIO;
+
+ if (tmp == ASUS_WMI_UNSUPPORTED_METHOD)
+ return -ENODEV;
+ return 0;
}
-static acpi_status asus_wmi_set_devstate(u32 dev_id, u32 ctrl_param,
- u32 *retval)
+static int asus_wmi_get_devstate(u32 dev_id, u32 *retval)
{
- struct bios_args args = {
- .dev_id = dev_id,
- .ctrl_param = ctrl_param,
- };
- struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
- acpi_status status;
-
- if (!retval) {
- status = wmi_evaluate_method(ASUS_WMI_MGMT_GUID, 1,
- ASUS_WMI_METHODID_DEVS,
- &input, NULL);
- } else {
- struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
- union acpi_object *obj;
- u32 tmp;
-
- status = wmi_evaluate_method(ASUS_WMI_MGMT_GUID, 1,
- ASUS_WMI_METHODID_DEVS,
- &input, &output);
-
- if (ACPI_FAILURE(status))
- return status;
-
- obj = (union acpi_object *)output.pointer;
- if (obj && obj->type == ACPI_TYPE_INTEGER)
- tmp = (u32) obj->integer.value;
- else
- tmp = 0;
-
- *retval = tmp;
-
- kfree(obj);
- }
+ return asus_wmi_evaluate_method(ASUS_WMI_METHODID_DSTS, dev_id,
+ 0, retval);
+}
- return status;
+static int asus_wmi_set_devstate(u32 dev_id, u32 ctrl_param,
+ u32 *retval)
+{
+ return asus_wmi_evaluate_method(ASUS_WMI_METHODID_DEVS, dev_id,
+ ctrl_param, retval);
}
/* Helper for special devices with magic return codes */
static int asus_wmi_get_devstate_bits(u32 dev_id, u32 mask)
{
u32 retval = 0;
- acpi_status status;
+ int err;
- status = asus_wmi_get_devstate(dev_id, &retval);
+ err = asus_wmi_get_devstate(dev_id, &retval);
- if (ACPI_FAILURE(status))
- return -EINVAL;
+ if (err < 0)
+ return err;
if (!(retval & ASUS_WMI_DSTS_PRESENCE_BIT))
return -ENODEV;
@@ -584,14 +569,8 @@ static int asus_rfkill_set(void *data, bool blocked)
{
struct asus_rfkill *priv = data;
u32 ctrl_param = !blocked;
- acpi_status status;
-
- status = asus_wmi_set_devstate(priv->dev_id, ctrl_param, NULL);
-
- if (ACPI_FAILURE(status))
- return -EIO;
- return 0;
+ return asus_wmi_set_devstate(priv->dev_id, ctrl_param, NULL);
}
static void asus_rfkill_query(struct rfkill *rfkill, void *data)
@@ -784,38 +763,34 @@ static int read_backlight_power(void)
static int read_brightness(struct backlight_device *bd)
{
u32 retval;
- acpi_status status;
+ int err;
- status = asus_wmi_get_devstate(ASUS_WMI_DEVID_BRIGHTNESS, &retval);
+ err = asus_wmi_get_devstate(ASUS_WMI_DEVID_BRIGHTNESS, &retval);
- if (ACPI_FAILURE(status))
- return -EIO;
- else
- return retval & ASUS_WMI_DSTS_BRIGHTNESS_MASK;
+ if (err < 0)
+ return err;
+
+ return retval & ASUS_WMI_DSTS_BRIGHTNESS_MASK;
}
static int update_bl_status(struct backlight_device *bd)
{
u32 ctrl_param;
- acpi_status status;
- int power;
+ int power, err;
ctrl_param = bd->props.brightness;
- status = asus_wmi_set_devstate(ASUS_WMI_DEVID_BRIGHTNESS,
- ctrl_param, NULL);
+ err = asus_wmi_set_devstate(ASUS_WMI_DEVID_BRIGHTNESS,
+ ctrl_param, NULL);
- if (ACPI_FAILURE(status))
- return -EIO;
+ if (err < 0)
+ return err;
power = read_backlight_power();
if (power != -ENODEV && bd->props.power != power) {
ctrl_param = !!(bd->props.power == FB_BLANK_UNBLANK);
- status = asus_wmi_set_devstate(ASUS_WMI_DEVID_BACKLIGHT,
- ctrl_param, NULL);
-
- if (ACPI_FAILURE(status))
- return -EIO;
+ err = asus_wmi_set_devstate(ASUS_WMI_DEVID_BACKLIGHT,
+ ctrl_param, NULL);
}
return 0;
}
@@ -948,19 +923,19 @@ static int parse_arg(const char *buf, unsigned long count, int *val)
static ssize_t store_sys_wmi(int devid, const char *buf, size_t count)
{
- acpi_status status;
u32 retval;
- int rv, value;
+ int rv, err, value;
value = asus_wmi_get_devstate_simple(devid);
if (value == -ENODEV) /* Check device presence */
return value;
rv = parse_arg(buf, count, &value);
- status = asus_wmi_set_devstate(devid, value, &retval);
+ err = asus_wmi_set_devstate(devid, value, &retval);
+
+ if (err < 0)
+ return err;
- if (ACPI_FAILURE(status))
- return -EIO;
return rv;
}
@@ -1003,21 +978,13 @@ static ssize_t store_cpufv(struct device *dev, struct device_attribute *attr,
const char *buf, size_t count)
{
int value;
- struct acpi_buffer input = { (acpi_size) sizeof(value), &value };
- acpi_status status;
if (!count || sscanf(buf, "%i", &value) != 1)
return -EINVAL;
if (value < 0 || value > 2)
return -EINVAL;
- status = wmi_evaluate_method(ASUS_WMI_MGMT_GUID,
- 1, ASUS_WMI_METHODID_CFVS, &input, NULL);
-
- if (ACPI_FAILURE(status))
- return -EIO;
- else
- return count;
+ return asus_wmi_evaluate_method(ASUS_WMI_METHODID_CFVS, value, 0, NULL);
}
static DEVICE_ATTR(cpufv, S_IRUGO | S_IWUSR, NULL, store_cpufv);
@@ -1089,13 +1056,13 @@ struct asus_wmi_debugfs_node {
static int show_dsts(struct seq_file *m, void *data)
{
struct asus_wmi *asus = m->private;
- acpi_status status;
+ int err;
u32 retval = -1;
- status = asus_wmi_get_devstate(asus->debug.dev_id, &retval);
+ err = asus_wmi_get_devstate(asus->debug.dev_id, &retval);
- if (ACPI_FAILURE(status))
- return -EIO;
+ if (err < 0)
+ return err;
seq_printf(m, "DSTS(%x) = %x\n", asus->debug.dev_id, retval);
@@ -1105,13 +1072,14 @@ static int show_dsts(struct seq_file *m, void *data)
static int show_devs(struct seq_file *m, void *data)
{
struct asus_wmi *asus = m->private;
- acpi_status status;
+ int err;
u32 retval = -1;
- status = asus_wmi_set_devstate(asus->debug.dev_id,
- asus->debug.ctrl_param, &retval);
- if (ACPI_FAILURE(status))
- return -EIO;
+ err = asus_wmi_set_devstate(asus->debug.dev_id, asus->debug.ctrl_param,
+ &retval);
+
+ if (err < 0)
+ return err;
seq_printf(m, "DEVS(%x, %x) = %x\n", asus->debug.dev_id,
asus->debug.ctrl_param, retval);
--
1.7.4
^ permalink raw reply [flat|nested] 16+ messages in thread* [PATCH 07/14] asus-wmi: try to guess the right DSTS methods
2011-02-26 9:20 [PATCH 00/14] Support Asus WMI capable Notebooks (asus-wmi, asus-nb-wmi and eeepc-wmi) Corentin Chary
` (5 preceding siblings ...)
2011-02-26 9:20 ` [PATCH 06/14] asus-wmi: factorise wmi_evaluate_method call Corentin Chary
@ 2011-02-26 9:20 ` Corentin Chary
2011-02-26 9:20 ` [PATCH 08/14] asus-wmi: fix and clean backlight code Corentin Chary
` (7 subsequent siblings)
14 siblings, 0 replies; 16+ messages in thread
From: Corentin Chary @ 2011-02-26 9:20 UTC (permalink / raw)
To: Matthew Garrett
Cc: Dmitry Torokhov, Corentin Chary, open list:ASUS NOTEBOOKS AN...,
open list:ASUS NOTEBOOKS AN...,
open list
This is tricky, new WMI aware notebooks seems to use
0x53545344 while Eee PCs are using 0x53544344. But there
is no way to know if there is an Eee PC in that wild that is
using 0x53545344 or a notebook using 0x53544344. So the
driver try to guess the available DSTS method ... But most Eee PCs
never return 0xFFFFFFFE when a method is not available, they return
0 instead (and that's useless).
So, first, try 0x53544344 then 0x53545344. We will find
a better way when we got more data.
Signed-off-by: Corentin Chary <corentincj@iksaif.net>
---
drivers/platform/x86/asus-wmi.c | 99 ++++++++++++++++++++++++++-------------
1 files changed, 66 insertions(+), 33 deletions(-)
diff --git a/drivers/platform/x86/asus-wmi.c b/drivers/platform/x86/asus-wmi.c
index 34e6b4d..fd5b08ee 100644
--- a/drivers/platform/x86/asus-wmi.c
+++ b/drivers/platform/x86/asus-wmi.c
@@ -67,6 +67,7 @@ MODULE_LICENSE("GPL");
/* WMI Methods */
#define ASUS_WMI_METHODID_DSTS 0x53544344
+#define ASUS_WMI_METHODID_DSTS2 0x53545344
#define ASUS_WMI_METHODID_DEVS 0x53564544
#define ASUS_WMI_METHODID_CFVS 0x53564643
@@ -124,6 +125,8 @@ struct asus_rfkill {
};
struct asus_wmi {
+ int dsts_id;
+
struct input_dev *inputdev;
struct backlight_device *backlight_device;
struct platform_device *platform_device;
@@ -229,26 +232,26 @@ exit:
return 0;
}
-static int asus_wmi_get_devstate(u32 dev_id, u32 *retval)
+static int asus_wmi_get_devstate(struct asus_wmi *asus, u32 dev_id, u32 *retval)
{
- return asus_wmi_evaluate_method(ASUS_WMI_METHODID_DSTS, dev_id,
- 0, retval);
+ return asus_wmi_evaluate_method(asus->dsts_id, dev_id, 0, retval);
}
static int asus_wmi_set_devstate(u32 dev_id, u32 ctrl_param,
- u32 *retval)
+ u32 *retval)
{
return asus_wmi_evaluate_method(ASUS_WMI_METHODID_DEVS, dev_id,
ctrl_param, retval);
}
/* Helper for special devices with magic return codes */
-static int asus_wmi_get_devstate_bits(u32 dev_id, u32 mask)
+static int asus_wmi_get_devstate_bits(struct asus_wmi *asus,
+ u32 dev_id, u32 mask)
{
u32 retval = 0;
int err;
- err = asus_wmi_get_devstate(dev_id, &retval);
+ err = asus_wmi_get_devstate(asus, dev_id, &retval);
if (err < 0)
return err;
@@ -264,9 +267,10 @@ static int asus_wmi_get_devstate_bits(u32 dev_id, u32 mask)
return retval & mask;
}
-static int asus_wmi_get_devstate_simple(u32 dev_id)
+static int asus_wmi_get_devstate_simple(struct asus_wmi *asus, u32 dev_id)
{
- return asus_wmi_get_devstate_bits(dev_id, ASUS_WMI_DSTS_STATUS_BIT);
+ return asus_wmi_get_devstate_bits(asus, dev_id,
+ ASUS_WMI_DSTS_STATUS_BIT);
}
/*
@@ -302,7 +306,7 @@ static void tpd_led_set(struct led_classdev *led_cdev,
static int read_tpd_led_state(struct asus_wmi *asus)
{
- return asus_wmi_get_devstate_simple(ASUS_WMI_DEVID_TOUCHPAD_LED);
+ return asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_TOUCHPAD_LED);
}
static enum led_brightness tpd_led_get(struct led_classdev *led_cdev)
@@ -353,7 +357,7 @@ static void asus_wmi_led_exit(struct asus_wmi *asus)
*/
static bool asus_wlan_rfkill_blocked(struct asus_wmi *asus)
{
- int result = asus_wmi_get_devstate_simple(ASUS_WMI_DEVID_WLAN);
+ int result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WLAN);
if (result < 0)
return false;
@@ -482,7 +486,8 @@ static void asus_unregister_rfkill_notifier(struct asus_wmi *asus, char *node)
static int asus_get_adapter_status(struct hotplug_slot *hotplug_slot,
u8 *value)
{
- int result = asus_wmi_get_devstate_simple(ASUS_WMI_DEVID_WLAN);
+ struct asus_wmi *asus = hotplug_slot->private;
+ int result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WLAN);
if (result < 0)
return result;
@@ -578,7 +583,7 @@ static void asus_rfkill_query(struct rfkill *rfkill, void *data)
struct asus_rfkill *priv = data;
int result;
- result = asus_wmi_get_devstate_simple(priv->dev_id);
+ result = asus_wmi_get_devstate_simple(priv->asus, priv->dev_id);
if (result < 0)
return;
@@ -619,7 +624,7 @@ static int asus_new_rfkill(struct asus_wmi *asus,
struct asus_rfkill *arfkill,
const char *name, enum rfkill_type type, int dev_id)
{
- int result = asus_wmi_get_devstate_simple(dev_id);
+ int result = asus_wmi_get_devstate_simple(asus, dev_id);
struct rfkill **rfkill = &arfkill->rfkill;
if (result < 0)
@@ -750,9 +755,9 @@ exit:
/*
* Backlight
*/
-static int read_backlight_power(void)
+static int read_backlight_power(struct asus_wmi *asus)
{
- int ret = asus_wmi_get_devstate_simple(ASUS_WMI_DEVID_BACKLIGHT);
+ int ret = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_BACKLIGHT);
if (ret < 0)
return ret;
@@ -762,10 +767,11 @@ static int read_backlight_power(void)
static int read_brightness(struct backlight_device *bd)
{
+ struct asus_wmi *asus = bl_get_data(bd);
u32 retval;
int err;
- err = asus_wmi_get_devstate(ASUS_WMI_DEVID_BRIGHTNESS, &retval);
+ err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_BRIGHTNESS, &retval);
if (err < 0)
return err;
@@ -775,6 +781,7 @@ static int read_brightness(struct backlight_device *bd)
static int update_bl_status(struct backlight_device *bd)
{
+ struct asus_wmi *asus = bl_get_data(bd);
u32 ctrl_param;
int power, err;
@@ -786,7 +793,7 @@ static int update_bl_status(struct backlight_device *bd)
if (err < 0)
return err;
- power = read_backlight_power();
+ power = read_backlight_power(asus);
if (power != -ENODEV && bd->props.power != power) {
ctrl_param = !!(bd->props.power == FB_BLANK_UNBLANK);
err = asus_wmi_set_devstate(ASUS_WMI_DEVID_BACKLIGHT,
@@ -825,9 +832,9 @@ static int asus_wmi_backlight_init(struct asus_wmi *asus)
int max;
int power;
- max = asus_wmi_get_devstate_bits(ASUS_WMI_DEVID_BRIGHTNESS,
+ max = asus_wmi_get_devstate_bits(asus, ASUS_WMI_DEVID_BRIGHTNESS,
ASUS_WMI_DSTS_MAX_BRIGTH_MASK);
- power = read_backlight_power();
+ power = read_backlight_power(asus);
if (max < 0 && power < 0) {
/* Try to keep the original error */
@@ -921,12 +928,13 @@ static int parse_arg(const char *buf, unsigned long count, int *val)
return count;
}
-static ssize_t store_sys_wmi(int devid, const char *buf, size_t count)
+static ssize_t store_sys_wmi(struct asus_wmi *asus, int devid,
+ const char *buf, size_t count)
{
u32 retval;
int rv, err, value;
- value = asus_wmi_get_devstate_simple(devid);
+ value = asus_wmi_get_devstate_simple(asus, devid);
if (value == -ENODEV) /* Check device presence */
return value;
@@ -939,9 +947,9 @@ static ssize_t store_sys_wmi(int devid, const char *buf, size_t count)
return rv;
}
-static ssize_t show_sys_wmi(int devid, char *buf)
+static ssize_t show_sys_wmi(struct asus_wmi *asus, int devid, char *buf)
{
- int value = asus_wmi_get_devstate_simple(devid);
+ int value = asus_wmi_get_devstate_simple(asus, devid);
if (value < 0)
return value;
@@ -954,13 +962,17 @@ static ssize_t show_sys_wmi(int devid, char *buf)
struct device_attribute *attr, \
char *buf) \
{ \
- return show_sys_wmi(_cm, buf); \
+ struct asus_wmi *asus = dev_get_drvdata(dev); \
+ \
+ return show_sys_wmi(asus, _cm, buf); \
} \
static ssize_t store_##_name(struct device *dev, \
struct device_attribute *attr, \
const char *buf, size_t count) \
{ \
- return store_sys_wmi(_cm, buf, count); \
+ struct asus_wmi *asus = dev_get_drvdata(dev); \
+ \
+ return store_sys_wmi(asus, _cm, buf, count); \
} \
static struct device_attribute dev_attr_##_name = { \
.attr = { \
@@ -1000,7 +1012,10 @@ static struct attribute *platform_attributes[] = {
static mode_t asus_sysfs_is_visible(struct kobject *kobj,
struct attribute *attr, int idx)
{
- bool supported = true;
+ struct device *dev = container_of(kobj, struct device, kobj);
+ struct platform_device *pdev = to_platform_device(dev);
+ struct asus_wmi *asus = platform_get_drvdata(pdev);
+ bool ok = true;
int devid = -1;
if (attr == &dev_attr_camera.attr)
@@ -1011,9 +1026,9 @@ static mode_t asus_sysfs_is_visible(struct kobject *kobj,
devid = ASUS_WMI_DEVID_TOUCHPAD;
if (devid != -1)
- supported = asus_wmi_get_devstate_simple(devid) != -ENODEV;
+ ok = !(asus_wmi_get_devstate_simple(asus, devid) < 0);
- return supported ? attr->mode : 0;
+ return ok ? attr->mode : 0;
}
static struct attribute_group platform_attribute_group = {
@@ -1036,6 +1051,23 @@ static int asus_wmi_sysfs_init(struct platform_device *device)
*/
static int __init asus_wmi_platform_init(struct asus_wmi *asus)
{
+ /*
+ * Eee PC and Notebooks seems to have different method_id for DSTS,
+ * but it may also be related to the BIOS's SPEC.
+ * Note, on most Eeepc, there is no way to check if a method exist
+ * or note, while on notebooks, they returns 0xFFFFFFFE on failure,
+ * but once again, SPEC may probably be used for that kind of things.
+ */
+ if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_DSTS, 0, 0, NULL))
+ asus->dsts_id = ASUS_WMI_METHODID_DSTS;
+ else if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_DSTS2, 0, 0, NULL))
+ asus->dsts_id = ASUS_WMI_METHODID_DSTS2;
+
+ if (!asus->dsts_id) {
+ pr_err("Can't find DSTS");
+ return -ENODEV;
+ }
+
return asus_wmi_sysfs_init(asus->platform_device);
}
@@ -1059,7 +1091,7 @@ static int show_dsts(struct seq_file *m, void *data)
int err;
u32 retval = -1;
- err = asus_wmi_get_devstate(asus->debug.dev_id, &retval);
+ err = asus_wmi_get_devstate(asus, asus->debug.dev_id, &retval);
if (err < 0)
return err;
@@ -1262,7 +1294,7 @@ static int asus_hotk_thaw(struct device *device)
* during suspend. Normally it restores it on resume, but
* we should kick it ourselves in case hibernation is aborted.
*/
- wlan = asus_wmi_get_devstate_simple(ASUS_WMI_DEVID_WLAN);
+ wlan = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WLAN);
asus_wmi_set_devstate(ASUS_WMI_DEVID_WLAN, wlan, NULL);
}
@@ -1279,15 +1311,16 @@ static int asus_hotk_restore(struct device *device)
asus_rfkill_hotplug(asus);
if (asus->bluetooth.rfkill) {
- bl = !asus_wmi_get_devstate_simple(ASUS_WMI_DEVID_BLUETOOTH);
+ bl = !asus_wmi_get_devstate_simple(asus,
+ ASUS_WMI_DEVID_BLUETOOTH);
rfkill_set_sw_state(asus->bluetooth.rfkill, bl);
}
if (asus->wimax.rfkill) {
- bl = !asus_wmi_get_devstate_simple(ASUS_WMI_DEVID_WIMAX);
+ bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WIMAX);
rfkill_set_sw_state(asus->wimax.rfkill, bl);
}
if (asus->wwan3g.rfkill) {
- bl = !asus_wmi_get_devstate_simple(ASUS_WMI_DEVID_WWAN3G);
+ bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WWAN3G);
rfkill_set_sw_state(asus->wwan3g.rfkill, bl);
}
--
1.7.4
^ permalink raw reply [flat|nested] 16+ messages in thread* [PATCH 08/14] asus-wmi: fix and clean backlight code
2011-02-26 9:20 [PATCH 00/14] Support Asus WMI capable Notebooks (asus-wmi, asus-nb-wmi and eeepc-wmi) Corentin Chary
` (6 preceding siblings ...)
2011-02-26 9:20 ` [PATCH 07/14] asus-wmi: try to guess the right DSTS methods Corentin Chary
@ 2011-02-26 9:20 ` Corentin Chary
2011-02-26 9:20 ` [PATCH 09/14] asus-wmi: add calls to INIT, SPEC and SFUN on init Corentin Chary
` (6 subsequent siblings)
14 siblings, 0 replies; 16+ messages in thread
From: Corentin Chary @ 2011-02-26 9:20 UTC (permalink / raw)
To: Matthew Garrett
Cc: Dmitry Torokhov, Corentin Chary, open list:ASUS NOTEBOOKS AN...,
open list:ASUS NOTEBOOKS AN...,
open list
Signed-off-by: Corentin Chary <corentincj@iksaif.net>
---
drivers/platform/x86/asus-wmi.c | 44 +++++++++++++++++++++++++-------------
1 files changed, 29 insertions(+), 15 deletions(-)
diff --git a/drivers/platform/x86/asus-wmi.c b/drivers/platform/x86/asus-wmi.c
index fd5b08ee..adf7b05 100644
--- a/drivers/platform/x86/asus-wmi.c
+++ b/drivers/platform/x86/asus-wmi.c
@@ -765,9 +765,8 @@ static int read_backlight_power(struct asus_wmi *asus)
return ret ? FB_BLANK_UNBLANK : FB_BLANK_POWERDOWN;
}
-static int read_brightness(struct backlight_device *bd)
+static int read_brightness_max(struct asus_wmi *asus)
{
- struct asus_wmi *asus = bl_get_data(bd);
u32 retval;
int err;
@@ -776,6 +775,25 @@ static int read_brightness(struct backlight_device *bd)
if (err < 0)
return err;
+ retval = retval & ASUS_WMI_DSTS_MAX_BRIGTH_MASK;
+ retval >>= 8;
+
+ if (!retval)
+ return -ENODEV;
+
+ return retval;
+}
+
+static int read_brightness(struct backlight_device *bd)
+{
+ struct asus_wmi *asus = bl_get_data(bd);
+ u32 retval, err;
+
+ err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_BRIGHTNESS, &retval);
+
+ if (err < 0)
+ return err;
+
return retval & ASUS_WMI_DSTS_BRIGHTNESS_MASK;
}
@@ -799,7 +817,7 @@ static int update_bl_status(struct backlight_device *bd)
err = asus_wmi_set_devstate(ASUS_WMI_DEVID_BACKLIGHT,
ctrl_param, NULL);
}
- return 0;
+ return err;
}
static const struct backlight_ops asus_wmi_bl_ops = {
@@ -832,23 +850,19 @@ static int asus_wmi_backlight_init(struct asus_wmi *asus)
int max;
int power;
- max = asus_wmi_get_devstate_bits(asus, ASUS_WMI_DEVID_BRIGHTNESS,
- ASUS_WMI_DSTS_MAX_BRIGTH_MASK);
- power = read_backlight_power(asus);
+ max = read_brightness_max(asus);
- if (max < 0 && power < 0) {
- /* Try to keep the original error */
- if (max == -ENODEV && power == -ENODEV)
- return -ENODEV;
- if (max != -ENODEV)
- return max;
- else
- return power;
- }
if (max == -ENODEV)
max = 0;
+ else if (max < 0)
+ return max;
+
+ power = read_backlight_power(asus);
+
if (power == -ENODEV)
power = FB_BLANK_UNBLANK;
+ else if (power < 0)
+ return power;
memset(&props, 0, sizeof(struct backlight_properties));
props.max_brightness = max;
--
1.7.4
^ permalink raw reply [flat|nested] 16+ messages in thread* [PATCH 09/14] asus-wmi: add calls to INIT, SPEC and SFUN on init
2011-02-26 9:20 [PATCH 00/14] Support Asus WMI capable Notebooks (asus-wmi, asus-nb-wmi and eeepc-wmi) Corentin Chary
` (7 preceding siblings ...)
2011-02-26 9:20 ` [PATCH 08/14] asus-wmi: fix and clean backlight code Corentin Chary
@ 2011-02-26 9:20 ` Corentin Chary
2011-02-26 9:20 ` [PATCH 10/14] asus-wmi: allow debugfs interface to call arbitrary method Corentin Chary
` (5 subsequent siblings)
14 siblings, 0 replies; 16+ messages in thread
From: Corentin Chary @ 2011-02-26 9:20 UTC (permalink / raw)
To: Matthew Garrett
Cc: Dmitry Torokhov, Corentin Chary, open list:ASUS NOTEBOOKS AN...,
open list:ASUS NOTEBOOKS AN...,
open list
INIT() call is needed to enable hotkeys on G73
SPEC() and SFUN() allow us to know more about
available features.
Signed-off-by: Corentin Chary <corentincj@iksaif.net>
---
drivers/platform/x86/asus-wmi.c | 28 ++++++++++++++++++++++++++++
1 files changed, 28 insertions(+), 0 deletions(-)
diff --git a/drivers/platform/x86/asus-wmi.c b/drivers/platform/x86/asus-wmi.c
index adf7b05..88596ea 100644
--- a/drivers/platform/x86/asus-wmi.c
+++ b/drivers/platform/x86/asus-wmi.c
@@ -66,10 +66,13 @@ MODULE_LICENSE("GPL");
#define NOTIFY_BRNDOWN_MAX 0x2e
/* WMI Methods */
+#define ASUS_WMI_METHODID_SPEC 0x43455053
+#define ASUS_WMI_METHODID_SFUN 0x4E554653
#define ASUS_WMI_METHODID_DSTS 0x53544344
#define ASUS_WMI_METHODID_DSTS2 0x53545344
#define ASUS_WMI_METHODID_DEVS 0x53564544
#define ASUS_WMI_METHODID_CFVS 0x53564643
+#define ASUS_WMI_METHODID_INIT 0x54494E49
#define ASUS_WMI_UNSUPPORTED_METHOD 0xFFFFFFFE
@@ -126,6 +129,8 @@ struct asus_rfkill {
struct asus_wmi {
int dsts_id;
+ int spec;
+ int sfun;
struct input_dev *inputdev;
struct backlight_device *backlight_device;
@@ -1065,6 +1070,29 @@ static int asus_wmi_sysfs_init(struct platform_device *device)
*/
static int __init asus_wmi_platform_init(struct asus_wmi *asus)
{
+ int rv;
+
+ /* INIT enable hotkeys on some models */
+ if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_INIT, 0, 0, &rv))
+ pr_info("Initialization: %#x", rv);
+
+ /* We don't know yet what to do with this version... */
+ if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_SPEC, 0, 0x9, &rv)) {
+ pr_info("BIOS WMI version: %d.%d", rv >> 8, rv & 0xFF);
+ asus->spec = rv;
+ }
+
+ /*
+ * The SFUN method probably allows the original driver to get the list
+ * of features supported by a given model. For now, 0x0100 or 0x0800
+ * bit signifies that the laptop is equipped with a Wi-Fi MiniPCI card.
+ * The significance of others is yet to be found.
+ */
+ if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_SFUN, 0, 0, &rv)) {
+ pr_info("SFUN value: %#x", rv);
+ asus->sfun = rv;
+ }
+
/*
* Eee PC and Notebooks seems to have different method_id for DSTS,
* but it may also be related to the BIOS's SPEC.
--
1.7.4
^ permalink raw reply [flat|nested] 16+ messages in thread* [PATCH 10/14] asus-wmi: allow debugfs interface to call arbitrary method
2011-02-26 9:20 [PATCH 00/14] Support Asus WMI capable Notebooks (asus-wmi, asus-nb-wmi and eeepc-wmi) Corentin Chary
` (8 preceding siblings ...)
2011-02-26 9:20 ` [PATCH 09/14] asus-wmi: add calls to INIT, SPEC and SFUN on init Corentin Chary
@ 2011-02-26 9:20 ` Corentin Chary
2011-02-26 9:20 ` [PATCH 11/14] asus-nb-wmi: Asus Notebooks WMI Driver Corentin Chary
` (4 subsequent siblings)
14 siblings, 0 replies; 16+ messages in thread
From: Corentin Chary @ 2011-02-26 9:20 UTC (permalink / raw)
To: Matthew Garrett
Cc: Dmitry Torokhov, Corentin Chary, open list:ASUS NOTEBOOKS AN...,
open list:ASUS NOTEBOOKS AN...,
open list
Also add some # format flags to debugfs output.
Signed-off-by: Corentin Chary <corentincj@iksaif.net>
---
drivers/platform/x86/asus-wmi.c | 47 +++++++++++++++++++++++++++++++++++++-
1 files changed, 45 insertions(+), 2 deletions(-)
diff --git a/drivers/platform/x86/asus-wmi.c b/drivers/platform/x86/asus-wmi.c
index 88596ea..9095c28 100644
--- a/drivers/platform/x86/asus-wmi.c
+++ b/drivers/platform/x86/asus-wmi.c
@@ -112,11 +112,14 @@ struct bios_args {
* <platform>/ - debugfs root directory
* dev_id - current dev_id
* ctrl_param - current ctrl_param
+ * method_id - current method_id
* devs - call DEVS(dev_id, ctrl_param) and print result
* dsts - call DSTS(dev_id) and print result
+ * call - call method_id(dev_id, ctrl_param) and print result
*/
struct asus_wmi_debug {
struct dentry *root;
+ u32 method_id;
u32 dev_id;
u32 ctrl_param;
};
@@ -1138,7 +1141,7 @@ static int show_dsts(struct seq_file *m, void *data)
if (err < 0)
return err;
- seq_printf(m, "DSTS(%x) = %x\n", asus->debug.dev_id, retval);
+ seq_printf(m, "DSTS(%#x) = %#x\n", asus->debug.dev_id, retval);
return 0;
}
@@ -1155,15 +1158,50 @@ static int show_devs(struct seq_file *m, void *data)
if (err < 0)
return err;
- seq_printf(m, "DEVS(%x, %x) = %x\n", asus->debug.dev_id,
+ seq_printf(m, "DEVS(%#x, %#x) = %#x\n", asus->debug.dev_id,
asus->debug.ctrl_param, retval);
return 0;
}
+static int show_call(struct seq_file *m, void *data)
+{
+ struct asus_wmi *asus = m->private;
+ struct bios_args args = {
+ .arg0 = asus->debug.dev_id,
+ .arg1 = asus->debug.ctrl_param,
+ };
+ struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
+ struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
+ union acpi_object *obj;
+ acpi_status status;
+
+ status = wmi_evaluate_method(ASUS_WMI_MGMT_GUID,
+ 1, asus->debug.method_id,
+ &input, &output);
+
+ if (ACPI_FAILURE(status))
+ return -EIO;
+
+ obj = (union acpi_object *)output.pointer;
+ if (obj && obj->type == ACPI_TYPE_INTEGER)
+ seq_printf(m, "%#x(%#x, %#x) = %#x\n", asus->debug.method_id,
+ asus->debug.dev_id, asus->debug.ctrl_param,
+ (u32) obj->integer.value);
+ else
+ seq_printf(m, "%#x(%#x, %#x) = t:%d\n", asus->debug.method_id,
+ asus->debug.dev_id, asus->debug.ctrl_param,
+ obj->type);
+
+ kfree(obj);
+
+ return 0;
+}
+
static struct asus_wmi_debugfs_node asus_wmi_debug_files[] = {
{NULL, "devs", show_devs},
{NULL, "dsts", show_dsts},
+ {NULL, "call", show_call},
};
static int asus_wmi_debugfs_open(struct inode *inode, struct file *file)
@@ -1197,6 +1235,11 @@ static int asus_wmi_debugfs_init(struct asus_wmi *asus)
goto error_debugfs;
}
+ dent = debugfs_create_x32("method_id", S_IRUGO | S_IWUSR,
+ asus->debug.root, &asus->debug.method_id);
+ if (!dent)
+ goto error_debugfs;
+
dent = debugfs_create_x32("dev_id", S_IRUGO | S_IWUSR,
asus->debug.root, &asus->debug.dev_id);
if (!dent)
--
1.7.4
^ permalink raw reply [flat|nested] 16+ messages in thread* [PATCH 11/14] asus-nb-wmi: Asus Notebooks WMI Driver
2011-02-26 9:20 [PATCH 00/14] Support Asus WMI capable Notebooks (asus-wmi, asus-nb-wmi and eeepc-wmi) Corentin Chary
` (9 preceding siblings ...)
2011-02-26 9:20 ` [PATCH 10/14] asus-wmi: allow debugfs interface to call arbitrary method Corentin Chary
@ 2011-02-26 9:20 ` Corentin Chary
2011-02-26 9:20 ` [PATCH 12/14] asus-wmi: add some common device ids and method ids Corentin Chary
` (3 subsequent siblings)
14 siblings, 0 replies; 16+ messages in thread
From: Corentin Chary @ 2011-02-26 9:20 UTC (permalink / raw)
To: Matthew Garrett
Cc: Dmitry Torokhov, Corentin Chary, Andrew Morton, Joe Perches,
David S. Miller, open list, open list:X86 PLATFORM DRIVERS,
open list:ASUS NOTEBOOKS AN...
Introduce a new driver for Asus Notebooks shipped with
a WMI device instead of the old ACPI device. The WMI
device is almost the same as the one present in Eee PC,
but the event guid and the keymap are different.
The keymap comes from asus-laptop module.
On Asus notebooks, when you call the WMI device, you always
need a 64bit buffer, even if you only want to get the state
of a device (tested on a G73).
Signed-off-by: Corentin Chary <corentincj@iksaif.net>
---
MAINTAINERS | 30 +----------
drivers/platform/x86/Kconfig | 16 ++++++-
drivers/platform/x86/Makefile | 1 +
drivers/platform/x86/asus-nb-wmi.c | 98 ++++++++++++++++++++++++++++++++++++
4 files changed, 117 insertions(+), 28 deletions(-)
create mode 100644 drivers/platform/x86/asus-nb-wmi.c
diff --git a/MAINTAINERS b/MAINTAINERS
index 6f99e12..4fafc2e 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -1126,14 +1126,14 @@ S: Maintained
F: Documentation/hwmon/asc7621
F: drivers/hwmon/asc7621.c
-ASUS ACPI EXTRAS DRIVER
+ASUS NOTEBOOKS AND EEEPC ACPI/WMI EXTRAS DRIVERS
M: Corentin Chary <corentincj@iksaif.net>
-M: Karol Kozimor <sziwan@users.sourceforge.net>
L: acpi4asus-user@lists.sourceforge.net
L: platform-driver-x86@vger.kernel.org
W: http://acpi4asus.sf.net
S: Maintained
-F: drivers/platform/x86/asus_acpi.c
+F: drivers/platform/x86/asus*.c
+F: drivers/platform/x86/eeepc*.c
ASUS ASB100 HARDWARE MONITOR DRIVER
M: "Mark M. Hoffman" <mhoffman@lightlink.com>
@@ -1141,14 +1141,6 @@ L: lm-sensors@lm-sensors.org
S: Maintained
F: drivers/hwmon/asb100.c
-ASUS LAPTOP EXTRAS DRIVER
-M: Corentin Chary <corentincj@iksaif.net>
-L: acpi4asus-user@lists.sourceforge.net
-L: platform-driver-x86@vger.kernel.org
-W: http://acpi4asus.sf.net
-S: Maintained
-F: drivers/platform/x86/asus-laptop.c
-
ASYNCHRONOUS TRANSFERS/TRANSFORMS (IOAT) API
M: Dan Williams <dan.j.williams@intel.com>
W: http://sourceforge.net/projects/xscaleiop
@@ -2368,22 +2360,6 @@ T: git git://git.alsa-project.org/alsa-kernel.git
S: Maintained
F: sound/usb/misc/ua101.c
-EEEPC LAPTOP EXTRAS DRIVER
-M: Corentin Chary <corentincj@iksaif.net>
-L: acpi4asus-user@lists.sourceforge.net
-L: platform-driver-x86@vger.kernel.org
-W: http://acpi4asus.sf.net
-S: Maintained
-F: drivers/platform/x86/eeepc-laptop.c
-
-EEEPC WMI EXTRAS DRIVER
-M: Corentin Chary <corentincj@iksaif.net>
-L: acpi4asus-user@lists.sourceforge.net
-L: platform-driver-x86@vger.kernel.org
-W: http://acpi4asus.sf.net
-S: Maintained
-F: drivers/platform/x86/eeepc-wmi.c
-
EFIFB FRAMEBUFFER DRIVER
L: linux-fbdev@vger.kernel.org
M: Peter Jones <pjones@redhat.com>
diff --git a/drivers/platform/x86/Kconfig b/drivers/platform/x86/Kconfig
index 22e5225..cd65dac 100644
--- a/drivers/platform/x86/Kconfig
+++ b/drivers/platform/x86/Kconfig
@@ -447,11 +447,25 @@ config ASUS_WMI
select LEDS_CLASS
select NEW_LEDS
---help---
- Say Y here if you have a WMI aware Asus laptop (like Eee PCs).
+ Say Y here if you have a WMI aware Asus laptop (like Eee PCs or new
+ Asus Notebooks).
To compile this driver as a module, choose M here: the module will
be called asus-wmi.
+config ASUS_NB_WMI
+ tristate "Asus Notebook WMI Driver (EXPERIMENTAL)"
+ depends on ASUS_WMI
+ ---help---
+ This is a driver for newer Asus notebooks. It adds extra features
+ like wireless radio and bluetooth control, leds, hotkeys, backlight...
+
+ For more informations, see
+ <file:Documentation/ABI/testing/sysfs-platform-asus-wmi>
+
+ If you have an ACPI-WMI compatible Asus Notebook, say Y or M
+ here.
+
config EEEPC_WMI
tristate "Eee PC WMI Driver (EXPERIMENTAL)"
depends on ASUS_WMI
diff --git a/drivers/platform/x86/Makefile b/drivers/platform/x86/Makefile
index f8d35f1..68acb23 100644
--- a/drivers/platform/x86/Makefile
+++ b/drivers/platform/x86/Makefile
@@ -4,6 +4,7 @@
#
obj-$(CONFIG_ASUS_LAPTOP) += asus-laptop.o
obj-$(CONFIG_ASUS_WMI) += asus-wmi.o
+obj-$(CONFIG_ASUS_NB_WMI) += asus-nb-wmi.o
obj-$(CONFIG_EEEPC_LAPTOP) += eeepc-laptop.o
obj-$(CONFIG_EEEPC_WMI) += eeepc-wmi.o
obj-$(CONFIG_MSI_LAPTOP) += msi-laptop.o
diff --git a/drivers/platform/x86/asus-nb-wmi.c b/drivers/platform/x86/asus-nb-wmi.c
new file mode 100644
index 0000000..0580d99
--- /dev/null
+++ b/drivers/platform/x86/asus-nb-wmi.c
@@ -0,0 +1,98 @@
+/*
+ * Asus Notebooks WMI hotkey driver
+ *
+ * Copyright(C) 2010 Corentin Chary <corentin.chary@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/input.h>
+#include <linux/input/sparse-keymap.h>
+
+#include "asus-wmi.h"
+
+#define ASUS_NB_WMI_FILE "asus-nb-wmi"
+
+MODULE_AUTHOR("Corentin Chary <corentincj@iksaif.net>");
+MODULE_DESCRIPTION("Asus Notebooks WMI Hotkey Driver");
+MODULE_LICENSE("GPL");
+
+#define ASUS_NB_WMI_EVENT_GUID "0B3CBB35-E3C2-45ED-91C2-4C5A6D195D1C"
+
+MODULE_ALIAS("wmi:"ASUS_NB_WMI_EVENT_GUID);
+
+static const struct key_entry asus_nb_wmi_keymap[] = {
+ { KE_KEY, 0x30, { KEY_VOLUMEUP } },
+ { KE_KEY, 0x31, { KEY_VOLUMEDOWN } },
+ { KE_KEY, 0x32, { KEY_MUTE } },
+ { KE_KEY, 0x33, { KEY_DISPLAYTOGGLE } }, /* LCD on */
+ { KE_KEY, 0x34, { KEY_DISPLAY_OFF } }, /* LCD off */
+ { KE_KEY, 0x40, { KEY_PREVIOUSSONG } },
+ { KE_KEY, 0x41, { KEY_NEXTSONG } },
+ { KE_KEY, 0x43, { KEY_STOPCD } },
+ { KE_KEY, 0x45, { KEY_PLAYPAUSE } },
+ { KE_KEY, 0x4c, { KEY_MEDIA } },
+ { KE_KEY, 0x50, { KEY_EMAIL } },
+ { KE_KEY, 0x51, { KEY_WWW } },
+ { KE_KEY, 0x55, { KEY_CALC } },
+ { KE_KEY, 0x5C, { KEY_F15 } }, /* Power Gear key */
+ { KE_KEY, 0x5D, { KEY_WLAN } },
+ { KE_KEY, 0x5E, { KEY_WLAN } },
+ { KE_KEY, 0x5F, { KEY_WLAN } },
+ { KE_KEY, 0x60, { KEY_SWITCHVIDEOMODE } },
+ { KE_KEY, 0x61, { KEY_SWITCHVIDEOMODE } },
+ { KE_KEY, 0x62, { KEY_SWITCHVIDEOMODE } },
+ { KE_KEY, 0x63, { KEY_SWITCHVIDEOMODE } },
+ { KE_KEY, 0x6B, { KEY_TOUCHPAD_TOGGLE } },
+ { KE_KEY, 0x7E, { KEY_BLUETOOTH } },
+ { KE_KEY, 0x7D, { KEY_BLUETOOTH } },
+ { KE_KEY, 0x82, { KEY_CAMERA } },
+ { KE_KEY, 0x88, { KEY_RFKILL } },
+ { KE_KEY, 0x8A, { KEY_PROG1 } },
+ { KE_KEY, 0x95, { KEY_MEDIA } },
+ { KE_KEY, 0x99, { KEY_PHONE } },
+ { KE_KEY, 0xb5, { KEY_CALC } },
+ { KE_KEY, 0xc4, { KEY_KBDILLUMUP } },
+ { KE_KEY, 0xc5, { KEY_KBDILLUMDOWN } },
+ { KE_END, 0},
+};
+
+static struct asus_wmi_driver asus_nb_wmi_driver = {
+ .name = ASUS_NB_WMI_FILE,
+ .owner = THIS_MODULE,
+ .event_guid = ASUS_NB_WMI_EVENT_GUID,
+ .keymap = asus_nb_wmi_keymap,
+ .input_name = "Asus WMI hotkeys",
+ .input_phys = ASUS_NB_WMI_FILE "/input0",
+};
+
+
+static int __init asus_nb_wmi_init(void)
+{
+ return asus_wmi_register_driver(&asus_nb_wmi_driver);
+}
+
+static void __exit asus_nb_wmi_exit(void)
+{
+ asus_wmi_unregister_driver(&asus_nb_wmi_driver);
+}
+
+module_init(asus_nb_wmi_init);
+module_exit(asus_nb_wmi_exit);
--
1.7.4
^ permalink raw reply [flat|nested] 16+ messages in thread* [PATCH 12/14] asus-wmi: add some common device ids and method ids
2011-02-26 9:20 [PATCH 00/14] Support Asus WMI capable Notebooks (asus-wmi, asus-nb-wmi and eeepc-wmi) Corentin Chary
` (10 preceding siblings ...)
2011-02-26 9:20 ` [PATCH 11/14] asus-nb-wmi: Asus Notebooks WMI Driver Corentin Chary
@ 2011-02-26 9:20 ` Corentin Chary
2011-02-26 9:20 ` [PATCH 13/14] asus-wmi: add hwmon interface and pwm1 Corentin Chary
` (2 subsequent siblings)
14 siblings, 0 replies; 16+ messages in thread
From: Corentin Chary @ 2011-02-26 9:20 UTC (permalink / raw)
To: Matthew Garrett
Cc: Dmitry Torokhov, Corentin Chary, open list:ASUS NOTEBOOKS AN...,
open list:ASUS NOTEBOOKS AN...,
open list
I also found some leds ids (0x00020011-0x00020016 and 0x00040015),
but since they are not really present on the notebook,
I can't guess their name .
Signed-off-by: Corentin Chary <corentincj@iksaif.net>
---
drivers/platform/x86/asus-wmi.c | 44 ++++++++++++++++++++++++++++++++------
1 files changed, 37 insertions(+), 7 deletions(-)
diff --git a/drivers/platform/x86/asus-wmi.c b/drivers/platform/x86/asus-wmi.c
index 9095c28..05db6b2 100644
--- a/drivers/platform/x86/asus-wmi.c
+++ b/drivers/platform/x86/asus-wmi.c
@@ -66,25 +66,46 @@ MODULE_LICENSE("GPL");
#define NOTIFY_BRNDOWN_MAX 0x2e
/* WMI Methods */
-#define ASUS_WMI_METHODID_SPEC 0x43455053
-#define ASUS_WMI_METHODID_SFUN 0x4E554653
-#define ASUS_WMI_METHODID_DSTS 0x53544344
-#define ASUS_WMI_METHODID_DSTS2 0x53545344
-#define ASUS_WMI_METHODID_DEVS 0x53564544
-#define ASUS_WMI_METHODID_CFVS 0x53564643
-#define ASUS_WMI_METHODID_INIT 0x54494E49
+#define ASUS_WMI_METHODID_SPEC 0x43455053 /* BIOS SPECification */
+#define ASUS_WMI_METHODID_SFBD 0x44424653 /* Set First Boot Device */
+#define ASUS_WMI_METHODID_GLCD 0x44434C47 /* Get LCD status */
+#define ASUS_WMI_METHODID_GPID 0x44495047 /* Get Panel ID?? (Resol) */
+#define ASUS_WMI_METHODID_QMOD 0x444F4D51 /* Quiet MODe */
+#define ASUS_WMI_METHODID_SPLV 0x4C425053 /* Set Panel Light Value */
+#define ASUS_WMI_METHODID_SFUN 0x4E554653 /* FUNCtionalities */
+#define ASUS_WMI_METHODID_SDSP 0x50534453 /* Set DiSPlay output */
+#define ASUS_WMI_METHODID_GDSP 0x50534447 /* Get DiSPlay output */
+#define ASUS_WMI_METHODID_DEVP 0x50564544 /* DEVice Policy */
+#define ASUS_WMI_METHODID_OSVR 0x5256534F /* OS VeRsion */
+#define ASUS_WMI_METHODID_DSTS 0x53544344 /* Device STatuS */
+#define ASUS_WMI_METHODID_DSTS2 0x53545344 /* Device STatuS #2*/
+#define ASUS_WMI_METHODID_BSTS 0x53545342 /* Bios STatuS ? */
+#define ASUS_WMI_METHODID_DEVS 0x53564544 /* DEVice Set */
+#define ASUS_WMI_METHODID_CFVS 0x53564643 /* CPU Frequency Volt Set */
+#define ASUS_WMI_METHODID_KBFT 0x5446424B /* KeyBoard FilTer */
+#define ASUS_WMI_METHODID_INIT 0x54494E49 /* INITialize */
+#define ASUS_WMI_METHODID_HKEY 0x59454B48 /* Hot KEY ?? */
#define ASUS_WMI_UNSUPPORTED_METHOD 0xFFFFFFFE
/* Wireless */
+#define ASUS_WMI_DEVID_HW_SWITCH 0x00010001
+#define ASUS_WMI_DEVID_WIRELESS_LED 0x00010002
#define ASUS_WMI_DEVID_WLAN 0x00010011
#define ASUS_WMI_DEVID_BLUETOOTH 0x00010013
+#define ASUS_WMI_DEVID_GPS 0x00010015
#define ASUS_WMI_DEVID_WIMAX 0x00010017
#define ASUS_WMI_DEVID_WWAN3G 0x00010019
+#define ASUS_WMI_DEVID_UWB 0x00010021
+
+/* Leds */
+/* 0x000200XX and 0x000400XX */
/* Backlight and Brightness */
#define ASUS_WMI_DEVID_BACKLIGHT 0x00050011
#define ASUS_WMI_DEVID_BRIGHTNESS 0x00050012
+#define ASUS_WMI_DEVID_KBD_BACKLIGHT 0x00050021
+#define ASUS_WMI_DEVID_LIGHT_SENSOR 0x00050022 /* ?? */
/* Misc */
#define ASUS_WMI_DEVID_CAMERA 0x00060013
@@ -96,10 +117,19 @@ MODULE_LICENSE("GPL");
#define ASUS_WMI_DEVID_TOUCHPAD 0x00100011
#define ASUS_WMI_DEVID_TOUCHPAD_LED 0x00100012
+/* Fan, Thermal */
+#define ASUS_WMI_DEVID_THERMAL_CTRL 0x00110011
+#define ASUS_WMI_DEVID_FAN_CTRL 0x00110012
+
+/* Power */
+#define ASUS_WMI_DEVID_PROCESSOR_STATE 0x00120012
+
/* DSTS masks */
#define ASUS_WMI_DSTS_STATUS_BIT 0x00000001
#define ASUS_WMI_DSTS_UNKNOWN_BIT 0x00000002
#define ASUS_WMI_DSTS_PRESENCE_BIT 0x00010000
+#define ASUS_WMI_DSTS_USER_BIT 0x00020000
+#define ASUS_WMI_DSTS_BIOS_BIT 0x00040000
#define ASUS_WMI_DSTS_BRIGHTNESS_MASK 0x000000FF
#define ASUS_WMI_DSTS_MAX_BRIGTH_MASK 0x0000FF00
--
1.7.4
^ permalink raw reply [flat|nested] 16+ messages in thread* [PATCH 13/14] asus-wmi: add hwmon interface and pwm1
2011-02-26 9:20 [PATCH 00/14] Support Asus WMI capable Notebooks (asus-wmi, asus-nb-wmi and eeepc-wmi) Corentin Chary
` (11 preceding siblings ...)
2011-02-26 9:20 ` [PATCH 12/14] asus-wmi: add some common device ids and method ids Corentin Chary
@ 2011-02-26 9:20 ` Corentin Chary
2011-02-26 9:20 ` [PATCH 14/14] eeepc-wmi: restore KEY_CAMERA_* keys lost in 190ca27 Corentin Chary
2011-03-11 17:29 ` [PATCH 00/14] Support Asus WMI capable Notebooks (asus-wmi, asus-nb-wmi and eeepc-wmi) Matthew Garrett
14 siblings, 0 replies; 16+ messages in thread
From: Corentin Chary @ 2011-02-26 9:20 UTC (permalink / raw)
To: Matthew Garrett
Cc: Dmitry Torokhov, Corentin Chary, open list:X86 PLATFORM DRIVERS,
open list, open list:ASUS NOTEBOOKS AN...
Signed-off-by: Corentin Chary <corentincj@iksaif.net>
---
drivers/platform/x86/Kconfig | 1 +
drivers/platform/x86/asus-wmi.c | 128 +++++++++++++++++++++++++++++++++++++++
2 files changed, 129 insertions(+), 0 deletions(-)
diff --git a/drivers/platform/x86/Kconfig b/drivers/platform/x86/Kconfig
index cd65dac..486f016 100644
--- a/drivers/platform/x86/Kconfig
+++ b/drivers/platform/x86/Kconfig
@@ -440,6 +440,7 @@ config ASUS_WMI
tristate "ASUS WMI Driver (EXPERIMENTAL)"
depends on ACPI_WMI
depends on INPUT
+ depends on HWMON
depends on EXPERIMENTAL
depends on BACKLIGHT_CLASS_DEVICE
depends on RFKILL || RFKILL = n
diff --git a/drivers/platform/x86/asus-wmi.c b/drivers/platform/x86/asus-wmi.c
index 05db6b2..5b779a9 100644
--- a/drivers/platform/x86/asus-wmi.c
+++ b/drivers/platform/x86/asus-wmi.c
@@ -39,6 +39,8 @@
#include <linux/rfkill.h>
#include <linux/pci.h>
#include <linux/pci_hotplug.h>
+#include <linux/hwmon.h>
+#include <linux/hwmon-sysfs.h>
#include <linux/debugfs.h>
#include <linux/seq_file.h>
#include <linux/platform_device.h>
@@ -167,6 +169,7 @@ struct asus_wmi {
struct input_dev *inputdev;
struct backlight_device *backlight_device;
+ struct device *hwmon_device;
struct platform_device *platform_device;
struct led_classdev tpd_led;
@@ -791,6 +794,124 @@ exit:
}
/*
+ * Hwmon device
+ */
+static ssize_t asus_hwmon_pwm1(struct device *dev,
+ struct device_attribute *attr,
+ char *buf)
+{
+ struct asus_wmi *asus = dev_get_drvdata(dev);
+ u32 value;
+ int err;
+
+ err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_FAN_CTRL, &value);
+
+ if (err < 0)
+ return err;
+
+ value |= 0xFF;
+
+ if (value == 1) /* Low Speed */
+ value = 85;
+ else if (value == 2)
+ value = 170;
+ else if (value == 3)
+ value = 255;
+ else if (value != 0) {
+ pr_err("Unknown fan speed %#x", value);
+ value = -1;
+ }
+
+ return sprintf(buf, "%d\n", value);
+}
+
+static SENSOR_DEVICE_ATTR(pwm1, S_IRUGO, asus_hwmon_pwm1, NULL, 0);
+
+static ssize_t
+show_name(struct device *dev, struct device_attribute *attr, char *buf)
+{
+ return sprintf(buf, "asus\n");
+}
+static SENSOR_DEVICE_ATTR(name, S_IRUGO, show_name, NULL, 0);
+
+static struct attribute *hwmon_attributes[] = {
+ &sensor_dev_attr_pwm1.dev_attr.attr,
+ &sensor_dev_attr_name.dev_attr.attr,
+ NULL
+};
+
+static mode_t asus_hwmon_sysfs_is_visible(struct kobject *kobj,
+ struct attribute *attr, int idx)
+{
+ struct device *dev = container_of(kobj, struct device, kobj);
+ struct platform_device *pdev = to_platform_device(dev->parent);
+ struct asus_wmi *asus = platform_get_drvdata(pdev);
+ bool ok = true;
+ int dev_id = -1;
+ u32 value = ASUS_WMI_UNSUPPORTED_METHOD;
+
+ if (attr == &sensor_dev_attr_pwm1.dev_attr.attr)
+ dev_id = ASUS_WMI_DEVID_FAN_CTRL;
+
+ if (dev_id != -1) {
+ int err = asus_wmi_get_devstate(asus, dev_id, &value);
+
+ if (err < 0)
+ return err;
+ }
+
+ if (dev_id == ASUS_WMI_DEVID_FAN_CTRL) {
+ /*
+ * We need to find a better way, probably using sfun,
+ * bits or spec ...
+ * Currently we disable it if:
+ * - ASUS_WMI_UNSUPPORTED_METHOD is returned
+ * - reverved bits are non-zero
+ * - sfun and presence bit are not set
+ */
+ if (value != ASUS_WMI_UNSUPPORTED_METHOD || value & 0xFFF80000
+ || (!asus->sfun && !(value & ASUS_WMI_DSTS_PRESENCE_BIT)))
+ ok = false;
+ }
+
+ return ok ? attr->mode : 0;
+}
+
+static struct attribute_group hwmon_attribute_group = {
+ .is_visible = asus_hwmon_sysfs_is_visible,
+ .attrs = hwmon_attributes
+};
+
+static void asus_wmi_hwmon_exit(struct asus_wmi *asus)
+{
+ struct device *hwmon;
+
+ hwmon = asus->hwmon_device;
+ if (!hwmon)
+ return;
+ sysfs_remove_group(&hwmon->kobj, &hwmon_attribute_group);
+ hwmon_device_unregister(hwmon);
+ asus->hwmon_device = NULL;
+}
+
+static int asus_wmi_hwmon_init(struct asus_wmi *asus)
+{
+ struct device *hwmon;
+ int result;
+
+ hwmon = hwmon_device_register(&asus->platform_device->dev);
+ if (IS_ERR(hwmon)) {
+ pr_err("Could not register asus hwmon device\n");
+ return PTR_ERR(hwmon);
+ }
+ asus->hwmon_device = hwmon;
+ result = sysfs_create_group(&hwmon->kobj, &hwmon_attribute_group);
+ if (result)
+ asus_wmi_hwmon_exit(asus);
+ return result;
+}
+
+/*
* Backlight
*/
static int read_backlight_power(struct asus_wmi *asus)
@@ -1331,6 +1452,10 @@ static int asus_wmi_add(struct platform_device *pdev)
if (err)
goto fail_input;
+ err = asus_wmi_hwmon_init(asus);
+ if (err)
+ goto fail_hwmon;
+
err = asus_wmi_led_init(asus);
if (err)
goto fail_leds;
@@ -1369,6 +1494,8 @@ fail_backlight:
fail_rfkill:
asus_wmi_led_exit(asus);
fail_leds:
+ asus_wmi_hwmon_exit(asus);
+fail_hwmon:
asus_wmi_input_exit(asus);
fail_input:
asus_wmi_platform_exit(asus);
@@ -1385,6 +1512,7 @@ static int asus_wmi_remove(struct platform_device *device)
wmi_remove_notify_handler(asus->driver->event_guid);
asus_wmi_backlight_exit(asus);
asus_wmi_input_exit(asus);
+ asus_wmi_hwmon_exit(asus);
asus_wmi_led_exit(asus);
asus_wmi_rfkill_exit(asus);
asus_wmi_debugfs_exit(asus);
--
1.7.4
^ permalink raw reply [flat|nested] 16+ messages in thread* [PATCH 14/14] eeepc-wmi: restore KEY_CAMERA_* keys lost in 190ca27
2011-02-26 9:20 [PATCH 00/14] Support Asus WMI capable Notebooks (asus-wmi, asus-nb-wmi and eeepc-wmi) Corentin Chary
` (12 preceding siblings ...)
2011-02-26 9:20 ` [PATCH 13/14] asus-wmi: add hwmon interface and pwm1 Corentin Chary
@ 2011-02-26 9:20 ` Corentin Chary
2011-03-11 17:29 ` [PATCH 00/14] Support Asus WMI capable Notebooks (asus-wmi, asus-nb-wmi and eeepc-wmi) Matthew Garrett
14 siblings, 0 replies; 16+ messages in thread
From: Corentin Chary @ 2011-02-26 9:20 UTC (permalink / raw)
To: Matthew Garrett
Cc: Dmitry Torokhov, Corentin Chary, open list:ASUS NOTEBOOKS AN...,
open list:ASUS NOTEBOOKS AN...,
open list
Signed-off-by: Corentin Chary <corentincj@iksaif.net>
---
drivers/platform/x86/eeepc-wmi.c | 6 ++++++
1 files changed, 6 insertions(+), 0 deletions(-)
diff --git a/drivers/platform/x86/eeepc-wmi.c b/drivers/platform/x86/eeepc-wmi.c
index e69701f..64e36de 100644
--- a/drivers/platform/x86/eeepc-wmi.c
+++ b/drivers/platform/x86/eeepc-wmi.c
@@ -65,11 +65,17 @@ static const struct key_entry eeepc_wmi_keymap[] = {
{ KE_KEY, 0x5d, { KEY_WLAN } },
{ KE_KEY, 0x6b, { KEY_F13 } }, /* Disable Touchpad */
{ KE_KEY, 0x82, { KEY_CAMERA } },
+ { KE_KEY, 0x83, { KEY_CAMERA_ZOOMIN } },
{ KE_KEY, 0x88, { KEY_WLAN } },
{ KE_KEY, 0xcc, { KEY_SWITCHVIDEOMODE } },
{ KE_KEY, 0xe0, { KEY_PROG1 } }, /* Task Manager */
{ KE_KEY, 0xe1, { KEY_F14 } }, /* Change Resolution */
{ KE_KEY, 0xe9, { KEY_BRIGHTNESS_ZERO } },
+ { KE_KEY, 0xeb, { KEY_CAMERA_ZOOMOUT } },
+ { KE_KEY, 0xec, { KEY_CAMERA_UP } },
+ { KE_KEY, 0xed, { KEY_CAMERA_DOWN } },
+ { KE_KEY, 0xee, { KEY_CAMERA_LEFT } },
+ { KE_KEY, 0xef, { KEY_CAMERA_RIGHT } },
{ KE_END, 0},
};
--
1.7.4
^ permalink raw reply [flat|nested] 16+ messages in thread* Re: [PATCH 00/14] Support Asus WMI capable Notebooks (asus-wmi, asus-nb-wmi and eeepc-wmi)
2011-02-26 9:20 [PATCH 00/14] Support Asus WMI capable Notebooks (asus-wmi, asus-nb-wmi and eeepc-wmi) Corentin Chary
` (13 preceding siblings ...)
2011-02-26 9:20 ` [PATCH 14/14] eeepc-wmi: restore KEY_CAMERA_* keys lost in 190ca27 Corentin Chary
@ 2011-03-11 17:29 ` Matthew Garrett
14 siblings, 0 replies; 16+ messages in thread
From: Matthew Garrett @ 2011-03-11 17:29 UTC (permalink / raw)
To: Corentin Chary
Cc: Dmitry Torokhov, Randy Dunlap, Andrew Morton, Joe Perches,
David S. Miller, open list:DOCUMENTATION, open list,
open list:X86 PLATFORM DRIVERS, open list:ASUS NOTEBOOKS AN...
Applied the series, thanks.
--
Matthew Garrett | mjg59@srcf.ucam.org
^ permalink raw reply [flat|nested] 16+ messages in thread