This source file includes following definitions.
- huawei_wmi_micmute_led_set
- huawei_wmi_leds_setup
- huawei_wmi_process_key
- huawei_wmi_notify
- huawei_wmi_input_setup
- huawei_wmi_probe
1
2
3
4
5
6
7
8 #include <linux/acpi.h>
9 #include <linux/input.h>
10 #include <linux/input/sparse-keymap.h>
11 #include <linux/leds.h>
12 #include <linux/module.h>
13 #include <linux/wmi.h>
14
15
16
17
18 #define WMI0_EVENT_GUID "59142400-C6A3-40fa-BADB-8A2652834100"
19 #define AMW0_EVENT_GUID "ABBC0F5C-8EA1-11D1-A000-C90629100000"
20
21 #define WMI0_EXPENSIVE_GUID "39142400-C6A3-40fa-BADB-8A2652834100"
22
23 struct huawei_wmi_priv {
24 struct input_dev *idev;
25 struct led_classdev cdev;
26 acpi_handle handle;
27 char *acpi_method;
28 };
29
30 static const struct key_entry huawei_wmi_keymap[] = {
31 { KE_KEY, 0x281, { KEY_BRIGHTNESSDOWN } },
32 { KE_KEY, 0x282, { KEY_BRIGHTNESSUP } },
33 { KE_KEY, 0x284, { KEY_MUTE } },
34 { KE_KEY, 0x285, { KEY_VOLUMEDOWN } },
35 { KE_KEY, 0x286, { KEY_VOLUMEUP } },
36 { KE_KEY, 0x287, { KEY_MICMUTE } },
37 { KE_KEY, 0x289, { KEY_WLAN } },
38
39 { KE_KEY, 0x28a, { KEY_CONFIG } },
40
41 { KE_IGNORE, 0x293, { KEY_KBDILLUMTOGGLE } },
42 { KE_IGNORE, 0x294, { KEY_KBDILLUMUP } },
43 { KE_IGNORE, 0x295, { KEY_KBDILLUMUP } },
44 { KE_END, 0 }
45 };
46
47 static int huawei_wmi_micmute_led_set(struct led_classdev *led_cdev,
48 enum led_brightness brightness)
49 {
50 struct huawei_wmi_priv *priv = dev_get_drvdata(led_cdev->dev->parent);
51 acpi_status status;
52 union acpi_object args[3];
53 struct acpi_object_list arg_list = {
54 .pointer = args,
55 .count = ARRAY_SIZE(args),
56 };
57
58 args[0].type = args[1].type = args[2].type = ACPI_TYPE_INTEGER;
59 args[1].integer.value = 0x04;
60
61 if (strcmp(priv->acpi_method, "SPIN") == 0) {
62 args[0].integer.value = 0;
63 args[2].integer.value = brightness ? 1 : 0;
64 } else if (strcmp(priv->acpi_method, "WPIN") == 0) {
65 args[0].integer.value = 1;
66 args[2].integer.value = brightness ? 0 : 1;
67 } else {
68 return -EINVAL;
69 }
70
71 status = acpi_evaluate_object(priv->handle, priv->acpi_method, &arg_list, NULL);
72 if (ACPI_FAILURE(status))
73 return -ENXIO;
74
75 return 0;
76 }
77
78 static int huawei_wmi_leds_setup(struct wmi_device *wdev)
79 {
80 struct huawei_wmi_priv *priv = dev_get_drvdata(&wdev->dev);
81
82 priv->handle = ec_get_handle();
83 if (!priv->handle)
84 return 0;
85
86 if (acpi_has_method(priv->handle, "SPIN"))
87 priv->acpi_method = "SPIN";
88 else if (acpi_has_method(priv->handle, "WPIN"))
89 priv->acpi_method = "WPIN";
90 else
91 return 0;
92
93 priv->cdev.name = "platform::micmute";
94 priv->cdev.max_brightness = 1;
95 priv->cdev.brightness_set_blocking = huawei_wmi_micmute_led_set;
96 priv->cdev.default_trigger = "audio-micmute";
97 priv->cdev.brightness = ledtrig_audio_get(LED_AUDIO_MICMUTE);
98 priv->cdev.dev = &wdev->dev;
99 priv->cdev.flags = LED_CORE_SUSPENDRESUME;
100
101 return devm_led_classdev_register(&wdev->dev, &priv->cdev);
102 }
103
104 static void huawei_wmi_process_key(struct wmi_device *wdev, int code)
105 {
106 struct huawei_wmi_priv *priv = dev_get_drvdata(&wdev->dev);
107 const struct key_entry *key;
108
109
110
111
112
113
114 if (code == 0x80) {
115 struct acpi_buffer response = { ACPI_ALLOCATE_BUFFER, NULL };
116 union acpi_object *obj;
117 acpi_status status;
118
119 status = wmi_query_block(WMI0_EXPENSIVE_GUID, 0, &response);
120 if (ACPI_FAILURE(status))
121 return;
122
123 obj = (union acpi_object *)response.pointer;
124 if (obj && obj->type == ACPI_TYPE_INTEGER)
125 code = obj->integer.value;
126
127 kfree(response.pointer);
128 }
129
130 key = sparse_keymap_entry_from_scancode(priv->idev, code);
131 if (!key) {
132 dev_info(&wdev->dev, "Unknown key pressed, code: 0x%04x\n", code);
133 return;
134 }
135
136 sparse_keymap_report_entry(priv->idev, key, 1, true);
137 }
138
139 static void huawei_wmi_notify(struct wmi_device *wdev,
140 union acpi_object *obj)
141 {
142 if (obj->type == ACPI_TYPE_INTEGER)
143 huawei_wmi_process_key(wdev, obj->integer.value);
144 else
145 dev_info(&wdev->dev, "Bad response type %d\n", obj->type);
146 }
147
148 static int huawei_wmi_input_setup(struct wmi_device *wdev)
149 {
150 struct huawei_wmi_priv *priv = dev_get_drvdata(&wdev->dev);
151 int err;
152
153 priv->idev = devm_input_allocate_device(&wdev->dev);
154 if (!priv->idev)
155 return -ENOMEM;
156
157 priv->idev->name = "Huawei WMI hotkeys";
158 priv->idev->phys = "wmi/input0";
159 priv->idev->id.bustype = BUS_HOST;
160 priv->idev->dev.parent = &wdev->dev;
161
162 err = sparse_keymap_setup(priv->idev, huawei_wmi_keymap, NULL);
163 if (err)
164 return err;
165
166 return input_register_device(priv->idev);
167 }
168
169 static int huawei_wmi_probe(struct wmi_device *wdev, const void *context)
170 {
171 struct huawei_wmi_priv *priv;
172 int err;
173
174 priv = devm_kzalloc(&wdev->dev, sizeof(struct huawei_wmi_priv), GFP_KERNEL);
175 if (!priv)
176 return -ENOMEM;
177
178 dev_set_drvdata(&wdev->dev, priv);
179
180 err = huawei_wmi_input_setup(wdev);
181 if (err)
182 return err;
183
184 return huawei_wmi_leds_setup(wdev);
185 }
186
187 static const struct wmi_device_id huawei_wmi_id_table[] = {
188 { .guid_string = WMI0_EVENT_GUID },
189 { .guid_string = AMW0_EVENT_GUID },
190 { }
191 };
192
193 static struct wmi_driver huawei_wmi_driver = {
194 .driver = {
195 .name = "huawei-wmi",
196 },
197 .id_table = huawei_wmi_id_table,
198 .probe = huawei_wmi_probe,
199 .notify = huawei_wmi_notify,
200 };
201
202 module_wmi_driver(huawei_wmi_driver);
203
204 MODULE_DEVICE_TABLE(wmi, huawei_wmi_id_table);
205 MODULE_AUTHOR("Ayman Bagabas <ayman.bagabas@gmail.com>");
206 MODULE_DESCRIPTION("Huawei WMI hotkeys");
207 MODULE_LICENSE("GPL v2");