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