1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*-*-linux-c-*-*/
3 
4 /*
5   Copyright (C) 2006 Lennart Poettering <mzxreary (at) 0pointer (dot) de>
6 
7  */
8 
9 /*
10  * msi-laptop.c - MSI S270 laptop support. This laptop is sold under
11  * various brands, including "Cytron/TCM/Medion/Tchibo MD96100".
12  *
13  * Driver also supports S271, S420 models.
14  *
15  * This driver exports a few files in /sys/devices/platform/msi-laptop-pf/:
16  *
17  *   lcd_level - Screen brightness: contains a single integer in the
18  *   range 0..8. (rw)
19  *
20  *   auto_brightness - Enable automatic brightness control: contains
21  *   either 0 or 1. If set to 1 the hardware adjusts the screen
22  *   brightness automatically when the power cord is
23  *   plugged/unplugged. (rw)
24  *
25  *   wlan - WLAN subsystem enabled: contains either 0 or 1. (ro)
26  *
27  *   bluetooth - Bluetooth subsystem enabled: contains either 0 or 1
28  *   Please note that this file is constantly 0 if no Bluetooth
29  *   hardware is available. (ro)
30  *
31  * In addition to these platform device attributes the driver
32  * registers itself in the Linux backlight control subsystem and is
33  * available to userspace under /sys/class/backlight/msi-laptop-bl/.
34  *
35  * This driver might work on other laptops produced by MSI. If you
36  * want to try it you can pass force=1 as argument to the module which
37  * will force it to load even when the DMI data doesn't identify the
38  * laptop as MSI S270. YMMV.
39  */
40 
41 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
42 
43 #include <linux/module.h>
44 #include <linux/kernel.h>
45 #include <linux/init.h>
46 #include <linux/acpi.h>
47 #include <linux/dmi.h>
48 #include <linux/backlight.h>
49 #include <linux/platform_device.h>
50 #include <linux/rfkill.h>
51 #include <linux/i8042.h>
52 #include <linux/input.h>
53 #include <linux/input/sparse-keymap.h>
54 #include <acpi/video.h>
55 
56 #define MSI_LCD_LEVEL_MAX 9
57 
58 #define MSI_EC_COMMAND_WIRELESS 0x10
59 #define MSI_EC_COMMAND_LCD_LEVEL 0x11
60 
61 #define MSI_STANDARD_EC_COMMAND_ADDRESS	0x2e
62 #define MSI_STANDARD_EC_BLUETOOTH_MASK	(1 << 0)
63 #define MSI_STANDARD_EC_WEBCAM_MASK	(1 << 1)
64 #define MSI_STANDARD_EC_WLAN_MASK	(1 << 3)
65 #define MSI_STANDARD_EC_3G_MASK		(1 << 4)
66 
67 /* For set SCM load flag to disable BIOS fn key */
68 #define MSI_STANDARD_EC_SCM_LOAD_ADDRESS	0x2d
69 #define MSI_STANDARD_EC_SCM_LOAD_MASK		(1 << 0)
70 
71 #define MSI_STANDARD_EC_FUNCTIONS_ADDRESS	0xe4
72 /* Power LED is orange - Turbo mode */
73 #define MSI_STANDARD_EC_TURBO_MASK		(1 << 1)
74 /* Power LED is green - ECO mode */
75 #define MSI_STANDARD_EC_ECO_MASK		(1 << 3)
76 /* Touchpad is turned on */
77 #define MSI_STANDARD_EC_TOUCHPAD_MASK		(1 << 4)
78 /* If this bit != bit 1, turbo mode can't be toggled */
79 #define MSI_STANDARD_EC_TURBO_COOLDOWN_MASK	(1 << 7)
80 
81 #define MSI_STANDARD_EC_FAN_ADDRESS		0x33
82 /* If zero, fan rotates at maximal speed */
83 #define MSI_STANDARD_EC_AUTOFAN_MASK		(1 << 0)
84 
85 #ifdef CONFIG_PM_SLEEP
86 static int msi_laptop_resume(struct device *device);
87 #endif
88 static SIMPLE_DEV_PM_OPS(msi_laptop_pm, NULL, msi_laptop_resume);
89 
90 #define MSI_STANDARD_EC_DEVICES_EXISTS_ADDRESS	0x2f
91 
92 static bool force;
93 module_param(force, bool, 0);
94 MODULE_PARM_DESC(force, "Force driver load, ignore DMI data");
95 
96 static int auto_brightness;
97 module_param(auto_brightness, int, 0);
98 MODULE_PARM_DESC(auto_brightness, "Enable automatic brightness control (0: disabled; 1: enabled; 2: don't touch)");
99 
100 static const struct key_entry msi_laptop_keymap[] = {
101 	{KE_KEY, KEY_TOUCHPAD_ON, {KEY_TOUCHPAD_ON} },	/* Touch Pad On */
102 	{KE_KEY, KEY_TOUCHPAD_OFF, {KEY_TOUCHPAD_OFF} },/* Touch Pad On */
103 	{KE_END, 0}
104 };
105 
106 static struct input_dev *msi_laptop_input_dev;
107 
108 static int wlan_s, bluetooth_s, threeg_s;
109 static int threeg_exists;
110 static struct rfkill *rfk_wlan, *rfk_bluetooth, *rfk_threeg;
111 
112 /* MSI laptop quirks */
113 struct quirk_entry {
114 	bool old_ec_model;
115 
116 	/* Some MSI 3G netbook only have one fn key to control
117 	 * Wlan/Bluetooth/3G, those netbook will load the SCM (windows app) to
118 	 * disable the original Wlan/Bluetooth control by BIOS when user press
119 	 * fn key, then control Wlan/Bluetooth/3G by SCM (software control by
120 	 * OS). Without SCM, user cann't on/off 3G module on those 3G netbook.
121 	 * On Linux, msi-laptop driver will do the same thing to disable the
122 	 * original BIOS control, then might need use HAL or other userland
123 	 * application to do the software control that simulate with SCM.
124 	 * e.g. MSI N034 netbook
125 	 */
126 	bool load_scm_model;
127 
128 	/* Some MSI laptops need delay before reading from EC */
129 	bool ec_delay;
130 
131 	/* Some MSI Wind netbooks (e.g. MSI Wind U100) need loading SCM to get
132 	 * some features working (e.g. ECO mode), but we cannot change
133 	 * Wlan/Bluetooth state in software and we can only read its state.
134 	 */
135 	bool ec_read_only;
136 };
137 
138 static struct quirk_entry *quirks;
139 
140 /* Hardware access */
141 
142 static int set_lcd_level(int level)
143 {
144 	u8 buf[2];
145 
146 	if (level < 0 || level >= MSI_LCD_LEVEL_MAX)
147 		return -EINVAL;
148 
149 	buf[0] = 0x80;
150 	buf[1] = (u8) (level*31);
151 
152 	return ec_transaction(MSI_EC_COMMAND_LCD_LEVEL, buf, sizeof(buf),
153 			      NULL, 0);
154 }
155 
156 static int get_lcd_level(void)
157 {
158 	u8 wdata = 0, rdata;
159 	int result;
160 
161 	result = ec_transaction(MSI_EC_COMMAND_LCD_LEVEL, &wdata, 1,
162 				&rdata, 1);
163 	if (result < 0)
164 		return result;
165 
166 	return (int) rdata / 31;
167 }
168 
169 static int get_auto_brightness(void)
170 {
171 	u8 wdata = 4, rdata;
172 	int result;
173 
174 	result = ec_transaction(MSI_EC_COMMAND_LCD_LEVEL, &wdata, 1,
175 				&rdata, 1);
176 	if (result < 0)
177 		return result;
178 
179 	return !!(rdata & 8);
180 }
181 
182 static int set_auto_brightness(int enable)
183 {
184 	u8 wdata[2], rdata;
185 	int result;
186 
187 	wdata[0] = 4;
188 
189 	result = ec_transaction(MSI_EC_COMMAND_LCD_LEVEL, wdata, 1,
190 				&rdata, 1);
191 	if (result < 0)
192 		return result;
193 
194 	wdata[0] = 0x84;
195 	wdata[1] = (rdata & 0xF7) | (enable ? 8 : 0);
196 
197 	return ec_transaction(MSI_EC_COMMAND_LCD_LEVEL, wdata, 2,
198 			      NULL, 0);
199 }
200 
201 static ssize_t set_device_state(const char *buf, size_t count, u8 mask)
202 {
203 	int status;
204 	u8 wdata = 0, rdata;
205 	int result;
206 
207 	if (sscanf(buf, "%i", &status) != 1 || (status < 0 || status > 1))
208 		return -EINVAL;
209 
210 	if (quirks->ec_read_only)
211 		return -EOPNOTSUPP;
212 
213 	/* read current device state */
214 	result = ec_read(MSI_STANDARD_EC_COMMAND_ADDRESS, &rdata);
215 	if (result < 0)
216 		return result;
217 
218 	if (!!(rdata & mask) != status) {
219 		/* reverse device bit */
220 		if (rdata & mask)
221 			wdata = rdata & ~mask;
222 		else
223 			wdata = rdata | mask;
224 
225 		result = ec_write(MSI_STANDARD_EC_COMMAND_ADDRESS, wdata);
226 		if (result < 0)
227 			return result;
228 	}
229 
230 	return count;
231 }
232 
233 static int get_wireless_state(int *wlan, int *bluetooth)
234 {
235 	u8 wdata = 0, rdata;
236 	int result;
237 
238 	result = ec_transaction(MSI_EC_COMMAND_WIRELESS, &wdata, 1, &rdata, 1);
239 	if (result < 0)
240 		return result;
241 
242 	if (wlan)
243 		*wlan = !!(rdata & 8);
244 
245 	if (bluetooth)
246 		*bluetooth = !!(rdata & 128);
247 
248 	return 0;
249 }
250 
251 static int get_wireless_state_ec_standard(void)
252 {
253 	u8 rdata;
254 	int result;
255 
256 	result = ec_read(MSI_STANDARD_EC_COMMAND_ADDRESS, &rdata);
257 	if (result < 0)
258 		return result;
259 
260 	wlan_s = !!(rdata & MSI_STANDARD_EC_WLAN_MASK);
261 
262 	bluetooth_s = !!(rdata & MSI_STANDARD_EC_BLUETOOTH_MASK);
263 
264 	threeg_s = !!(rdata & MSI_STANDARD_EC_3G_MASK);
265 
266 	return 0;
267 }
268 
269 static int get_threeg_exists(void)
270 {
271 	u8 rdata;
272 	int result;
273 
274 	result = ec_read(MSI_STANDARD_EC_DEVICES_EXISTS_ADDRESS, &rdata);
275 	if (result < 0)
276 		return result;
277 
278 	threeg_exists = !!(rdata & MSI_STANDARD_EC_3G_MASK);
279 
280 	return 0;
281 }
282 
283 /* Backlight device stuff */
284 
285 static int bl_get_brightness(struct backlight_device *b)
286 {
287 	return get_lcd_level();
288 }
289 
290 
291 static int bl_update_status(struct backlight_device *b)
292 {
293 	return set_lcd_level(b->props.brightness);
294 }
295 
296 static const struct backlight_ops msibl_ops = {
297 	.get_brightness = bl_get_brightness,
298 	.update_status  = bl_update_status,
299 };
300 
301 static struct backlight_device *msibl_device;
302 
303 /* Platform device */
304 
305 static ssize_t show_wlan(struct device *dev,
306 	struct device_attribute *attr, char *buf)
307 {
308 
309 	int ret, enabled = 0;
310 
311 	if (quirks->old_ec_model) {
312 		ret = get_wireless_state(&enabled, NULL);
313 	} else {
314 		ret = get_wireless_state_ec_standard();
315 		enabled = wlan_s;
316 	}
317 	if (ret < 0)
318 		return ret;
319 
320 	return sprintf(buf, "%i\n", enabled);
321 }
322 
323 static ssize_t store_wlan(struct device *dev,
324 	struct device_attribute *attr, const char *buf, size_t count)
325 {
326 	return set_device_state(buf, count, MSI_STANDARD_EC_WLAN_MASK);
327 }
328 
329 static ssize_t show_bluetooth(struct device *dev,
330 	struct device_attribute *attr, char *buf)
331 {
332 
333 	int ret, enabled = 0;
334 
335 	if (quirks->old_ec_model) {
336 		ret = get_wireless_state(NULL, &enabled);
337 	} else {
338 		ret = get_wireless_state_ec_standard();
339 		enabled = bluetooth_s;
340 	}
341 	if (ret < 0)
342 		return ret;
343 
344 	return sprintf(buf, "%i\n", enabled);
345 }
346 
347 static ssize_t store_bluetooth(struct device *dev,
348 	struct device_attribute *attr, const char *buf, size_t count)
349 {
350 	return set_device_state(buf, count, MSI_STANDARD_EC_BLUETOOTH_MASK);
351 }
352 
353 static ssize_t show_threeg(struct device *dev,
354 	struct device_attribute *attr, char *buf)
355 {
356 
357 	int ret;
358 
359 	/* old msi ec not support 3G */
360 	if (quirks->old_ec_model)
361 		return -ENODEV;
362 
363 	ret = get_wireless_state_ec_standard();
364 	if (ret < 0)
365 		return ret;
366 
367 	return sprintf(buf, "%i\n", threeg_s);
368 }
369 
370 static ssize_t store_threeg(struct device *dev,
371 	struct device_attribute *attr, const char *buf, size_t count)
372 {
373 	return set_device_state(buf, count, MSI_STANDARD_EC_3G_MASK);
374 }
375 
376 static ssize_t show_lcd_level(struct device *dev,
377 	struct device_attribute *attr, char *buf)
378 {
379 
380 	int ret;
381 
382 	ret = get_lcd_level();
383 	if (ret < 0)
384 		return ret;
385 
386 	return sprintf(buf, "%i\n", ret);
387 }
388 
389 static ssize_t store_lcd_level(struct device *dev,
390 	struct device_attribute *attr, const char *buf, size_t count)
391 {
392 
393 	int level, ret;
394 
395 	if (sscanf(buf, "%i", &level) != 1 ||
396 	    (level < 0 || level >= MSI_LCD_LEVEL_MAX))
397 		return -EINVAL;
398 
399 	ret = set_lcd_level(level);
400 	if (ret < 0)
401 		return ret;
402 
403 	return count;
404 }
405 
406 static ssize_t show_auto_brightness(struct device *dev,
407 	struct device_attribute *attr, char *buf)
408 {
409 
410 	int ret;
411 
412 	ret = get_auto_brightness();
413 	if (ret < 0)
414 		return ret;
415 
416 	return sprintf(buf, "%i\n", ret);
417 }
418 
419 static ssize_t store_auto_brightness(struct device *dev,
420 	struct device_attribute *attr, const char *buf, size_t count)
421 {
422 
423 	int enable, ret;
424 
425 	if (sscanf(buf, "%i", &enable) != 1 || (enable != (enable & 1)))
426 		return -EINVAL;
427 
428 	ret = set_auto_brightness(enable);
429 	if (ret < 0)
430 		return ret;
431 
432 	return count;
433 }
434 
435 static ssize_t show_touchpad(struct device *dev,
436 	struct device_attribute *attr, char *buf)
437 {
438 
439 	u8 rdata;
440 	int result;
441 
442 	result = ec_read(MSI_STANDARD_EC_FUNCTIONS_ADDRESS, &rdata);
443 	if (result < 0)
444 		return result;
445 
446 	return sprintf(buf, "%i\n", !!(rdata & MSI_STANDARD_EC_TOUCHPAD_MASK));
447 }
448 
449 static ssize_t show_turbo(struct device *dev,
450 	struct device_attribute *attr, char *buf)
451 {
452 
453 	u8 rdata;
454 	int result;
455 
456 	result = ec_read(MSI_STANDARD_EC_FUNCTIONS_ADDRESS, &rdata);
457 	if (result < 0)
458 		return result;
459 
460 	return sprintf(buf, "%i\n", !!(rdata & MSI_STANDARD_EC_TURBO_MASK));
461 }
462 
463 static ssize_t show_eco(struct device *dev,
464 	struct device_attribute *attr, char *buf)
465 {
466 
467 	u8 rdata;
468 	int result;
469 
470 	result = ec_read(MSI_STANDARD_EC_FUNCTIONS_ADDRESS, &rdata);
471 	if (result < 0)
472 		return result;
473 
474 	return sprintf(buf, "%i\n", !!(rdata & MSI_STANDARD_EC_ECO_MASK));
475 }
476 
477 static ssize_t show_turbo_cooldown(struct device *dev,
478 	struct device_attribute *attr, char *buf)
479 {
480 
481 	u8 rdata;
482 	int result;
483 
484 	result = ec_read(MSI_STANDARD_EC_FUNCTIONS_ADDRESS, &rdata);
485 	if (result < 0)
486 		return result;
487 
488 	return sprintf(buf, "%i\n", (!!(rdata & MSI_STANDARD_EC_TURBO_MASK)) |
489 		(!!(rdata & MSI_STANDARD_EC_TURBO_COOLDOWN_MASK) << 1));
490 }
491 
492 static ssize_t show_auto_fan(struct device *dev,
493 	struct device_attribute *attr, char *buf)
494 {
495 
496 	u8 rdata;
497 	int result;
498 
499 	result = ec_read(MSI_STANDARD_EC_FAN_ADDRESS, &rdata);
500 	if (result < 0)
501 		return result;
502 
503 	return sprintf(buf, "%i\n", !!(rdata & MSI_STANDARD_EC_AUTOFAN_MASK));
504 }
505 
506 static ssize_t store_auto_fan(struct device *dev,
507 	struct device_attribute *attr, const char *buf, size_t count)
508 {
509 
510 	int enable, result;
511 
512 	if (sscanf(buf, "%i", &enable) != 1 || (enable != (enable & 1)))
513 		return -EINVAL;
514 
515 	result = ec_write(MSI_STANDARD_EC_FAN_ADDRESS, enable);
516 	if (result < 0)
517 		return result;
518 
519 	return count;
520 }
521 
522 static DEVICE_ATTR(lcd_level, 0644, show_lcd_level, store_lcd_level);
523 static DEVICE_ATTR(auto_brightness, 0644, show_auto_brightness,
524 		   store_auto_brightness);
525 static DEVICE_ATTR(bluetooth, 0444, show_bluetooth, NULL);
526 static DEVICE_ATTR(wlan, 0444, show_wlan, NULL);
527 static DEVICE_ATTR(threeg, 0444, show_threeg, NULL);
528 static DEVICE_ATTR(touchpad, 0444, show_touchpad, NULL);
529 static DEVICE_ATTR(turbo_mode, 0444, show_turbo, NULL);
530 static DEVICE_ATTR(eco_mode, 0444, show_eco, NULL);
531 static DEVICE_ATTR(turbo_cooldown, 0444, show_turbo_cooldown, NULL);
532 static DEVICE_ATTR(auto_fan, 0644, show_auto_fan, store_auto_fan);
533 
534 static struct attribute *msipf_attributes[] = {
535 	&dev_attr_bluetooth.attr,
536 	&dev_attr_wlan.attr,
537 	&dev_attr_touchpad.attr,
538 	&dev_attr_turbo_mode.attr,
539 	&dev_attr_eco_mode.attr,
540 	&dev_attr_turbo_cooldown.attr,
541 	&dev_attr_auto_fan.attr,
542 	NULL
543 };
544 
545 static struct attribute *msipf_old_attributes[] = {
546 	&dev_attr_lcd_level.attr,
547 	&dev_attr_auto_brightness.attr,
548 	NULL
549 };
550 
551 static const struct attribute_group msipf_attribute_group = {
552 	.attrs = msipf_attributes
553 };
554 
555 static const struct attribute_group msipf_old_attribute_group = {
556 	.attrs = msipf_old_attributes
557 };
558 
559 static struct platform_driver msipf_driver = {
560 	.driver = {
561 		.name = "msi-laptop-pf",
562 		.pm = &msi_laptop_pm,
563 	},
564 };
565 
566 static struct platform_device *msipf_device;
567 
568 /* Initialization */
569 
570 static struct quirk_entry quirk_old_ec_model = {
571 	.old_ec_model = true,
572 };
573 
574 static struct quirk_entry quirk_load_scm_model = {
575 	.load_scm_model = true,
576 	.ec_delay = true,
577 };
578 
579 static struct quirk_entry quirk_load_scm_ro_model = {
580 	.load_scm_model = true,
581 	.ec_read_only = true,
582 };
583 
584 static int dmi_check_cb(const struct dmi_system_id *dmi)
585 {
586 	pr_info("Identified laptop model '%s'\n", dmi->ident);
587 
588 	quirks = dmi->driver_data;
589 
590 	return 1;
591 }
592 
593 static unsigned long msi_work_delay(int msecs)
594 {
595 	if (quirks->ec_delay)
596 		return msecs_to_jiffies(msecs);
597 
598 	return 0;
599 }
600 
601 static const struct dmi_system_id msi_dmi_table[] __initconst = {
602 	{
603 		.ident = "MSI S270",
604 		.matches = {
605 			DMI_MATCH(DMI_SYS_VENDOR, "MICRO-STAR INT"),
606 			DMI_MATCH(DMI_PRODUCT_NAME, "MS-1013"),
607 			DMI_MATCH(DMI_PRODUCT_VERSION, "0131"),
608 			DMI_MATCH(DMI_CHASSIS_VENDOR, "MICRO-STAR INT")
609 		},
610 		.driver_data = &quirk_old_ec_model,
611 		.callback = dmi_check_cb
612 	},
613 	{
614 		.ident = "MSI S271",
615 		.matches = {
616 			DMI_MATCH(DMI_SYS_VENDOR, "Micro-Star International"),
617 			DMI_MATCH(DMI_PRODUCT_NAME, "MS-1058"),
618 			DMI_MATCH(DMI_PRODUCT_VERSION, "0581"),
619 			DMI_MATCH(DMI_BOARD_NAME, "MS-1058")
620 		},
621 		.driver_data = &quirk_old_ec_model,
622 		.callback = dmi_check_cb
623 	},
624 	{
625 		.ident = "MSI S420",
626 		.matches = {
627 			DMI_MATCH(DMI_SYS_VENDOR, "Micro-Star International"),
628 			DMI_MATCH(DMI_PRODUCT_NAME, "MS-1412"),
629 			DMI_MATCH(DMI_BOARD_VENDOR, "MSI"),
630 			DMI_MATCH(DMI_BOARD_NAME, "MS-1412")
631 		},
632 		.driver_data = &quirk_old_ec_model,
633 		.callback = dmi_check_cb
634 	},
635 	{
636 		.ident = "Medion MD96100",
637 		.matches = {
638 			DMI_MATCH(DMI_SYS_VENDOR, "NOTEBOOK"),
639 			DMI_MATCH(DMI_PRODUCT_NAME, "SAM2000"),
640 			DMI_MATCH(DMI_PRODUCT_VERSION, "0131"),
641 			DMI_MATCH(DMI_CHASSIS_VENDOR, "MICRO-STAR INT")
642 		},
643 		.driver_data = &quirk_old_ec_model,
644 		.callback = dmi_check_cb
645 	},
646 	{
647 		.ident = "MSI N034",
648 		.matches = {
649 			DMI_MATCH(DMI_SYS_VENDOR,
650 				"MICRO-STAR INTERNATIONAL CO., LTD"),
651 			DMI_MATCH(DMI_PRODUCT_NAME, "MS-N034"),
652 			DMI_MATCH(DMI_CHASSIS_VENDOR,
653 			"MICRO-STAR INTERNATIONAL CO., LTD")
654 		},
655 		.driver_data = &quirk_load_scm_model,
656 		.callback = dmi_check_cb
657 	},
658 	{
659 		.ident = "MSI N051",
660 		.matches = {
661 			DMI_MATCH(DMI_SYS_VENDOR,
662 				"MICRO-STAR INTERNATIONAL CO., LTD"),
663 			DMI_MATCH(DMI_PRODUCT_NAME, "MS-N051"),
664 			DMI_MATCH(DMI_CHASSIS_VENDOR,
665 			"MICRO-STAR INTERNATIONAL CO., LTD")
666 		},
667 		.driver_data = &quirk_load_scm_model,
668 		.callback = dmi_check_cb
669 	},
670 	{
671 		.ident = "MSI N014",
672 		.matches = {
673 			DMI_MATCH(DMI_SYS_VENDOR,
674 				"MICRO-STAR INTERNATIONAL CO., LTD"),
675 			DMI_MATCH(DMI_PRODUCT_NAME, "MS-N014"),
676 		},
677 		.driver_data = &quirk_load_scm_model,
678 		.callback = dmi_check_cb
679 	},
680 	{
681 		.ident = "MSI CR620",
682 		.matches = {
683 			DMI_MATCH(DMI_SYS_VENDOR,
684 				"Micro-Star International"),
685 			DMI_MATCH(DMI_PRODUCT_NAME, "CR620"),
686 		},
687 		.driver_data = &quirk_load_scm_model,
688 		.callback = dmi_check_cb
689 	},
690 	{
691 		.ident = "MSI U270",
692 		.matches = {
693 			DMI_MATCH(DMI_SYS_VENDOR,
694 				"Micro-Star International Co., Ltd."),
695 			DMI_MATCH(DMI_PRODUCT_NAME, "U270 series"),
696 		},
697 		.driver_data = &quirk_load_scm_model,
698 		.callback = dmi_check_cb
699 	},
700 	{
701 		.ident = "MSI U90/U100",
702 		.matches = {
703 			DMI_MATCH(DMI_SYS_VENDOR,
704 				"MICRO-STAR INTERNATIONAL CO., LTD"),
705 			DMI_MATCH(DMI_PRODUCT_NAME, "U90/U100"),
706 		},
707 		.driver_data = &quirk_load_scm_ro_model,
708 		.callback = dmi_check_cb
709 	},
710 	{ }
711 };
712 MODULE_DEVICE_TABLE(dmi, msi_dmi_table);
713 
714 static int rfkill_bluetooth_set(void *data, bool blocked)
715 {
716 	/* Do something with blocked...*/
717 	/*
718 	 * blocked == false is on
719 	 * blocked == true is off
720 	 */
721 	int result = set_device_state(blocked ? "0" : "1", 0,
722 			MSI_STANDARD_EC_BLUETOOTH_MASK);
723 
724 	return min(result, 0);
725 }
726 
727 static int rfkill_wlan_set(void *data, bool blocked)
728 {
729 	int result = set_device_state(blocked ? "0" : "1", 0,
730 			MSI_STANDARD_EC_WLAN_MASK);
731 
732 	return min(result, 0);
733 }
734 
735 static int rfkill_threeg_set(void *data, bool blocked)
736 {
737 	int result = set_device_state(blocked ? "0" : "1", 0,
738 			MSI_STANDARD_EC_3G_MASK);
739 
740 	return min(result, 0);
741 }
742 
743 static const struct rfkill_ops rfkill_bluetooth_ops = {
744 	.set_block = rfkill_bluetooth_set
745 };
746 
747 static const struct rfkill_ops rfkill_wlan_ops = {
748 	.set_block = rfkill_wlan_set
749 };
750 
751 static const struct rfkill_ops rfkill_threeg_ops = {
752 	.set_block = rfkill_threeg_set
753 };
754 
755 static void rfkill_cleanup(void)
756 {
757 	if (rfk_bluetooth) {
758 		rfkill_unregister(rfk_bluetooth);
759 		rfkill_destroy(rfk_bluetooth);
760 	}
761 
762 	if (rfk_threeg) {
763 		rfkill_unregister(rfk_threeg);
764 		rfkill_destroy(rfk_threeg);
765 	}
766 
767 	if (rfk_wlan) {
768 		rfkill_unregister(rfk_wlan);
769 		rfkill_destroy(rfk_wlan);
770 	}
771 }
772 
773 static bool msi_rfkill_set_state(struct rfkill *rfkill, bool blocked)
774 {
775 	if (quirks->ec_read_only)
776 		return rfkill_set_hw_state(rfkill, blocked);
777 	else
778 		return rfkill_set_sw_state(rfkill, blocked);
779 }
780 
781 static void msi_update_rfkill(struct work_struct *ignored)
782 {
783 	get_wireless_state_ec_standard();
784 
785 	if (rfk_wlan)
786 		msi_rfkill_set_state(rfk_wlan, !wlan_s);
787 	if (rfk_bluetooth)
788 		msi_rfkill_set_state(rfk_bluetooth, !bluetooth_s);
789 	if (rfk_threeg)
790 		msi_rfkill_set_state(rfk_threeg, !threeg_s);
791 }
792 static DECLARE_DELAYED_WORK(msi_rfkill_dwork, msi_update_rfkill);
793 
794 static void msi_send_touchpad_key(struct work_struct *ignored)
795 {
796 	u8 rdata;
797 	int result;
798 
799 	result = ec_read(MSI_STANDARD_EC_FUNCTIONS_ADDRESS, &rdata);
800 	if (result < 0)
801 		return;
802 
803 	sparse_keymap_report_event(msi_laptop_input_dev,
804 		(rdata & MSI_STANDARD_EC_TOUCHPAD_MASK) ?
805 		KEY_TOUCHPAD_ON : KEY_TOUCHPAD_OFF, 1, true);
806 }
807 static DECLARE_DELAYED_WORK(msi_touchpad_dwork, msi_send_touchpad_key);
808 
809 static bool msi_laptop_i8042_filter(unsigned char data, unsigned char str,
810 				struct serio *port)
811 {
812 	static bool extended;
813 
814 	if (str & I8042_STR_AUXDATA)
815 		return false;
816 
817 	/* 0x54 wwan, 0x62 bluetooth, 0x76 wlan, 0xE4 touchpad toggle*/
818 	if (unlikely(data == 0xe0)) {
819 		extended = true;
820 		return false;
821 	} else if (unlikely(extended)) {
822 		extended = false;
823 		switch (data) {
824 		case 0xE4:
825 			schedule_delayed_work(&msi_touchpad_dwork, msi_work_delay(500));
826 			break;
827 		case 0x54:
828 		case 0x62:
829 		case 0x76:
830 			schedule_delayed_work(&msi_rfkill_dwork, msi_work_delay(500));
831 			break;
832 		}
833 	}
834 
835 	return false;
836 }
837 
838 static void msi_init_rfkill(struct work_struct *ignored)
839 {
840 	if (rfk_wlan) {
841 		rfkill_set_sw_state(rfk_wlan, !wlan_s);
842 		rfkill_wlan_set(NULL, !wlan_s);
843 	}
844 	if (rfk_bluetooth) {
845 		rfkill_set_sw_state(rfk_bluetooth, !bluetooth_s);
846 		rfkill_bluetooth_set(NULL, !bluetooth_s);
847 	}
848 	if (rfk_threeg) {
849 		rfkill_set_sw_state(rfk_threeg, !threeg_s);
850 		rfkill_threeg_set(NULL, !threeg_s);
851 	}
852 }
853 static DECLARE_DELAYED_WORK(msi_rfkill_init, msi_init_rfkill);
854 
855 static int rfkill_init(struct platform_device *sdev)
856 {
857 	/* add rfkill */
858 	int retval;
859 
860 	/* keep the hardware wireless state */
861 	get_wireless_state_ec_standard();
862 
863 	rfk_bluetooth = rfkill_alloc("msi-bluetooth", &sdev->dev,
864 				RFKILL_TYPE_BLUETOOTH,
865 				&rfkill_bluetooth_ops, NULL);
866 	if (!rfk_bluetooth) {
867 		retval = -ENOMEM;
868 		goto err_bluetooth;
869 	}
870 	retval = rfkill_register(rfk_bluetooth);
871 	if (retval)
872 		goto err_bluetooth;
873 
874 	rfk_wlan = rfkill_alloc("msi-wlan", &sdev->dev, RFKILL_TYPE_WLAN,
875 				&rfkill_wlan_ops, NULL);
876 	if (!rfk_wlan) {
877 		retval = -ENOMEM;
878 		goto err_wlan;
879 	}
880 	retval = rfkill_register(rfk_wlan);
881 	if (retval)
882 		goto err_wlan;
883 
884 	if (threeg_exists) {
885 		rfk_threeg = rfkill_alloc("msi-threeg", &sdev->dev,
886 				RFKILL_TYPE_WWAN, &rfkill_threeg_ops, NULL);
887 		if (!rfk_threeg) {
888 			retval = -ENOMEM;
889 			goto err_threeg;
890 		}
891 		retval = rfkill_register(rfk_threeg);
892 		if (retval)
893 			goto err_threeg;
894 	}
895 
896 	/* schedule to run rfkill state initial */
897 	schedule_delayed_work(&msi_rfkill_init, msi_work_delay(1000));
898 	return 0;
899 
900 err_threeg:
901 	rfkill_destroy(rfk_threeg);
902 	if (rfk_wlan)
903 		rfkill_unregister(rfk_wlan);
904 err_wlan:
905 	rfkill_destroy(rfk_wlan);
906 	if (rfk_bluetooth)
907 		rfkill_unregister(rfk_bluetooth);
908 err_bluetooth:
909 	rfkill_destroy(rfk_bluetooth);
910 
911 	return retval;
912 }
913 
914 static int msi_scm_disable_hw_fn_handling(void)
915 {
916 	u8 data;
917 	int result;
918 
919 	if (!quirks->load_scm_model)
920 		return 0;
921 
922 	/* set load SCM to disable hardware control by fn key */
923 	result = ec_read(MSI_STANDARD_EC_SCM_LOAD_ADDRESS, &data);
924 	if (result < 0)
925 		return result;
926 
927 	result = ec_write(MSI_STANDARD_EC_SCM_LOAD_ADDRESS,
928 		data | MSI_STANDARD_EC_SCM_LOAD_MASK);
929 	if (result < 0)
930 		return result;
931 
932 	return 0;
933 }
934 
935 #ifdef CONFIG_PM_SLEEP
936 static int msi_laptop_resume(struct device *device)
937 {
938 	return msi_scm_disable_hw_fn_handling();
939 }
940 #endif
941 
942 static int __init msi_laptop_input_setup(void)
943 {
944 	int err;
945 
946 	msi_laptop_input_dev = input_allocate_device();
947 	if (!msi_laptop_input_dev)
948 		return -ENOMEM;
949 
950 	msi_laptop_input_dev->name = "MSI Laptop hotkeys";
951 	msi_laptop_input_dev->phys = "msi-laptop/input0";
952 	msi_laptop_input_dev->id.bustype = BUS_HOST;
953 
954 	err = sparse_keymap_setup(msi_laptop_input_dev,
955 		msi_laptop_keymap, NULL);
956 	if (err)
957 		goto err_free_dev;
958 
959 	err = input_register_device(msi_laptop_input_dev);
960 	if (err)
961 		goto err_free_dev;
962 
963 	return 0;
964 
965 err_free_dev:
966 	input_free_device(msi_laptop_input_dev);
967 	return err;
968 }
969 
970 static int __init load_scm_model_init(struct platform_device *sdev)
971 {
972 	int result;
973 
974 	if (!quirks->ec_read_only) {
975 		/* allow userland write sysfs file  */
976 		dev_attr_bluetooth.store = store_bluetooth;
977 		dev_attr_wlan.store = store_wlan;
978 		dev_attr_threeg.store = store_threeg;
979 		dev_attr_bluetooth.attr.mode |= S_IWUSR;
980 		dev_attr_wlan.attr.mode |= S_IWUSR;
981 		dev_attr_threeg.attr.mode |= S_IWUSR;
982 	}
983 
984 	/* disable hardware control by fn key */
985 	result = msi_scm_disable_hw_fn_handling();
986 	if (result < 0)
987 		return result;
988 
989 	/* initial rfkill */
990 	result = rfkill_init(sdev);
991 	if (result < 0)
992 		goto fail_rfkill;
993 
994 	/* setup input device */
995 	result = msi_laptop_input_setup();
996 	if (result)
997 		goto fail_input;
998 
999 	result = i8042_install_filter(msi_laptop_i8042_filter);
1000 	if (result) {
1001 		pr_err("Unable to install key filter\n");
1002 		goto fail_filter;
1003 	}
1004 
1005 	return 0;
1006 
1007 fail_filter:
1008 	input_unregister_device(msi_laptop_input_dev);
1009 
1010 fail_input:
1011 	rfkill_cleanup();
1012 
1013 fail_rfkill:
1014 	return result;
1015 }
1016 
1017 static void msi_scm_model_exit(void)
1018 {
1019 	if (!quirks->load_scm_model)
1020 		return;
1021 
1022 	i8042_remove_filter(msi_laptop_i8042_filter);
1023 	cancel_delayed_work_sync(&msi_touchpad_dwork);
1024 	input_unregister_device(msi_laptop_input_dev);
1025 	cancel_delayed_work_sync(&msi_rfkill_dwork);
1026 	rfkill_cleanup();
1027 }
1028 
1029 static int __init msi_init(void)
1030 {
1031 	int ret;
1032 
1033 	if (acpi_disabled)
1034 		return -ENODEV;
1035 
1036 	dmi_check_system(msi_dmi_table);
1037 	if (!quirks)
1038 		/* quirks may be NULL if no match in DMI table */
1039 		quirks = &quirk_load_scm_model;
1040 	if (force)
1041 		quirks = &quirk_old_ec_model;
1042 
1043 	if (!quirks->old_ec_model)
1044 		get_threeg_exists();
1045 
1046 	if (auto_brightness < 0 || auto_brightness > 2)
1047 		return -EINVAL;
1048 
1049 	/* Register backlight stuff */
1050 	if (quirks->old_ec_model &&
1051 	    acpi_video_get_backlight_type() == acpi_backlight_vendor) {
1052 		struct backlight_properties props;
1053 		memset(&props, 0, sizeof(struct backlight_properties));
1054 		props.type = BACKLIGHT_PLATFORM;
1055 		props.max_brightness = MSI_LCD_LEVEL_MAX - 1;
1056 		msibl_device = backlight_device_register("msi-laptop-bl", NULL,
1057 							 NULL, &msibl_ops,
1058 							 &props);
1059 		if (IS_ERR(msibl_device))
1060 			return PTR_ERR(msibl_device);
1061 	}
1062 
1063 	ret = platform_driver_register(&msipf_driver);
1064 	if (ret)
1065 		goto fail_backlight;
1066 
1067 	/* Register platform stuff */
1068 
1069 	msipf_device = platform_device_alloc("msi-laptop-pf", PLATFORM_DEVID_NONE);
1070 	if (!msipf_device) {
1071 		ret = -ENOMEM;
1072 		goto fail_platform_driver;
1073 	}
1074 
1075 	ret = platform_device_add(msipf_device);
1076 	if (ret)
1077 		goto fail_device_add;
1078 
1079 	if (quirks->load_scm_model && (load_scm_model_init(msipf_device) < 0)) {
1080 		ret = -EINVAL;
1081 		goto fail_scm_model_init;
1082 	}
1083 
1084 	ret = sysfs_create_group(&msipf_device->dev.kobj,
1085 				 &msipf_attribute_group);
1086 	if (ret)
1087 		goto fail_create_group;
1088 
1089 	if (!quirks->old_ec_model) {
1090 		if (threeg_exists)
1091 			ret = device_create_file(&msipf_device->dev,
1092 						&dev_attr_threeg);
1093 		if (ret)
1094 			goto fail_create_attr;
1095 	} else {
1096 		ret = sysfs_create_group(&msipf_device->dev.kobj,
1097 					 &msipf_old_attribute_group);
1098 		if (ret)
1099 			goto fail_create_attr;
1100 
1101 		/* Disable automatic brightness control by default because
1102 		 * this module was probably loaded to do brightness control in
1103 		 * software. */
1104 
1105 		if (auto_brightness != 2)
1106 			set_auto_brightness(auto_brightness);
1107 	}
1108 
1109 	return 0;
1110 
1111 fail_create_attr:
1112 	sysfs_remove_group(&msipf_device->dev.kobj, &msipf_attribute_group);
1113 fail_create_group:
1114 	msi_scm_model_exit();
1115 fail_scm_model_init:
1116 	platform_device_del(msipf_device);
1117 fail_device_add:
1118 	platform_device_put(msipf_device);
1119 fail_platform_driver:
1120 	platform_driver_unregister(&msipf_driver);
1121 fail_backlight:
1122 	backlight_device_unregister(msibl_device);
1123 
1124 	return ret;
1125 }
1126 
1127 static void __exit msi_cleanup(void)
1128 {
1129 	msi_scm_model_exit();
1130 	sysfs_remove_group(&msipf_device->dev.kobj, &msipf_attribute_group);
1131 	if (!quirks->old_ec_model && threeg_exists)
1132 		device_remove_file(&msipf_device->dev, &dev_attr_threeg);
1133 	platform_device_unregister(msipf_device);
1134 	platform_driver_unregister(&msipf_driver);
1135 	backlight_device_unregister(msibl_device);
1136 
1137 	if (quirks->old_ec_model) {
1138 		/* Enable automatic brightness control again */
1139 		if (auto_brightness != 2)
1140 			set_auto_brightness(1);
1141 	}
1142 }
1143 
1144 module_init(msi_init);
1145 module_exit(msi_cleanup);
1146 
1147 MODULE_AUTHOR("Lennart Poettering");
1148 MODULE_DESCRIPTION("MSI Laptop Support");
1149 MODULE_LICENSE("GPL");
1150