1 /*
2  * Samsung Laptop driver
3  *
4  * Copyright (C) 2009,2011 Greg Kroah-Hartman (gregkh@suse.de)
5  * Copyright (C) 2009,2011 Novell Inc.
6  *
7  * This program is free software; you can redistribute it and/or modify it
8  * under the terms of the GNU General Public License version 2 as published by
9  * the Free Software Foundation.
10  *
11  */
12 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
13 
14 #include <linux/kernel.h>
15 #include <linux/init.h>
16 #include <linux/module.h>
17 #include <linux/delay.h>
18 #include <linux/pci.h>
19 #include <linux/backlight.h>
20 #include <linux/leds.h>
21 #include <linux/fb.h>
22 #include <linux/dmi.h>
23 #include <linux/platform_device.h>
24 #include <linux/rfkill.h>
25 #include <linux/acpi.h>
26 #include <linux/seq_file.h>
27 #include <linux/debugfs.h>
28 #include <linux/ctype.h>
29 #include <linux/efi.h>
30 #include <linux/suspend.h>
31 #include <acpi/video.h>
32 
33 /*
34  * This driver is needed because a number of Samsung laptops do not hook
35  * their control settings through ACPI.  So we have to poke around in the
36  * BIOS to do things like brightness values, and "special" key controls.
37  */
38 
39 /*
40  * We have 0 - 8 as valid brightness levels.  The specs say that level 0 should
41  * be reserved by the BIOS (which really doesn't make much sense), we tell
42  * userspace that the value is 0 - 7 and then just tell the hardware 1 - 8
43  */
44 #define MAX_BRIGHT	0x07
45 
46 
47 #define SABI_IFACE_MAIN			0x00
48 #define SABI_IFACE_SUB			0x02
49 #define SABI_IFACE_COMPLETE		0x04
50 #define SABI_IFACE_DATA			0x05
51 
52 #define WL_STATUS_WLAN			0x0
53 #define WL_STATUS_BT			0x2
54 
55 /* Structure get/set data using sabi */
56 struct sabi_data {
57 	union {
58 		struct {
59 			u32 d0;
60 			u32 d1;
61 			u16 d2;
62 			u8  d3;
63 		};
64 		u8 data[11];
65 	};
66 };
67 
68 struct sabi_header_offsets {
69 	u8 port;
70 	u8 re_mem;
71 	u8 iface_func;
72 	u8 en_mem;
73 	u8 data_offset;
74 	u8 data_segment;
75 };
76 
77 struct sabi_commands {
78 	/*
79 	 * Brightness is 0 - 8, as described above.
80 	 * Value 0 is for the BIOS to use
81 	 */
82 	u16 get_brightness;
83 	u16 set_brightness;
84 
85 	/*
86 	 * first byte:
87 	 * 0x00 - wireless is off
88 	 * 0x01 - wireless is on
89 	 * second byte:
90 	 * 0x02 - 3G is off
91 	 * 0x03 - 3G is on
92 	 * TODO, verify 3G is correct, that doesn't seem right...
93 	 */
94 	u16 get_wireless_button;
95 	u16 set_wireless_button;
96 
97 	/* 0 is off, 1 is on */
98 	u16 get_backlight;
99 	u16 set_backlight;
100 
101 	/*
102 	 * 0x80 or 0x00 - no action
103 	 * 0x81 - recovery key pressed
104 	 */
105 	u16 get_recovery_mode;
106 	u16 set_recovery_mode;
107 
108 	/*
109 	 * on seclinux: 0 is low, 1 is high,
110 	 * on swsmi: 0 is normal, 1 is silent, 2 is turbo
111 	 */
112 	u16 get_performance_level;
113 	u16 set_performance_level;
114 
115 	/* 0x80 is off, 0x81 is on */
116 	u16 get_battery_life_extender;
117 	u16 set_battery_life_extender;
118 
119 	/* 0x80 is off, 0x81 is on */
120 	u16 get_usb_charge;
121 	u16 set_usb_charge;
122 
123 	/* the first byte is for bluetooth and the third one is for wlan */
124 	u16 get_wireless_status;
125 	u16 set_wireless_status;
126 
127 	/* 0x81 to read, (0x82 | level << 8) to set, 0xaabb to enable */
128 	u16 kbd_backlight;
129 
130 	/*
131 	 * Tell the BIOS that Linux is running on this machine.
132 	 * 81 is on, 80 is off
133 	 */
134 	u16 set_linux;
135 };
136 
137 struct sabi_performance_level {
138 	const char *name;
139 	u16 value;
140 };
141 
142 struct sabi_config {
143 	int sabi_version;
144 	const char *test_string;
145 	u16 main_function;
146 	const struct sabi_header_offsets header_offsets;
147 	const struct sabi_commands commands;
148 	const struct sabi_performance_level performance_levels[4];
149 	u8 min_brightness;
150 	u8 max_brightness;
151 };
152 
153 static const struct sabi_config sabi_configs[] = {
154 	{
155 		/* I don't know if it is really 2, but it it is
156 		 * less than 3 anyway */
157 		.sabi_version = 2,
158 
159 		.test_string = "SECLINUX",
160 
161 		.main_function = 0x4c49,
162 
163 		.header_offsets = {
164 			.port = 0x00,
165 			.re_mem = 0x02,
166 			.iface_func = 0x03,
167 			.en_mem = 0x04,
168 			.data_offset = 0x05,
169 			.data_segment = 0x07,
170 		},
171 
172 		.commands = {
173 			.get_brightness = 0x00,
174 			.set_brightness = 0x01,
175 
176 			.get_wireless_button = 0x02,
177 			.set_wireless_button = 0x03,
178 
179 			.get_backlight = 0x04,
180 			.set_backlight = 0x05,
181 
182 			.get_recovery_mode = 0x06,
183 			.set_recovery_mode = 0x07,
184 
185 			.get_performance_level = 0x08,
186 			.set_performance_level = 0x09,
187 
188 			.get_battery_life_extender = 0xFFFF,
189 			.set_battery_life_extender = 0xFFFF,
190 
191 			.get_usb_charge = 0xFFFF,
192 			.set_usb_charge = 0xFFFF,
193 
194 			.get_wireless_status = 0xFFFF,
195 			.set_wireless_status = 0xFFFF,
196 
197 			.kbd_backlight = 0xFFFF,
198 
199 			.set_linux = 0x0a,
200 		},
201 
202 		.performance_levels = {
203 			{
204 				.name = "silent",
205 				.value = 0,
206 			},
207 			{
208 				.name = "normal",
209 				.value = 1,
210 			},
211 			{ },
212 		},
213 		.min_brightness = 1,
214 		.max_brightness = 8,
215 	},
216 	{
217 		.sabi_version = 3,
218 
219 		.test_string = "SwSmi@",
220 
221 		.main_function = 0x5843,
222 
223 		.header_offsets = {
224 			.port = 0x00,
225 			.re_mem = 0x04,
226 			.iface_func = 0x02,
227 			.en_mem = 0x03,
228 			.data_offset = 0x05,
229 			.data_segment = 0x07,
230 		},
231 
232 		.commands = {
233 			.get_brightness = 0x10,
234 			.set_brightness = 0x11,
235 
236 			.get_wireless_button = 0x12,
237 			.set_wireless_button = 0x13,
238 
239 			.get_backlight = 0x2d,
240 			.set_backlight = 0x2e,
241 
242 			.get_recovery_mode = 0xff,
243 			.set_recovery_mode = 0xff,
244 
245 			.get_performance_level = 0x31,
246 			.set_performance_level = 0x32,
247 
248 			.get_battery_life_extender = 0x65,
249 			.set_battery_life_extender = 0x66,
250 
251 			.get_usb_charge = 0x67,
252 			.set_usb_charge = 0x68,
253 
254 			.get_wireless_status = 0x69,
255 			.set_wireless_status = 0x6a,
256 
257 			.kbd_backlight = 0x78,
258 
259 			.set_linux = 0xff,
260 		},
261 
262 		.performance_levels = {
263 			{
264 				.name = "normal",
265 				.value = 0,
266 			},
267 			{
268 				.name = "silent",
269 				.value = 1,
270 			},
271 			{
272 				.name = "overclock",
273 				.value = 2,
274 			},
275 			{ },
276 		},
277 		.min_brightness = 0,
278 		.max_brightness = 8,
279 	},
280 	{ },
281 };
282 
283 /*
284  * samsung-laptop/    - debugfs root directory
285  *   f0000_segment    - dump f0000 segment
286  *   command          - current command
287  *   data             - current data
288  *   d0, d1, d2, d3   - data fields
289  *   call             - call SABI using command and data
290  *
291  * This allow to call arbitrary sabi commands wihout
292  * modifying the driver at all.
293  * For example, setting the keyboard backlight brightness to 5
294  *
295  *  echo 0x78 > command
296  *  echo 0x0582 > d0
297  *  echo 0 > d1
298  *  echo 0 > d2
299  *  echo 0 > d3
300  *  cat call
301  */
302 
303 struct samsung_laptop_debug {
304 	struct dentry *root;
305 	struct sabi_data data;
306 	u16 command;
307 
308 	struct debugfs_blob_wrapper f0000_wrapper;
309 	struct debugfs_blob_wrapper data_wrapper;
310 	struct debugfs_blob_wrapper sdiag_wrapper;
311 };
312 
313 struct samsung_laptop;
314 
315 struct samsung_rfkill {
316 	struct samsung_laptop *samsung;
317 	struct rfkill *rfkill;
318 	enum rfkill_type type;
319 };
320 
321 struct samsung_laptop {
322 	const struct sabi_config *config;
323 
324 	void __iomem *sabi;
325 	void __iomem *sabi_iface;
326 	void __iomem *f0000_segment;
327 
328 	struct mutex sabi_mutex;
329 
330 	struct platform_device *platform_device;
331 	struct backlight_device *backlight_device;
332 
333 	struct samsung_rfkill wlan;
334 	struct samsung_rfkill bluetooth;
335 
336 	struct led_classdev kbd_led;
337 	int kbd_led_wk;
338 	struct workqueue_struct *led_workqueue;
339 	struct work_struct kbd_led_work;
340 
341 	struct samsung_laptop_debug debug;
342 	struct samsung_quirks *quirks;
343 
344 	struct notifier_block pm_nb;
345 
346 	bool handle_backlight;
347 	bool has_stepping_quirk;
348 
349 	char sdiag[64];
350 };
351 
352 struct samsung_quirks {
353 	bool broken_acpi_video;
354 	bool four_kbd_backlight_levels;
355 	bool enable_kbd_backlight;
356 };
357 
358 static struct samsung_quirks samsung_unknown = {};
359 
360 static struct samsung_quirks samsung_broken_acpi_video = {
361 	.broken_acpi_video = true,
362 };
363 
364 static struct samsung_quirks samsung_np740u3e = {
365 	.four_kbd_backlight_levels = true,
366 	.enable_kbd_backlight = true,
367 };
368 
369 static bool force;
370 module_param(force, bool, 0);
371 MODULE_PARM_DESC(force,
372 		"Disable the DMI check and forces the driver to be loaded");
373 
374 static bool debug;
375 module_param(debug, bool, S_IRUGO | S_IWUSR);
376 MODULE_PARM_DESC(debug, "Debug enabled or not");
377 
378 static int sabi_command(struct samsung_laptop *samsung, u16 command,
379 			struct sabi_data *in,
380 			struct sabi_data *out)
381 {
382 	const struct sabi_config *config = samsung->config;
383 	int ret = 0;
384 	u16 port = readw(samsung->sabi + config->header_offsets.port);
385 	u8 complete, iface_data;
386 
387 	mutex_lock(&samsung->sabi_mutex);
388 
389 	if (debug) {
390 		if (in)
391 			pr_info("SABI command:0x%04x "
392 				"data:{0x%08x, 0x%08x, 0x%04x, 0x%02x}",
393 				command, in->d0, in->d1, in->d2, in->d3);
394 		else
395 			pr_info("SABI command:0x%04x", command);
396 	}
397 
398 	/* enable memory to be able to write to it */
399 	outb(readb(samsung->sabi + config->header_offsets.en_mem), port);
400 
401 	/* write out the command */
402 	writew(config->main_function, samsung->sabi_iface + SABI_IFACE_MAIN);
403 	writew(command, samsung->sabi_iface + SABI_IFACE_SUB);
404 	writeb(0, samsung->sabi_iface + SABI_IFACE_COMPLETE);
405 	if (in) {
406 		writel(in->d0, samsung->sabi_iface + SABI_IFACE_DATA);
407 		writel(in->d1, samsung->sabi_iface + SABI_IFACE_DATA + 4);
408 		writew(in->d2, samsung->sabi_iface + SABI_IFACE_DATA + 8);
409 		writeb(in->d3, samsung->sabi_iface + SABI_IFACE_DATA + 10);
410 	}
411 	outb(readb(samsung->sabi + config->header_offsets.iface_func), port);
412 
413 	/* write protect memory to make it safe */
414 	outb(readb(samsung->sabi + config->header_offsets.re_mem), port);
415 
416 	/* see if the command actually succeeded */
417 	complete = readb(samsung->sabi_iface + SABI_IFACE_COMPLETE);
418 	iface_data = readb(samsung->sabi_iface + SABI_IFACE_DATA);
419 
420 	/* iface_data = 0xFF happens when a command is not known
421 	 * so we only add a warning in debug mode since we will
422 	 * probably issue some unknown command at startup to find
423 	 * out which features are supported */
424 	if (complete != 0xaa || (iface_data == 0xff && debug))
425 		pr_warn("SABI command 0x%04x failed with"
426 			" completion flag 0x%02x and interface data 0x%02x",
427 			command, complete, iface_data);
428 
429 	if (complete != 0xaa || iface_data == 0xff) {
430 		ret = -EINVAL;
431 		goto exit;
432 	}
433 
434 	if (out) {
435 		out->d0 = readl(samsung->sabi_iface + SABI_IFACE_DATA);
436 		out->d1 = readl(samsung->sabi_iface + SABI_IFACE_DATA + 4);
437 		out->d2 = readw(samsung->sabi_iface + SABI_IFACE_DATA + 2);
438 		out->d3 = readb(samsung->sabi_iface + SABI_IFACE_DATA + 1);
439 	}
440 
441 	if (debug && out) {
442 		pr_info("SABI return data:{0x%08x, 0x%08x, 0x%04x, 0x%02x}",
443 			out->d0, out->d1, out->d2, out->d3);
444 	}
445 
446 exit:
447 	mutex_unlock(&samsung->sabi_mutex);
448 	return ret;
449 }
450 
451 /* simple wrappers usable with most commands */
452 static int sabi_set_commandb(struct samsung_laptop *samsung,
453 			     u16 command, u8 data)
454 {
455 	struct sabi_data in = { { { .d0 = 0, .d1 = 0, .d2 = 0, .d3 = 0 } } };
456 
457 	in.data[0] = data;
458 	return sabi_command(samsung, command, &in, NULL);
459 }
460 
461 static int read_brightness(struct samsung_laptop *samsung)
462 {
463 	const struct sabi_config *config = samsung->config;
464 	const struct sabi_commands *commands = &samsung->config->commands;
465 	struct sabi_data sretval;
466 	int user_brightness = 0;
467 	int retval;
468 
469 	retval = sabi_command(samsung, commands->get_brightness,
470 			      NULL, &sretval);
471 	if (retval)
472 		return retval;
473 
474 	user_brightness = sretval.data[0];
475 	if (user_brightness > config->min_brightness)
476 		user_brightness -= config->min_brightness;
477 	else
478 		user_brightness = 0;
479 
480 	return user_brightness;
481 }
482 
483 static void set_brightness(struct samsung_laptop *samsung, u8 user_brightness)
484 {
485 	const struct sabi_config *config = samsung->config;
486 	const struct sabi_commands *commands = &samsung->config->commands;
487 	u8 user_level = user_brightness + config->min_brightness;
488 
489 	if (samsung->has_stepping_quirk && user_level != 0) {
490 		/*
491 		 * short circuit if the specified level is what's already set
492 		 * to prevent the screen from flickering needlessly
493 		 */
494 		if (user_brightness == read_brightness(samsung))
495 			return;
496 
497 		sabi_set_commandb(samsung, commands->set_brightness, 0);
498 	}
499 
500 	sabi_set_commandb(samsung, commands->set_brightness, user_level);
501 }
502 
503 static int get_brightness(struct backlight_device *bd)
504 {
505 	struct samsung_laptop *samsung = bl_get_data(bd);
506 
507 	return read_brightness(samsung);
508 }
509 
510 static void check_for_stepping_quirk(struct samsung_laptop *samsung)
511 {
512 	int initial_level;
513 	int check_level;
514 	int orig_level = read_brightness(samsung);
515 
516 	/*
517 	 * Some laptops exhibit the strange behaviour of stepping toward
518 	 * (rather than setting) the brightness except when changing to/from
519 	 * brightness level 0. This behaviour is checked for here and worked
520 	 * around in set_brightness.
521 	 */
522 
523 	if (orig_level == 0)
524 		set_brightness(samsung, 1);
525 
526 	initial_level = read_brightness(samsung);
527 
528 	if (initial_level <= 2)
529 		check_level = initial_level + 2;
530 	else
531 		check_level = initial_level - 2;
532 
533 	samsung->has_stepping_quirk = false;
534 	set_brightness(samsung, check_level);
535 
536 	if (read_brightness(samsung) != check_level) {
537 		samsung->has_stepping_quirk = true;
538 		pr_info("enabled workaround for brightness stepping quirk\n");
539 	}
540 
541 	set_brightness(samsung, orig_level);
542 }
543 
544 static int update_status(struct backlight_device *bd)
545 {
546 	struct samsung_laptop *samsung = bl_get_data(bd);
547 	const struct sabi_commands *commands = &samsung->config->commands;
548 
549 	set_brightness(samsung, bd->props.brightness);
550 
551 	if (bd->props.power == FB_BLANK_UNBLANK)
552 		sabi_set_commandb(samsung, commands->set_backlight, 1);
553 	else
554 		sabi_set_commandb(samsung, commands->set_backlight, 0);
555 
556 	return 0;
557 }
558 
559 static const struct backlight_ops backlight_ops = {
560 	.get_brightness	= get_brightness,
561 	.update_status	= update_status,
562 };
563 
564 static int seclinux_rfkill_set(void *data, bool blocked)
565 {
566 	struct samsung_rfkill *srfkill = data;
567 	struct samsung_laptop *samsung = srfkill->samsung;
568 	const struct sabi_commands *commands = &samsung->config->commands;
569 
570 	return sabi_set_commandb(samsung, commands->set_wireless_button,
571 				 !blocked);
572 }
573 
574 static struct rfkill_ops seclinux_rfkill_ops = {
575 	.set_block = seclinux_rfkill_set,
576 };
577 
578 static int swsmi_wireless_status(struct samsung_laptop *samsung,
579 				 struct sabi_data *data)
580 {
581 	const struct sabi_commands *commands = &samsung->config->commands;
582 
583 	return sabi_command(samsung, commands->get_wireless_status,
584 			    NULL, data);
585 }
586 
587 static int swsmi_rfkill_set(void *priv, bool blocked)
588 {
589 	struct samsung_rfkill *srfkill = priv;
590 	struct samsung_laptop *samsung = srfkill->samsung;
591 	const struct sabi_commands *commands = &samsung->config->commands;
592 	struct sabi_data data;
593 	int ret, i;
594 
595 	ret = swsmi_wireless_status(samsung, &data);
596 	if (ret)
597 		return ret;
598 
599 	/* Don't set the state for non-present devices */
600 	for (i = 0; i < 4; i++)
601 		if (data.data[i] == 0x02)
602 			data.data[1] = 0;
603 
604 	if (srfkill->type == RFKILL_TYPE_WLAN)
605 		data.data[WL_STATUS_WLAN] = !blocked;
606 	else if (srfkill->type == RFKILL_TYPE_BLUETOOTH)
607 		data.data[WL_STATUS_BT] = !blocked;
608 
609 	return sabi_command(samsung, commands->set_wireless_status,
610 			    &data, &data);
611 }
612 
613 static void swsmi_rfkill_query(struct rfkill *rfkill, void *priv)
614 {
615 	struct samsung_rfkill *srfkill = priv;
616 	struct samsung_laptop *samsung = srfkill->samsung;
617 	struct sabi_data data;
618 	int ret;
619 
620 	ret = swsmi_wireless_status(samsung, &data);
621 	if (ret)
622 		return ;
623 
624 	if (srfkill->type == RFKILL_TYPE_WLAN)
625 		ret = data.data[WL_STATUS_WLAN];
626 	else if (srfkill->type == RFKILL_TYPE_BLUETOOTH)
627 		ret = data.data[WL_STATUS_BT];
628 	else
629 		return ;
630 
631 	rfkill_set_sw_state(rfkill, !ret);
632 }
633 
634 static struct rfkill_ops swsmi_rfkill_ops = {
635 	.set_block = swsmi_rfkill_set,
636 	.query = swsmi_rfkill_query,
637 };
638 
639 static ssize_t get_performance_level(struct device *dev,
640 				     struct device_attribute *attr, char *buf)
641 {
642 	struct samsung_laptop *samsung = dev_get_drvdata(dev);
643 	const struct sabi_config *config = samsung->config;
644 	const struct sabi_commands *commands = &config->commands;
645 	struct sabi_data sretval;
646 	int retval;
647 	int i;
648 
649 	/* Read the state */
650 	retval = sabi_command(samsung, commands->get_performance_level,
651 			      NULL, &sretval);
652 	if (retval)
653 		return retval;
654 
655 	/* The logic is backwards, yeah, lots of fun... */
656 	for (i = 0; config->performance_levels[i].name; ++i) {
657 		if (sretval.data[0] == config->performance_levels[i].value)
658 			return sprintf(buf, "%s\n", config->performance_levels[i].name);
659 	}
660 	return sprintf(buf, "%s\n", "unknown");
661 }
662 
663 static ssize_t set_performance_level(struct device *dev,
664 				struct device_attribute *attr, const char *buf,
665 				size_t count)
666 {
667 	struct samsung_laptop *samsung = dev_get_drvdata(dev);
668 	const struct sabi_config *config = samsung->config;
669 	const struct sabi_commands *commands = &config->commands;
670 	int i;
671 
672 	if (count < 1)
673 		return count;
674 
675 	for (i = 0; config->performance_levels[i].name; ++i) {
676 		const struct sabi_performance_level *level =
677 			&config->performance_levels[i];
678 		if (!strncasecmp(level->name, buf, strlen(level->name))) {
679 			sabi_set_commandb(samsung,
680 					  commands->set_performance_level,
681 					  level->value);
682 			break;
683 		}
684 	}
685 
686 	if (!config->performance_levels[i].name)
687 		return -EINVAL;
688 
689 	return count;
690 }
691 
692 static DEVICE_ATTR(performance_level, S_IWUSR | S_IRUGO,
693 		   get_performance_level, set_performance_level);
694 
695 static int read_battery_life_extender(struct samsung_laptop *samsung)
696 {
697 	const struct sabi_commands *commands = &samsung->config->commands;
698 	struct sabi_data data;
699 	int retval;
700 
701 	if (commands->get_battery_life_extender == 0xFFFF)
702 		return -ENODEV;
703 
704 	memset(&data, 0, sizeof(data));
705 	data.data[0] = 0x80;
706 	retval = sabi_command(samsung, commands->get_battery_life_extender,
707 			      &data, &data);
708 
709 	if (retval)
710 		return retval;
711 
712 	if (data.data[0] != 0 && data.data[0] != 1)
713 		return -ENODEV;
714 
715 	return data.data[0];
716 }
717 
718 static int write_battery_life_extender(struct samsung_laptop *samsung,
719 				       int enabled)
720 {
721 	const struct sabi_commands *commands = &samsung->config->commands;
722 	struct sabi_data data;
723 
724 	memset(&data, 0, sizeof(data));
725 	data.data[0] = 0x80 | enabled;
726 	return sabi_command(samsung, commands->set_battery_life_extender,
727 			    &data, NULL);
728 }
729 
730 static ssize_t get_battery_life_extender(struct device *dev,
731 					 struct device_attribute *attr,
732 					 char *buf)
733 {
734 	struct samsung_laptop *samsung = dev_get_drvdata(dev);
735 	int ret;
736 
737 	ret = read_battery_life_extender(samsung);
738 	if (ret < 0)
739 		return ret;
740 
741 	return sprintf(buf, "%d\n", ret);
742 }
743 
744 static ssize_t set_battery_life_extender(struct device *dev,
745 					struct device_attribute *attr,
746 					const char *buf, size_t count)
747 {
748 	struct samsung_laptop *samsung = dev_get_drvdata(dev);
749 	int ret, value;
750 
751 	if (!count || sscanf(buf, "%i", &value) != 1)
752 		return -EINVAL;
753 
754 	ret = write_battery_life_extender(samsung, !!value);
755 	if (ret < 0)
756 		return ret;
757 
758 	return count;
759 }
760 
761 static DEVICE_ATTR(battery_life_extender, S_IWUSR | S_IRUGO,
762 		   get_battery_life_extender, set_battery_life_extender);
763 
764 static int read_usb_charge(struct samsung_laptop *samsung)
765 {
766 	const struct sabi_commands *commands = &samsung->config->commands;
767 	struct sabi_data data;
768 	int retval;
769 
770 	if (commands->get_usb_charge == 0xFFFF)
771 		return -ENODEV;
772 
773 	memset(&data, 0, sizeof(data));
774 	data.data[0] = 0x80;
775 	retval = sabi_command(samsung, commands->get_usb_charge,
776 			      &data, &data);
777 
778 	if (retval)
779 		return retval;
780 
781 	if (data.data[0] != 0 && data.data[0] != 1)
782 		return -ENODEV;
783 
784 	return data.data[0];
785 }
786 
787 static int write_usb_charge(struct samsung_laptop *samsung,
788 			    int enabled)
789 {
790 	const struct sabi_commands *commands = &samsung->config->commands;
791 	struct sabi_data data;
792 
793 	memset(&data, 0, sizeof(data));
794 	data.data[0] = 0x80 | enabled;
795 	return sabi_command(samsung, commands->set_usb_charge,
796 			    &data, NULL);
797 }
798 
799 static ssize_t get_usb_charge(struct device *dev,
800 			      struct device_attribute *attr,
801 			      char *buf)
802 {
803 	struct samsung_laptop *samsung = dev_get_drvdata(dev);
804 	int ret;
805 
806 	ret = read_usb_charge(samsung);
807 	if (ret < 0)
808 		return ret;
809 
810 	return sprintf(buf, "%d\n", ret);
811 }
812 
813 static ssize_t set_usb_charge(struct device *dev,
814 			      struct device_attribute *attr,
815 			      const char *buf, size_t count)
816 {
817 	struct samsung_laptop *samsung = dev_get_drvdata(dev);
818 	int ret, value;
819 
820 	if (!count || sscanf(buf, "%i", &value) != 1)
821 		return -EINVAL;
822 
823 	ret = write_usb_charge(samsung, !!value);
824 	if (ret < 0)
825 		return ret;
826 
827 	return count;
828 }
829 
830 static DEVICE_ATTR(usb_charge, S_IWUSR | S_IRUGO,
831 		   get_usb_charge, set_usb_charge);
832 
833 static struct attribute *platform_attributes[] = {
834 	&dev_attr_performance_level.attr,
835 	&dev_attr_battery_life_extender.attr,
836 	&dev_attr_usb_charge.attr,
837 	NULL
838 };
839 
840 static int find_signature(void __iomem *memcheck, const char *testStr)
841 {
842 	int i = 0;
843 	int loca;
844 
845 	for (loca = 0; loca < 0xffff; loca++) {
846 		char temp = readb(memcheck + loca);
847 
848 		if (temp == testStr[i]) {
849 			if (i == strlen(testStr)-1)
850 				break;
851 			++i;
852 		} else {
853 			i = 0;
854 		}
855 	}
856 	return loca;
857 }
858 
859 static void samsung_rfkill_exit(struct samsung_laptop *samsung)
860 {
861 	if (samsung->wlan.rfkill) {
862 		rfkill_unregister(samsung->wlan.rfkill);
863 		rfkill_destroy(samsung->wlan.rfkill);
864 		samsung->wlan.rfkill = NULL;
865 	}
866 	if (samsung->bluetooth.rfkill) {
867 		rfkill_unregister(samsung->bluetooth.rfkill);
868 		rfkill_destroy(samsung->bluetooth.rfkill);
869 		samsung->bluetooth.rfkill = NULL;
870 	}
871 }
872 
873 static int samsung_new_rfkill(struct samsung_laptop *samsung,
874 			      struct samsung_rfkill *arfkill,
875 			      const char *name, enum rfkill_type type,
876 			      const struct rfkill_ops *ops,
877 			      int blocked)
878 {
879 	struct rfkill **rfkill = &arfkill->rfkill;
880 	int ret;
881 
882 	arfkill->type = type;
883 	arfkill->samsung = samsung;
884 
885 	*rfkill = rfkill_alloc(name, &samsung->platform_device->dev,
886 			       type, ops, arfkill);
887 
888 	if (!*rfkill)
889 		return -EINVAL;
890 
891 	if (blocked != -1)
892 		rfkill_init_sw_state(*rfkill, blocked);
893 
894 	ret = rfkill_register(*rfkill);
895 	if (ret) {
896 		rfkill_destroy(*rfkill);
897 		*rfkill = NULL;
898 		return ret;
899 	}
900 	return 0;
901 }
902 
903 static int __init samsung_rfkill_init_seclinux(struct samsung_laptop *samsung)
904 {
905 	return samsung_new_rfkill(samsung, &samsung->wlan, "samsung-wlan",
906 				  RFKILL_TYPE_WLAN, &seclinux_rfkill_ops, -1);
907 }
908 
909 static int __init samsung_rfkill_init_swsmi(struct samsung_laptop *samsung)
910 {
911 	struct sabi_data data;
912 	int ret;
913 
914 	ret = swsmi_wireless_status(samsung, &data);
915 	if (ret) {
916 		/* Some swsmi laptops use the old seclinux way to control
917 		 * wireless devices */
918 		if (ret == -EINVAL)
919 			ret = samsung_rfkill_init_seclinux(samsung);
920 		return ret;
921 	}
922 
923 	/* 0x02 seems to mean that the device is no present/available */
924 
925 	if (data.data[WL_STATUS_WLAN] != 0x02)
926 		ret = samsung_new_rfkill(samsung, &samsung->wlan,
927 					 "samsung-wlan",
928 					 RFKILL_TYPE_WLAN,
929 					 &swsmi_rfkill_ops,
930 					 !data.data[WL_STATUS_WLAN]);
931 	if (ret)
932 		goto exit;
933 
934 	if (data.data[WL_STATUS_BT] != 0x02)
935 		ret = samsung_new_rfkill(samsung, &samsung->bluetooth,
936 					 "samsung-bluetooth",
937 					 RFKILL_TYPE_BLUETOOTH,
938 					 &swsmi_rfkill_ops,
939 					 !data.data[WL_STATUS_BT]);
940 	if (ret)
941 		goto exit;
942 
943 exit:
944 	if (ret)
945 		samsung_rfkill_exit(samsung);
946 
947 	return ret;
948 }
949 
950 static int __init samsung_rfkill_init(struct samsung_laptop *samsung)
951 {
952 	if (samsung->config->sabi_version == 2)
953 		return samsung_rfkill_init_seclinux(samsung);
954 	if (samsung->config->sabi_version == 3)
955 		return samsung_rfkill_init_swsmi(samsung);
956 	return 0;
957 }
958 
959 static int kbd_backlight_enable(struct samsung_laptop *samsung)
960 {
961 	const struct sabi_commands *commands = &samsung->config->commands;
962 	struct sabi_data data;
963 	int retval;
964 
965 	if (commands->kbd_backlight == 0xFFFF)
966 		return -ENODEV;
967 
968 	memset(&data, 0, sizeof(data));
969 	data.d0 = 0xaabb;
970 	retval = sabi_command(samsung, commands->kbd_backlight,
971 			      &data, &data);
972 
973 	if (retval)
974 		return retval;
975 
976 	if (data.d0 != 0xccdd)
977 		return -ENODEV;
978 	return 0;
979 }
980 
981 static int kbd_backlight_read(struct samsung_laptop *samsung)
982 {
983 	const struct sabi_commands *commands = &samsung->config->commands;
984 	struct sabi_data data;
985 	int retval;
986 
987 	memset(&data, 0, sizeof(data));
988 	data.data[0] = 0x81;
989 	retval = sabi_command(samsung, commands->kbd_backlight,
990 			      &data, &data);
991 
992 	if (retval)
993 		return retval;
994 
995 	return data.data[0];
996 }
997 
998 static int kbd_backlight_write(struct samsung_laptop *samsung, int brightness)
999 {
1000 	const struct sabi_commands *commands = &samsung->config->commands;
1001 	struct sabi_data data;
1002 
1003 	memset(&data, 0, sizeof(data));
1004 	data.d0 = 0x82 | ((brightness & 0xFF) << 8);
1005 	return sabi_command(samsung, commands->kbd_backlight,
1006 			    &data, NULL);
1007 }
1008 
1009 static void kbd_led_update(struct work_struct *work)
1010 {
1011 	struct samsung_laptop *samsung;
1012 
1013 	samsung = container_of(work, struct samsung_laptop, kbd_led_work);
1014 	kbd_backlight_write(samsung, samsung->kbd_led_wk);
1015 }
1016 
1017 static void kbd_led_set(struct led_classdev *led_cdev,
1018 			enum led_brightness value)
1019 {
1020 	struct samsung_laptop *samsung;
1021 
1022 	samsung = container_of(led_cdev, struct samsung_laptop, kbd_led);
1023 
1024 	if (value > samsung->kbd_led.max_brightness)
1025 		value = samsung->kbd_led.max_brightness;
1026 	else if (value < 0)
1027 		value = 0;
1028 
1029 	samsung->kbd_led_wk = value;
1030 	queue_work(samsung->led_workqueue, &samsung->kbd_led_work);
1031 }
1032 
1033 static enum led_brightness kbd_led_get(struct led_classdev *led_cdev)
1034 {
1035 	struct samsung_laptop *samsung;
1036 
1037 	samsung = container_of(led_cdev, struct samsung_laptop, kbd_led);
1038 	return kbd_backlight_read(samsung);
1039 }
1040 
1041 static void samsung_leds_exit(struct samsung_laptop *samsung)
1042 {
1043 	if (!IS_ERR_OR_NULL(samsung->kbd_led.dev))
1044 		led_classdev_unregister(&samsung->kbd_led);
1045 	if (samsung->led_workqueue)
1046 		destroy_workqueue(samsung->led_workqueue);
1047 }
1048 
1049 static int __init samsung_leds_init(struct samsung_laptop *samsung)
1050 {
1051 	int ret = 0;
1052 
1053 	samsung->led_workqueue = create_singlethread_workqueue("led_workqueue");
1054 	if (!samsung->led_workqueue)
1055 		return -ENOMEM;
1056 
1057 	if (kbd_backlight_enable(samsung) >= 0) {
1058 		INIT_WORK(&samsung->kbd_led_work, kbd_led_update);
1059 
1060 		samsung->kbd_led.name = "samsung::kbd_backlight";
1061 		samsung->kbd_led.brightness_set = kbd_led_set;
1062 		samsung->kbd_led.brightness_get = kbd_led_get;
1063 		samsung->kbd_led.max_brightness = 8;
1064 		if (samsung->quirks->four_kbd_backlight_levels)
1065 			samsung->kbd_led.max_brightness = 4;
1066 
1067 		ret = led_classdev_register(&samsung->platform_device->dev,
1068 					   &samsung->kbd_led);
1069 	}
1070 
1071 	if (ret)
1072 		samsung_leds_exit(samsung);
1073 
1074 	return ret;
1075 }
1076 
1077 static void samsung_backlight_exit(struct samsung_laptop *samsung)
1078 {
1079 	if (samsung->backlight_device) {
1080 		backlight_device_unregister(samsung->backlight_device);
1081 		samsung->backlight_device = NULL;
1082 	}
1083 }
1084 
1085 static int __init samsung_backlight_init(struct samsung_laptop *samsung)
1086 {
1087 	struct backlight_device *bd;
1088 	struct backlight_properties props;
1089 
1090 	if (!samsung->handle_backlight)
1091 		return 0;
1092 
1093 	memset(&props, 0, sizeof(struct backlight_properties));
1094 	props.type = BACKLIGHT_PLATFORM;
1095 	props.max_brightness = samsung->config->max_brightness -
1096 		samsung->config->min_brightness;
1097 
1098 	bd = backlight_device_register("samsung",
1099 				       &samsung->platform_device->dev,
1100 				       samsung, &backlight_ops,
1101 				       &props);
1102 	if (IS_ERR(bd))
1103 		return PTR_ERR(bd);
1104 
1105 	samsung->backlight_device = bd;
1106 	samsung->backlight_device->props.brightness = read_brightness(samsung);
1107 	samsung->backlight_device->props.power = FB_BLANK_UNBLANK;
1108 	backlight_update_status(samsung->backlight_device);
1109 
1110 	return 0;
1111 }
1112 
1113 static umode_t samsung_sysfs_is_visible(struct kobject *kobj,
1114 				       struct attribute *attr, int idx)
1115 {
1116 	struct device *dev = container_of(kobj, struct device, kobj);
1117 	struct platform_device *pdev = to_platform_device(dev);
1118 	struct samsung_laptop *samsung = platform_get_drvdata(pdev);
1119 	bool ok = true;
1120 
1121 	if (attr == &dev_attr_performance_level.attr)
1122 		ok = !!samsung->config->performance_levels[0].name;
1123 	if (attr == &dev_attr_battery_life_extender.attr)
1124 		ok = !!(read_battery_life_extender(samsung) >= 0);
1125 	if (attr == &dev_attr_usb_charge.attr)
1126 		ok = !!(read_usb_charge(samsung) >= 0);
1127 
1128 	return ok ? attr->mode : 0;
1129 }
1130 
1131 static struct attribute_group platform_attribute_group = {
1132 	.is_visible = samsung_sysfs_is_visible,
1133 	.attrs = platform_attributes
1134 };
1135 
1136 static void samsung_sysfs_exit(struct samsung_laptop *samsung)
1137 {
1138 	struct platform_device *device = samsung->platform_device;
1139 
1140 	sysfs_remove_group(&device->dev.kobj, &platform_attribute_group);
1141 }
1142 
1143 static int __init samsung_sysfs_init(struct samsung_laptop *samsung)
1144 {
1145 	struct platform_device *device = samsung->platform_device;
1146 
1147 	return sysfs_create_group(&device->dev.kobj, &platform_attribute_group);
1148 
1149 }
1150 
1151 static int show_call(struct seq_file *m, void *data)
1152 {
1153 	struct samsung_laptop *samsung = m->private;
1154 	struct sabi_data *sdata = &samsung->debug.data;
1155 	int ret;
1156 
1157 	seq_printf(m, "SABI 0x%04x {0x%08x, 0x%08x, 0x%04x, 0x%02x}\n",
1158 		   samsung->debug.command,
1159 		   sdata->d0, sdata->d1, sdata->d2, sdata->d3);
1160 
1161 	ret = sabi_command(samsung, samsung->debug.command, sdata, sdata);
1162 
1163 	if (ret) {
1164 		seq_printf(m, "SABI command 0x%04x failed\n",
1165 			   samsung->debug.command);
1166 		return ret;
1167 	}
1168 
1169 	seq_printf(m, "SABI {0x%08x, 0x%08x, 0x%04x, 0x%02x}\n",
1170 		   sdata->d0, sdata->d1, sdata->d2, sdata->d3);
1171 	return 0;
1172 }
1173 
1174 static int samsung_debugfs_open(struct inode *inode, struct file *file)
1175 {
1176 	return single_open(file, show_call, inode->i_private);
1177 }
1178 
1179 static const struct file_operations samsung_laptop_call_io_ops = {
1180 	.owner = THIS_MODULE,
1181 	.open = samsung_debugfs_open,
1182 	.read = seq_read,
1183 	.llseek = seq_lseek,
1184 	.release = single_release,
1185 };
1186 
1187 static void samsung_debugfs_exit(struct samsung_laptop *samsung)
1188 {
1189 	debugfs_remove_recursive(samsung->debug.root);
1190 }
1191 
1192 static int samsung_debugfs_init(struct samsung_laptop *samsung)
1193 {
1194 	struct dentry *dent;
1195 
1196 	samsung->debug.root = debugfs_create_dir("samsung-laptop", NULL);
1197 	if (!samsung->debug.root) {
1198 		pr_err("failed to create debugfs directory");
1199 		goto error_debugfs;
1200 	}
1201 
1202 	samsung->debug.f0000_wrapper.data = samsung->f0000_segment;
1203 	samsung->debug.f0000_wrapper.size = 0xffff;
1204 
1205 	samsung->debug.data_wrapper.data = &samsung->debug.data;
1206 	samsung->debug.data_wrapper.size = sizeof(samsung->debug.data);
1207 
1208 	samsung->debug.sdiag_wrapper.data = samsung->sdiag;
1209 	samsung->debug.sdiag_wrapper.size = strlen(samsung->sdiag);
1210 
1211 	dent = debugfs_create_u16("command", S_IRUGO | S_IWUSR,
1212 				  samsung->debug.root, &samsung->debug.command);
1213 	if (!dent)
1214 		goto error_debugfs;
1215 
1216 	dent = debugfs_create_u32("d0", S_IRUGO | S_IWUSR, samsung->debug.root,
1217 				  &samsung->debug.data.d0);
1218 	if (!dent)
1219 		goto error_debugfs;
1220 
1221 	dent = debugfs_create_u32("d1", S_IRUGO | S_IWUSR, samsung->debug.root,
1222 				  &samsung->debug.data.d1);
1223 	if (!dent)
1224 		goto error_debugfs;
1225 
1226 	dent = debugfs_create_u16("d2", S_IRUGO | S_IWUSR, samsung->debug.root,
1227 				  &samsung->debug.data.d2);
1228 	if (!dent)
1229 		goto error_debugfs;
1230 
1231 	dent = debugfs_create_u8("d3", S_IRUGO | S_IWUSR, samsung->debug.root,
1232 				 &samsung->debug.data.d3);
1233 	if (!dent)
1234 		goto error_debugfs;
1235 
1236 	dent = debugfs_create_blob("data", S_IRUGO | S_IWUSR,
1237 				   samsung->debug.root,
1238 				   &samsung->debug.data_wrapper);
1239 	if (!dent)
1240 		goto error_debugfs;
1241 
1242 	dent = debugfs_create_blob("f0000_segment", S_IRUSR | S_IWUSR,
1243 				   samsung->debug.root,
1244 				   &samsung->debug.f0000_wrapper);
1245 	if (!dent)
1246 		goto error_debugfs;
1247 
1248 	dent = debugfs_create_file("call", S_IFREG | S_IRUGO,
1249 				   samsung->debug.root, samsung,
1250 				   &samsung_laptop_call_io_ops);
1251 	if (!dent)
1252 		goto error_debugfs;
1253 
1254 	dent = debugfs_create_blob("sdiag", S_IRUGO | S_IWUSR,
1255 				   samsung->debug.root,
1256 				   &samsung->debug.sdiag_wrapper);
1257 	if (!dent)
1258 		goto error_debugfs;
1259 
1260 	return 0;
1261 
1262 error_debugfs:
1263 	samsung_debugfs_exit(samsung);
1264 	return -ENOMEM;
1265 }
1266 
1267 static void samsung_sabi_exit(struct samsung_laptop *samsung)
1268 {
1269 	const struct sabi_config *config = samsung->config;
1270 
1271 	/* Turn off "Linux" mode in the BIOS */
1272 	if (config && config->commands.set_linux != 0xff)
1273 		sabi_set_commandb(samsung, config->commands.set_linux, 0x80);
1274 
1275 	if (samsung->sabi_iface) {
1276 		iounmap(samsung->sabi_iface);
1277 		samsung->sabi_iface = NULL;
1278 	}
1279 	if (samsung->f0000_segment) {
1280 		iounmap(samsung->f0000_segment);
1281 		samsung->f0000_segment = NULL;
1282 	}
1283 
1284 	samsung->config = NULL;
1285 }
1286 
1287 static __init void samsung_sabi_infos(struct samsung_laptop *samsung, int loca,
1288 				      unsigned int ifaceP)
1289 {
1290 	const struct sabi_config *config = samsung->config;
1291 
1292 	printk(KERN_DEBUG "This computer supports SABI==%x\n",
1293 	       loca + 0xf0000 - 6);
1294 
1295 	printk(KERN_DEBUG "SABI header:\n");
1296 	printk(KERN_DEBUG " SMI Port Number = 0x%04x\n",
1297 	       readw(samsung->sabi + config->header_offsets.port));
1298 	printk(KERN_DEBUG " SMI Interface Function = 0x%02x\n",
1299 	       readb(samsung->sabi + config->header_offsets.iface_func));
1300 	printk(KERN_DEBUG " SMI enable memory buffer = 0x%02x\n",
1301 	       readb(samsung->sabi + config->header_offsets.en_mem));
1302 	printk(KERN_DEBUG " SMI restore memory buffer = 0x%02x\n",
1303 	       readb(samsung->sabi + config->header_offsets.re_mem));
1304 	printk(KERN_DEBUG " SABI data offset = 0x%04x\n",
1305 	       readw(samsung->sabi + config->header_offsets.data_offset));
1306 	printk(KERN_DEBUG " SABI data segment = 0x%04x\n",
1307 	       readw(samsung->sabi + config->header_offsets.data_segment));
1308 
1309 	printk(KERN_DEBUG " SABI pointer = 0x%08x\n", ifaceP);
1310 }
1311 
1312 static void __init samsung_sabi_diag(struct samsung_laptop *samsung)
1313 {
1314 	int loca = find_signature(samsung->f0000_segment, "SDiaG@");
1315 	int i;
1316 
1317 	if (loca == 0xffff)
1318 		return ;
1319 
1320 	/* Example:
1321 	 * Ident: @SDiaG@686XX-N90X3A/966-SEC-07HL-S90X3A
1322 	 *
1323 	 * Product name: 90X3A
1324 	 * BIOS Version: 07HL
1325 	 */
1326 	loca += 1;
1327 	for (i = 0; loca < 0xffff && i < sizeof(samsung->sdiag) - 1; loca++) {
1328 		char temp = readb(samsung->f0000_segment + loca);
1329 
1330 		if (isalnum(temp) || temp == '/' || temp == '-')
1331 			samsung->sdiag[i++] = temp;
1332 		else
1333 			break ;
1334 	}
1335 
1336 	if (debug && samsung->sdiag[0])
1337 		pr_info("sdiag: %s", samsung->sdiag);
1338 }
1339 
1340 static int __init samsung_sabi_init(struct samsung_laptop *samsung)
1341 {
1342 	const struct sabi_config *config = NULL;
1343 	const struct sabi_commands *commands;
1344 	unsigned int ifaceP;
1345 	int ret = 0;
1346 	int i;
1347 	int loca;
1348 
1349 	samsung->f0000_segment = ioremap_nocache(0xf0000, 0xffff);
1350 	if (!samsung->f0000_segment) {
1351 		if (debug || force)
1352 			pr_err("Can't map the segment at 0xf0000\n");
1353 		ret = -EINVAL;
1354 		goto exit;
1355 	}
1356 
1357 	samsung_sabi_diag(samsung);
1358 
1359 	/* Try to find one of the signatures in memory to find the header */
1360 	for (i = 0; sabi_configs[i].test_string != 0; ++i) {
1361 		samsung->config = &sabi_configs[i];
1362 		loca = find_signature(samsung->f0000_segment,
1363 				      samsung->config->test_string);
1364 		if (loca != 0xffff)
1365 			break;
1366 	}
1367 
1368 	if (loca == 0xffff) {
1369 		if (debug || force)
1370 			pr_err("This computer does not support SABI\n");
1371 		ret = -ENODEV;
1372 		goto exit;
1373 	}
1374 
1375 	config = samsung->config;
1376 	commands = &config->commands;
1377 
1378 	/* point to the SMI port Number */
1379 	loca += 1;
1380 	samsung->sabi = (samsung->f0000_segment + loca);
1381 
1382 	/* Get a pointer to the SABI Interface */
1383 	ifaceP = (readw(samsung->sabi + config->header_offsets.data_segment) & 0x0ffff) << 4;
1384 	ifaceP += readw(samsung->sabi + config->header_offsets.data_offset) & 0x0ffff;
1385 
1386 	if (debug)
1387 		samsung_sabi_infos(samsung, loca, ifaceP);
1388 
1389 	samsung->sabi_iface = ioremap_nocache(ifaceP, 16);
1390 	if (!samsung->sabi_iface) {
1391 		pr_err("Can't remap %x\n", ifaceP);
1392 		ret = -EINVAL;
1393 		goto exit;
1394 	}
1395 
1396 	/* Turn on "Linux" mode in the BIOS */
1397 	if (commands->set_linux != 0xff) {
1398 		int retval = sabi_set_commandb(samsung,
1399 					       commands->set_linux, 0x81);
1400 		if (retval) {
1401 			pr_warn("Linux mode was not set!\n");
1402 			ret = -ENODEV;
1403 			goto exit;
1404 		}
1405 	}
1406 
1407 	/* Check for stepping quirk */
1408 	if (samsung->handle_backlight)
1409 		check_for_stepping_quirk(samsung);
1410 
1411 	pr_info("detected SABI interface: %s\n",
1412 		samsung->config->test_string);
1413 
1414 exit:
1415 	if (ret)
1416 		samsung_sabi_exit(samsung);
1417 
1418 	return ret;
1419 }
1420 
1421 static void samsung_platform_exit(struct samsung_laptop *samsung)
1422 {
1423 	if (samsung->platform_device) {
1424 		platform_device_unregister(samsung->platform_device);
1425 		samsung->platform_device = NULL;
1426 	}
1427 }
1428 
1429 static int samsung_pm_notification(struct notifier_block *nb,
1430 				   unsigned long val, void *ptr)
1431 {
1432 	struct samsung_laptop *samsung;
1433 
1434 	samsung = container_of(nb, struct samsung_laptop, pm_nb);
1435 	if (val == PM_POST_HIBERNATION &&
1436 	    samsung->quirks->enable_kbd_backlight)
1437 		kbd_backlight_enable(samsung);
1438 
1439 	return 0;
1440 }
1441 
1442 static int __init samsung_platform_init(struct samsung_laptop *samsung)
1443 {
1444 	struct platform_device *pdev;
1445 
1446 	pdev = platform_device_register_simple("samsung", -1, NULL, 0);
1447 	if (IS_ERR(pdev))
1448 		return PTR_ERR(pdev);
1449 
1450 	samsung->platform_device = pdev;
1451 	platform_set_drvdata(samsung->platform_device, samsung);
1452 	return 0;
1453 }
1454 
1455 static struct samsung_quirks *quirks;
1456 
1457 static int __init samsung_dmi_matched(const struct dmi_system_id *d)
1458 {
1459 	quirks = d->driver_data;
1460 	return 0;
1461 }
1462 
1463 static struct dmi_system_id __initdata samsung_dmi_table[] = {
1464 	{
1465 		.matches = {
1466 			DMI_MATCH(DMI_SYS_VENDOR,
1467 					"SAMSUNG ELECTRONICS CO., LTD."),
1468 			DMI_MATCH(DMI_CHASSIS_TYPE, "8"), /* Portable */
1469 		},
1470 	},
1471 	{
1472 		.matches = {
1473 			DMI_MATCH(DMI_SYS_VENDOR,
1474 					"SAMSUNG ELECTRONICS CO., LTD."),
1475 			DMI_MATCH(DMI_CHASSIS_TYPE, "9"), /* Laptop */
1476 		},
1477 	},
1478 	{
1479 		.matches = {
1480 			DMI_MATCH(DMI_SYS_VENDOR,
1481 					"SAMSUNG ELECTRONICS CO., LTD."),
1482 			DMI_MATCH(DMI_CHASSIS_TYPE, "10"), /* Notebook */
1483 		},
1484 	},
1485 	{
1486 		.matches = {
1487 			DMI_MATCH(DMI_SYS_VENDOR,
1488 					"SAMSUNG ELECTRONICS CO., LTD."),
1489 			DMI_MATCH(DMI_CHASSIS_TYPE, "14"), /* Sub-Notebook */
1490 		},
1491 	},
1492 	/* DMI ids for laptops with bad Chassis Type */
1493 	{
1494 	  .ident = "R40/R41",
1495 	  .matches = {
1496 		DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."),
1497 		DMI_MATCH(DMI_PRODUCT_NAME, "R40/R41"),
1498 		DMI_MATCH(DMI_BOARD_NAME, "R40/R41"),
1499 		},
1500 	},
1501 	/* Specific DMI ids for laptop with quirks */
1502 	{
1503 	 .callback = samsung_dmi_matched,
1504 	 .ident = "N150P",
1505 	 .matches = {
1506 		DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."),
1507 		DMI_MATCH(DMI_PRODUCT_NAME, "N150P"),
1508 		DMI_MATCH(DMI_BOARD_NAME, "N150P"),
1509 		},
1510 	 .driver_data = &samsung_broken_acpi_video,
1511 	},
1512 	{
1513 	 .callback = samsung_dmi_matched,
1514 	 .ident = "N145P/N250P/N260P",
1515 	 .matches = {
1516 		DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."),
1517 		DMI_MATCH(DMI_PRODUCT_NAME, "N145P/N250P/N260P"),
1518 		DMI_MATCH(DMI_BOARD_NAME, "N145P/N250P/N260P"),
1519 		},
1520 	 .driver_data = &samsung_broken_acpi_video,
1521 	},
1522 	{
1523 	 .callback = samsung_dmi_matched,
1524 	 .ident = "N150/N210/N220",
1525 	 .matches = {
1526 		DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."),
1527 		DMI_MATCH(DMI_PRODUCT_NAME, "N150/N210/N220"),
1528 		DMI_MATCH(DMI_BOARD_NAME, "N150/N210/N220"),
1529 		},
1530 	 .driver_data = &samsung_broken_acpi_video,
1531 	},
1532 	{
1533 	 .callback = samsung_dmi_matched,
1534 	 .ident = "NF110/NF210/NF310",
1535 	 .matches = {
1536 		DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."),
1537 		DMI_MATCH(DMI_PRODUCT_NAME, "NF110/NF210/NF310"),
1538 		DMI_MATCH(DMI_BOARD_NAME, "NF110/NF210/NF310"),
1539 		},
1540 	 .driver_data = &samsung_broken_acpi_video,
1541 	},
1542 	{
1543 	 .callback = samsung_dmi_matched,
1544 	 .ident = "X360",
1545 	 .matches = {
1546 		DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."),
1547 		DMI_MATCH(DMI_PRODUCT_NAME, "X360"),
1548 		DMI_MATCH(DMI_BOARD_NAME, "X360"),
1549 		},
1550 	 .driver_data = &samsung_broken_acpi_video,
1551 	},
1552 	{
1553 	 .callback = samsung_dmi_matched,
1554 	 .ident = "N250P",
1555 	 .matches = {
1556 		DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."),
1557 		DMI_MATCH(DMI_PRODUCT_NAME, "N250P"),
1558 		DMI_MATCH(DMI_BOARD_NAME, "N250P"),
1559 		},
1560 	 .driver_data = &samsung_broken_acpi_video,
1561 	},
1562 	{
1563 	 .callback = samsung_dmi_matched,
1564 	 .ident = "NC210",
1565 	 .matches = {
1566 		DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."),
1567 		DMI_MATCH(DMI_PRODUCT_NAME, "NC210/NC110"),
1568 		DMI_MATCH(DMI_BOARD_NAME, "NC210/NC110"),
1569 		},
1570 	 .driver_data = &samsung_broken_acpi_video,
1571 	},
1572 	{
1573 	 .callback = samsung_dmi_matched,
1574 	 .ident = "730U3E/740U3E",
1575 	 .matches = {
1576 		DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."),
1577 		DMI_MATCH(DMI_PRODUCT_NAME, "730U3E/740U3E"),
1578 		},
1579 	 .driver_data = &samsung_np740u3e,
1580 	},
1581 	{ },
1582 };
1583 MODULE_DEVICE_TABLE(dmi, samsung_dmi_table);
1584 
1585 static struct platform_device *samsung_platform_device;
1586 
1587 static int __init samsung_init(void)
1588 {
1589 	struct samsung_laptop *samsung;
1590 	int ret;
1591 
1592 	if (efi_enabled(EFI_BOOT))
1593 		return -ENODEV;
1594 
1595 	quirks = &samsung_unknown;
1596 	if (!force && !dmi_check_system(samsung_dmi_table))
1597 		return -ENODEV;
1598 
1599 	samsung = kzalloc(sizeof(*samsung), GFP_KERNEL);
1600 	if (!samsung)
1601 		return -ENOMEM;
1602 
1603 	mutex_init(&samsung->sabi_mutex);
1604 	samsung->handle_backlight = true;
1605 	samsung->quirks = quirks;
1606 
1607 
1608 #ifdef CONFIG_ACPI
1609 	if (samsung->quirks->broken_acpi_video)
1610 		acpi_video_dmi_promote_vendor();
1611 
1612 	/* Don't handle backlight here if the acpi video already handle it */
1613 	if (acpi_video_backlight_support()) {
1614 		samsung->handle_backlight = false;
1615 	} else if (samsung->quirks->broken_acpi_video) {
1616 		pr_info("Disabling ACPI video driver\n");
1617 		acpi_video_unregister();
1618 	}
1619 #endif
1620 
1621 	ret = samsung_platform_init(samsung);
1622 	if (ret)
1623 		goto error_platform;
1624 
1625 	ret = samsung_sabi_init(samsung);
1626 	if (ret)
1627 		goto error_sabi;
1628 
1629 #ifdef CONFIG_ACPI
1630 	/* Only log that if we are really on a sabi platform */
1631 	if (acpi_video_backlight_support())
1632 		pr_info("Backlight controlled by ACPI video driver\n");
1633 #endif
1634 
1635 	ret = samsung_sysfs_init(samsung);
1636 	if (ret)
1637 		goto error_sysfs;
1638 
1639 	ret = samsung_backlight_init(samsung);
1640 	if (ret)
1641 		goto error_backlight;
1642 
1643 	ret = samsung_rfkill_init(samsung);
1644 	if (ret)
1645 		goto error_rfkill;
1646 
1647 	ret = samsung_leds_init(samsung);
1648 	if (ret)
1649 		goto error_leds;
1650 
1651 	ret = samsung_debugfs_init(samsung);
1652 	if (ret)
1653 		goto error_debugfs;
1654 
1655 	samsung->pm_nb.notifier_call = samsung_pm_notification;
1656 	register_pm_notifier(&samsung->pm_nb);
1657 
1658 	samsung_platform_device = samsung->platform_device;
1659 	return ret;
1660 
1661 error_debugfs:
1662 	samsung_leds_exit(samsung);
1663 error_leds:
1664 	samsung_rfkill_exit(samsung);
1665 error_rfkill:
1666 	samsung_backlight_exit(samsung);
1667 error_backlight:
1668 	samsung_sysfs_exit(samsung);
1669 error_sysfs:
1670 	samsung_sabi_exit(samsung);
1671 error_sabi:
1672 	samsung_platform_exit(samsung);
1673 error_platform:
1674 	kfree(samsung);
1675 	return ret;
1676 }
1677 
1678 static void __exit samsung_exit(void)
1679 {
1680 	struct samsung_laptop *samsung;
1681 
1682 	samsung = platform_get_drvdata(samsung_platform_device);
1683 	unregister_pm_notifier(&samsung->pm_nb);
1684 
1685 	samsung_debugfs_exit(samsung);
1686 	samsung_leds_exit(samsung);
1687 	samsung_rfkill_exit(samsung);
1688 	samsung_backlight_exit(samsung);
1689 	samsung_sysfs_exit(samsung);
1690 	samsung_sabi_exit(samsung);
1691 	samsung_platform_exit(samsung);
1692 
1693 	kfree(samsung);
1694 	samsung_platform_device = NULL;
1695 }
1696 
1697 module_init(samsung_init);
1698 module_exit(samsung_exit);
1699 
1700 MODULE_AUTHOR("Greg Kroah-Hartman <gregkh@suse.de>");
1701 MODULE_DESCRIPTION("Samsung Backlight driver");
1702 MODULE_LICENSE("GPL");
1703