asus-wireless.c 5.2 KB

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