This source file includes following definitions.
- dmi_matched
- dell_fill_request
- dell_send_request
- dell_rfkill_set
- dell_rfkill_update_sw_state
- dell_rfkill_update_hw_state
- dell_rfkill_query
- dell_debugfs_show
- dell_update_rfkill
- dell_laptop_i8042_filter
- dell_laptop_rbtn_notifier_call
- dell_setup_rfkill
- dell_cleanup_rfkill
- dell_send_intensity
- dell_get_intensity
- touchpad_led_on
- touchpad_led_off
- touchpad_led_set
- touchpad_led_init
- touchpad_led_exit
- kbd_get_info
- kbd_get_max_level
- kbd_get_level
- kbd_set_level
- kbd_get_state
- kbd_set_state
- kbd_set_state_safe
- kbd_set_token_bit
- kbd_get_token_bit
- kbd_get_first_active_token_bit
- kbd_get_valid_token_counts
- kbd_init_info
- kbd_init_tokens
- kbd_init
- kbd_led_timeout_store
- kbd_led_timeout_show
- kbd_led_triggers_store
- kbd_led_triggers_show
- kbd_led_als_enabled_store
- kbd_led_als_enabled_show
- kbd_led_als_setting_store
- kbd_led_als_setting_show
- kbd_led_level_get
- kbd_led_level_set
- kbd_led_init
- brightness_set_exit
- kbd_led_exit
- dell_laptop_notifier_call
- micmute_led_set
- dell_init
- dell_exit
1
2
3
4
5
6
7
8
9
10
11
12
13 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
14
15 #include <linux/module.h>
16 #include <linux/kernel.h>
17 #include <linux/init.h>
18 #include <linux/platform_device.h>
19 #include <linux/backlight.h>
20 #include <linux/err.h>
21 #include <linux/dmi.h>
22 #include <linux/io.h>
23 #include <linux/rfkill.h>
24 #include <linux/power_supply.h>
25 #include <linux/acpi.h>
26 #include <linux/mm.h>
27 #include <linux/i8042.h>
28 #include <linux/debugfs.h>
29 #include <linux/seq_file.h>
30 #include <acpi/video.h>
31 #include "dell-rbtn.h"
32 #include "dell-smbios.h"
33
34 struct quirk_entry {
35 bool touchpad_led;
36 bool kbd_led_not_present;
37 bool kbd_led_levels_off_1;
38 bool kbd_missing_ac_tag;
39
40 bool needs_kbd_timeouts;
41
42
43
44
45 int kbd_timeouts[];
46 };
47
48 static struct quirk_entry *quirks;
49
50 static struct quirk_entry quirk_dell_vostro_v130 = {
51 .touchpad_led = true,
52 };
53
54 static int __init dmi_matched(const struct dmi_system_id *dmi)
55 {
56 quirks = dmi->driver_data;
57 return 1;
58 }
59
60
61
62
63
64 static struct quirk_entry quirk_dell_xps13_9333 = {
65 .needs_kbd_timeouts = true,
66 .kbd_timeouts = { 0, 5, 15, 60, 5 * 60, 15 * 60, -1 },
67 };
68
69 static struct quirk_entry quirk_dell_xps13_9370 = {
70 .kbd_missing_ac_tag = true,
71 };
72
73 static struct quirk_entry quirk_dell_latitude_e6410 = {
74 .kbd_led_levels_off_1 = true,
75 };
76
77 static struct quirk_entry quirk_dell_inspiron_1012 = {
78 .kbd_led_not_present = true,
79 };
80
81 static struct platform_driver platform_driver = {
82 .driver = {
83 .name = "dell-laptop",
84 }
85 };
86
87 static struct platform_device *platform_device;
88 static struct backlight_device *dell_backlight_device;
89 static struct rfkill *wifi_rfkill;
90 static struct rfkill *bluetooth_rfkill;
91 static struct rfkill *wwan_rfkill;
92 static bool force_rfkill;
93
94 module_param(force_rfkill, bool, 0444);
95 MODULE_PARM_DESC(force_rfkill, "enable rfkill on non whitelisted models");
96
97 static const struct dmi_system_id dell_device_table[] __initconst = {
98 {
99 .ident = "Dell laptop",
100 .matches = {
101 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
102 DMI_MATCH(DMI_CHASSIS_TYPE, "8"),
103 },
104 },
105 {
106 .matches = {
107 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
108 DMI_MATCH(DMI_CHASSIS_TYPE, "9"),
109 },
110 },
111 {
112 .matches = {
113 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
114 DMI_MATCH(DMI_CHASSIS_TYPE, "10"),
115 },
116 },
117 {
118 .matches = {
119 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
120 DMI_MATCH(DMI_CHASSIS_TYPE, "30"),
121 },
122 },
123 {
124 .matches = {
125 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
126 DMI_MATCH(DMI_CHASSIS_TYPE, "31"),
127 },
128 },
129 {
130 .matches = {
131 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
132 DMI_MATCH(DMI_CHASSIS_TYPE, "32"),
133 },
134 },
135 {
136 .ident = "Dell Computer Corporation",
137 .matches = {
138 DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer Corporation"),
139 DMI_MATCH(DMI_CHASSIS_TYPE, "8"),
140 },
141 },
142 { }
143 };
144 MODULE_DEVICE_TABLE(dmi, dell_device_table);
145
146 static const struct dmi_system_id dell_quirks[] __initconst = {
147 {
148 .callback = dmi_matched,
149 .ident = "Dell Vostro V130",
150 .matches = {
151 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
152 DMI_MATCH(DMI_PRODUCT_NAME, "Vostro V130"),
153 },
154 .driver_data = &quirk_dell_vostro_v130,
155 },
156 {
157 .callback = dmi_matched,
158 .ident = "Dell Vostro V131",
159 .matches = {
160 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
161 DMI_MATCH(DMI_PRODUCT_NAME, "Vostro V131"),
162 },
163 .driver_data = &quirk_dell_vostro_v130,
164 },
165 {
166 .callback = dmi_matched,
167 .ident = "Dell Vostro 3350",
168 .matches = {
169 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
170 DMI_MATCH(DMI_PRODUCT_NAME, "Vostro 3350"),
171 },
172 .driver_data = &quirk_dell_vostro_v130,
173 },
174 {
175 .callback = dmi_matched,
176 .ident = "Dell Vostro 3555",
177 .matches = {
178 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
179 DMI_MATCH(DMI_PRODUCT_NAME, "Vostro 3555"),
180 },
181 .driver_data = &quirk_dell_vostro_v130,
182 },
183 {
184 .callback = dmi_matched,
185 .ident = "Dell Inspiron N311z",
186 .matches = {
187 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
188 DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron N311z"),
189 },
190 .driver_data = &quirk_dell_vostro_v130,
191 },
192 {
193 .callback = dmi_matched,
194 .ident = "Dell Inspiron M5110",
195 .matches = {
196 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
197 DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron M5110"),
198 },
199 .driver_data = &quirk_dell_vostro_v130,
200 },
201 {
202 .callback = dmi_matched,
203 .ident = "Dell Vostro 3360",
204 .matches = {
205 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
206 DMI_MATCH(DMI_PRODUCT_NAME, "Vostro 3360"),
207 },
208 .driver_data = &quirk_dell_vostro_v130,
209 },
210 {
211 .callback = dmi_matched,
212 .ident = "Dell Vostro 3460",
213 .matches = {
214 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
215 DMI_MATCH(DMI_PRODUCT_NAME, "Vostro 3460"),
216 },
217 .driver_data = &quirk_dell_vostro_v130,
218 },
219 {
220 .callback = dmi_matched,
221 .ident = "Dell Vostro 3560",
222 .matches = {
223 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
224 DMI_MATCH(DMI_PRODUCT_NAME, "Vostro 3560"),
225 },
226 .driver_data = &quirk_dell_vostro_v130,
227 },
228 {
229 .callback = dmi_matched,
230 .ident = "Dell Vostro 3450",
231 .matches = {
232 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
233 DMI_MATCH(DMI_PRODUCT_NAME, "Dell System Vostro 3450"),
234 },
235 .driver_data = &quirk_dell_vostro_v130,
236 },
237 {
238 .callback = dmi_matched,
239 .ident = "Dell Inspiron 5420",
240 .matches = {
241 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
242 DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron 5420"),
243 },
244 .driver_data = &quirk_dell_vostro_v130,
245 },
246 {
247 .callback = dmi_matched,
248 .ident = "Dell Inspiron 5520",
249 .matches = {
250 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
251 DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron 5520"),
252 },
253 .driver_data = &quirk_dell_vostro_v130,
254 },
255 {
256 .callback = dmi_matched,
257 .ident = "Dell Inspiron 5720",
258 .matches = {
259 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
260 DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron 5720"),
261 },
262 .driver_data = &quirk_dell_vostro_v130,
263 },
264 {
265 .callback = dmi_matched,
266 .ident = "Dell Inspiron 7420",
267 .matches = {
268 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
269 DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron 7420"),
270 },
271 .driver_data = &quirk_dell_vostro_v130,
272 },
273 {
274 .callback = dmi_matched,
275 .ident = "Dell Inspiron 7520",
276 .matches = {
277 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
278 DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron 7520"),
279 },
280 .driver_data = &quirk_dell_vostro_v130,
281 },
282 {
283 .callback = dmi_matched,
284 .ident = "Dell Inspiron 7720",
285 .matches = {
286 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
287 DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron 7720"),
288 },
289 .driver_data = &quirk_dell_vostro_v130,
290 },
291 {
292 .callback = dmi_matched,
293 .ident = "Dell XPS13 9333",
294 .matches = {
295 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
296 DMI_MATCH(DMI_PRODUCT_NAME, "XPS13 9333"),
297 },
298 .driver_data = &quirk_dell_xps13_9333,
299 },
300 {
301 .callback = dmi_matched,
302 .ident = "Dell XPS 13 9370",
303 .matches = {
304 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
305 DMI_MATCH(DMI_PRODUCT_NAME, "XPS 13 9370"),
306 },
307 .driver_data = &quirk_dell_xps13_9370,
308 },
309 {
310 .callback = dmi_matched,
311 .ident = "Dell Latitude E6410",
312 .matches = {
313 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
314 DMI_MATCH(DMI_PRODUCT_NAME, "Latitude E6410"),
315 },
316 .driver_data = &quirk_dell_latitude_e6410,
317 },
318 {
319 .callback = dmi_matched,
320 .ident = "Dell Inspiron 1012",
321 .matches = {
322 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
323 DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron 1012"),
324 },
325 .driver_data = &quirk_dell_inspiron_1012,
326 },
327 {
328 .callback = dmi_matched,
329 .ident = "Dell Inspiron 1018",
330 .matches = {
331 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
332 DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron 1018"),
333 },
334 .driver_data = &quirk_dell_inspiron_1012,
335 },
336 { }
337 };
338
339 static void dell_fill_request(struct calling_interface_buffer *buffer,
340 u32 arg0, u32 arg1, u32 arg2, u32 arg3)
341 {
342 memset(buffer, 0, sizeof(struct calling_interface_buffer));
343 buffer->input[0] = arg0;
344 buffer->input[1] = arg1;
345 buffer->input[2] = arg2;
346 buffer->input[3] = arg3;
347 }
348
349 static int dell_send_request(struct calling_interface_buffer *buffer,
350 u16 class, u16 select)
351 {
352 int ret;
353
354 buffer->cmd_class = class;
355 buffer->cmd_select = select;
356 ret = dell_smbios_call(buffer);
357 if (ret != 0)
358 return ret;
359 return dell_smbios_error(buffer->output[0]);
360 }
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482 static int dell_rfkill_set(void *data, bool blocked)
483 {
484 int disable = blocked ? 1 : 0;
485 unsigned long radio = (unsigned long)data;
486 int hwswitch_bit = (unsigned long)data - 1;
487 struct calling_interface_buffer buffer;
488 int hwswitch;
489 int status;
490 int ret;
491
492 dell_fill_request(&buffer, 0, 0, 0, 0);
493 ret = dell_send_request(&buffer, CLASS_INFO, SELECT_RFKILL);
494 if (ret)
495 return ret;
496 status = buffer.output[1];
497
498 dell_fill_request(&buffer, 0x2, 0, 0, 0);
499 ret = dell_send_request(&buffer, CLASS_INFO, SELECT_RFKILL);
500 if (ret)
501 return ret;
502 hwswitch = buffer.output[1];
503
504
505
506 if (ret == 0 && (hwswitch & BIT(hwswitch_bit)) &&
507 (status & BIT(0)) && !(status & BIT(16)))
508 disable = 1;
509
510 dell_fill_request(&buffer, 1 | (radio<<8) | (disable << 16), 0, 0, 0);
511 ret = dell_send_request(&buffer, CLASS_INFO, SELECT_RFKILL);
512 return ret;
513 }
514
515 static void dell_rfkill_update_sw_state(struct rfkill *rfkill, int radio,
516 int status)
517 {
518 if (status & BIT(0)) {
519
520 struct calling_interface_buffer buffer;
521 int block = rfkill_blocked(rfkill);
522 dell_fill_request(&buffer,
523 1 | (radio << 8) | (block << 16), 0, 0, 0);
524 dell_send_request(&buffer, CLASS_INFO, SELECT_RFKILL);
525 } else {
526
527 rfkill_set_sw_state(rfkill, !!(status & BIT(radio + 16)));
528 }
529 }
530
531 static void dell_rfkill_update_hw_state(struct rfkill *rfkill, int radio,
532 int status, int hwswitch)
533 {
534 if (hwswitch & (BIT(radio - 1)))
535 rfkill_set_hw_state(rfkill, !(status & BIT(16)));
536 }
537
538 static void dell_rfkill_query(struct rfkill *rfkill, void *data)
539 {
540 int radio = ((unsigned long)data & 0xF);
541 struct calling_interface_buffer buffer;
542 int hwswitch;
543 int status;
544 int ret;
545
546 dell_fill_request(&buffer, 0, 0, 0, 0);
547 ret = dell_send_request(&buffer, CLASS_INFO, SELECT_RFKILL);
548 status = buffer.output[1];
549
550 if (ret != 0 || !(status & BIT(0))) {
551 return;
552 }
553
554 dell_fill_request(&buffer, 0x2, 0, 0, 0);
555 ret = dell_send_request(&buffer, CLASS_INFO, SELECT_RFKILL);
556 hwswitch = buffer.output[1];
557
558 if (ret != 0)
559 return;
560
561 dell_rfkill_update_hw_state(rfkill, radio, status, hwswitch);
562 }
563
564 static const struct rfkill_ops dell_rfkill_ops = {
565 .set_block = dell_rfkill_set,
566 .query = dell_rfkill_query,
567 };
568
569 static struct dentry *dell_laptop_dir;
570
571 static int dell_debugfs_show(struct seq_file *s, void *data)
572 {
573 struct calling_interface_buffer buffer;
574 int hwswitch_state;
575 int hwswitch_ret;
576 int status;
577 int ret;
578
579 dell_fill_request(&buffer, 0, 0, 0, 0);
580 ret = dell_send_request(&buffer, CLASS_INFO, SELECT_RFKILL);
581 if (ret)
582 return ret;
583 status = buffer.output[1];
584
585 dell_fill_request(&buffer, 0x2, 0, 0, 0);
586 hwswitch_ret = dell_send_request(&buffer, CLASS_INFO, SELECT_RFKILL);
587 if (hwswitch_ret)
588 return hwswitch_ret;
589 hwswitch_state = buffer.output[1];
590
591 seq_printf(s, "return:\t%d\n", ret);
592 seq_printf(s, "status:\t0x%X\n", status);
593 seq_printf(s, "Bit 0 : Hardware switch supported: %lu\n",
594 status & BIT(0));
595 seq_printf(s, "Bit 1 : Wifi locator supported: %lu\n",
596 (status & BIT(1)) >> 1);
597 seq_printf(s, "Bit 2 : Wifi is supported: %lu\n",
598 (status & BIT(2)) >> 2);
599 seq_printf(s, "Bit 3 : Bluetooth is supported: %lu\n",
600 (status & BIT(3)) >> 3);
601 seq_printf(s, "Bit 4 : WWAN is supported: %lu\n",
602 (status & BIT(4)) >> 4);
603 seq_printf(s, "Bit 5 : Wireless keyboard supported: %lu\n",
604 (status & BIT(5)) >> 5);
605 seq_printf(s, "Bit 6 : UWB supported: %lu\n",
606 (status & BIT(6)) >> 6);
607 seq_printf(s, "Bit 7 : WiGig supported: %lu\n",
608 (status & BIT(7)) >> 7);
609 seq_printf(s, "Bit 8 : Wifi is installed: %lu\n",
610 (status & BIT(8)) >> 8);
611 seq_printf(s, "Bit 9 : Bluetooth is installed: %lu\n",
612 (status & BIT(9)) >> 9);
613 seq_printf(s, "Bit 10: WWAN is installed: %lu\n",
614 (status & BIT(10)) >> 10);
615 seq_printf(s, "Bit 11: UWB installed: %lu\n",
616 (status & BIT(11)) >> 11);
617 seq_printf(s, "Bit 12: WiGig installed: %lu\n",
618 (status & BIT(12)) >> 12);
619
620 seq_printf(s, "Bit 16: Hardware switch is on: %lu\n",
621 (status & BIT(16)) >> 16);
622 seq_printf(s, "Bit 17: Wifi is blocked: %lu\n",
623 (status & BIT(17)) >> 17);
624 seq_printf(s, "Bit 18: Bluetooth is blocked: %lu\n",
625 (status & BIT(18)) >> 18);
626 seq_printf(s, "Bit 19: WWAN is blocked: %lu\n",
627 (status & BIT(19)) >> 19);
628 seq_printf(s, "Bit 20: UWB is blocked: %lu\n",
629 (status & BIT(20)) >> 20);
630 seq_printf(s, "Bit 21: WiGig is blocked: %lu\n",
631 (status & BIT(21)) >> 21);
632
633 seq_printf(s, "\nhwswitch_return:\t%d\n", hwswitch_ret);
634 seq_printf(s, "hwswitch_state:\t0x%X\n", hwswitch_state);
635 seq_printf(s, "Bit 0 : Wifi controlled by switch: %lu\n",
636 hwswitch_state & BIT(0));
637 seq_printf(s, "Bit 1 : Bluetooth controlled by switch: %lu\n",
638 (hwswitch_state & BIT(1)) >> 1);
639 seq_printf(s, "Bit 2 : WWAN controlled by switch: %lu\n",
640 (hwswitch_state & BIT(2)) >> 2);
641 seq_printf(s, "Bit 3 : UWB controlled by switch: %lu\n",
642 (hwswitch_state & BIT(3)) >> 3);
643 seq_printf(s, "Bit 4 : WiGig controlled by switch: %lu\n",
644 (hwswitch_state & BIT(4)) >> 4);
645 seq_printf(s, "Bit 7 : Wireless switch config locked: %lu\n",
646 (hwswitch_state & BIT(7)) >> 7);
647 seq_printf(s, "Bit 8 : Wifi locator enabled: %lu\n",
648 (hwswitch_state & BIT(8)) >> 8);
649 seq_printf(s, "Bit 15: Wifi locator setting locked: %lu\n",
650 (hwswitch_state & BIT(15)) >> 15);
651
652 return 0;
653 }
654 DEFINE_SHOW_ATTRIBUTE(dell_debugfs);
655
656 static void dell_update_rfkill(struct work_struct *ignored)
657 {
658 struct calling_interface_buffer buffer;
659 int hwswitch = 0;
660 int status;
661 int ret;
662
663 dell_fill_request(&buffer, 0, 0, 0, 0);
664 ret = dell_send_request(&buffer, CLASS_INFO, SELECT_RFKILL);
665 status = buffer.output[1];
666
667 if (ret != 0)
668 return;
669
670 dell_fill_request(&buffer, 0x2, 0, 0, 0);
671 ret = dell_send_request(&buffer, CLASS_INFO, SELECT_RFKILL);
672
673 if (ret == 0 && (status & BIT(0)))
674 hwswitch = buffer.output[1];
675
676 if (wifi_rfkill) {
677 dell_rfkill_update_hw_state(wifi_rfkill, 1, status, hwswitch);
678 dell_rfkill_update_sw_state(wifi_rfkill, 1, status);
679 }
680 if (bluetooth_rfkill) {
681 dell_rfkill_update_hw_state(bluetooth_rfkill, 2, status,
682 hwswitch);
683 dell_rfkill_update_sw_state(bluetooth_rfkill, 2, status);
684 }
685 if (wwan_rfkill) {
686 dell_rfkill_update_hw_state(wwan_rfkill, 3, status, hwswitch);
687 dell_rfkill_update_sw_state(wwan_rfkill, 3, status);
688 }
689 }
690 static DECLARE_DELAYED_WORK(dell_rfkill_work, dell_update_rfkill);
691
692 static bool dell_laptop_i8042_filter(unsigned char data, unsigned char str,
693 struct serio *port)
694 {
695 static bool extended;
696
697 if (str & I8042_STR_AUXDATA)
698 return false;
699
700 if (unlikely(data == 0xe0)) {
701 extended = true;
702 return false;
703 } else if (unlikely(extended)) {
704 switch (data) {
705 case 0x8:
706 schedule_delayed_work(&dell_rfkill_work,
707 round_jiffies_relative(HZ / 4));
708 break;
709 }
710 extended = false;
711 }
712
713 return false;
714 }
715
716 static int (*dell_rbtn_notifier_register_func)(struct notifier_block *);
717 static int (*dell_rbtn_notifier_unregister_func)(struct notifier_block *);
718
719 static int dell_laptop_rbtn_notifier_call(struct notifier_block *nb,
720 unsigned long action, void *data)
721 {
722 schedule_delayed_work(&dell_rfkill_work, 0);
723 return NOTIFY_OK;
724 }
725
726 static struct notifier_block dell_laptop_rbtn_notifier = {
727 .notifier_call = dell_laptop_rbtn_notifier_call,
728 };
729
730 static int __init dell_setup_rfkill(void)
731 {
732 struct calling_interface_buffer buffer;
733 int status, ret, whitelisted;
734 const char *product;
735
736
737
738
739
740 whitelisted = 0;
741 product = dmi_get_system_info(DMI_PRODUCT_NAME);
742 if (product && (strncmp(product, "Latitude", 8) == 0 ||
743 strncmp(product, "Precision", 9) == 0))
744 whitelisted = 1;
745 if (!force_rfkill && !whitelisted)
746 return 0;
747
748 dell_fill_request(&buffer, 0, 0, 0, 0);
749 ret = dell_send_request(&buffer, CLASS_INFO, SELECT_RFKILL);
750 status = buffer.output[1];
751
752
753 if (ret != 0)
754 return 0;
755
756
757 if (!(status & BIT(0)) && !force_rfkill)
758 return 0;
759
760 if ((status & (1<<2|1<<8)) == (1<<2|1<<8)) {
761 wifi_rfkill = rfkill_alloc("dell-wifi", &platform_device->dev,
762 RFKILL_TYPE_WLAN,
763 &dell_rfkill_ops, (void *) 1);
764 if (!wifi_rfkill) {
765 ret = -ENOMEM;
766 goto err_wifi;
767 }
768 ret = rfkill_register(wifi_rfkill);
769 if (ret)
770 goto err_wifi;
771 }
772
773 if ((status & (1<<3|1<<9)) == (1<<3|1<<9)) {
774 bluetooth_rfkill = rfkill_alloc("dell-bluetooth",
775 &platform_device->dev,
776 RFKILL_TYPE_BLUETOOTH,
777 &dell_rfkill_ops, (void *) 2);
778 if (!bluetooth_rfkill) {
779 ret = -ENOMEM;
780 goto err_bluetooth;
781 }
782 ret = rfkill_register(bluetooth_rfkill);
783 if (ret)
784 goto err_bluetooth;
785 }
786
787 if ((status & (1<<4|1<<10)) == (1<<4|1<<10)) {
788 wwan_rfkill = rfkill_alloc("dell-wwan",
789 &platform_device->dev,
790 RFKILL_TYPE_WWAN,
791 &dell_rfkill_ops, (void *) 3);
792 if (!wwan_rfkill) {
793 ret = -ENOMEM;
794 goto err_wwan;
795 }
796 ret = rfkill_register(wwan_rfkill);
797 if (ret)
798 goto err_wwan;
799 }
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820 dell_rbtn_notifier_register_func =
821 symbol_request(dell_rbtn_notifier_register);
822 if (dell_rbtn_notifier_register_func) {
823 dell_rbtn_notifier_unregister_func =
824 symbol_request(dell_rbtn_notifier_unregister);
825 if (!dell_rbtn_notifier_unregister_func) {
826 symbol_put(dell_rbtn_notifier_register);
827 dell_rbtn_notifier_register_func = NULL;
828 }
829 }
830
831 if (dell_rbtn_notifier_register_func) {
832 ret = dell_rbtn_notifier_register_func(
833 &dell_laptop_rbtn_notifier);
834 symbol_put(dell_rbtn_notifier_register);
835 dell_rbtn_notifier_register_func = NULL;
836 if (ret != 0) {
837 symbol_put(dell_rbtn_notifier_unregister);
838 dell_rbtn_notifier_unregister_func = NULL;
839 }
840 } else {
841 pr_info("Symbols from dell-rbtn acpi driver are not available\n");
842 ret = -ENODEV;
843 }
844
845 if (ret == 0) {
846 pr_info("Using dell-rbtn acpi driver for receiving events\n");
847 } else if (ret != -ENODEV) {
848 pr_warn("Unable to register dell rbtn notifier\n");
849 goto err_filter;
850 } else {
851 ret = i8042_install_filter(dell_laptop_i8042_filter);
852 if (ret) {
853 pr_warn("Unable to install key filter\n");
854 goto err_filter;
855 }
856 pr_info("Using i8042 filter function for receiving events\n");
857 }
858
859 return 0;
860 err_filter:
861 if (wwan_rfkill)
862 rfkill_unregister(wwan_rfkill);
863 err_wwan:
864 rfkill_destroy(wwan_rfkill);
865 if (bluetooth_rfkill)
866 rfkill_unregister(bluetooth_rfkill);
867 err_bluetooth:
868 rfkill_destroy(bluetooth_rfkill);
869 if (wifi_rfkill)
870 rfkill_unregister(wifi_rfkill);
871 err_wifi:
872 rfkill_destroy(wifi_rfkill);
873
874 return ret;
875 }
876
877 static void dell_cleanup_rfkill(void)
878 {
879 if (dell_rbtn_notifier_unregister_func) {
880 dell_rbtn_notifier_unregister_func(&dell_laptop_rbtn_notifier);
881 symbol_put(dell_rbtn_notifier_unregister);
882 dell_rbtn_notifier_unregister_func = NULL;
883 } else {
884 i8042_remove_filter(dell_laptop_i8042_filter);
885 }
886 cancel_delayed_work_sync(&dell_rfkill_work);
887 if (wifi_rfkill) {
888 rfkill_unregister(wifi_rfkill);
889 rfkill_destroy(wifi_rfkill);
890 }
891 if (bluetooth_rfkill) {
892 rfkill_unregister(bluetooth_rfkill);
893 rfkill_destroy(bluetooth_rfkill);
894 }
895 if (wwan_rfkill) {
896 rfkill_unregister(wwan_rfkill);
897 rfkill_destroy(wwan_rfkill);
898 }
899 }
900
901 static int dell_send_intensity(struct backlight_device *bd)
902 {
903 struct calling_interface_buffer buffer;
904 struct calling_interface_token *token;
905 int ret;
906
907 token = dell_smbios_find_token(BRIGHTNESS_TOKEN);
908 if (!token)
909 return -ENODEV;
910
911 dell_fill_request(&buffer,
912 token->location, bd->props.brightness, 0, 0);
913 if (power_supply_is_system_supplied() > 0)
914 ret = dell_send_request(&buffer,
915 CLASS_TOKEN_WRITE, SELECT_TOKEN_AC);
916 else
917 ret = dell_send_request(&buffer,
918 CLASS_TOKEN_WRITE, SELECT_TOKEN_BAT);
919
920 return ret;
921 }
922
923 static int dell_get_intensity(struct backlight_device *bd)
924 {
925 struct calling_interface_buffer buffer;
926 struct calling_interface_token *token;
927 int ret;
928
929 token = dell_smbios_find_token(BRIGHTNESS_TOKEN);
930 if (!token)
931 return -ENODEV;
932
933 dell_fill_request(&buffer, token->location, 0, 0, 0);
934 if (power_supply_is_system_supplied() > 0)
935 ret = dell_send_request(&buffer,
936 CLASS_TOKEN_READ, SELECT_TOKEN_AC);
937 else
938 ret = dell_send_request(&buffer,
939 CLASS_TOKEN_READ, SELECT_TOKEN_BAT);
940
941 if (ret == 0)
942 ret = buffer.output[1];
943
944 return ret;
945 }
946
947 static const struct backlight_ops dell_ops = {
948 .get_brightness = dell_get_intensity,
949 .update_status = dell_send_intensity,
950 };
951
952 static void touchpad_led_on(void)
953 {
954 int command = 0x97;
955 char data = 1;
956 i8042_command(&data, command | 1 << 12);
957 }
958
959 static void touchpad_led_off(void)
960 {
961 int command = 0x97;
962 char data = 2;
963 i8042_command(&data, command | 1 << 12);
964 }
965
966 static void touchpad_led_set(struct led_classdev *led_cdev,
967 enum led_brightness value)
968 {
969 if (value > 0)
970 touchpad_led_on();
971 else
972 touchpad_led_off();
973 }
974
975 static struct led_classdev touchpad_led = {
976 .name = "dell-laptop::touchpad",
977 .brightness_set = touchpad_led_set,
978 .flags = LED_CORE_SUSPENDRESUME,
979 };
980
981 static int __init touchpad_led_init(struct device *dev)
982 {
983 return led_classdev_register(dev, &touchpad_led);
984 }
985
986 static void touchpad_led_exit(void)
987 {
988 led_classdev_unregister(&touchpad_led);
989 }
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118 enum kbd_timeout_unit {
1119 KBD_TIMEOUT_SECONDS = 0,
1120 KBD_TIMEOUT_MINUTES,
1121 KBD_TIMEOUT_HOURS,
1122 KBD_TIMEOUT_DAYS,
1123 };
1124
1125 enum kbd_mode_bit {
1126 KBD_MODE_BIT_OFF = 0,
1127 KBD_MODE_BIT_ON,
1128 KBD_MODE_BIT_ALS,
1129 KBD_MODE_BIT_TRIGGER_ALS,
1130 KBD_MODE_BIT_TRIGGER,
1131 KBD_MODE_BIT_TRIGGER_25,
1132 KBD_MODE_BIT_TRIGGER_50,
1133 KBD_MODE_BIT_TRIGGER_75,
1134 KBD_MODE_BIT_TRIGGER_100,
1135 };
1136
1137 #define kbd_is_als_mode_bit(bit) \
1138 ((bit) == KBD_MODE_BIT_ALS || (bit) == KBD_MODE_BIT_TRIGGER_ALS)
1139 #define kbd_is_trigger_mode_bit(bit) \
1140 ((bit) >= KBD_MODE_BIT_TRIGGER_ALS && (bit) <= KBD_MODE_BIT_TRIGGER_100)
1141 #define kbd_is_level_mode_bit(bit) \
1142 ((bit) >= KBD_MODE_BIT_TRIGGER_25 && (bit) <= KBD_MODE_BIT_TRIGGER_100)
1143
1144 struct kbd_info {
1145 u16 modes;
1146 u8 type;
1147 u8 triggers;
1148 u8 levels;
1149 u8 seconds;
1150 u8 minutes;
1151 u8 hours;
1152 u8 days;
1153 };
1154
1155 struct kbd_state {
1156 u8 mode_bit;
1157 u8 triggers;
1158 u8 timeout_value;
1159 u8 timeout_unit;
1160 u8 timeout_value_ac;
1161 u8 timeout_unit_ac;
1162 u8 als_setting;
1163 u8 als_value;
1164 u8 level;
1165 };
1166
1167 static const int kbd_tokens[] = {
1168 KBD_LED_OFF_TOKEN,
1169 KBD_LED_AUTO_25_TOKEN,
1170 KBD_LED_AUTO_50_TOKEN,
1171 KBD_LED_AUTO_75_TOKEN,
1172 KBD_LED_AUTO_100_TOKEN,
1173 KBD_LED_ON_TOKEN,
1174 };
1175
1176 static u16 kbd_token_bits;
1177
1178 static struct kbd_info kbd_info;
1179 static bool kbd_als_supported;
1180 static bool kbd_triggers_supported;
1181 static bool kbd_timeout_ac_supported;
1182
1183 static u8 kbd_mode_levels[16];
1184 static int kbd_mode_levels_count;
1185
1186 static u8 kbd_previous_level;
1187 static u8 kbd_previous_mode_bit;
1188
1189 static bool kbd_led_present;
1190 static DEFINE_MUTEX(kbd_led_mutex);
1191 static enum led_brightness kbd_led_level;
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206 static int kbd_get_info(struct kbd_info *info)
1207 {
1208 struct calling_interface_buffer buffer;
1209 u8 units;
1210 int ret;
1211
1212 dell_fill_request(&buffer, 0, 0, 0, 0);
1213 ret = dell_send_request(&buffer,
1214 CLASS_KBD_BACKLIGHT, SELECT_KBD_BACKLIGHT);
1215 if (ret)
1216 return ret;
1217
1218 info->modes = buffer.output[1] & 0xFFFF;
1219 info->type = (buffer.output[1] >> 24) & 0xFF;
1220 info->triggers = buffer.output[2] & 0xFF;
1221 units = (buffer.output[2] >> 8) & 0xFF;
1222 info->levels = (buffer.output[2] >> 16) & 0xFF;
1223
1224 if (quirks && quirks->kbd_led_levels_off_1 && info->levels)
1225 info->levels--;
1226
1227 if (units & BIT(0))
1228 info->seconds = (buffer.output[3] >> 0) & 0xFF;
1229 if (units & BIT(1))
1230 info->minutes = (buffer.output[3] >> 8) & 0xFF;
1231 if (units & BIT(2))
1232 info->hours = (buffer.output[3] >> 16) & 0xFF;
1233 if (units & BIT(3))
1234 info->days = (buffer.output[3] >> 24) & 0xFF;
1235
1236 return ret;
1237 }
1238
1239 static unsigned int kbd_get_max_level(void)
1240 {
1241 if (kbd_info.levels != 0)
1242 return kbd_info.levels;
1243 if (kbd_mode_levels_count > 0)
1244 return kbd_mode_levels_count - 1;
1245 return 0;
1246 }
1247
1248 static int kbd_get_level(struct kbd_state *state)
1249 {
1250 int i;
1251
1252 if (kbd_info.levels != 0)
1253 return state->level;
1254
1255 if (kbd_mode_levels_count > 0) {
1256 for (i = 0; i < kbd_mode_levels_count; ++i)
1257 if (kbd_mode_levels[i] == state->mode_bit)
1258 return i;
1259 return 0;
1260 }
1261
1262 return -EINVAL;
1263 }
1264
1265 static int kbd_set_level(struct kbd_state *state, u8 level)
1266 {
1267 if (kbd_info.levels != 0) {
1268 if (level != 0)
1269 kbd_previous_level = level;
1270 if (state->level == level)
1271 return 0;
1272 state->level = level;
1273 if (level != 0 && state->mode_bit == KBD_MODE_BIT_OFF)
1274 state->mode_bit = kbd_previous_mode_bit;
1275 else if (level == 0 && state->mode_bit != KBD_MODE_BIT_OFF) {
1276 kbd_previous_mode_bit = state->mode_bit;
1277 state->mode_bit = KBD_MODE_BIT_OFF;
1278 }
1279 return 0;
1280 }
1281
1282 if (kbd_mode_levels_count > 0 && level < kbd_mode_levels_count) {
1283 if (level != 0)
1284 kbd_previous_level = level;
1285 state->mode_bit = kbd_mode_levels[level];
1286 return 0;
1287 }
1288
1289 return -EINVAL;
1290 }
1291
1292 static int kbd_get_state(struct kbd_state *state)
1293 {
1294 struct calling_interface_buffer buffer;
1295 int ret;
1296
1297 dell_fill_request(&buffer, 0x1, 0, 0, 0);
1298 ret = dell_send_request(&buffer,
1299 CLASS_KBD_BACKLIGHT, SELECT_KBD_BACKLIGHT);
1300 if (ret)
1301 return ret;
1302
1303 state->mode_bit = ffs(buffer.output[1] & 0xFFFF);
1304 if (state->mode_bit != 0)
1305 state->mode_bit--;
1306
1307 state->triggers = (buffer.output[1] >> 16) & 0xFF;
1308 state->timeout_value = (buffer.output[1] >> 24) & 0x3F;
1309 state->timeout_unit = (buffer.output[1] >> 30) & 0x3;
1310 state->als_setting = buffer.output[2] & 0xFF;
1311 state->als_value = (buffer.output[2] >> 8) & 0xFF;
1312 state->level = (buffer.output[2] >> 16) & 0xFF;
1313 state->timeout_value_ac = (buffer.output[2] >> 24) & 0x3F;
1314 state->timeout_unit_ac = (buffer.output[2] >> 30) & 0x3;
1315
1316 return ret;
1317 }
1318
1319 static int kbd_set_state(struct kbd_state *state)
1320 {
1321 struct calling_interface_buffer buffer;
1322 int ret;
1323 u32 input1;
1324 u32 input2;
1325
1326 input1 = BIT(state->mode_bit) & 0xFFFF;
1327 input1 |= (state->triggers & 0xFF) << 16;
1328 input1 |= (state->timeout_value & 0x3F) << 24;
1329 input1 |= (state->timeout_unit & 0x3) << 30;
1330 input2 = state->als_setting & 0xFF;
1331 input2 |= (state->level & 0xFF) << 16;
1332 input2 |= (state->timeout_value_ac & 0x3F) << 24;
1333 input2 |= (state->timeout_unit_ac & 0x3) << 30;
1334 dell_fill_request(&buffer, 0x2, input1, input2, 0);
1335 ret = dell_send_request(&buffer,
1336 CLASS_KBD_BACKLIGHT, SELECT_KBD_BACKLIGHT);
1337
1338 return ret;
1339 }
1340
1341 static int kbd_set_state_safe(struct kbd_state *state, struct kbd_state *old)
1342 {
1343 int ret;
1344
1345 ret = kbd_set_state(state);
1346 if (ret == 0)
1347 return 0;
1348
1349
1350
1351
1352
1353
1354
1355 if (kbd_set_state(old))
1356 pr_err("Setting old previous keyboard state failed\n");
1357
1358 return ret;
1359 }
1360
1361 static int kbd_set_token_bit(u8 bit)
1362 {
1363 struct calling_interface_buffer buffer;
1364 struct calling_interface_token *token;
1365 int ret;
1366
1367 if (bit >= ARRAY_SIZE(kbd_tokens))
1368 return -EINVAL;
1369
1370 token = dell_smbios_find_token(kbd_tokens[bit]);
1371 if (!token)
1372 return -EINVAL;
1373
1374 dell_fill_request(&buffer, token->location, token->value, 0, 0);
1375 ret = dell_send_request(&buffer, CLASS_TOKEN_WRITE, SELECT_TOKEN_STD);
1376
1377 return ret;
1378 }
1379
1380 static int kbd_get_token_bit(u8 bit)
1381 {
1382 struct calling_interface_buffer buffer;
1383 struct calling_interface_token *token;
1384 int ret;
1385 int val;
1386
1387 if (bit >= ARRAY_SIZE(kbd_tokens))
1388 return -EINVAL;
1389
1390 token = dell_smbios_find_token(kbd_tokens[bit]);
1391 if (!token)
1392 return -EINVAL;
1393
1394 dell_fill_request(&buffer, token->location, 0, 0, 0);
1395 ret = dell_send_request(&buffer, CLASS_TOKEN_READ, SELECT_TOKEN_STD);
1396 val = buffer.output[1];
1397
1398 if (ret)
1399 return ret;
1400
1401 return (val == token->value);
1402 }
1403
1404 static int kbd_get_first_active_token_bit(void)
1405 {
1406 int i;
1407 int ret;
1408
1409 for (i = 0; i < ARRAY_SIZE(kbd_tokens); ++i) {
1410 ret = kbd_get_token_bit(i);
1411 if (ret == 1)
1412 return i;
1413 }
1414
1415 return ret;
1416 }
1417
1418 static int kbd_get_valid_token_counts(void)
1419 {
1420 return hweight16(kbd_token_bits);
1421 }
1422
1423 static inline int kbd_init_info(void)
1424 {
1425 struct kbd_state state;
1426 int ret;
1427 int i;
1428
1429 ret = kbd_get_info(&kbd_info);
1430 if (ret)
1431 return ret;
1432
1433
1434
1435
1436
1437 if ((quirks && quirks->kbd_missing_ac_tag) ||
1438 dell_smbios_find_token(KBD_LED_AC_TOKEN))
1439 kbd_timeout_ac_supported = true;
1440
1441 kbd_get_state(&state);
1442
1443
1444 if (kbd_info.seconds > 63)
1445 kbd_info.seconds = 63;
1446 if (kbd_info.minutes > 63)
1447 kbd_info.minutes = 63;
1448 if (kbd_info.hours > 63)
1449 kbd_info.hours = 63;
1450 if (kbd_info.days > 63)
1451 kbd_info.days = 63;
1452
1453
1454
1455
1456 kbd_info.modes &= ~BIT(KBD_MODE_BIT_ON);
1457
1458 kbd_previous_level = kbd_get_level(&state);
1459 kbd_previous_mode_bit = state.mode_bit;
1460
1461 if (kbd_previous_level == 0 && kbd_get_max_level() != 0)
1462 kbd_previous_level = 1;
1463
1464 if (kbd_previous_mode_bit == KBD_MODE_BIT_OFF) {
1465 kbd_previous_mode_bit =
1466 ffs(kbd_info.modes & ~BIT(KBD_MODE_BIT_OFF));
1467 if (kbd_previous_mode_bit != 0)
1468 kbd_previous_mode_bit--;
1469 }
1470
1471 if (kbd_info.modes & (BIT(KBD_MODE_BIT_ALS) |
1472 BIT(KBD_MODE_BIT_TRIGGER_ALS)))
1473 kbd_als_supported = true;
1474
1475 if (kbd_info.modes & (
1476 BIT(KBD_MODE_BIT_TRIGGER_ALS) | BIT(KBD_MODE_BIT_TRIGGER) |
1477 BIT(KBD_MODE_BIT_TRIGGER_25) | BIT(KBD_MODE_BIT_TRIGGER_50) |
1478 BIT(KBD_MODE_BIT_TRIGGER_75) | BIT(KBD_MODE_BIT_TRIGGER_100)
1479 ))
1480 kbd_triggers_supported = true;
1481
1482
1483 for (i = 0; i < 16; ++i)
1484 if (kbd_is_level_mode_bit(i) && (BIT(i) & kbd_info.modes))
1485 kbd_mode_levels[1 + kbd_mode_levels_count++] = i;
1486
1487
1488
1489
1490
1491
1492 if (kbd_mode_levels_count > 0) {
1493 for (i = 0; i < 16; ++i) {
1494 if (BIT(i) & kbd_info.modes) {
1495 kbd_mode_levels[0] = i;
1496 break;
1497 }
1498 }
1499 kbd_mode_levels_count++;
1500 }
1501
1502 return 0;
1503
1504 }
1505
1506 static inline void kbd_init_tokens(void)
1507 {
1508 int i;
1509
1510 for (i = 0; i < ARRAY_SIZE(kbd_tokens); ++i)
1511 if (dell_smbios_find_token(kbd_tokens[i]))
1512 kbd_token_bits |= BIT(i);
1513 }
1514
1515 static void kbd_init(void)
1516 {
1517 int ret;
1518
1519 if (quirks && quirks->kbd_led_not_present)
1520 return;
1521
1522 ret = kbd_init_info();
1523 kbd_init_tokens();
1524
1525
1526
1527
1528 if ((ret == 0 && (kbd_info.levels != 0 || kbd_mode_levels_count >= 2))
1529 || kbd_get_valid_token_counts() >= 2)
1530 kbd_led_present = true;
1531 }
1532
1533 static ssize_t kbd_led_timeout_store(struct device *dev,
1534 struct device_attribute *attr,
1535 const char *buf, size_t count)
1536 {
1537 struct kbd_state new_state;
1538 struct kbd_state state;
1539 bool convert;
1540 int value;
1541 int ret;
1542 char ch;
1543 u8 unit;
1544 int i;
1545
1546 ret = sscanf(buf, "%d %c", &value, &ch);
1547 if (ret < 1)
1548 return -EINVAL;
1549 else if (ret == 1)
1550 ch = 's';
1551
1552 if (value < 0)
1553 return -EINVAL;
1554
1555 convert = false;
1556
1557 switch (ch) {
1558 case 's':
1559 if (value > kbd_info.seconds)
1560 convert = true;
1561 unit = KBD_TIMEOUT_SECONDS;
1562 break;
1563 case 'm':
1564 if (value > kbd_info.minutes)
1565 convert = true;
1566 unit = KBD_TIMEOUT_MINUTES;
1567 break;
1568 case 'h':
1569 if (value > kbd_info.hours)
1570 convert = true;
1571 unit = KBD_TIMEOUT_HOURS;
1572 break;
1573 case 'd':
1574 if (value > kbd_info.days)
1575 convert = true;
1576 unit = KBD_TIMEOUT_DAYS;
1577 break;
1578 default:
1579 return -EINVAL;
1580 }
1581
1582 if (quirks && quirks->needs_kbd_timeouts)
1583 convert = true;
1584
1585 if (convert) {
1586
1587 switch (unit) {
1588 case KBD_TIMEOUT_DAYS:
1589 value *= 24;
1590
1591 case KBD_TIMEOUT_HOURS:
1592 value *= 60;
1593
1594 case KBD_TIMEOUT_MINUTES:
1595 value *= 60;
1596 unit = KBD_TIMEOUT_SECONDS;
1597 }
1598
1599 if (quirks && quirks->needs_kbd_timeouts) {
1600 for (i = 0; quirks->kbd_timeouts[i] != -1; i++) {
1601 if (value <= quirks->kbd_timeouts[i]) {
1602 value = quirks->kbd_timeouts[i];
1603 break;
1604 }
1605 }
1606 }
1607
1608 if (value <= kbd_info.seconds && kbd_info.seconds) {
1609 unit = KBD_TIMEOUT_SECONDS;
1610 } else if (value / 60 <= kbd_info.minutes && kbd_info.minutes) {
1611 value /= 60;
1612 unit = KBD_TIMEOUT_MINUTES;
1613 } else if (value / (60 * 60) <= kbd_info.hours && kbd_info.hours) {
1614 value /= (60 * 60);
1615 unit = KBD_TIMEOUT_HOURS;
1616 } else if (value / (60 * 60 * 24) <= kbd_info.days && kbd_info.days) {
1617 value /= (60 * 60 * 24);
1618 unit = KBD_TIMEOUT_DAYS;
1619 } else {
1620 return -EINVAL;
1621 }
1622 }
1623
1624 mutex_lock(&kbd_led_mutex);
1625
1626 ret = kbd_get_state(&state);
1627 if (ret)
1628 goto out;
1629
1630 new_state = state;
1631
1632 if (kbd_timeout_ac_supported && power_supply_is_system_supplied() > 0) {
1633 new_state.timeout_value_ac = value;
1634 new_state.timeout_unit_ac = unit;
1635 } else {
1636 new_state.timeout_value = value;
1637 new_state.timeout_unit = unit;
1638 }
1639
1640 ret = kbd_set_state_safe(&new_state, &state);
1641 if (ret)
1642 goto out;
1643
1644 ret = count;
1645 out:
1646 mutex_unlock(&kbd_led_mutex);
1647 return ret;
1648 }
1649
1650 static ssize_t kbd_led_timeout_show(struct device *dev,
1651 struct device_attribute *attr, char *buf)
1652 {
1653 struct kbd_state state;
1654 int value;
1655 int ret;
1656 int len;
1657 u8 unit;
1658
1659 ret = kbd_get_state(&state);
1660 if (ret)
1661 return ret;
1662
1663 if (kbd_timeout_ac_supported && power_supply_is_system_supplied() > 0) {
1664 value = state.timeout_value_ac;
1665 unit = state.timeout_unit_ac;
1666 } else {
1667 value = state.timeout_value;
1668 unit = state.timeout_unit;
1669 }
1670
1671 len = sprintf(buf, "%d", value);
1672
1673 switch (unit) {
1674 case KBD_TIMEOUT_SECONDS:
1675 return len + sprintf(buf+len, "s\n");
1676 case KBD_TIMEOUT_MINUTES:
1677 return len + sprintf(buf+len, "m\n");
1678 case KBD_TIMEOUT_HOURS:
1679 return len + sprintf(buf+len, "h\n");
1680 case KBD_TIMEOUT_DAYS:
1681 return len + sprintf(buf+len, "d\n");
1682 default:
1683 return -EINVAL;
1684 }
1685
1686 return len;
1687 }
1688
1689 static DEVICE_ATTR(stop_timeout, S_IRUGO | S_IWUSR,
1690 kbd_led_timeout_show, kbd_led_timeout_store);
1691
1692 static const char * const kbd_led_triggers[] = {
1693 "keyboard",
1694 "touchpad",
1695 NULL,
1696 "mouse",
1697 };
1698
1699 static ssize_t kbd_led_triggers_store(struct device *dev,
1700 struct device_attribute *attr,
1701 const char *buf, size_t count)
1702 {
1703 struct kbd_state new_state;
1704 struct kbd_state state;
1705 bool triggers_enabled = false;
1706 int trigger_bit = -1;
1707 char trigger[21];
1708 int i, ret;
1709
1710 ret = sscanf(buf, "%20s", trigger);
1711 if (ret != 1)
1712 return -EINVAL;
1713
1714 if (trigger[0] != '+' && trigger[0] != '-')
1715 return -EINVAL;
1716
1717 mutex_lock(&kbd_led_mutex);
1718
1719 ret = kbd_get_state(&state);
1720 if (ret)
1721 goto out;
1722
1723 if (kbd_triggers_supported)
1724 triggers_enabled = kbd_is_trigger_mode_bit(state.mode_bit);
1725
1726 if (kbd_triggers_supported) {
1727 for (i = 0; i < ARRAY_SIZE(kbd_led_triggers); ++i) {
1728 if (!(kbd_info.triggers & BIT(i)))
1729 continue;
1730 if (!kbd_led_triggers[i])
1731 continue;
1732 if (strcmp(trigger+1, kbd_led_triggers[i]) != 0)
1733 continue;
1734 if (trigger[0] == '+' &&
1735 triggers_enabled && (state.triggers & BIT(i))) {
1736 ret = count;
1737 goto out;
1738 }
1739 if (trigger[0] == '-' &&
1740 (!triggers_enabled || !(state.triggers & BIT(i)))) {
1741 ret = count;
1742 goto out;
1743 }
1744 trigger_bit = i;
1745 break;
1746 }
1747 }
1748
1749 if (trigger_bit == -1) {
1750 ret = -EINVAL;
1751 goto out;
1752 }
1753
1754 new_state = state;
1755 if (trigger[0] == '+')
1756 new_state.triggers |= BIT(trigger_bit);
1757 else {
1758 new_state.triggers &= ~BIT(trigger_bit);
1759
1760
1761
1762
1763
1764 if (trigger_bit == 1)
1765 new_state.triggers &= ~BIT(2);
1766 }
1767 if ((kbd_info.triggers & new_state.triggers) !=
1768 new_state.triggers) {
1769 ret = -EINVAL;
1770 goto out;
1771 }
1772 if (new_state.triggers && !triggers_enabled) {
1773 new_state.mode_bit = KBD_MODE_BIT_TRIGGER;
1774 kbd_set_level(&new_state, kbd_previous_level);
1775 } else if (new_state.triggers == 0) {
1776 kbd_set_level(&new_state, 0);
1777 }
1778 if (!(kbd_info.modes & BIT(new_state.mode_bit))) {
1779 ret = -EINVAL;
1780 goto out;
1781 }
1782 ret = kbd_set_state_safe(&new_state, &state);
1783 if (ret)
1784 goto out;
1785 if (new_state.mode_bit != KBD_MODE_BIT_OFF)
1786 kbd_previous_mode_bit = new_state.mode_bit;
1787 ret = count;
1788 out:
1789 mutex_unlock(&kbd_led_mutex);
1790 return ret;
1791 }
1792
1793 static ssize_t kbd_led_triggers_show(struct device *dev,
1794 struct device_attribute *attr, char *buf)
1795 {
1796 struct kbd_state state;
1797 bool triggers_enabled;
1798 int level, i, ret;
1799 int len = 0;
1800
1801 ret = kbd_get_state(&state);
1802 if (ret)
1803 return ret;
1804
1805 len = 0;
1806
1807 if (kbd_triggers_supported) {
1808 triggers_enabled = kbd_is_trigger_mode_bit(state.mode_bit);
1809 level = kbd_get_level(&state);
1810 for (i = 0; i < ARRAY_SIZE(kbd_led_triggers); ++i) {
1811 if (!(kbd_info.triggers & BIT(i)))
1812 continue;
1813 if (!kbd_led_triggers[i])
1814 continue;
1815 if ((triggers_enabled || level <= 0) &&
1816 (state.triggers & BIT(i)))
1817 buf[len++] = '+';
1818 else
1819 buf[len++] = '-';
1820 len += sprintf(buf+len, "%s ", kbd_led_triggers[i]);
1821 }
1822 }
1823
1824 if (len)
1825 buf[len - 1] = '\n';
1826
1827 return len;
1828 }
1829
1830 static DEVICE_ATTR(start_triggers, S_IRUGO | S_IWUSR,
1831 kbd_led_triggers_show, kbd_led_triggers_store);
1832
1833 static ssize_t kbd_led_als_enabled_store(struct device *dev,
1834 struct device_attribute *attr,
1835 const char *buf, size_t count)
1836 {
1837 struct kbd_state new_state;
1838 struct kbd_state state;
1839 bool triggers_enabled = false;
1840 int enable;
1841 int ret;
1842
1843 ret = kstrtoint(buf, 0, &enable);
1844 if (ret)
1845 return ret;
1846
1847 mutex_lock(&kbd_led_mutex);
1848
1849 ret = kbd_get_state(&state);
1850 if (ret)
1851 goto out;
1852
1853 if (enable == kbd_is_als_mode_bit(state.mode_bit)) {
1854 ret = count;
1855 goto out;
1856 }
1857
1858 new_state = state;
1859
1860 if (kbd_triggers_supported)
1861 triggers_enabled = kbd_is_trigger_mode_bit(state.mode_bit);
1862
1863 if (enable) {
1864 if (triggers_enabled)
1865 new_state.mode_bit = KBD_MODE_BIT_TRIGGER_ALS;
1866 else
1867 new_state.mode_bit = KBD_MODE_BIT_ALS;
1868 } else {
1869 if (triggers_enabled) {
1870 new_state.mode_bit = KBD_MODE_BIT_TRIGGER;
1871 kbd_set_level(&new_state, kbd_previous_level);
1872 } else {
1873 new_state.mode_bit = KBD_MODE_BIT_ON;
1874 }
1875 }
1876 if (!(kbd_info.modes & BIT(new_state.mode_bit))) {
1877 ret = -EINVAL;
1878 goto out;
1879 }
1880
1881 ret = kbd_set_state_safe(&new_state, &state);
1882 if (ret)
1883 goto out;
1884 kbd_previous_mode_bit = new_state.mode_bit;
1885
1886 ret = count;
1887 out:
1888 mutex_unlock(&kbd_led_mutex);
1889 return ret;
1890 }
1891
1892 static ssize_t kbd_led_als_enabled_show(struct device *dev,
1893 struct device_attribute *attr,
1894 char *buf)
1895 {
1896 struct kbd_state state;
1897 bool enabled = false;
1898 int ret;
1899
1900 ret = kbd_get_state(&state);
1901 if (ret)
1902 return ret;
1903 enabled = kbd_is_als_mode_bit(state.mode_bit);
1904
1905 return sprintf(buf, "%d\n", enabled ? 1 : 0);
1906 }
1907
1908 static DEVICE_ATTR(als_enabled, S_IRUGO | S_IWUSR,
1909 kbd_led_als_enabled_show, kbd_led_als_enabled_store);
1910
1911 static ssize_t kbd_led_als_setting_store(struct device *dev,
1912 struct device_attribute *attr,
1913 const char *buf, size_t count)
1914 {
1915 struct kbd_state state;
1916 struct kbd_state new_state;
1917 u8 setting;
1918 int ret;
1919
1920 ret = kstrtou8(buf, 10, &setting);
1921 if (ret)
1922 return ret;
1923
1924 mutex_lock(&kbd_led_mutex);
1925
1926 ret = kbd_get_state(&state);
1927 if (ret)
1928 goto out;
1929
1930 new_state = state;
1931 new_state.als_setting = setting;
1932
1933 ret = kbd_set_state_safe(&new_state, &state);
1934 if (ret)
1935 goto out;
1936
1937 ret = count;
1938 out:
1939 mutex_unlock(&kbd_led_mutex);
1940 return ret;
1941 }
1942
1943 static ssize_t kbd_led_als_setting_show(struct device *dev,
1944 struct device_attribute *attr,
1945 char *buf)
1946 {
1947 struct kbd_state state;
1948 int ret;
1949
1950 ret = kbd_get_state(&state);
1951 if (ret)
1952 return ret;
1953
1954 return sprintf(buf, "%d\n", state.als_setting);
1955 }
1956
1957 static DEVICE_ATTR(als_setting, S_IRUGO | S_IWUSR,
1958 kbd_led_als_setting_show, kbd_led_als_setting_store);
1959
1960 static struct attribute *kbd_led_attrs[] = {
1961 &dev_attr_stop_timeout.attr,
1962 &dev_attr_start_triggers.attr,
1963 NULL,
1964 };
1965
1966 static const struct attribute_group kbd_led_group = {
1967 .attrs = kbd_led_attrs,
1968 };
1969
1970 static struct attribute *kbd_led_als_attrs[] = {
1971 &dev_attr_als_enabled.attr,
1972 &dev_attr_als_setting.attr,
1973 NULL,
1974 };
1975
1976 static const struct attribute_group kbd_led_als_group = {
1977 .attrs = kbd_led_als_attrs,
1978 };
1979
1980 static const struct attribute_group *kbd_led_groups[] = {
1981 &kbd_led_group,
1982 &kbd_led_als_group,
1983 NULL,
1984 };
1985
1986 static enum led_brightness kbd_led_level_get(struct led_classdev *led_cdev)
1987 {
1988 int ret;
1989 u16 num;
1990 struct kbd_state state;
1991
1992 if (kbd_get_max_level()) {
1993 ret = kbd_get_state(&state);
1994 if (ret)
1995 return 0;
1996 ret = kbd_get_level(&state);
1997 if (ret < 0)
1998 return 0;
1999 return ret;
2000 }
2001
2002 if (kbd_get_valid_token_counts()) {
2003 ret = kbd_get_first_active_token_bit();
2004 if (ret < 0)
2005 return 0;
2006 for (num = kbd_token_bits; num != 0 && ret > 0; --ret)
2007 num &= num - 1;
2008 if (num == 0)
2009 return 0;
2010 return ffs(num) - 1;
2011 }
2012
2013 pr_warn("Keyboard brightness level control not supported\n");
2014 return 0;
2015 }
2016
2017 static int kbd_led_level_set(struct led_classdev *led_cdev,
2018 enum led_brightness value)
2019 {
2020 enum led_brightness new_value = value;
2021 struct kbd_state state;
2022 struct kbd_state new_state;
2023 u16 num;
2024 int ret;
2025
2026 mutex_lock(&kbd_led_mutex);
2027
2028 if (kbd_get_max_level()) {
2029 ret = kbd_get_state(&state);
2030 if (ret)
2031 goto out;
2032 new_state = state;
2033 ret = kbd_set_level(&new_state, value);
2034 if (ret)
2035 goto out;
2036 ret = kbd_set_state_safe(&new_state, &state);
2037 } else if (kbd_get_valid_token_counts()) {
2038 for (num = kbd_token_bits; num != 0 && value > 0; --value)
2039 num &= num - 1;
2040 if (num == 0)
2041 ret = 0;
2042 else
2043 ret = kbd_set_token_bit(ffs(num) - 1);
2044 } else {
2045 pr_warn("Keyboard brightness level control not supported\n");
2046 ret = -ENXIO;
2047 }
2048
2049 out:
2050 if (ret == 0)
2051 kbd_led_level = new_value;
2052
2053 mutex_unlock(&kbd_led_mutex);
2054 return ret;
2055 }
2056
2057 static struct led_classdev kbd_led = {
2058 .name = "dell::kbd_backlight",
2059 .flags = LED_BRIGHT_HW_CHANGED,
2060 .brightness_set_blocking = kbd_led_level_set,
2061 .brightness_get = kbd_led_level_get,
2062 .groups = kbd_led_groups,
2063 };
2064
2065 static int __init kbd_led_init(struct device *dev)
2066 {
2067 int ret;
2068
2069 kbd_init();
2070 if (!kbd_led_present)
2071 return -ENODEV;
2072 if (!kbd_als_supported)
2073 kbd_led_groups[1] = NULL;
2074 kbd_led.max_brightness = kbd_get_max_level();
2075 if (!kbd_led.max_brightness) {
2076 kbd_led.max_brightness = kbd_get_valid_token_counts();
2077 if (kbd_led.max_brightness)
2078 kbd_led.max_brightness--;
2079 }
2080
2081 kbd_led_level = kbd_led_level_get(NULL);
2082
2083 ret = led_classdev_register(dev, &kbd_led);
2084 if (ret)
2085 kbd_led_present = false;
2086
2087 return ret;
2088 }
2089
2090 static void brightness_set_exit(struct led_classdev *led_cdev,
2091 enum led_brightness value)
2092 {
2093
2094 };
2095
2096 static void kbd_led_exit(void)
2097 {
2098 if (!kbd_led_present)
2099 return;
2100 kbd_led.brightness_set = brightness_set_exit;
2101 led_classdev_unregister(&kbd_led);
2102 }
2103
2104 static int dell_laptop_notifier_call(struct notifier_block *nb,
2105 unsigned long action, void *data)
2106 {
2107 bool changed = false;
2108 enum led_brightness new_kbd_led_level;
2109
2110 switch (action) {
2111 case DELL_LAPTOP_KBD_BACKLIGHT_BRIGHTNESS_CHANGED:
2112 if (!kbd_led_present)
2113 break;
2114
2115 mutex_lock(&kbd_led_mutex);
2116 new_kbd_led_level = kbd_led_level_get(&kbd_led);
2117 if (kbd_led_level != new_kbd_led_level) {
2118 kbd_led_level = new_kbd_led_level;
2119 changed = true;
2120 }
2121 mutex_unlock(&kbd_led_mutex);
2122
2123 if (changed)
2124 led_classdev_notify_brightness_hw_changed(&kbd_led,
2125 kbd_led_level);
2126 break;
2127 }
2128
2129 return NOTIFY_OK;
2130 }
2131
2132 static struct notifier_block dell_laptop_notifier = {
2133 .notifier_call = dell_laptop_notifier_call,
2134 };
2135
2136 static int micmute_led_set(struct led_classdev *led_cdev,
2137 enum led_brightness brightness)
2138 {
2139 struct calling_interface_buffer buffer;
2140 struct calling_interface_token *token;
2141 int state = brightness != LED_OFF;
2142
2143 if (state == 0)
2144 token = dell_smbios_find_token(GLOBAL_MIC_MUTE_DISABLE);
2145 else
2146 token = dell_smbios_find_token(GLOBAL_MIC_MUTE_ENABLE);
2147
2148 if (!token)
2149 return -ENODEV;
2150
2151 dell_fill_request(&buffer, token->location, token->value, 0, 0);
2152 dell_send_request(&buffer, CLASS_TOKEN_WRITE, SELECT_TOKEN_STD);
2153
2154 return 0;
2155 }
2156
2157 static struct led_classdev micmute_led_cdev = {
2158 .name = "platform::micmute",
2159 .max_brightness = 1,
2160 .brightness_set_blocking = micmute_led_set,
2161 .default_trigger = "audio-micmute",
2162 };
2163
2164 static int __init dell_init(void)
2165 {
2166 struct calling_interface_token *token;
2167 int max_intensity = 0;
2168 int ret;
2169
2170 if (!dmi_check_system(dell_device_table))
2171 return -ENODEV;
2172
2173 quirks = NULL;
2174
2175 dmi_check_system(dell_quirks);
2176
2177 ret = platform_driver_register(&platform_driver);
2178 if (ret)
2179 goto fail_platform_driver;
2180 platform_device = platform_device_alloc("dell-laptop", -1);
2181 if (!platform_device) {
2182 ret = -ENOMEM;
2183 goto fail_platform_device1;
2184 }
2185 ret = platform_device_add(platform_device);
2186 if (ret)
2187 goto fail_platform_device2;
2188
2189 ret = dell_setup_rfkill();
2190
2191 if (ret) {
2192 pr_warn("Unable to setup rfkill\n");
2193 goto fail_rfkill;
2194 }
2195
2196 if (quirks && quirks->touchpad_led)
2197 touchpad_led_init(&platform_device->dev);
2198
2199 kbd_led_init(&platform_device->dev);
2200
2201 dell_laptop_dir = debugfs_create_dir("dell_laptop", NULL);
2202 debugfs_create_file("rfkill", 0444, dell_laptop_dir, NULL,
2203 &dell_debugfs_fops);
2204
2205 dell_laptop_register_notifier(&dell_laptop_notifier);
2206
2207 micmute_led_cdev.brightness = ledtrig_audio_get(LED_AUDIO_MICMUTE);
2208 ret = led_classdev_register(&platform_device->dev, &micmute_led_cdev);
2209 if (ret < 0)
2210 goto fail_led;
2211
2212 if (acpi_video_get_backlight_type() != acpi_backlight_vendor)
2213 return 0;
2214
2215 token = dell_smbios_find_token(BRIGHTNESS_TOKEN);
2216 if (token) {
2217 struct calling_interface_buffer buffer;
2218
2219 dell_fill_request(&buffer, token->location, 0, 0, 0);
2220 ret = dell_send_request(&buffer,
2221 CLASS_TOKEN_READ, SELECT_TOKEN_AC);
2222 if (ret == 0)
2223 max_intensity = buffer.output[3];
2224 }
2225
2226 if (max_intensity) {
2227 struct backlight_properties props;
2228 memset(&props, 0, sizeof(struct backlight_properties));
2229 props.type = BACKLIGHT_PLATFORM;
2230 props.max_brightness = max_intensity;
2231 dell_backlight_device = backlight_device_register("dell_backlight",
2232 &platform_device->dev,
2233 NULL,
2234 &dell_ops,
2235 &props);
2236
2237 if (IS_ERR(dell_backlight_device)) {
2238 ret = PTR_ERR(dell_backlight_device);
2239 dell_backlight_device = NULL;
2240 goto fail_backlight;
2241 }
2242
2243 dell_backlight_device->props.brightness =
2244 dell_get_intensity(dell_backlight_device);
2245 if (dell_backlight_device->props.brightness < 0) {
2246 ret = dell_backlight_device->props.brightness;
2247 goto fail_get_brightness;
2248 }
2249 backlight_update_status(dell_backlight_device);
2250 }
2251
2252 return 0;
2253
2254 fail_get_brightness:
2255 backlight_device_unregister(dell_backlight_device);
2256 fail_backlight:
2257 led_classdev_unregister(&micmute_led_cdev);
2258 fail_led:
2259 dell_cleanup_rfkill();
2260 fail_rfkill:
2261 platform_device_del(platform_device);
2262 fail_platform_device2:
2263 platform_device_put(platform_device);
2264 fail_platform_device1:
2265 platform_driver_unregister(&platform_driver);
2266 fail_platform_driver:
2267 return ret;
2268 }
2269
2270 static void __exit dell_exit(void)
2271 {
2272 dell_laptop_unregister_notifier(&dell_laptop_notifier);
2273 debugfs_remove_recursive(dell_laptop_dir);
2274 if (quirks && quirks->touchpad_led)
2275 touchpad_led_exit();
2276 kbd_led_exit();
2277 backlight_device_unregister(dell_backlight_device);
2278 led_classdev_unregister(&micmute_led_cdev);
2279 dell_cleanup_rfkill();
2280 if (platform_device) {
2281 platform_device_unregister(platform_device);
2282 platform_driver_unregister(&platform_driver);
2283 }
2284 }
2285
2286
2287
2288
2289
2290
2291
2292
2293 late_initcall(dell_init);
2294 module_exit(dell_exit);
2295
2296 MODULE_AUTHOR("Matthew Garrett <mjg@redhat.com>");
2297 MODULE_AUTHOR("Gabriele Mazzotta <gabriele.mzt@gmail.com>");
2298 MODULE_AUTHOR("Pali Rohár <pali.rohar@gmail.com>");
2299 MODULE_DESCRIPTION("Dell laptop driver");
2300 MODULE_LICENSE("GPL");