drivers/platform/x86/asus-wireless.c

   1 /*
   2  * Asus Wireless Radio Control Driver
   3  *
   4  * Copyright (C) 2015-2016 Endless Mobile, Inc.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 as
   8  * published by the Free Software Foundation.
   9  */
  10
  11 #include <linux/kernel.h>
  12 #include <linux/module.h>
  13 #include <linux/init.h>
  14 #include <linux/types.h>
  15 #include <linux/acpi.h>
  16 #include <linux/input.h>
  17 #include <linux/pci_ids.h>
  18 #include <linux/leds.h>
  19
  20 struct hswc_params {
  21         u8 on;
  22         u8 off;
  23         u8 status;
  24 };
  25
  26 struct asus_wireless_data {
  27         struct input_dev *idev;
  28         struct acpi_device *adev;
  29         const struct hswc_params *hswc_params;
  30         struct workqueue_struct *wq;
  31         struct work_struct led_work;
  32         struct led_classdev led;
  33         int led_state;
  34 };
  35
  36 static const struct hswc_params atk4001_id_params = {
  37         .on = 0x0,
  38         .off = 0x1,
  39         .status = 0x2,
  40 };
  41
  42 static const struct hswc_params atk4002_id_params = {
  43         .on = 0x5,
  44         .off = 0x4,
  45         .status = 0x2,
  46 };
  47
  48 static const struct acpi_device_id device_ids[] = {
  49         {"ATK4001", (kernel_ulong_t)&atk4001_id_params},
  50         {"ATK4002", (kernel_ulong_t)&atk4002_id_params},
  51         {"", 0},
  52 };
  53 MODULE_DEVICE_TABLE(acpi, device_ids);
  54
  55 static acpi_status asus_wireless_method(acpi_handle handle, const char *method,
  56                                         int param, u64 *ret)
  57 {
  58         struct acpi_object_list p;
  59         union acpi_object obj;
  60         acpi_status s;
  61
  62         acpi_handle_debug(handle, "Evaluating method %s, parameter %#x\n",
  63                           method, param);
  64         obj.type = ACPI_TYPE_INTEGER;
  65         obj.integer.value = param;
  66         p.count = 1;
  67         p.pointer = &obj;
  68
  69         s = acpi_evaluate_integer(handle, (acpi_string) method, &p, ret);
  70         if (ACPI_FAILURE(s))
  71                 acpi_handle_err(handle,
  72                                 "Failed to eval method %s, param %#x (%d)\n",
  73                                 method, param, s);
  74         else
  75                 acpi_handle_debug(handle, "%s returned %#llx\n", method, *ret);
  76
  77         return s;
  78 }
  79
  80 static enum led_brightness led_state_get(struct led_classdev *led)
  81 {
  82         struct asus_wireless_data *data;
  83         acpi_status s;
  84         u64 ret;
  85
  86         data = container_of(led, struct asus_wireless_data, led);
  87         s = asus_wireless_method(acpi_device_handle(data->adev), "HSWC",
  88                                  data->hswc_params->status, &ret);
  89         if (ACPI_SUCCESS(s) && ret == data->hswc_params->on)
  90                 return LED_FULL;
  91         return LED_OFF;
  92 }
  93
  94 static void led_state_update(struct work_struct *work)
  95 {
  96         struct asus_wireless_data *data;
  97         u64 ret;
  98
  99         data = container_of(work, struct asus_wireless_data, led_work);
 100         asus_wireless_method(acpi_device_handle(data->adev), "HSWC",
 101                              data->led_state, &ret);
 102 }
 103
 104 static void led_state_set(struct led_classdev *led, enum led_brightness value)
 105 {
 106         struct asus_wireless_data *data;
 107
 108         data = container_of(led, struct asus_wireless_data, led);
 109         data->led_state = value == LED_OFF ? data->hswc_params->off :
 110                                              data->hswc_params->on;
 111         queue_work(data->wq, &data->led_work);
 112 }
 113
 114 static void asus_wireless_notify(struct acpi_device *adev, u32 event)
 115 {
 116         struct asus_wireless_data *data = acpi_driver_data(adev);
 117
 118         dev_dbg(&adev->dev, "event=%#x\n", event);
 119         if (event != 0x88) {
 120                 dev_notice(&adev->dev, "Unknown ASHS event: %#x\n", event);
 121                 return;
 122         }
 123         input_report_key(data->idev, KEY_RFKILL, 1);
 124         input_sync(data->idev);
 125         input_report_key(data->idev, KEY_RFKILL, 0);
 126         input_sync(data->idev);
 127 }
 128
 129 static int asus_wireless_add(struct acpi_device *adev)
 130 {
 131         struct asus_wireless_data *data;
 132         const struct acpi_device_id *id;
 133         int err;
 134
 135         data = devm_kzalloc(&adev->dev, sizeof(*data), GFP_KERNEL);
 136         if (!data)
 137                 return -ENOMEM;
 138         adev->driver_data = data;
 139         data->adev = adev;
 140
 141         data->idev = devm_input_allocate_device(&adev->dev);
 142         if (!data->idev)
 143                 return -ENOMEM;
 144         data->idev->name = "Asus Wireless Radio Control";
 145         data->idev->phys = "asus-wireless/input0";
 146         data->idev->id.bustype = BUS_HOST;
 147         data->idev->id.vendor = PCI_VENDOR_ID_ASUSTEK;
 148         set_bit(EV_KEY, data->idev->evbit);
 149         set_bit(KEY_RFKILL, data->idev->keybit);
 150         err = input_register_device(data->idev);
 151         if (err)
 152                 return err;
 153
 154         for (id = device_ids; id->id[0]; id++) {
 155                 if (!strcmp((char *) id->id, acpi_device_hid(adev))) {
 156                         data->hswc_params =
 157                                 (const struct hswc_params *)id->driver_data;
 158                         break;
 159                 }
 160         }
 161         if (!data->hswc_params)
 162                 return 0;
 163
 164         data->wq = create_singlethread_workqueue("asus_wireless_workqueue");
 165         if (!data->wq)
 166                 return -ENOMEM;
 167         INIT_WORK(&data->led_work, led_state_update);
 168         data->led.name = "asus-wireless::airplane";
 169         data->led.brightness_set = led_state_set;
 170         data->led.brightness_get = led_state_get;
 171         data->led.flags = LED_CORE_SUSPENDRESUME;
 172         data->led.max_brightness = 1;
 173         data->led.default_trigger = "rfkill-none";
 174         err = devm_led_classdev_register(&adev->dev, &data->led);
 175         if (err)
 176                 destroy_workqueue(data->wq);
 177
 178         return err;
 179 }
 180
 181 static int asus_wireless_remove(struct acpi_device *adev)
 182 {
 183         struct asus_wireless_data *data = acpi_driver_data(adev);
 184
 185         if (data->wq) {
 186                 devm_led_classdev_unregister(&adev->dev, &data->led);
 187                 destroy_workqueue(data->wq);
 188         }
 189         return 0;
 190 }
 191
 192 static struct acpi_driver asus_wireless_driver = {
 193         .name = "Asus Wireless Radio Control Driver",
 194         .class = "hotkey",
 195         .ids = device_ids,
 196         .ops = {
 197                 .add = asus_wireless_add,
 198                 .remove = asus_wireless_remove,
 199                 .notify = asus_wireless_notify,
 200         },
 201 };
 202 module_acpi_driver(asus_wireless_driver);
 203
 204 MODULE_DESCRIPTION("Asus Wireless Radio Control Driver");
 205 MODULE_AUTHOR("João Paulo Rechi Vita <jprvita@gmail.com>");
 206 MODULE_LICENSE("GPL");