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