projects / deliverable / linux.git / blob
? search:


2179c03b94deea90aaa05d69ba5fcb51f17785bd
[deliverable/linux.git] / drivers / platform / x86 / hp-wmi.c
1 /*
2 * HP WMI hotkeys
3 *
4 * Copyright (C) 2008 Red Hat <mjg@redhat.com>
5 * Copyright (C) 2010, 2011 Anssi Hannula <anssi.hannula@iki.fi>
6 *
7 * Portions based on wistron_btns.c:
8 * Copyright (C) 2005 Miloslav Trmac <mitr@volny.cz>
9 * Copyright (C) 2005 Bernhard Rosenkraenzer <bero@arklinux.org>
10 * Copyright (C) 2005 Dmitry Torokhov <dtor@mail.ru>
11 *
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or
15 * (at your option) any later version.
16 *
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 */
26
27 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
28
29 #include <linux/kernel.h>
30 #include <linux/module.h>
31 #include <linux/init.h>
32 #include <linux/slab.h>
33 #include <linux/types.h>
34 #include <linux/input.h>
35 #include <linux/input/sparse-keymap.h>
36 #include <linux/platform_device.h>
37 #include <linux/acpi.h>
38 #include <linux/rfkill.h>
39 #include <linux/string.h>
40
41 MODULE_AUTHOR("Matthew Garrett <mjg59@srcf.ucam.org>");
42 MODULE_DESCRIPTION("HP laptop WMI hotkeys driver");
43 MODULE_LICENSE("GPL");
44
45 MODULE_ALIAS("wmi:95F24279-4D7B-4334-9387-ACCDC67EF61C");
46 MODULE_ALIAS("wmi:5FB7F034-2C63-45e9-BE91-3D44E2C707E4");
47
48 #define HPWMI_EVENT_GUID "95F24279-4D7B-4334-9387-ACCDC67EF61C"
49 #define HPWMI_BIOS_GUID "5FB7F034-2C63-45e9-BE91-3D44E2C707E4"
50
51 #define HPWMI_DISPLAY_QUERY 0x1
52 #define HPWMI_HDDTEMP_QUERY 0x2
53 #define HPWMI_ALS_QUERY 0x3
54 #define HPWMI_HARDWARE_QUERY 0x4
55 #define HPWMI_WIRELESS_QUERY 0x5
56 #define HPWMI_HOTKEY_QUERY 0xc
57 #define HPWMI_WIRELESS2_QUERY 0x1b
58
59 enum hp_wmi_radio {
60 HPWMI_WIFI = 0,
61 HPWMI_BLUETOOTH = 1,
62 HPWMI_WWAN = 2,
63 HPWMI_GPS = 3,
64 };
65
66 enum hp_wmi_event_ids {
67 HPWMI_DOCK_EVENT = 1,
68 HPWMI_PARK_HDD = 2,
69 HPWMI_SMART_ADAPTER = 3,
70 HPWMI_BEZEL_BUTTON = 4,
71 HPWMI_WIRELESS = 5,
72 HPWMI_CPU_BATTERY_THROTTLE = 6,
73 HPWMI_LOCK_SWITCH = 7,
74 };
75
76 static int hp_wmi_bios_setup(struct platform_device *device);
77 static int __exit hp_wmi_bios_remove(struct platform_device *device);
78 static int hp_wmi_resume_handler(struct device *device);
79
80 struct bios_args {
81 u32 signature;
82 u32 command;
83 u32 commandtype;
84 u32 datasize;
85 u32 data;
86 };
87
88 struct bios_return {
89 u32 sigpass;
90 u32 return_code;
91 };
92
93 enum hp_return_value {
94 HPWMI_RET_WRONG_SIGNATURE = 0x02,
95 HPWMI_RET_UNKNOWN_COMMAND = 0x03,
96 HPWMI_RET_UNKNOWN_CMDTYPE = 0x04,
97 HPWMI_RET_INVALID_PARAMETERS = 0x05,
98 };
99
100 enum hp_wireless2_bits {
101 HPWMI_POWER_STATE = 0x01,
102 HPWMI_POWER_SOFT = 0x02,
103 HPWMI_POWER_BIOS = 0x04,
104 HPWMI_POWER_HARD = 0x08,
105 };
106
107 #define IS_HWBLOCKED(x) ((x & (HPWMI_POWER_BIOS | HPWMI_POWER_HARD)) \
108 != (HPWMI_POWER_BIOS | HPWMI_POWER_HARD))
109 #define IS_SWBLOCKED(x) !(x & HPWMI_POWER_SOFT)
110
111 struct bios_rfkill2_device_state {
112 u8 radio_type;
113 u8 bus_type;
114 u16 vendor_id;
115 u16 product_id;
116 u16 subsys_vendor_id;
117 u16 subsys_product_id;
118 u8 rfkill_id;
119 u8 power;
120 u8 unknown[4];
121 };
122
123 /* 7 devices fit into the 128 byte buffer */
124 #define HPWMI_MAX_RFKILL2_DEVICES 7
125
126 struct bios_rfkill2_state {
127 u8 unknown[7];
128 u8 count;
129 u8 pad[8];
130 struct bios_rfkill2_device_state device[HPWMI_MAX_RFKILL2_DEVICES];
131 };
132
133 static const struct key_entry hp_wmi_keymap[] = {
134 { KE_KEY, 0x02, { KEY_BRIGHTNESSUP } },
135 { KE_KEY, 0x03, { KEY_BRIGHTNESSDOWN } },
136 { KE_KEY, 0x20e6, { KEY_PROG1 } },
137 { KE_KEY, 0x20e8, { KEY_MEDIA } },
138 { KE_KEY, 0x2142, { KEY_MEDIA } },
139 { KE_KEY, 0x213b, { KEY_INFO } },
140 { KE_KEY, 0x2169, { KEY_DIRECTION } },
141 { KE_KEY, 0x231b, { KEY_HELP } },
142 { KE_END, 0 }
143 };
144
145 static struct input_dev *hp_wmi_input_dev;
146 static struct platform_device *hp_wmi_platform_dev;
147
148 static struct rfkill *wifi_rfkill;
149 static struct rfkill *bluetooth_rfkill;
150 static struct rfkill *wwan_rfkill;
151 static struct rfkill *gps_rfkill;
152
153 struct rfkill2_device {
154 u8 id;
155 int num;
156 struct rfkill *rfkill;
157 };
158
159 static int rfkill2_count;
160 static struct rfkill2_device rfkill2[HPWMI_MAX_RFKILL2_DEVICES];
161
162 static const struct dev_pm_ops hp_wmi_pm_ops = {
163 .resume = hp_wmi_resume_handler,
164 .restore = hp_wmi_resume_handler,
165 };
166
167 static struct platform_driver hp_wmi_driver = {
168 .driver = {
169 .name = "hp-wmi",
170 .owner = THIS_MODULE,
171 .pm = &hp_wmi_pm_ops,
172 },
173 .probe = hp_wmi_bios_setup,
174 .remove = hp_wmi_bios_remove,
175 };
176
177 /*
178 * hp_wmi_perform_query
179 *
180 * query: The commandtype -> What should be queried
181 * write: The command -> 0 read, 1 write, 3 ODM specific
182 * buffer: Buffer used as input and/or output
183 * insize: Size of input buffer
184 * outsize: Size of output buffer
185 *
186 * returns zero on success
187 * an HP WMI query specific error code (which is positive)
188 * -EINVAL if the query was not successful at all
189 * -EINVAL if the output buffer size exceeds buffersize
190 *
191 * Note: The buffersize must at least be the maximum of the input and output
192 * size. E.g. Battery info query (0x7) is defined to have 1 byte input
193 * and 128 byte output. The caller would do:
194 * buffer = kzalloc(128, GFP_KERNEL);
195 * ret = hp_wmi_perform_query(0x7, 0, buffer, 1, 128)
196 */
197 static int hp_wmi_perform_query(int query, int write, void *buffer,
198 int insize, int outsize)
199 {
200 struct bios_return *bios_return;
201 int actual_outsize;
202 union acpi_object *obj;
203 struct bios_args args = {
204 .signature = 0x55434553,
205 .command = write ? 0x2 : 0x1,
206 .commandtype = query,
207 .datasize = insize,
208 .data = 0,
209 };
210 struct acpi_buffer input = { sizeof(struct bios_args), &args };
211 struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
212 u32 rc;
213
214 if (WARN_ON(insize > sizeof(args.data)))
215 return -EINVAL;
216 memcpy(&args.data, buffer, insize);
217
218 wmi_evaluate_method(HPWMI_BIOS_GUID, 0, 0x3, &input, &output);
219
220 obj = output.pointer;
221
222 if (!obj)
223 return -EINVAL;
224 else if (obj->type != ACPI_TYPE_BUFFER) {
225 kfree(obj);
226 return -EINVAL;
227 }
228
229 bios_return = (struct bios_return *)obj->buffer.pointer;
230 rc = bios_return->return_code;
231
232 if (rc) {
233 if (rc != HPWMI_RET_UNKNOWN_CMDTYPE)
234 pr_warn("query 0x%x returned error 0x%x\n", query, rc);
235 kfree(obj);
236 return rc;
237 }
238
239 if (!outsize) {
240 /* ignore output data */
241 kfree(obj);
242 return 0;
243 }
244
245 actual_outsize = min(outsize, (int)(obj->buffer.length - sizeof(*bios_return)));
246 memcpy(buffer, obj->buffer.pointer + sizeof(*bios_return), actual_outsize);
247 memset(buffer + actual_outsize, 0, outsize - actual_outsize);
248 kfree(obj);
249 return 0;
250 }
251
252 static int hp_wmi_display_state(void)
253 {
254 int state = 0;
255 int ret = hp_wmi_perform_query(HPWMI_DISPLAY_QUERY, 0, &state,
256 sizeof(state), sizeof(state));
257 if (ret)
258 return -EINVAL;
259 return state;
260 }
261
262 static int hp_wmi_hddtemp_state(void)
263 {
264 int state = 0;
265 int ret = hp_wmi_perform_query(HPWMI_HDDTEMP_QUERY, 0, &state,
266 sizeof(state), sizeof(state));
267 if (ret)
268 return -EINVAL;
269 return state;
270 }
271
272 static int hp_wmi_als_state(void)
273 {
274 int state = 0;
275 int ret = hp_wmi_perform_query(HPWMI_ALS_QUERY, 0, &state,
276 sizeof(state), sizeof(state));
277 if (ret)
278 return -EINVAL;
279 return state;
280 }
281
282 static int hp_wmi_dock_state(void)
283 {
284 int state = 0;
285 int ret = hp_wmi_perform_query(HPWMI_HARDWARE_QUERY, 0, &state,
286 sizeof(state), sizeof(state));
287
288 if (ret)
289 return -EINVAL;
290
291 return state & 0x1;
292 }
293
294 static int hp_wmi_tablet_state(void)
295 {
296 int state = 0;
297 int ret = hp_wmi_perform_query(HPWMI_HARDWARE_QUERY, 0, &state,
298 sizeof(state), sizeof(state));
299 if (ret)
300 return ret;
301
302 return (state & 0x4) ? 1 : 0;
303 }
304
305 static int hp_wmi_set_block(void *data, bool blocked)
306 {
307 enum hp_wmi_radio r = (enum hp_wmi_radio) data;
308 int query = BIT(r + 8) | ((!blocked) << r);
309 int ret;
310
311 ret = hp_wmi_perform_query(HPWMI_WIRELESS_QUERY, 1,
312 &query, sizeof(query), 0);
313 if (ret)
314 return -EINVAL;
315 return 0;
316 }
317
318 static const struct rfkill_ops hp_wmi_rfkill_ops = {
319 .set_block = hp_wmi_set_block,
320 };
321
322 static bool hp_wmi_get_sw_state(enum hp_wmi_radio r)
323 {
324 int wireless = 0;
325 int mask;
326 hp_wmi_perform_query(HPWMI_WIRELESS_QUERY, 0,
327 &wireless, sizeof(wireless),
328 sizeof(wireless));
329 /* TBD: Pass error */
330
331 mask = 0x200 << (r * 8);
332
333 if (wireless & mask)
334 return false;
335 else
336 return true;
337 }
338
339 static bool hp_wmi_get_hw_state(enum hp_wmi_radio r)
340 {
341 int wireless = 0;
342 int mask;
343 hp_wmi_perform_query(HPWMI_WIRELESS_QUERY, 0,
344 &wireless, sizeof(wireless),
345 sizeof(wireless));
346 /* TBD: Pass error */
347
348 mask = 0x800 << (r * 8);
349
350 if (wireless & mask)
351 return false;
352 else
353 return true;
354 }
355
356 static int hp_wmi_rfkill2_set_block(void *data, bool blocked)
357 {
358 int rfkill_id = (int)(long)data;
359 char buffer[4] = { 0x01, 0x00, rfkill_id, !blocked };
360
361 if (hp_wmi_perform_query(HPWMI_WIRELESS2_QUERY, 1,
362 buffer, sizeof(buffer), 0))
363 return -EINVAL;
364 return 0;
365 }
366
367 static const struct rfkill_ops hp_wmi_rfkill2_ops = {
368 .set_block = hp_wmi_rfkill2_set_block,
369 };
370
371 static int hp_wmi_rfkill2_refresh(void)
372 {
373 int err, i;
374 struct bios_rfkill2_state state;
375
376 err = hp_wmi_perform_query(HPWMI_WIRELESS2_QUERY, 0, &state,
377 0, sizeof(state));
378 if (err)
379 return err;
380
381 for (i = 0; i < rfkill2_count; i++) {
382 int num = rfkill2[i].num;
383 struct bios_rfkill2_device_state *devstate;
384 devstate = &state.device[num];
385
386 if (num >= state.count ||
387 devstate->rfkill_id != rfkill2[i].id) {
388 pr_warn("power configuration of the wireless devices unexpectedly changed\n");
389 continue;
390 }
391
392 rfkill_set_states(rfkill2[i].rfkill,
393 IS_SWBLOCKED(devstate->power),
394 IS_HWBLOCKED(devstate->power));
395 }
396
397 return 0;
398 }
399
400 static ssize_t show_display(struct device *dev, struct device_attribute *attr,
401 char *buf)
402 {
403 int value = hp_wmi_display_state();
404 if (value < 0)
405 return -EINVAL;
406 return sprintf(buf, "%d\n", value);
407 }
408
409 static ssize_t show_hddtemp(struct device *dev, struct device_attribute *attr,
410 char *buf)
411 {
412 int value = hp_wmi_hddtemp_state();
413 if (value < 0)
414 return -EINVAL;
415 return sprintf(buf, "%d\n", value);
416 }
417
418 static ssize_t show_als(struct device *dev, struct device_attribute *attr,
419 char *buf)
420 {
421 int value = hp_wmi_als_state();
422 if (value < 0)
423 return -EINVAL;
424 return sprintf(buf, "%d\n", value);
425 }
426
427 static ssize_t show_dock(struct device *dev, struct device_attribute *attr,
428 char *buf)
429 {
430 int value = hp_wmi_dock_state();
431 if (value < 0)
432 return -EINVAL;
433 return sprintf(buf, "%d\n", value);
434 }
435
436 static ssize_t show_tablet(struct device *dev, struct device_attribute *attr,
437 char *buf)
438 {
439 int value = hp_wmi_tablet_state();
440 if (value < 0)
441 return -EINVAL;
442 return sprintf(buf, "%d\n", value);
443 }
444
445 static ssize_t set_als(struct device *dev, struct device_attribute *attr,
446 const char *buf, size_t count)
447 {
448 u32 tmp = simple_strtoul(buf, NULL, 10);
449 int ret = hp_wmi_perform_query(HPWMI_ALS_QUERY, 1, &tmp,
450 sizeof(tmp), sizeof(tmp));
451 if (ret)
452 return -EINVAL;
453
454 return count;
455 }
456
457 static DEVICE_ATTR(display, S_IRUGO, show_display, NULL);
458 static DEVICE_ATTR(hddtemp, S_IRUGO, show_hddtemp, NULL);
459 static DEVICE_ATTR(als, S_IRUGO | S_IWUSR, show_als, set_als);
460 static DEVICE_ATTR(dock, S_IRUGO, show_dock, NULL);
461 static DEVICE_ATTR(tablet, S_IRUGO, show_tablet, NULL);
462
463 static void hp_wmi_notify(u32 value, void *context)
464 {
465 struct acpi_buffer response = { ACPI_ALLOCATE_BUFFER, NULL };
466 union acpi_object *obj;
467 u32 event_id, event_data;
468 int key_code = 0, ret;
469 u32 *location;
470 acpi_status status;
471
472 status = wmi_get_event_data(value, &response);
473 if (status != AE_OK) {
474 pr_info("bad event status 0x%x\n", status);
475 return;
476 }
477
478 obj = (union acpi_object *)response.pointer;
479
480 if (!obj)
481 return;
482 if (obj->type != ACPI_TYPE_BUFFER) {
483 pr_info("Unknown response received %d\n", obj->type);
484 kfree(obj);
485 return;
486 }
487
488 /*
489 * Depending on ACPI version the concatenation of id and event data
490 * inside _WED function will result in a 8 or 16 byte buffer.
491 */
492 location = (u32 *)obj->buffer.pointer;
493 if (obj->buffer.length == 8) {
494 event_id = *location;
495 event_data = *(location + 1);
496 } else if (obj->buffer.length == 16) {
497 event_id = *location;
498 event_data = *(location + 2);
499 } else {
500 pr_info("Unknown buffer length %d\n", obj->buffer.length);
501 kfree(obj);
502 return;
503 }
504 kfree(obj);
505
506 switch (event_id) {
507 case HPWMI_DOCK_EVENT:
508 input_report_switch(hp_wmi_input_dev, SW_DOCK,
509 hp_wmi_dock_state());
510 input_report_switch(hp_wmi_input_dev, SW_TABLET_MODE,
511 hp_wmi_tablet_state());
512 input_sync(hp_wmi_input_dev);
513 break;
514 case HPWMI_PARK_HDD:
515 break;
516 case HPWMI_SMART_ADAPTER:
517 break;
518 case HPWMI_BEZEL_BUTTON:
519 ret = hp_wmi_perform_query(HPWMI_HOTKEY_QUERY, 0,
520 &key_code,
521 sizeof(key_code),
522 sizeof(key_code));
523 if (ret)
524 break;
525
526 if (!sparse_keymap_report_event(hp_wmi_input_dev,
527 key_code, 1, true))
528 pr_info("Unknown key code - 0x%x\n", key_code);
529 break;
530 case HPWMI_WIRELESS:
531 if (rfkill2_count) {
532 hp_wmi_rfkill2_refresh();
533 break;
534 }
535
536 if (wifi_rfkill)
537 rfkill_set_states(wifi_rfkill,
538 hp_wmi_get_sw_state(HPWMI_WIFI),
539 hp_wmi_get_hw_state(HPWMI_WIFI));
540 if (bluetooth_rfkill)
541 rfkill_set_states(bluetooth_rfkill,
542 hp_wmi_get_sw_state(HPWMI_BLUETOOTH),
543 hp_wmi_get_hw_state(HPWMI_BLUETOOTH));
544 if (wwan_rfkill)
545 rfkill_set_states(wwan_rfkill,
546 hp_wmi_get_sw_state(HPWMI_WWAN),
547 hp_wmi_get_hw_state(HPWMI_WWAN));
548 if (gps_rfkill)
549 rfkill_set_states(gps_rfkill,
550 hp_wmi_get_sw_state(HPWMI_GPS),
551 hp_wmi_get_hw_state(HPWMI_GPS));
552 break;
553 case HPWMI_CPU_BATTERY_THROTTLE:
554 pr_info("Unimplemented CPU throttle because of 3 Cell battery event detected\n");
555 break;
556 case HPWMI_LOCK_SWITCH:
557 break;
558 default:
559 pr_info("Unknown event_id - %d - 0x%x\n", event_id, event_data);
560 break;
561 }
562 }
563
564 static int __init hp_wmi_input_setup(void)
565 {
566 acpi_status status;
567 int err;
568
569 hp_wmi_input_dev = input_allocate_device();
570 if (!hp_wmi_input_dev)
571 return -ENOMEM;
572
573 hp_wmi_input_dev->name = "HP WMI hotkeys";
574 hp_wmi_input_dev->phys = "wmi/input0";
575 hp_wmi_input_dev->id.bustype = BUS_HOST;
576
577 __set_bit(EV_SW, hp_wmi_input_dev->evbit);
578 __set_bit(SW_DOCK, hp_wmi_input_dev->swbit);
579 __set_bit(SW_TABLET_MODE, hp_wmi_input_dev->swbit);
580
581 err = sparse_keymap_setup(hp_wmi_input_dev, hp_wmi_keymap, NULL);
582 if (err)
583 goto err_free_dev;
584
585 /* Set initial hardware state */
586 input_report_switch(hp_wmi_input_dev, SW_DOCK, hp_wmi_dock_state());
587 input_report_switch(hp_wmi_input_dev, SW_TABLET_MODE,
588 hp_wmi_tablet_state());
589 input_sync(hp_wmi_input_dev);
590
591 status = wmi_install_notify_handler(HPWMI_EVENT_GUID, hp_wmi_notify, NULL);
592 if (ACPI_FAILURE(status)) {
593 err = -EIO;
594 goto err_free_keymap;
595 }
596
597 err = input_register_device(hp_wmi_input_dev);
598 if (err)
599 goto err_uninstall_notifier;
600
601 return 0;
602
603 err_uninstall_notifier:
604 wmi_remove_notify_handler(HPWMI_EVENT_GUID);
605 err_free_keymap:
606 sparse_keymap_free(hp_wmi_input_dev);
607 err_free_dev:
608 input_free_device(hp_wmi_input_dev);
609 return err;
610 }
611
612 static void hp_wmi_input_destroy(void)
613 {
614 wmi_remove_notify_handler(HPWMI_EVENT_GUID);
615 sparse_keymap_free(hp_wmi_input_dev);
616 input_unregister_device(hp_wmi_input_dev);
617 }
618
619 static void cleanup_sysfs(struct platform_device *device)
620 {
621 device_remove_file(&device->dev, &dev_attr_display);
622 device_remove_file(&device->dev, &dev_attr_hddtemp);
623 device_remove_file(&device->dev, &dev_attr_als);
624 device_remove_file(&device->dev, &dev_attr_dock);
625 device_remove_file(&device->dev, &dev_attr_tablet);
626 }
627
628 static int hp_wmi_rfkill_setup(struct platform_device *device)
629 {
630 int err;
631 int wireless = 0;
632
633 err = hp_wmi_perform_query(HPWMI_WIRELESS_QUERY, 0, &wireless,
634 sizeof(wireless), sizeof(wireless));
635 if (err)
636 return err;
637
638 if (wireless & 0x1) {
639 wifi_rfkill = rfkill_alloc("hp-wifi", &device->dev,
640 RFKILL_TYPE_WLAN,
641 &hp_wmi_rfkill_ops,
642 (void *) HPWMI_WIFI);
643 if (!wifi_rfkill)
644 return -ENOMEM;
645 rfkill_init_sw_state(wifi_rfkill,
646 hp_wmi_get_sw_state(HPWMI_WIFI));
647 rfkill_set_hw_state(wifi_rfkill,
648 hp_wmi_get_hw_state(HPWMI_WIFI));
649 err = rfkill_register(wifi_rfkill);
650 if (err)
651 goto register_wifi_error;
652 }
653
654 if (wireless & 0x2) {
655 bluetooth_rfkill = rfkill_alloc("hp-bluetooth", &device->dev,
656 RFKILL_TYPE_BLUETOOTH,
657 &hp_wmi_rfkill_ops,
658 (void *) HPWMI_BLUETOOTH);
659 if (!bluetooth_rfkill) {
660 err = -ENOMEM;
661 goto register_wifi_error;
662 }
663 rfkill_init_sw_state(bluetooth_rfkill,
664 hp_wmi_get_sw_state(HPWMI_BLUETOOTH));
665 rfkill_set_hw_state(bluetooth_rfkill,
666 hp_wmi_get_hw_state(HPWMI_BLUETOOTH));
667 err = rfkill_register(bluetooth_rfkill);
668 if (err)
669 goto register_bluetooth_error;
670 }
671
672 if (wireless & 0x4) {
673 wwan_rfkill = rfkill_alloc("hp-wwan", &device->dev,
674 RFKILL_TYPE_WWAN,
675 &hp_wmi_rfkill_ops,
676 (void *) HPWMI_WWAN);
677 if (!wwan_rfkill) {
678 err = -ENOMEM;
679 goto register_gps_error;
680 }
681 rfkill_init_sw_state(wwan_rfkill,
682 hp_wmi_get_sw_state(HPWMI_WWAN));
683 rfkill_set_hw_state(wwan_rfkill,
684 hp_wmi_get_hw_state(HPWMI_WWAN));
685 err = rfkill_register(wwan_rfkill);
686 if (err)
687 goto register_wwan_err;
688 }
689
690 if (wireless & 0x8) {
691 gps_rfkill = rfkill_alloc("hp-gps", &device->dev,
692 RFKILL_TYPE_GPS,
693 &hp_wmi_rfkill_ops,
694 (void *) HPWMI_GPS);
695 if (!gps_rfkill) {
696 err = -ENOMEM;
697 goto register_bluetooth_error;
698 }
699 rfkill_init_sw_state(gps_rfkill,
700 hp_wmi_get_sw_state(HPWMI_GPS));
701 rfkill_set_hw_state(bluetooth_rfkill,
702 hp_wmi_get_hw_state(HPWMI_GPS));
703 err = rfkill_register(gps_rfkill);
704 if (err)
705 goto register_gps_error;
706 }
707
708 return 0;
709 register_wwan_err:
710 rfkill_destroy(wwan_rfkill);
711 wwan_rfkill = NULL;
712 if (gps_rfkill)
713 rfkill_unregister(gps_rfkill);
714 register_gps_error:
715 rfkill_destroy(gps_rfkill);
716 gps_rfkill = NULL;
717 if (bluetooth_rfkill)
718 rfkill_unregister(bluetooth_rfkill);
719 register_bluetooth_error:
720 rfkill_destroy(bluetooth_rfkill);
721 bluetooth_rfkill = NULL;
722 if (wifi_rfkill)
723 rfkill_unregister(wifi_rfkill);
724 register_wifi_error:
725 rfkill_destroy(wifi_rfkill);
726 wifi_rfkill = NULL;
727 return err;
728 }
729
730 static int hp_wmi_rfkill2_setup(struct platform_device *device)
731 {
732 int err, i;
733 struct bios_rfkill2_state state;
734 err = hp_wmi_perform_query(HPWMI_WIRELESS2_QUERY, 0, &state,
735 0, sizeof(state));
736 if (err)
737 return err;
738
739 if (state.count > HPWMI_MAX_RFKILL2_DEVICES) {
740 pr_warn("unable to parse 0x1b query output\n");
741 return -EINVAL;
742 }
743
744 for (i = 0; i < state.count; i++) {
745 struct rfkill *rfkill;
746 enum rfkill_type type;
747 char *name;
748 switch (state.device[i].radio_type) {
749 case HPWMI_WIFI:
750 type = RFKILL_TYPE_WLAN;
751 name = "hp-wifi";
752 break;
753 case HPWMI_BLUETOOTH:
754 type = RFKILL_TYPE_BLUETOOTH;
755 name = "hp-bluetooth";
756 break;
757 case HPWMI_WWAN:
758 type = RFKILL_TYPE_WWAN;
759 name = "hp-wwan";
760 break;
761 case HPWMI_GPS:
762 type = RFKILL_TYPE_GPS;
763 name = "hp-gps";
764 break;
765 default:
766 pr_warn("unknown device type 0x%x\n",
767 state.device[i].radio_type);
768 continue;
769 }
770
771 if (!state.device[i].vendor_id) {
772 pr_warn("zero device %d while %d reported\n",
773 i, state.count);
774 continue;
775 }
776
777 rfkill = rfkill_alloc(name, &device->dev, type,
778 &hp_wmi_rfkill2_ops, (void *)(long)i);
779 if (!rfkill) {
780 err = -ENOMEM;
781 goto fail;
782 }
783
784 rfkill2[rfkill2_count].id = state.device[i].rfkill_id;
785 rfkill2[rfkill2_count].num = i;
786 rfkill2[rfkill2_count].rfkill = rfkill;
787
788 rfkill_init_sw_state(rfkill,
789 IS_SWBLOCKED(state.device[i].power));
790 rfkill_set_hw_state(rfkill,
791 IS_HWBLOCKED(state.device[i].power));
792
793 if (!(state.device[i].power & HPWMI_POWER_BIOS))
794 pr_info("device %s blocked by BIOS\n", name);
795
796 err = rfkill_register(rfkill);
797 if (err) {
798 rfkill_destroy(rfkill);
799 goto fail;
800 }
801
802 rfkill2_count++;
803 }
804
805 return 0;
806 fail:
807 for (; rfkill2_count > 0; rfkill2_count--) {
808 rfkill_unregister(rfkill2[rfkill2_count - 1].rfkill);
809 rfkill_destroy(rfkill2[rfkill2_count - 1].rfkill);
810 }
811 return err;
812 }
813
814 static int hp_wmi_bios_setup(struct platform_device *device)
815 {
816 int err;
817
818 /* clear detected rfkill devices */
819 wifi_rfkill = NULL;
820 bluetooth_rfkill = NULL;
821 wwan_rfkill = NULL;
822 gps_rfkill = NULL;
823 rfkill2_count = 0;
824
825 if (hp_wmi_rfkill_setup(device))
826 hp_wmi_rfkill2_setup(device);
827
828 err = device_create_file(&device->dev, &dev_attr_display);
829 if (err)
830 goto add_sysfs_error;
831 err = device_create_file(&device->dev, &dev_attr_hddtemp);
832 if (err)
833 goto add_sysfs_error;
834 err = device_create_file(&device->dev, &dev_attr_als);
835 if (err)
836 goto add_sysfs_error;
837 err = device_create_file(&device->dev, &dev_attr_dock);
838 if (err)
839 goto add_sysfs_error;
840 err = device_create_file(&device->dev, &dev_attr_tablet);
841 if (err)
842 goto add_sysfs_error;
843 return 0;
844
845 add_sysfs_error:
846 cleanup_sysfs(device);
847 return err;
848 }
849
850 static int __exit hp_wmi_bios_remove(struct platform_device *device)
851 {
852 int i;
853 cleanup_sysfs(device);
854
855 for (i = 0; i < rfkill2_count; i++) {
856 rfkill_unregister(rfkill2[i].rfkill);
857 rfkill_destroy(rfkill2[i].rfkill);
858 }
859
860 if (wifi_rfkill) {
861 rfkill_unregister(wifi_rfkill);
862 rfkill_destroy(wifi_rfkill);
863 }
864 if (bluetooth_rfkill) {
865 rfkill_unregister(bluetooth_rfkill);
866 rfkill_destroy(bluetooth_rfkill);
867 }
868 if (wwan_rfkill) {
869 rfkill_unregister(wwan_rfkill);
870 rfkill_destroy(wwan_rfkill);
871 }
872 if (gps_rfkill) {
873 rfkill_unregister(gps_rfkill);
874 rfkill_destroy(gps_rfkill);
875 }
876
877 return 0;
878 }
879
880 static int hp_wmi_resume_handler(struct device *device)
881 {
882 /*
883 * Hardware state may have changed while suspended, so trigger
884 * input events for the current state. As this is a switch,
885 * the input layer will only actually pass it on if the state
886 * changed.
887 */
888 if (hp_wmi_input_dev) {
889 input_report_switch(hp_wmi_input_dev, SW_DOCK,
890 hp_wmi_dock_state());
891 input_report_switch(hp_wmi_input_dev, SW_TABLET_MODE,
892 hp_wmi_tablet_state());
893 input_sync(hp_wmi_input_dev);
894 }
895
896 if (rfkill2_count)
897 hp_wmi_rfkill2_refresh();
898
899 if (wifi_rfkill)
900 rfkill_set_states(wifi_rfkill,
901 hp_wmi_get_sw_state(HPWMI_WIFI),
902 hp_wmi_get_hw_state(HPWMI_WIFI));
903 if (bluetooth_rfkill)
904 rfkill_set_states(bluetooth_rfkill,
905 hp_wmi_get_sw_state(HPWMI_BLUETOOTH),
906 hp_wmi_get_hw_state(HPWMI_BLUETOOTH));
907 if (wwan_rfkill)
908 rfkill_set_states(wwan_rfkill,
909 hp_wmi_get_sw_state(HPWMI_WWAN),
910 hp_wmi_get_hw_state(HPWMI_WWAN));
911 if (gps_rfkill)
912 rfkill_set_states(gps_rfkill,
913 hp_wmi_get_sw_state(HPWMI_GPS),
914 hp_wmi_get_hw_state(HPWMI_GPS));
915
916 return 0;
917 }
918
919 static int __init hp_wmi_init(void)
920 {
921 int err;
922 int event_capable = wmi_has_guid(HPWMI_EVENT_GUID);
923 int bios_capable = wmi_has_guid(HPWMI_BIOS_GUID);
924
925 if (event_capable) {
926 err = hp_wmi_input_setup();
927 if (err)
928 return err;
929 }
930
931 if (bios_capable) {
932 err = platform_driver_register(&hp_wmi_driver);
933 if (err)
934 goto err_driver_reg;
935 hp_wmi_platform_dev = platform_device_alloc("hp-wmi", -1);
936 if (!hp_wmi_platform_dev) {
937 err = -ENOMEM;
938 goto err_device_alloc;
939 }
940 err = platform_device_add(hp_wmi_platform_dev);
941 if (err)
942 goto err_device_add;
943 }
944
945 if (!bios_capable && !event_capable)
946 return -ENODEV;
947
948 return 0;
949
950 err_device_add:
951 platform_device_put(hp_wmi_platform_dev);
952 err_device_alloc:
953 platform_driver_unregister(&hp_wmi_driver);
954 err_driver_reg:
955 if (event_capable)
956 hp_wmi_input_destroy();
957
958 return err;
959 }
960
961 static void __exit hp_wmi_exit(void)
962 {
963 if (wmi_has_guid(HPWMI_EVENT_GUID))
964 hp_wmi_input_destroy();
965
966 if (hp_wmi_platform_dev) {
967 platform_device_unregister(hp_wmi_platform_dev);
968 platform_driver_unregister(&hp_wmi_driver);
969 }
970 }
971
972 module_init(hp_wmi_init);
973 module_exit(hp_wmi_exit);
Linux kernel - Deliverables
This page took 0.080603 seconds and 4 git commands to generate.