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