1 /*
2  * ACPI Sony Notebook Control Driver (SNC and SPIC)
3  *
4  * Copyright (C) 2004-2005 Stelian Pop <stelian@popies.net>
5  * Copyright (C) 2007-2009 Mattia Dongili <malattia@linux.it>
6  *
7  * Parts of this driver inspired from asus_acpi.c and ibm_acpi.c
8  * which are copyrighted by their respective authors.
9  *
10  * The SNY6001 driver part is based on the sonypi driver which includes
11  * material from:
12  *
13  * Copyright (C) 2001-2005 Stelian Pop <stelian@popies.net>
14  *
15  * Copyright (C) 2005 Narayanan R S <nars@kadamba.org>
16  *
17  * Copyright (C) 2001-2002 Alcôve <www.alcove.com>
18  *
19  * Copyright (C) 2001 Michael Ashley <m.ashley@unsw.edu.au>
20  *
21  * Copyright (C) 2001 Junichi Morita <jun1m@mars.dti.ne.jp>
22  *
23  * Copyright (C) 2000 Takaya Kinjo <t-kinjo@tc4.so-net.ne.jp>
24  *
25  * Copyright (C) 2000 Andrew Tridgell <tridge@valinux.com>
26  *
27  * Earlier work by Werner Almesberger, Paul `Rusty' Russell and Paul Mackerras.
28  *
29  * This program is free software; you can redistribute it and/or modify
30  * it under the terms of the GNU General Public License as published by
31  * the Free Software Foundation; either version 2 of the License, or
32  * (at your option) any later version.
33  *
34  * This program is distributed in the hope that it will be useful,
35  * but WITHOUT ANY WARRANTY; without even the implied warranty of
36  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
37  * GNU General Public License for more details.
38  *
39  * You should have received a copy of the GNU General Public License
40  * along with this program; if not, write to the Free Software
41  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
42  *
43  */
44 
45 #include <linux/kernel.h>
46 #include <linux/module.h>
47 #include <linux/moduleparam.h>
48 #include <linux/init.h>
49 #include <linux/types.h>
50 #include <linux/backlight.h>
51 #include <linux/platform_device.h>
52 #include <linux/err.h>
53 #include <linux/dmi.h>
54 #include <linux/pci.h>
55 #include <linux/interrupt.h>
56 #include <linux/delay.h>
57 #include <linux/input.h>
58 #include <linux/kfifo.h>
59 #include <linux/workqueue.h>
60 #include <linux/acpi.h>
61 #include <linux/slab.h>
62 #include <acpi/acpi_drivers.h>
63 #include <acpi/acpi_bus.h>
64 #include <asm/uaccess.h>
65 #include <linux/sonypi.h>
66 #include <linux/sony-laptop.h>
67 #include <linux/rfkill.h>
68 #ifdef CONFIG_SONYPI_COMPAT
69 #include <linux/poll.h>
70 #include <linux/miscdevice.h>
71 #endif
72 
73 #define DRV_PFX			"sony-laptop: "
74 #define dprintk(msg...)		do {			\
75 	if (debug) printk(KERN_WARNING DRV_PFX  msg);	\
76 } while (0)
77 
78 #define SONY_LAPTOP_DRIVER_VERSION	"0.6"
79 
80 #define SONY_NC_CLASS		"sony-nc"
81 #define SONY_NC_HID		"SNY5001"
82 #define SONY_NC_DRIVER_NAME	"Sony Notebook Control Driver"
83 
84 #define SONY_PIC_CLASS		"sony-pic"
85 #define SONY_PIC_HID		"SNY6001"
86 #define SONY_PIC_DRIVER_NAME	"Sony Programmable IO Control Driver"
87 
88 MODULE_AUTHOR("Stelian Pop, Mattia Dongili");
89 MODULE_DESCRIPTION("Sony laptop extras driver (SPIC and SNC ACPI device)");
90 MODULE_LICENSE("GPL");
91 MODULE_VERSION(SONY_LAPTOP_DRIVER_VERSION);
92 
93 static int debug;
94 module_param(debug, int, 0);
95 MODULE_PARM_DESC(debug, "set this to 1 (and RTFM) if you want to help "
96 		 "the development of this driver");
97 
98 static int no_spic;		/* = 0 */
99 module_param(no_spic, int, 0444);
100 MODULE_PARM_DESC(no_spic,
101 		 "set this if you don't want to enable the SPIC device");
102 
103 static int compat;		/* = 0 */
104 module_param(compat, int, 0444);
105 MODULE_PARM_DESC(compat,
106 		 "set this if you want to enable backward compatibility mode");
107 
108 static unsigned long mask = 0xffffffff;
109 module_param(mask, ulong, 0644);
110 MODULE_PARM_DESC(mask,
111 		 "set this to the mask of event you want to enable (see doc)");
112 
113 static int camera;		/* = 0 */
114 module_param(camera, int, 0444);
115 MODULE_PARM_DESC(camera,
116 		 "set this to 1 to enable Motion Eye camera controls "
117 		 "(only use it if you have a C1VE or C1VN model)");
118 
119 #ifdef CONFIG_SONYPI_COMPAT
120 static int minor = -1;
121 module_param(minor, int, 0);
122 MODULE_PARM_DESC(minor,
123 		 "minor number of the misc device for the SPIC compatibility code, "
124 		 "default is -1 (automatic)");
125 #endif
126 
127 enum sony_nc_rfkill {
128 	SONY_WIFI,
129 	SONY_BLUETOOTH,
130 	SONY_WWAN,
131 	SONY_WIMAX,
132 	N_SONY_RFKILL,
133 };
134 
135 static int sony_rfkill_handle;
136 static struct rfkill *sony_rfkill_devices[N_SONY_RFKILL];
137 static int sony_rfkill_address[N_SONY_RFKILL] = {0x300, 0x500, 0x700, 0x900};
138 static void sony_nc_rfkill_update(void);
139 
140 /*********** Input Devices ***********/
141 
142 #define SONY_LAPTOP_BUF_SIZE	128
143 struct sony_laptop_input_s {
144 	atomic_t		users;
145 	struct input_dev	*jog_dev;
146 	struct input_dev	*key_dev;
147 	struct kfifo		fifo;
148 	spinlock_t		fifo_lock;
149 	struct timer_list	release_key_timer;
150 };
151 
152 static struct sony_laptop_input_s sony_laptop_input = {
153 	.users = ATOMIC_INIT(0),
154 };
155 
156 struct sony_laptop_keypress {
157 	struct input_dev *dev;
158 	int key;
159 };
160 
161 /* Correspondance table between sonypi events
162  * and input layer indexes in the keymap
163  */
164 static int sony_laptop_input_index[] = {
165 	-1,	/*  0 no event */
166 	-1,	/*  1 SONYPI_EVENT_JOGDIAL_DOWN */
167 	-1,	/*  2 SONYPI_EVENT_JOGDIAL_UP */
168 	-1,	/*  3 SONYPI_EVENT_JOGDIAL_DOWN_PRESSED */
169 	-1,	/*  4 SONYPI_EVENT_JOGDIAL_UP_PRESSED */
170 	-1,	/*  5 SONYPI_EVENT_JOGDIAL_PRESSED */
171 	-1,	/*  6 SONYPI_EVENT_JOGDIAL_RELEASED */
172 	 0,	/*  7 SONYPI_EVENT_CAPTURE_PRESSED */
173 	 1,	/*  8 SONYPI_EVENT_CAPTURE_RELEASED */
174 	 2,	/*  9 SONYPI_EVENT_CAPTURE_PARTIALPRESSED */
175 	 3,	/* 10 SONYPI_EVENT_CAPTURE_PARTIALRELEASED */
176 	 4,	/* 11 SONYPI_EVENT_FNKEY_ESC */
177 	 5,	/* 12 SONYPI_EVENT_FNKEY_F1 */
178 	 6,	/* 13 SONYPI_EVENT_FNKEY_F2 */
179 	 7,	/* 14 SONYPI_EVENT_FNKEY_F3 */
180 	 8,	/* 15 SONYPI_EVENT_FNKEY_F4 */
181 	 9,	/* 16 SONYPI_EVENT_FNKEY_F5 */
182 	10,	/* 17 SONYPI_EVENT_FNKEY_F6 */
183 	11,	/* 18 SONYPI_EVENT_FNKEY_F7 */
184 	12,	/* 19 SONYPI_EVENT_FNKEY_F8 */
185 	13,	/* 20 SONYPI_EVENT_FNKEY_F9 */
186 	14,	/* 21 SONYPI_EVENT_FNKEY_F10 */
187 	15,	/* 22 SONYPI_EVENT_FNKEY_F11 */
188 	16,	/* 23 SONYPI_EVENT_FNKEY_F12 */
189 	17,	/* 24 SONYPI_EVENT_FNKEY_1 */
190 	18,	/* 25 SONYPI_EVENT_FNKEY_2 */
191 	19,	/* 26 SONYPI_EVENT_FNKEY_D */
192 	20,	/* 27 SONYPI_EVENT_FNKEY_E */
193 	21,	/* 28 SONYPI_EVENT_FNKEY_F */
194 	22,	/* 29 SONYPI_EVENT_FNKEY_S */
195 	23,	/* 30 SONYPI_EVENT_FNKEY_B */
196 	24,	/* 31 SONYPI_EVENT_BLUETOOTH_PRESSED */
197 	25,	/* 32 SONYPI_EVENT_PKEY_P1 */
198 	26,	/* 33 SONYPI_EVENT_PKEY_P2 */
199 	27,	/* 34 SONYPI_EVENT_PKEY_P3 */
200 	28,	/* 35 SONYPI_EVENT_BACK_PRESSED */
201 	-1,	/* 36 SONYPI_EVENT_LID_CLOSED */
202 	-1,	/* 37 SONYPI_EVENT_LID_OPENED */
203 	29,	/* 38 SONYPI_EVENT_BLUETOOTH_ON */
204 	30,	/* 39 SONYPI_EVENT_BLUETOOTH_OFF */
205 	31,	/* 40 SONYPI_EVENT_HELP_PRESSED */
206 	32,	/* 41 SONYPI_EVENT_FNKEY_ONLY */
207 	33,	/* 42 SONYPI_EVENT_JOGDIAL_FAST_DOWN */
208 	34,	/* 43 SONYPI_EVENT_JOGDIAL_FAST_UP */
209 	35,	/* 44 SONYPI_EVENT_JOGDIAL_FAST_DOWN_PRESSED */
210 	36,	/* 45 SONYPI_EVENT_JOGDIAL_FAST_UP_PRESSED */
211 	37,	/* 46 SONYPI_EVENT_JOGDIAL_VFAST_DOWN */
212 	38,	/* 47 SONYPI_EVENT_JOGDIAL_VFAST_UP */
213 	39,	/* 48 SONYPI_EVENT_JOGDIAL_VFAST_DOWN_PRESSED */
214 	40,	/* 49 SONYPI_EVENT_JOGDIAL_VFAST_UP_PRESSED */
215 	41,	/* 50 SONYPI_EVENT_ZOOM_PRESSED */
216 	42,	/* 51 SONYPI_EVENT_THUMBPHRASE_PRESSED */
217 	43,	/* 52 SONYPI_EVENT_MEYE_FACE */
218 	44,	/* 53 SONYPI_EVENT_MEYE_OPPOSITE */
219 	45,	/* 54 SONYPI_EVENT_MEMORYSTICK_INSERT */
220 	46,	/* 55 SONYPI_EVENT_MEMORYSTICK_EJECT */
221 	-1,	/* 56 SONYPI_EVENT_ANYBUTTON_RELEASED */
222 	-1,	/* 57 SONYPI_EVENT_BATTERY_INSERT */
223 	-1,	/* 58 SONYPI_EVENT_BATTERY_REMOVE */
224 	-1,	/* 59 SONYPI_EVENT_FNKEY_RELEASED */
225 	47,	/* 60 SONYPI_EVENT_WIRELESS_ON */
226 	48,	/* 61 SONYPI_EVENT_WIRELESS_OFF */
227 	49,	/* 62 SONYPI_EVENT_ZOOM_IN_PRESSED */
228 	50,	/* 63 SONYPI_EVENT_ZOOM_OUT_PRESSED */
229 	51,	/* 64 SONYPI_EVENT_CD_EJECT_PRESSED */
230 	52,	/* 65 SONYPI_EVENT_MODEKEY_PRESSED */
231 	53,	/* 66 SONYPI_EVENT_PKEY_P4 */
232 	54,	/* 67 SONYPI_EVENT_PKEY_P5 */
233 	55,	/* 68 SONYPI_EVENT_SETTINGKEY_PRESSED */
234 	56,	/* 69 SONYPI_EVENT_VOLUME_INC_PRESSED */
235 	57,	/* 70 SONYPI_EVENT_VOLUME_DEC_PRESSED */
236 	-1,	/* 71 SONYPI_EVENT_BRIGHTNESS_PRESSED */
237 	58,	/* 72 SONYPI_EVENT_MEDIA_PRESSED */
238 	59,	/* 72 SONYPI_EVENT_VENDOR_PRESSED */
239 };
240 
241 static int sony_laptop_input_keycode_map[] = {
242 	KEY_CAMERA,	/*  0 SONYPI_EVENT_CAPTURE_PRESSED */
243 	KEY_RESERVED,	/*  1 SONYPI_EVENT_CAPTURE_RELEASED */
244 	KEY_RESERVED,	/*  2 SONYPI_EVENT_CAPTURE_PARTIALPRESSED */
245 	KEY_RESERVED,	/*  3 SONYPI_EVENT_CAPTURE_PARTIALRELEASED */
246 	KEY_FN_ESC,	/*  4 SONYPI_EVENT_FNKEY_ESC */
247 	KEY_FN_F1,	/*  5 SONYPI_EVENT_FNKEY_F1 */
248 	KEY_FN_F2,	/*  6 SONYPI_EVENT_FNKEY_F2 */
249 	KEY_FN_F3,	/*  7 SONYPI_EVENT_FNKEY_F3 */
250 	KEY_FN_F4,	/*  8 SONYPI_EVENT_FNKEY_F4 */
251 	KEY_FN_F5,	/*  9 SONYPI_EVENT_FNKEY_F5 */
252 	KEY_FN_F6,	/* 10 SONYPI_EVENT_FNKEY_F6 */
253 	KEY_FN_F7,	/* 11 SONYPI_EVENT_FNKEY_F7 */
254 	KEY_FN_F8,	/* 12 SONYPI_EVENT_FNKEY_F8 */
255 	KEY_FN_F9,	/* 13 SONYPI_EVENT_FNKEY_F9 */
256 	KEY_FN_F10,	/* 14 SONYPI_EVENT_FNKEY_F10 */
257 	KEY_FN_F11,	/* 15 SONYPI_EVENT_FNKEY_F11 */
258 	KEY_FN_F12,	/* 16 SONYPI_EVENT_FNKEY_F12 */
259 	KEY_FN_F1,	/* 17 SONYPI_EVENT_FNKEY_1 */
260 	KEY_FN_F2,	/* 18 SONYPI_EVENT_FNKEY_2 */
261 	KEY_FN_D,	/* 19 SONYPI_EVENT_FNKEY_D */
262 	KEY_FN_E,	/* 20 SONYPI_EVENT_FNKEY_E */
263 	KEY_FN_F,	/* 21 SONYPI_EVENT_FNKEY_F */
264 	KEY_FN_S,	/* 22 SONYPI_EVENT_FNKEY_S */
265 	KEY_FN_B,	/* 23 SONYPI_EVENT_FNKEY_B */
266 	KEY_BLUETOOTH,	/* 24 SONYPI_EVENT_BLUETOOTH_PRESSED */
267 	KEY_PROG1,	/* 25 SONYPI_EVENT_PKEY_P1 */
268 	KEY_PROG2,	/* 26 SONYPI_EVENT_PKEY_P2 */
269 	KEY_PROG3,	/* 27 SONYPI_EVENT_PKEY_P3 */
270 	KEY_BACK,	/* 28 SONYPI_EVENT_BACK_PRESSED */
271 	KEY_BLUETOOTH,	/* 29 SONYPI_EVENT_BLUETOOTH_ON */
272 	KEY_BLUETOOTH,	/* 30 SONYPI_EVENT_BLUETOOTH_OFF */
273 	KEY_HELP,	/* 31 SONYPI_EVENT_HELP_PRESSED */
274 	KEY_FN,		/* 32 SONYPI_EVENT_FNKEY_ONLY */
275 	KEY_RESERVED,	/* 33 SONYPI_EVENT_JOGDIAL_FAST_DOWN */
276 	KEY_RESERVED,	/* 34 SONYPI_EVENT_JOGDIAL_FAST_UP */
277 	KEY_RESERVED,	/* 35 SONYPI_EVENT_JOGDIAL_FAST_DOWN_PRESSED */
278 	KEY_RESERVED,	/* 36 SONYPI_EVENT_JOGDIAL_FAST_UP_PRESSED */
279 	KEY_RESERVED,	/* 37 SONYPI_EVENT_JOGDIAL_VFAST_DOWN */
280 	KEY_RESERVED,	/* 38 SONYPI_EVENT_JOGDIAL_VFAST_UP */
281 	KEY_RESERVED,	/* 39 SONYPI_EVENT_JOGDIAL_VFAST_DOWN_PRESSED */
282 	KEY_RESERVED,	/* 40 SONYPI_EVENT_JOGDIAL_VFAST_UP_PRESSED */
283 	KEY_ZOOM,	/* 41 SONYPI_EVENT_ZOOM_PRESSED */
284 	BTN_THUMB,	/* 42 SONYPI_EVENT_THUMBPHRASE_PRESSED */
285 	KEY_RESERVED,	/* 43 SONYPI_EVENT_MEYE_FACE */
286 	KEY_RESERVED,	/* 44 SONYPI_EVENT_MEYE_OPPOSITE */
287 	KEY_RESERVED,	/* 45 SONYPI_EVENT_MEMORYSTICK_INSERT */
288 	KEY_RESERVED,	/* 46 SONYPI_EVENT_MEMORYSTICK_EJECT */
289 	KEY_WLAN,	/* 47 SONYPI_EVENT_WIRELESS_ON */
290 	KEY_WLAN,	/* 48 SONYPI_EVENT_WIRELESS_OFF */
291 	KEY_ZOOMIN,	/* 49 SONYPI_EVENT_ZOOM_IN_PRESSED */
292 	KEY_ZOOMOUT,	/* 50 SONYPI_EVENT_ZOOM_OUT_PRESSED */
293 	KEY_EJECTCD,	/* 51 SONYPI_EVENT_CD_EJECT_PRESSED */
294 	KEY_F13,	/* 52 SONYPI_EVENT_MODEKEY_PRESSED */
295 	KEY_PROG4,	/* 53 SONYPI_EVENT_PKEY_P4 */
296 	KEY_F14,	/* 54 SONYPI_EVENT_PKEY_P5 */
297 	KEY_F15,	/* 55 SONYPI_EVENT_SETTINGKEY_PRESSED */
298 	KEY_VOLUMEUP,	/* 56 SONYPI_EVENT_VOLUME_INC_PRESSED */
299 	KEY_VOLUMEDOWN,	/* 57 SONYPI_EVENT_VOLUME_DEC_PRESSED */
300 	KEY_MEDIA,	/* 58 SONYPI_EVENT_MEDIA_PRESSED */
301 	KEY_VENDOR,	/* 59 SONYPI_EVENT_VENDOR_PRESSED */
302 };
303 
304 /* release buttons after a short delay if pressed */
305 static void do_sony_laptop_release_key(unsigned long unused)
306 {
307 	struct sony_laptop_keypress kp;
308 	unsigned long flags;
309 
310 	spin_lock_irqsave(&sony_laptop_input.fifo_lock, flags);
311 
312 	if (kfifo_out(&sony_laptop_input.fifo,
313 		      (unsigned char *)&kp, sizeof(kp)) == sizeof(kp)) {
314 		input_report_key(kp.dev, kp.key, 0);
315 		input_sync(kp.dev);
316 	}
317 
318 	/* If there is something in the fifo schedule next release. */
319 	if (kfifo_len(&sony_laptop_input.fifo) != 0)
320 		mod_timer(&sony_laptop_input.release_key_timer,
321 			  jiffies + msecs_to_jiffies(10));
322 
323 	spin_unlock_irqrestore(&sony_laptop_input.fifo_lock, flags);
324 }
325 
326 /* forward event to the input subsystem */
327 static void sony_laptop_report_input_event(u8 event)
328 {
329 	struct input_dev *jog_dev = sony_laptop_input.jog_dev;
330 	struct input_dev *key_dev = sony_laptop_input.key_dev;
331 	struct sony_laptop_keypress kp = { NULL };
332 
333 	if (event == SONYPI_EVENT_FNKEY_RELEASED ||
334 			event == SONYPI_EVENT_ANYBUTTON_RELEASED) {
335 		/* Nothing, not all VAIOs generate this event */
336 		return;
337 	}
338 
339 	/* report events */
340 	switch (event) {
341 	/* jog_dev events */
342 	case SONYPI_EVENT_JOGDIAL_UP:
343 	case SONYPI_EVENT_JOGDIAL_UP_PRESSED:
344 		input_report_rel(jog_dev, REL_WHEEL, 1);
345 		input_sync(jog_dev);
346 		return;
347 
348 	case SONYPI_EVENT_JOGDIAL_DOWN:
349 	case SONYPI_EVENT_JOGDIAL_DOWN_PRESSED:
350 		input_report_rel(jog_dev, REL_WHEEL, -1);
351 		input_sync(jog_dev);
352 		return;
353 
354 	/* key_dev events */
355 	case SONYPI_EVENT_JOGDIAL_PRESSED:
356 		kp.key = BTN_MIDDLE;
357 		kp.dev = jog_dev;
358 		break;
359 
360 	default:
361 		if (event >= ARRAY_SIZE(sony_laptop_input_index)) {
362 			dprintk("sony_laptop_report_input_event, event not known: %d\n", event);
363 			break;
364 		}
365 		if (sony_laptop_input_index[event] != -1) {
366 			kp.key = sony_laptop_input_keycode_map[sony_laptop_input_index[event]];
367 			if (kp.key != KEY_UNKNOWN)
368 				kp.dev = key_dev;
369 		}
370 		break;
371 	}
372 
373 	if (kp.dev) {
374 		input_report_key(kp.dev, kp.key, 1);
375 		/* we emit the scancode so we can always remap the key */
376 		input_event(kp.dev, EV_MSC, MSC_SCAN, event);
377 		input_sync(kp.dev);
378 
379 		/* schedule key release */
380 		kfifo_in_locked(&sony_laptop_input.fifo,
381 				(unsigned char *)&kp, sizeof(kp),
382 				&sony_laptop_input.fifo_lock);
383 		mod_timer(&sony_laptop_input.release_key_timer,
384 			  jiffies + msecs_to_jiffies(10));
385 	} else
386 		dprintk("unknown input event %.2x\n", event);
387 }
388 
389 static int sony_laptop_setup_input(struct acpi_device *acpi_device)
390 {
391 	struct input_dev *jog_dev;
392 	struct input_dev *key_dev;
393 	int i;
394 	int error;
395 
396 	/* don't run again if already initialized */
397 	if (atomic_add_return(1, &sony_laptop_input.users) > 1)
398 		return 0;
399 
400 	/* kfifo */
401 	spin_lock_init(&sony_laptop_input.fifo_lock);
402 	error = kfifo_alloc(&sony_laptop_input.fifo,
403 			    SONY_LAPTOP_BUF_SIZE, GFP_KERNEL);
404 	if (error) {
405 		printk(KERN_ERR DRV_PFX "kfifo_alloc failed\n");
406 		goto err_dec_users;
407 	}
408 
409 	setup_timer(&sony_laptop_input.release_key_timer,
410 		    do_sony_laptop_release_key, 0);
411 
412 	/* input keys */
413 	key_dev = input_allocate_device();
414 	if (!key_dev) {
415 		error = -ENOMEM;
416 		goto err_free_kfifo;
417 	}
418 
419 	key_dev->name = "Sony Vaio Keys";
420 	key_dev->id.bustype = BUS_ISA;
421 	key_dev->id.vendor = PCI_VENDOR_ID_SONY;
422 	key_dev->dev.parent = &acpi_device->dev;
423 
424 	/* Initialize the Input Drivers: special keys */
425 	input_set_capability(key_dev, EV_MSC, MSC_SCAN);
426 
427 	__set_bit(EV_KEY, key_dev->evbit);
428 	key_dev->keycodesize = sizeof(sony_laptop_input_keycode_map[0]);
429 	key_dev->keycodemax = ARRAY_SIZE(sony_laptop_input_keycode_map);
430 	key_dev->keycode = &sony_laptop_input_keycode_map;
431 	for (i = 0; i < ARRAY_SIZE(sony_laptop_input_keycode_map); i++)
432 		__set_bit(sony_laptop_input_keycode_map[i], key_dev->keybit);
433 	__clear_bit(KEY_RESERVED, key_dev->keybit);
434 
435 	error = input_register_device(key_dev);
436 	if (error)
437 		goto err_free_keydev;
438 
439 	sony_laptop_input.key_dev = key_dev;
440 
441 	/* jogdial */
442 	jog_dev = input_allocate_device();
443 	if (!jog_dev) {
444 		error = -ENOMEM;
445 		goto err_unregister_keydev;
446 	}
447 
448 	jog_dev->name = "Sony Vaio Jogdial";
449 	jog_dev->id.bustype = BUS_ISA;
450 	jog_dev->id.vendor = PCI_VENDOR_ID_SONY;
451 	key_dev->dev.parent = &acpi_device->dev;
452 
453 	input_set_capability(jog_dev, EV_KEY, BTN_MIDDLE);
454 	input_set_capability(jog_dev, EV_REL, REL_WHEEL);
455 
456 	error = input_register_device(jog_dev);
457 	if (error)
458 		goto err_free_jogdev;
459 
460 	sony_laptop_input.jog_dev = jog_dev;
461 
462 	return 0;
463 
464 err_free_jogdev:
465 	input_free_device(jog_dev);
466 
467 err_unregister_keydev:
468 	input_unregister_device(key_dev);
469 	/* to avoid kref underflow below at input_free_device */
470 	key_dev = NULL;
471 
472 err_free_keydev:
473 	input_free_device(key_dev);
474 
475 err_free_kfifo:
476 	kfifo_free(&sony_laptop_input.fifo);
477 
478 err_dec_users:
479 	atomic_dec(&sony_laptop_input.users);
480 	return error;
481 }
482 
483 static void sony_laptop_remove_input(void)
484 {
485 	struct sony_laptop_keypress kp = { NULL };
486 
487 	/* Cleanup only after the last user has gone */
488 	if (!atomic_dec_and_test(&sony_laptop_input.users))
489 		return;
490 
491 	del_timer_sync(&sony_laptop_input.release_key_timer);
492 
493 	/*
494 	 * Generate key-up events for remaining keys. Note that we don't
495 	 * need locking since nobody is adding new events to the kfifo.
496 	 */
497 	while (kfifo_out(&sony_laptop_input.fifo,
498 			 (unsigned char *)&kp, sizeof(kp)) == sizeof(kp)) {
499 		input_report_key(kp.dev, kp.key, 0);
500 		input_sync(kp.dev);
501 	}
502 
503 	/* destroy input devs */
504 	input_unregister_device(sony_laptop_input.key_dev);
505 	sony_laptop_input.key_dev = NULL;
506 
507 	if (sony_laptop_input.jog_dev) {
508 		input_unregister_device(sony_laptop_input.jog_dev);
509 		sony_laptop_input.jog_dev = NULL;
510 	}
511 
512 	kfifo_free(&sony_laptop_input.fifo);
513 }
514 
515 /*********** Platform Device ***********/
516 
517 static atomic_t sony_pf_users = ATOMIC_INIT(0);
518 static struct platform_driver sony_pf_driver = {
519 	.driver = {
520 		   .name = "sony-laptop",
521 		   .owner = THIS_MODULE,
522 		   }
523 };
524 static struct platform_device *sony_pf_device;
525 
526 static int sony_pf_add(void)
527 {
528 	int ret = 0;
529 
530 	/* don't run again if already initialized */
531 	if (atomic_add_return(1, &sony_pf_users) > 1)
532 		return 0;
533 
534 	ret = platform_driver_register(&sony_pf_driver);
535 	if (ret)
536 		goto out;
537 
538 	sony_pf_device = platform_device_alloc("sony-laptop", -1);
539 	if (!sony_pf_device) {
540 		ret = -ENOMEM;
541 		goto out_platform_registered;
542 	}
543 
544 	ret = platform_device_add(sony_pf_device);
545 	if (ret)
546 		goto out_platform_alloced;
547 
548 	return 0;
549 
550       out_platform_alloced:
551 	platform_device_put(sony_pf_device);
552 	sony_pf_device = NULL;
553       out_platform_registered:
554 	platform_driver_unregister(&sony_pf_driver);
555       out:
556 	atomic_dec(&sony_pf_users);
557 	return ret;
558 }
559 
560 static void sony_pf_remove(void)
561 {
562 	/* deregister only after the last user has gone */
563 	if (!atomic_dec_and_test(&sony_pf_users))
564 		return;
565 
566 	platform_device_unregister(sony_pf_device);
567 	platform_driver_unregister(&sony_pf_driver);
568 }
569 
570 /*********** SNC (SNY5001) Device ***********/
571 
572 /* the device uses 1-based values, while the backlight subsystem uses
573    0-based values */
574 #define SONY_MAX_BRIGHTNESS	8
575 
576 #define SNC_VALIDATE_IN		0
577 #define SNC_VALIDATE_OUT	1
578 
579 static ssize_t sony_nc_sysfs_show(struct device *, struct device_attribute *,
580 			      char *);
581 static ssize_t sony_nc_sysfs_store(struct device *, struct device_attribute *,
582 			       const char *, size_t);
583 static int boolean_validate(const int, const int);
584 static int brightness_default_validate(const int, const int);
585 
586 struct sony_nc_value {
587 	char *name;		/* name of the entry */
588 	char **acpiget;		/* names of the ACPI get function */
589 	char **acpiset;		/* names of the ACPI set function */
590 	int (*validate)(const int, const int);	/* input/output validation */
591 	int value;		/* current setting */
592 	int valid;		/* Has ever been set */
593 	int debug;		/* active only in debug mode ? */
594 	struct device_attribute devattr;	/* sysfs atribute */
595 };
596 
597 #define SNC_HANDLE_NAMES(_name, _values...) \
598 	static char *snc_##_name[] = { _values, NULL }
599 
600 #define SNC_HANDLE(_name, _getters, _setters, _validate, _debug) \
601 	{ \
602 		.name		= __stringify(_name), \
603 		.acpiget	= _getters, \
604 		.acpiset	= _setters, \
605 		.validate	= _validate, \
606 		.debug		= _debug, \
607 		.devattr	= __ATTR(_name, 0, sony_nc_sysfs_show, sony_nc_sysfs_store), \
608 	}
609 
610 #define SNC_HANDLE_NULL	{ .name = NULL }
611 
612 SNC_HANDLE_NAMES(fnkey_get, "GHKE");
613 
614 SNC_HANDLE_NAMES(brightness_def_get, "GPBR");
615 SNC_HANDLE_NAMES(brightness_def_set, "SPBR");
616 
617 SNC_HANDLE_NAMES(cdpower_get, "GCDP");
618 SNC_HANDLE_NAMES(cdpower_set, "SCDP", "CDPW");
619 
620 SNC_HANDLE_NAMES(audiopower_get, "GAZP");
621 SNC_HANDLE_NAMES(audiopower_set, "AZPW");
622 
623 SNC_HANDLE_NAMES(lanpower_get, "GLNP");
624 SNC_HANDLE_NAMES(lanpower_set, "LNPW");
625 
626 SNC_HANDLE_NAMES(lidstate_get, "GLID");
627 
628 SNC_HANDLE_NAMES(indicatorlamp_get, "GILS");
629 SNC_HANDLE_NAMES(indicatorlamp_set, "SILS");
630 
631 SNC_HANDLE_NAMES(gainbass_get, "GMGB");
632 SNC_HANDLE_NAMES(gainbass_set, "CMGB");
633 
634 SNC_HANDLE_NAMES(PID_get, "GPID");
635 
636 SNC_HANDLE_NAMES(CTR_get, "GCTR");
637 SNC_HANDLE_NAMES(CTR_set, "SCTR");
638 
639 SNC_HANDLE_NAMES(PCR_get, "GPCR");
640 SNC_HANDLE_NAMES(PCR_set, "SPCR");
641 
642 SNC_HANDLE_NAMES(CMI_get, "GCMI");
643 SNC_HANDLE_NAMES(CMI_set, "SCMI");
644 
645 static struct sony_nc_value sony_nc_values[] = {
646 	SNC_HANDLE(brightness_default, snc_brightness_def_get,
647 			snc_brightness_def_set, brightness_default_validate, 0),
648 	SNC_HANDLE(fnkey, snc_fnkey_get, NULL, NULL, 0),
649 	SNC_HANDLE(cdpower, snc_cdpower_get, snc_cdpower_set, boolean_validate, 0),
650 	SNC_HANDLE(audiopower, snc_audiopower_get, snc_audiopower_set,
651 			boolean_validate, 0),
652 	SNC_HANDLE(lanpower, snc_lanpower_get, snc_lanpower_set,
653 			boolean_validate, 1),
654 	SNC_HANDLE(lidstate, snc_lidstate_get, NULL,
655 			boolean_validate, 0),
656 	SNC_HANDLE(indicatorlamp, snc_indicatorlamp_get, snc_indicatorlamp_set,
657 			boolean_validate, 0),
658 	SNC_HANDLE(gainbass, snc_gainbass_get, snc_gainbass_set,
659 			boolean_validate, 0),
660 	/* unknown methods */
661 	SNC_HANDLE(PID, snc_PID_get, NULL, NULL, 1),
662 	SNC_HANDLE(CTR, snc_CTR_get, snc_CTR_set, NULL, 1),
663 	SNC_HANDLE(PCR, snc_PCR_get, snc_PCR_set, NULL, 1),
664 	SNC_HANDLE(CMI, snc_CMI_get, snc_CMI_set, NULL, 1),
665 	SNC_HANDLE_NULL
666 };
667 
668 static acpi_handle sony_nc_acpi_handle;
669 static struct acpi_device *sony_nc_acpi_device = NULL;
670 
671 /*
672  * acpi_evaluate_object wrappers
673  */
674 static int acpi_callgetfunc(acpi_handle handle, char *name, int *result)
675 {
676 	struct acpi_buffer output;
677 	union acpi_object out_obj;
678 	acpi_status status;
679 
680 	output.length = sizeof(out_obj);
681 	output.pointer = &out_obj;
682 
683 	status = acpi_evaluate_object(handle, name, NULL, &output);
684 	if ((status == AE_OK) && (out_obj.type == ACPI_TYPE_INTEGER)) {
685 		*result = out_obj.integer.value;
686 		return 0;
687 	}
688 
689 	printk(KERN_WARNING DRV_PFX "acpi_callreadfunc failed\n");
690 
691 	return -1;
692 }
693 
694 static int acpi_callsetfunc(acpi_handle handle, char *name, int value,
695 			    int *result)
696 {
697 	struct acpi_object_list params;
698 	union acpi_object in_obj;
699 	struct acpi_buffer output;
700 	union acpi_object out_obj;
701 	acpi_status status;
702 
703 	params.count = 1;
704 	params.pointer = &in_obj;
705 	in_obj.type = ACPI_TYPE_INTEGER;
706 	in_obj.integer.value = value;
707 
708 	output.length = sizeof(out_obj);
709 	output.pointer = &out_obj;
710 
711 	status = acpi_evaluate_object(handle, name, &params, &output);
712 	if (status == AE_OK) {
713 		if (result != NULL) {
714 			if (out_obj.type != ACPI_TYPE_INTEGER) {
715 				printk(KERN_WARNING DRV_PFX "acpi_evaluate_object bad "
716 				       "return type\n");
717 				return -1;
718 			}
719 			*result = out_obj.integer.value;
720 		}
721 		return 0;
722 	}
723 
724 	printk(KERN_WARNING DRV_PFX "acpi_evaluate_object failed\n");
725 
726 	return -1;
727 }
728 
729 static int sony_find_snc_handle(int handle)
730 {
731 	int i;
732 	int result;
733 
734 	for (i = 0x20; i < 0x30; i++) {
735 		acpi_callsetfunc(sony_nc_acpi_handle, "SN00", i, &result);
736 		if (result == handle)
737 			return i-0x20;
738 	}
739 
740 	return -1;
741 }
742 
743 static int sony_call_snc_handle(int handle, int argument, int *result)
744 {
745 	int offset = sony_find_snc_handle(handle);
746 
747 	if (offset < 0)
748 		return -1;
749 
750 	return acpi_callsetfunc(sony_nc_acpi_handle, "SN07", offset | argument,
751 				result);
752 }
753 
754 /*
755  * sony_nc_values input/output validate functions
756  */
757 
758 /* brightness_default_validate:
759  *
760  * manipulate input output values to keep consistency with the
761  * backlight framework for which brightness values are 0-based.
762  */
763 static int brightness_default_validate(const int direction, const int value)
764 {
765 	switch (direction) {
766 		case SNC_VALIDATE_OUT:
767 			return value - 1;
768 		case SNC_VALIDATE_IN:
769 			if (value >= 0 && value < SONY_MAX_BRIGHTNESS)
770 				return value + 1;
771 	}
772 	return -EINVAL;
773 }
774 
775 /* boolean_validate:
776  *
777  * on input validate boolean values 0/1, on output just pass the
778  * received value.
779  */
780 static int boolean_validate(const int direction, const int value)
781 {
782 	if (direction == SNC_VALIDATE_IN) {
783 		if (value != 0 && value != 1)
784 			return -EINVAL;
785 	}
786 	return value;
787 }
788 
789 /*
790  * Sysfs show/store common to all sony_nc_values
791  */
792 static ssize_t sony_nc_sysfs_show(struct device *dev, struct device_attribute *attr,
793 			      char *buffer)
794 {
795 	int value;
796 	struct sony_nc_value *item =
797 	    container_of(attr, struct sony_nc_value, devattr);
798 
799 	if (!*item->acpiget)
800 		return -EIO;
801 
802 	if (acpi_callgetfunc(sony_nc_acpi_handle, *item->acpiget, &value) < 0)
803 		return -EIO;
804 
805 	if (item->validate)
806 		value = item->validate(SNC_VALIDATE_OUT, value);
807 
808 	return snprintf(buffer, PAGE_SIZE, "%d\n", value);
809 }
810 
811 static ssize_t sony_nc_sysfs_store(struct device *dev,
812 			       struct device_attribute *attr,
813 			       const char *buffer, size_t count)
814 {
815 	int value;
816 	struct sony_nc_value *item =
817 	    container_of(attr, struct sony_nc_value, devattr);
818 
819 	if (!item->acpiset)
820 		return -EIO;
821 
822 	if (count > 31)
823 		return -EINVAL;
824 
825 	value = simple_strtoul(buffer, NULL, 10);
826 
827 	if (item->validate)
828 		value = item->validate(SNC_VALIDATE_IN, value);
829 
830 	if (value < 0)
831 		return value;
832 
833 	if (acpi_callsetfunc(sony_nc_acpi_handle, *item->acpiset, value, NULL) < 0)
834 		return -EIO;
835 	item->value = value;
836 	item->valid = 1;
837 	return count;
838 }
839 
840 
841 /*
842  * Backlight device
843  */
844 static int sony_backlight_update_status(struct backlight_device *bd)
845 {
846 	return acpi_callsetfunc(sony_nc_acpi_handle, "SBRT",
847 				bd->props.brightness + 1, NULL);
848 }
849 
850 static int sony_backlight_get_brightness(struct backlight_device *bd)
851 {
852 	int value;
853 
854 	if (acpi_callgetfunc(sony_nc_acpi_handle, "GBRT", &value))
855 		return 0;
856 	/* brightness levels are 1-based, while backlight ones are 0-based */
857 	return value - 1;
858 }
859 
860 static struct backlight_device *sony_backlight_device;
861 static const struct backlight_ops sony_backlight_ops = {
862 	.update_status = sony_backlight_update_status,
863 	.get_brightness = sony_backlight_get_brightness,
864 };
865 
866 /*
867  * New SNC-only Vaios event mapping to driver known keys
868  */
869 struct sony_nc_event {
870 	u8	data;
871 	u8	event;
872 };
873 
874 static struct sony_nc_event sony_100_events[] = {
875 	{ 0x90, SONYPI_EVENT_PKEY_P1 },
876 	{ 0x10, SONYPI_EVENT_ANYBUTTON_RELEASED },
877 	{ 0x91, SONYPI_EVENT_PKEY_P2 },
878 	{ 0x11, SONYPI_EVENT_ANYBUTTON_RELEASED },
879 	{ 0x81, SONYPI_EVENT_FNKEY_F1 },
880 	{ 0x01, SONYPI_EVENT_FNKEY_RELEASED },
881 	{ 0x82, SONYPI_EVENT_FNKEY_F2 },
882 	{ 0x02, SONYPI_EVENT_FNKEY_RELEASED },
883 	{ 0x83, SONYPI_EVENT_FNKEY_F3 },
884 	{ 0x03, SONYPI_EVENT_FNKEY_RELEASED },
885 	{ 0x84, SONYPI_EVENT_FNKEY_F4 },
886 	{ 0x04, SONYPI_EVENT_FNKEY_RELEASED },
887 	{ 0x85, SONYPI_EVENT_FNKEY_F5 },
888 	{ 0x05, SONYPI_EVENT_FNKEY_RELEASED },
889 	{ 0x86, SONYPI_EVENT_FNKEY_F6 },
890 	{ 0x06, SONYPI_EVENT_FNKEY_RELEASED },
891 	{ 0x87, SONYPI_EVENT_FNKEY_F7 },
892 	{ 0x07, SONYPI_EVENT_FNKEY_RELEASED },
893 	{ 0x89, SONYPI_EVENT_FNKEY_F9 },
894 	{ 0x09, SONYPI_EVENT_FNKEY_RELEASED },
895 	{ 0x8A, SONYPI_EVENT_FNKEY_F10 },
896 	{ 0x0A, SONYPI_EVENT_FNKEY_RELEASED },
897 	{ 0x8C, SONYPI_EVENT_FNKEY_F12 },
898 	{ 0x0C, SONYPI_EVENT_FNKEY_RELEASED },
899 	{ 0x9d, SONYPI_EVENT_ZOOM_PRESSED },
900 	{ 0x1d, SONYPI_EVENT_ANYBUTTON_RELEASED },
901 	{ 0x9f, SONYPI_EVENT_CD_EJECT_PRESSED },
902 	{ 0x1f, SONYPI_EVENT_ANYBUTTON_RELEASED },
903 	{ 0xa1, SONYPI_EVENT_MEDIA_PRESSED },
904 	{ 0x21, SONYPI_EVENT_ANYBUTTON_RELEASED },
905 	{ 0xa4, SONYPI_EVENT_CD_EJECT_PRESSED },
906 	{ 0x24, SONYPI_EVENT_ANYBUTTON_RELEASED },
907 	{ 0xa5, SONYPI_EVENT_VENDOR_PRESSED },
908 	{ 0x25, SONYPI_EVENT_ANYBUTTON_RELEASED },
909 	{ 0xa6, SONYPI_EVENT_HELP_PRESSED },
910 	{ 0x26, SONYPI_EVENT_ANYBUTTON_RELEASED },
911 	{ 0, 0 },
912 };
913 
914 static struct sony_nc_event sony_127_events[] = {
915 	{ 0x81, SONYPI_EVENT_MODEKEY_PRESSED },
916 	{ 0x01, SONYPI_EVENT_ANYBUTTON_RELEASED },
917 	{ 0x82, SONYPI_EVENT_PKEY_P1 },
918 	{ 0x02, SONYPI_EVENT_ANYBUTTON_RELEASED },
919 	{ 0x83, SONYPI_EVENT_PKEY_P2 },
920 	{ 0x03, SONYPI_EVENT_ANYBUTTON_RELEASED },
921 	{ 0x84, SONYPI_EVENT_PKEY_P3 },
922 	{ 0x04, SONYPI_EVENT_ANYBUTTON_RELEASED },
923 	{ 0x85, SONYPI_EVENT_PKEY_P4 },
924 	{ 0x05, SONYPI_EVENT_ANYBUTTON_RELEASED },
925 	{ 0x86, SONYPI_EVENT_PKEY_P5 },
926 	{ 0x06, SONYPI_EVENT_ANYBUTTON_RELEASED },
927 	{ 0x87, SONYPI_EVENT_SETTINGKEY_PRESSED },
928 	{ 0x07, SONYPI_EVENT_ANYBUTTON_RELEASED },
929 	{ 0, 0 },
930 };
931 
932 /*
933  * ACPI callbacks
934  */
935 static void sony_nc_notify(struct acpi_device *device, u32 event)
936 {
937 	u32 ev = event;
938 
939 	if (ev >= 0x90) {
940 		/* New-style event */
941 		int result;
942 		int key_handle = 0;
943 		ev -= 0x90;
944 
945 		if (sony_find_snc_handle(0x100) == ev)
946 			key_handle = 0x100;
947 		if (sony_find_snc_handle(0x127) == ev)
948 			key_handle = 0x127;
949 
950 		if (key_handle) {
951 			struct sony_nc_event *key_event;
952 
953 			if (sony_call_snc_handle(key_handle, 0x200, &result)) {
954 				dprintk("sony_nc_notify, unable to decode"
955 					" event 0x%.2x 0x%.2x\n", key_handle,
956 					ev);
957 				/* restore the original event */
958 				ev = event;
959 			} else {
960 				ev = result & 0xFF;
961 
962 				if (key_handle == 0x100)
963 					key_event = sony_100_events;
964 				else
965 					key_event = sony_127_events;
966 
967 				for (; key_event->data; key_event++) {
968 					if (key_event->data == ev) {
969 						ev = key_event->event;
970 						break;
971 					}
972 				}
973 
974 				if (!key_event->data)
975 					printk(KERN_INFO DRV_PFX
976 							"Unknown event: 0x%x 0x%x\n",
977 							key_handle,
978 							ev);
979 				else
980 					sony_laptop_report_input_event(ev);
981 			}
982 		} else if (sony_find_snc_handle(sony_rfkill_handle) == ev) {
983 			sony_nc_rfkill_update();
984 			return;
985 		}
986 	} else
987 		sony_laptop_report_input_event(ev);
988 
989 	dprintk("sony_nc_notify, event: 0x%.2x\n", ev);
990 	acpi_bus_generate_proc_event(sony_nc_acpi_device, 1, ev);
991 }
992 
993 static acpi_status sony_walk_callback(acpi_handle handle, u32 level,
994 				      void *context, void **return_value)
995 {
996 	struct acpi_device_info *info;
997 
998 	if (ACPI_SUCCESS(acpi_get_object_info(handle, &info))) {
999 		printk(KERN_WARNING DRV_PFX "method: name: %4.4s, args %X\n",
1000 			(char *)&info->name, info->param_count);
1001 
1002 		kfree(info);
1003 	}
1004 
1005 	return AE_OK;
1006 }
1007 
1008 /*
1009  * ACPI device
1010  */
1011 static int sony_nc_function_setup(struct acpi_device *device)
1012 {
1013 	int result;
1014 
1015 	/* Enable all events */
1016 	acpi_callsetfunc(sony_nc_acpi_handle, "SN02", 0xffff, &result);
1017 
1018 	/* Setup hotkeys */
1019 	sony_call_snc_handle(0x0100, 0, &result);
1020 	sony_call_snc_handle(0x0101, 0, &result);
1021 	sony_call_snc_handle(0x0102, 0x100, &result);
1022 	sony_call_snc_handle(0x0127, 0, &result);
1023 
1024 	return 0;
1025 }
1026 
1027 static int sony_nc_resume(struct acpi_device *device)
1028 {
1029 	struct sony_nc_value *item;
1030 	acpi_handle handle;
1031 
1032 	for (item = sony_nc_values; item->name; item++) {
1033 		int ret;
1034 
1035 		if (!item->valid)
1036 			continue;
1037 		ret = acpi_callsetfunc(sony_nc_acpi_handle, *item->acpiset,
1038 				       item->value, NULL);
1039 		if (ret < 0) {
1040 			printk("%s: %d\n", __func__, ret);
1041 			break;
1042 		}
1043 	}
1044 
1045 	if (ACPI_SUCCESS(acpi_get_handle(sony_nc_acpi_handle, "ECON",
1046 					 &handle))) {
1047 		if (acpi_callsetfunc(sony_nc_acpi_handle, "ECON", 1, NULL))
1048 			dprintk("ECON Method failed\n");
1049 	}
1050 
1051 	if (ACPI_SUCCESS(acpi_get_handle(sony_nc_acpi_handle, "SN00",
1052 					 &handle))) {
1053 		dprintk("Doing SNC setup\n");
1054 		sony_nc_function_setup(device);
1055 	}
1056 
1057 	/* set the last requested brightness level */
1058 	if (sony_backlight_device &&
1059 			sony_backlight_update_status(sony_backlight_device) < 0)
1060 		printk(KERN_WARNING DRV_PFX "unable to restore brightness level\n");
1061 
1062 	/* re-read rfkill state */
1063 	sony_nc_rfkill_update();
1064 
1065 	return 0;
1066 }
1067 
1068 static void sony_nc_rfkill_cleanup(void)
1069 {
1070 	int i;
1071 
1072 	for (i = 0; i < N_SONY_RFKILL; i++) {
1073 		if (sony_rfkill_devices[i]) {
1074 			rfkill_unregister(sony_rfkill_devices[i]);
1075 			rfkill_destroy(sony_rfkill_devices[i]);
1076 		}
1077 	}
1078 }
1079 
1080 static int sony_nc_rfkill_set(void *data, bool blocked)
1081 {
1082 	int result;
1083 	int argument = sony_rfkill_address[(long) data] + 0x100;
1084 
1085 	if (!blocked)
1086 		argument |= 0xff0000;
1087 
1088 	return sony_call_snc_handle(sony_rfkill_handle, argument, &result);
1089 }
1090 
1091 static const struct rfkill_ops sony_rfkill_ops = {
1092 	.set_block = sony_nc_rfkill_set,
1093 };
1094 
1095 static int sony_nc_setup_rfkill(struct acpi_device *device,
1096 				enum sony_nc_rfkill nc_type)
1097 {
1098 	int err = 0;
1099 	struct rfkill *rfk;
1100 	enum rfkill_type type;
1101 	const char *name;
1102 	int result;
1103 	bool hwblock;
1104 
1105 	switch (nc_type) {
1106 	case SONY_WIFI:
1107 		type = RFKILL_TYPE_WLAN;
1108 		name = "sony-wifi";
1109 		break;
1110 	case SONY_BLUETOOTH:
1111 		type = RFKILL_TYPE_BLUETOOTH;
1112 		name = "sony-bluetooth";
1113 		break;
1114 	case SONY_WWAN:
1115 		type = RFKILL_TYPE_WWAN;
1116 		name = "sony-wwan";
1117 		break;
1118 	case SONY_WIMAX:
1119 		type = RFKILL_TYPE_WIMAX;
1120 		name = "sony-wimax";
1121 		break;
1122 	default:
1123 		return -EINVAL;
1124 	}
1125 
1126 	rfk = rfkill_alloc(name, &device->dev, type,
1127 			   &sony_rfkill_ops, (void *)nc_type);
1128 	if (!rfk)
1129 		return -ENOMEM;
1130 
1131 	sony_call_snc_handle(sony_rfkill_handle, 0x200, &result);
1132 	hwblock = !(result & 0x1);
1133 	rfkill_set_hw_state(rfk, hwblock);
1134 
1135 	err = rfkill_register(rfk);
1136 	if (err) {
1137 		rfkill_destroy(rfk);
1138 		return err;
1139 	}
1140 	sony_rfkill_devices[nc_type] = rfk;
1141 	return err;
1142 }
1143 
1144 static void sony_nc_rfkill_update(void)
1145 {
1146 	enum sony_nc_rfkill i;
1147 	int result;
1148 	bool hwblock;
1149 
1150 	sony_call_snc_handle(sony_rfkill_handle, 0x200, &result);
1151 	hwblock = !(result & 0x1);
1152 
1153 	for (i = 0; i < N_SONY_RFKILL; i++) {
1154 		int argument = sony_rfkill_address[i];
1155 
1156 		if (!sony_rfkill_devices[i])
1157 			continue;
1158 
1159 		if (hwblock) {
1160 			if (rfkill_set_hw_state(sony_rfkill_devices[i], true)) {
1161 				/* we already know we're blocked */
1162 			}
1163 			continue;
1164 		}
1165 
1166 		sony_call_snc_handle(sony_rfkill_handle, argument, &result);
1167 		rfkill_set_states(sony_rfkill_devices[i],
1168 				  !(result & 0xf), false);
1169 	}
1170 }
1171 
1172 static void sony_nc_rfkill_setup(struct acpi_device *device)
1173 {
1174 	int offset;
1175 	u8 dev_code, i;
1176 	acpi_status status;
1177 	struct acpi_object_list params;
1178 	union acpi_object in_obj;
1179 	union acpi_object *device_enum;
1180 	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
1181 
1182 	offset = sony_find_snc_handle(0x124);
1183 	if (offset == -1) {
1184 		offset = sony_find_snc_handle(0x135);
1185 		if (offset == -1)
1186 			return;
1187 		else
1188 			sony_rfkill_handle = 0x135;
1189 	} else
1190 		sony_rfkill_handle = 0x124;
1191 	dprintk("Found rkfill handle: 0x%.4x\n", sony_rfkill_handle);
1192 
1193 	/* need to read the whole buffer returned by the acpi call to SN06
1194 	 * here otherwise we may miss some features
1195 	 */
1196 	params.count = 1;
1197 	params.pointer = &in_obj;
1198 	in_obj.type = ACPI_TYPE_INTEGER;
1199 	in_obj.integer.value = offset;
1200 	status = acpi_evaluate_object(sony_nc_acpi_handle, "SN06", &params,
1201 			&buffer);
1202 	if (ACPI_FAILURE(status)) {
1203 		dprintk("Radio device enumeration failed\n");
1204 		return;
1205 	}
1206 
1207 	device_enum = (union acpi_object *) buffer.pointer;
1208 	if (!device_enum) {
1209 		pr_err("Invalid SN06 return object\n");
1210 		goto out_no_enum;
1211 	}
1212 	if (device_enum->type != ACPI_TYPE_BUFFER) {
1213 		pr_err("Invalid SN06 return object type 0x%.2x\n",
1214 		       device_enum->type);
1215 		goto out_no_enum;
1216 	}
1217 
1218 	/* the buffer is filled with magic numbers describing the devices
1219 	 * available, 0xff terminates the enumeration
1220 	 */
1221 	for (i = 0; i < device_enum->buffer.length; i++) {
1222 
1223 		dev_code = *(device_enum->buffer.pointer + i);
1224 		if (dev_code == 0xff)
1225 			break;
1226 
1227 		dprintk("Radio devices, looking at 0x%.2x\n", dev_code);
1228 
1229 		if (dev_code == 0 && !sony_rfkill_devices[SONY_WIFI])
1230 			sony_nc_setup_rfkill(device, SONY_WIFI);
1231 
1232 		if (dev_code == 0x10 && !sony_rfkill_devices[SONY_BLUETOOTH])
1233 			sony_nc_setup_rfkill(device, SONY_BLUETOOTH);
1234 
1235 		if ((0xf0 & dev_code) == 0x20 &&
1236 				!sony_rfkill_devices[SONY_WWAN])
1237 			sony_nc_setup_rfkill(device, SONY_WWAN);
1238 
1239 		if (dev_code == 0x30 && !sony_rfkill_devices[SONY_WIMAX])
1240 			sony_nc_setup_rfkill(device, SONY_WIMAX);
1241 	}
1242 
1243 out_no_enum:
1244 	kfree(buffer.pointer);
1245 	return;
1246 }
1247 
1248 static int sony_nc_add(struct acpi_device *device)
1249 {
1250 	acpi_status status;
1251 	int result = 0;
1252 	acpi_handle handle;
1253 	struct sony_nc_value *item;
1254 
1255 	printk(KERN_INFO DRV_PFX "%s v%s.\n",
1256 		SONY_NC_DRIVER_NAME, SONY_LAPTOP_DRIVER_VERSION);
1257 
1258 	sony_nc_acpi_device = device;
1259 	strcpy(acpi_device_class(device), "sony/hotkey");
1260 
1261 	sony_nc_acpi_handle = device->handle;
1262 
1263 	/* read device status */
1264 	result = acpi_bus_get_status(device);
1265 	/* bail IFF the above call was successful and the device is not present */
1266 	if (!result && !device->status.present) {
1267 		dprintk("Device not present\n");
1268 		result = -ENODEV;
1269 		goto outwalk;
1270 	}
1271 
1272 	if (debug) {
1273 		status = acpi_walk_namespace(ACPI_TYPE_METHOD, sony_nc_acpi_handle,
1274 					     1, sony_walk_callback, NULL, NULL, NULL);
1275 		if (ACPI_FAILURE(status)) {
1276 			printk(KERN_WARNING DRV_PFX "unable to walk acpi resources\n");
1277 			result = -ENODEV;
1278 			goto outwalk;
1279 		}
1280 	}
1281 
1282 	if (ACPI_SUCCESS(acpi_get_handle(sony_nc_acpi_handle, "ECON",
1283 					 &handle))) {
1284 		if (acpi_callsetfunc(sony_nc_acpi_handle, "ECON", 1, NULL))
1285 			dprintk("ECON Method failed\n");
1286 	}
1287 
1288 	if (ACPI_SUCCESS(acpi_get_handle(sony_nc_acpi_handle, "SN00",
1289 					 &handle))) {
1290 		dprintk("Doing SNC setup\n");
1291 		sony_nc_function_setup(device);
1292 		sony_nc_rfkill_setup(device);
1293 	}
1294 
1295 	/* setup input devices and helper fifo */
1296 	result = sony_laptop_setup_input(device);
1297 	if (result) {
1298 		printk(KERN_ERR DRV_PFX
1299 				"Unable to create input devices.\n");
1300 		goto outwalk;
1301 	}
1302 
1303 	if (acpi_video_backlight_support()) {
1304 		printk(KERN_INFO DRV_PFX "brightness ignored, must be "
1305 		       "controlled by ACPI video driver\n");
1306 	} else if (ACPI_SUCCESS(acpi_get_handle(sony_nc_acpi_handle, "GBRT",
1307 						&handle))) {
1308 							struct backlight_properties props;
1309 		memset(&props, 0, sizeof(struct backlight_properties));
1310 		props.max_brightness = SONY_MAX_BRIGHTNESS - 1;
1311 		sony_backlight_device = backlight_device_register("sony", NULL,
1312 								  NULL,
1313 								  &sony_backlight_ops,
1314 								  &props);
1315 
1316 		if (IS_ERR(sony_backlight_device)) {
1317 			printk(KERN_WARNING DRV_PFX "unable to register backlight device\n");
1318 			sony_backlight_device = NULL;
1319 		} else {
1320 			sony_backlight_device->props.brightness =
1321 			    sony_backlight_get_brightness
1322 			    (sony_backlight_device);
1323 		}
1324 
1325 	}
1326 
1327 	result = sony_pf_add();
1328 	if (result)
1329 		goto outbacklight;
1330 
1331 	/* create sony_pf sysfs attributes related to the SNC device */
1332 	for (item = sony_nc_values; item->name; ++item) {
1333 
1334 		if (!debug && item->debug)
1335 			continue;
1336 
1337 		/* find the available acpiget as described in the DSDT */
1338 		for (; item->acpiget && *item->acpiget; ++item->acpiget) {
1339 			if (ACPI_SUCCESS(acpi_get_handle(sony_nc_acpi_handle,
1340 							 *item->acpiget,
1341 							 &handle))) {
1342 				dprintk("Found %s getter: %s\n",
1343 						item->name, *item->acpiget);
1344 				item->devattr.attr.mode |= S_IRUGO;
1345 				break;
1346 			}
1347 		}
1348 
1349 		/* find the available acpiset as described in the DSDT */
1350 		for (; item->acpiset && *item->acpiset; ++item->acpiset) {
1351 			if (ACPI_SUCCESS(acpi_get_handle(sony_nc_acpi_handle,
1352 							 *item->acpiset,
1353 							 &handle))) {
1354 				dprintk("Found %s setter: %s\n",
1355 						item->name, *item->acpiset);
1356 				item->devattr.attr.mode |= S_IWUSR;
1357 				break;
1358 			}
1359 		}
1360 
1361 		if (item->devattr.attr.mode != 0) {
1362 			result =
1363 			    device_create_file(&sony_pf_device->dev,
1364 					       &item->devattr);
1365 			if (result)
1366 				goto out_sysfs;
1367 		}
1368 	}
1369 
1370 	return 0;
1371 
1372       out_sysfs:
1373 	for (item = sony_nc_values; item->name; ++item) {
1374 		device_remove_file(&sony_pf_device->dev, &item->devattr);
1375 	}
1376 	sony_pf_remove();
1377 
1378       outbacklight:
1379 	if (sony_backlight_device)
1380 		backlight_device_unregister(sony_backlight_device);
1381 
1382 	sony_laptop_remove_input();
1383 
1384       outwalk:
1385 	sony_nc_rfkill_cleanup();
1386 	return result;
1387 }
1388 
1389 static int sony_nc_remove(struct acpi_device *device, int type)
1390 {
1391 	struct sony_nc_value *item;
1392 
1393 	if (sony_backlight_device)
1394 		backlight_device_unregister(sony_backlight_device);
1395 
1396 	sony_nc_acpi_device = NULL;
1397 
1398 	for (item = sony_nc_values; item->name; ++item) {
1399 		device_remove_file(&sony_pf_device->dev, &item->devattr);
1400 	}
1401 
1402 	sony_pf_remove();
1403 	sony_laptop_remove_input();
1404 	sony_nc_rfkill_cleanup();
1405 	dprintk(SONY_NC_DRIVER_NAME " removed.\n");
1406 
1407 	return 0;
1408 }
1409 
1410 static const struct acpi_device_id sony_device_ids[] = {
1411 	{SONY_NC_HID, 0},
1412 	{SONY_PIC_HID, 0},
1413 	{"", 0},
1414 };
1415 MODULE_DEVICE_TABLE(acpi, sony_device_ids);
1416 
1417 static const struct acpi_device_id sony_nc_device_ids[] = {
1418 	{SONY_NC_HID, 0},
1419 	{"", 0},
1420 };
1421 
1422 static struct acpi_driver sony_nc_driver = {
1423 	.name = SONY_NC_DRIVER_NAME,
1424 	.class = SONY_NC_CLASS,
1425 	.ids = sony_nc_device_ids,
1426 	.owner = THIS_MODULE,
1427 	.ops = {
1428 		.add = sony_nc_add,
1429 		.remove = sony_nc_remove,
1430 		.resume = sony_nc_resume,
1431 		.notify = sony_nc_notify,
1432 		},
1433 };
1434 
1435 /*********** SPIC (SNY6001) Device ***********/
1436 
1437 #define SONYPI_DEVICE_TYPE1	0x00000001
1438 #define SONYPI_DEVICE_TYPE2	0x00000002
1439 #define SONYPI_DEVICE_TYPE3	0x00000004
1440 #define SONYPI_DEVICE_TYPE4	0x00000008
1441 
1442 #define SONYPI_TYPE1_OFFSET	0x04
1443 #define SONYPI_TYPE2_OFFSET	0x12
1444 #define SONYPI_TYPE3_OFFSET	0x12
1445 
1446 struct sony_pic_ioport {
1447 	struct acpi_resource_io	io1;
1448 	struct acpi_resource_io	io2;
1449 	struct list_head	list;
1450 };
1451 
1452 struct sony_pic_irq {
1453 	struct acpi_resource_irq	irq;
1454 	struct list_head		list;
1455 };
1456 
1457 struct sonypi_eventtypes {
1458 	u8			data;
1459 	unsigned long		mask;
1460 	struct sonypi_event	*events;
1461 };
1462 
1463 struct sony_pic_dev {
1464 	struct acpi_device		*acpi_dev;
1465 	struct sony_pic_irq		*cur_irq;
1466 	struct sony_pic_ioport		*cur_ioport;
1467 	struct list_head		interrupts;
1468 	struct list_head		ioports;
1469 	struct mutex			lock;
1470 	struct sonypi_eventtypes	*event_types;
1471 	int                             (*handle_irq)(const u8, const u8);
1472 	int				model;
1473 	u16				evport_offset;
1474 	u8				camera_power;
1475 	u8				bluetooth_power;
1476 	u8				wwan_power;
1477 };
1478 
1479 static struct sony_pic_dev spic_dev = {
1480 	.interrupts	= LIST_HEAD_INIT(spic_dev.interrupts),
1481 	.ioports	= LIST_HEAD_INIT(spic_dev.ioports),
1482 };
1483 
1484 static int spic_drv_registered;
1485 
1486 /* Event masks */
1487 #define SONYPI_JOGGER_MASK			0x00000001
1488 #define SONYPI_CAPTURE_MASK			0x00000002
1489 #define SONYPI_FNKEY_MASK			0x00000004
1490 #define SONYPI_BLUETOOTH_MASK			0x00000008
1491 #define SONYPI_PKEY_MASK			0x00000010
1492 #define SONYPI_BACK_MASK			0x00000020
1493 #define SONYPI_HELP_MASK			0x00000040
1494 #define SONYPI_LID_MASK				0x00000080
1495 #define SONYPI_ZOOM_MASK			0x00000100
1496 #define SONYPI_THUMBPHRASE_MASK			0x00000200
1497 #define SONYPI_MEYE_MASK			0x00000400
1498 #define SONYPI_MEMORYSTICK_MASK			0x00000800
1499 #define SONYPI_BATTERY_MASK			0x00001000
1500 #define SONYPI_WIRELESS_MASK			0x00002000
1501 
1502 struct sonypi_event {
1503 	u8	data;
1504 	u8	event;
1505 };
1506 
1507 /* The set of possible button release events */
1508 static struct sonypi_event sonypi_releaseev[] = {
1509 	{ 0x00, SONYPI_EVENT_ANYBUTTON_RELEASED },
1510 	{ 0, 0 }
1511 };
1512 
1513 /* The set of possible jogger events  */
1514 static struct sonypi_event sonypi_joggerev[] = {
1515 	{ 0x1f, SONYPI_EVENT_JOGDIAL_UP },
1516 	{ 0x01, SONYPI_EVENT_JOGDIAL_DOWN },
1517 	{ 0x5f, SONYPI_EVENT_JOGDIAL_UP_PRESSED },
1518 	{ 0x41, SONYPI_EVENT_JOGDIAL_DOWN_PRESSED },
1519 	{ 0x1e, SONYPI_EVENT_JOGDIAL_FAST_UP },
1520 	{ 0x02, SONYPI_EVENT_JOGDIAL_FAST_DOWN },
1521 	{ 0x5e, SONYPI_EVENT_JOGDIAL_FAST_UP_PRESSED },
1522 	{ 0x42, SONYPI_EVENT_JOGDIAL_FAST_DOWN_PRESSED },
1523 	{ 0x1d, SONYPI_EVENT_JOGDIAL_VFAST_UP },
1524 	{ 0x03, SONYPI_EVENT_JOGDIAL_VFAST_DOWN },
1525 	{ 0x5d, SONYPI_EVENT_JOGDIAL_VFAST_UP_PRESSED },
1526 	{ 0x43, SONYPI_EVENT_JOGDIAL_VFAST_DOWN_PRESSED },
1527 	{ 0x40, SONYPI_EVENT_JOGDIAL_PRESSED },
1528 	{ 0, 0 }
1529 };
1530 
1531 /* The set of possible capture button events */
1532 static struct sonypi_event sonypi_captureev[] = {
1533 	{ 0x05, SONYPI_EVENT_CAPTURE_PARTIALPRESSED },
1534 	{ 0x07, SONYPI_EVENT_CAPTURE_PRESSED },
1535 	{ 0x40, SONYPI_EVENT_CAPTURE_PRESSED },
1536 	{ 0x01, SONYPI_EVENT_CAPTURE_PARTIALRELEASED },
1537 	{ 0, 0 }
1538 };
1539 
1540 /* The set of possible fnkeys events */
1541 static struct sonypi_event sonypi_fnkeyev[] = {
1542 	{ 0x10, SONYPI_EVENT_FNKEY_ESC },
1543 	{ 0x11, SONYPI_EVENT_FNKEY_F1 },
1544 	{ 0x12, SONYPI_EVENT_FNKEY_F2 },
1545 	{ 0x13, SONYPI_EVENT_FNKEY_F3 },
1546 	{ 0x14, SONYPI_EVENT_FNKEY_F4 },
1547 	{ 0x15, SONYPI_EVENT_FNKEY_F5 },
1548 	{ 0x16, SONYPI_EVENT_FNKEY_F6 },
1549 	{ 0x17, SONYPI_EVENT_FNKEY_F7 },
1550 	{ 0x18, SONYPI_EVENT_FNKEY_F8 },
1551 	{ 0x19, SONYPI_EVENT_FNKEY_F9 },
1552 	{ 0x1a, SONYPI_EVENT_FNKEY_F10 },
1553 	{ 0x1b, SONYPI_EVENT_FNKEY_F11 },
1554 	{ 0x1c, SONYPI_EVENT_FNKEY_F12 },
1555 	{ 0x1f, SONYPI_EVENT_FNKEY_RELEASED },
1556 	{ 0x21, SONYPI_EVENT_FNKEY_1 },
1557 	{ 0x22, SONYPI_EVENT_FNKEY_2 },
1558 	{ 0x31, SONYPI_EVENT_FNKEY_D },
1559 	{ 0x32, SONYPI_EVENT_FNKEY_E },
1560 	{ 0x33, SONYPI_EVENT_FNKEY_F },
1561 	{ 0x34, SONYPI_EVENT_FNKEY_S },
1562 	{ 0x35, SONYPI_EVENT_FNKEY_B },
1563 	{ 0x36, SONYPI_EVENT_FNKEY_ONLY },
1564 	{ 0, 0 }
1565 };
1566 
1567 /* The set of possible program key events */
1568 static struct sonypi_event sonypi_pkeyev[] = {
1569 	{ 0x01, SONYPI_EVENT_PKEY_P1 },
1570 	{ 0x02, SONYPI_EVENT_PKEY_P2 },
1571 	{ 0x04, SONYPI_EVENT_PKEY_P3 },
1572 	{ 0x20, SONYPI_EVENT_PKEY_P1 },
1573 	{ 0, 0 }
1574 };
1575 
1576 /* The set of possible bluetooth events */
1577 static struct sonypi_event sonypi_blueev[] = {
1578 	{ 0x55, SONYPI_EVENT_BLUETOOTH_PRESSED },
1579 	{ 0x59, SONYPI_EVENT_BLUETOOTH_ON },
1580 	{ 0x5a, SONYPI_EVENT_BLUETOOTH_OFF },
1581 	{ 0, 0 }
1582 };
1583 
1584 /* The set of possible wireless events */
1585 static struct sonypi_event sonypi_wlessev[] = {
1586 	{ 0x59, SONYPI_EVENT_WIRELESS_ON },
1587 	{ 0x5a, SONYPI_EVENT_WIRELESS_OFF },
1588 	{ 0, 0 }
1589 };
1590 
1591 /* The set of possible back button events */
1592 static struct sonypi_event sonypi_backev[] = {
1593 	{ 0x20, SONYPI_EVENT_BACK_PRESSED },
1594 	{ 0, 0 }
1595 };
1596 
1597 /* The set of possible help button events */
1598 static struct sonypi_event sonypi_helpev[] = {
1599 	{ 0x3b, SONYPI_EVENT_HELP_PRESSED },
1600 	{ 0, 0 }
1601 };
1602 
1603 
1604 /* The set of possible lid events */
1605 static struct sonypi_event sonypi_lidev[] = {
1606 	{ 0x51, SONYPI_EVENT_LID_CLOSED },
1607 	{ 0x50, SONYPI_EVENT_LID_OPENED },
1608 	{ 0, 0 }
1609 };
1610 
1611 /* The set of possible zoom events */
1612 static struct sonypi_event sonypi_zoomev[] = {
1613 	{ 0x39, SONYPI_EVENT_ZOOM_PRESSED },
1614 	{ 0x10, SONYPI_EVENT_ZOOM_IN_PRESSED },
1615 	{ 0x20, SONYPI_EVENT_ZOOM_OUT_PRESSED },
1616 	{ 0x04, SONYPI_EVENT_ZOOM_PRESSED },
1617 	{ 0, 0 }
1618 };
1619 
1620 /* The set of possible thumbphrase events */
1621 static struct sonypi_event sonypi_thumbphraseev[] = {
1622 	{ 0x3a, SONYPI_EVENT_THUMBPHRASE_PRESSED },
1623 	{ 0, 0 }
1624 };
1625 
1626 /* The set of possible motioneye camera events */
1627 static struct sonypi_event sonypi_meyeev[] = {
1628 	{ 0x00, SONYPI_EVENT_MEYE_FACE },
1629 	{ 0x01, SONYPI_EVENT_MEYE_OPPOSITE },
1630 	{ 0, 0 }
1631 };
1632 
1633 /* The set of possible memorystick events */
1634 static struct sonypi_event sonypi_memorystickev[] = {
1635 	{ 0x53, SONYPI_EVENT_MEMORYSTICK_INSERT },
1636 	{ 0x54, SONYPI_EVENT_MEMORYSTICK_EJECT },
1637 	{ 0, 0 }
1638 };
1639 
1640 /* The set of possible battery events */
1641 static struct sonypi_event sonypi_batteryev[] = {
1642 	{ 0x20, SONYPI_EVENT_BATTERY_INSERT },
1643 	{ 0x30, SONYPI_EVENT_BATTERY_REMOVE },
1644 	{ 0, 0 }
1645 };
1646 
1647 /* The set of possible volume events */
1648 static struct sonypi_event sonypi_volumeev[] = {
1649 	{ 0x01, SONYPI_EVENT_VOLUME_INC_PRESSED },
1650 	{ 0x02, SONYPI_EVENT_VOLUME_DEC_PRESSED },
1651 	{ 0, 0 }
1652 };
1653 
1654 /* The set of possible brightness events */
1655 static struct sonypi_event sonypi_brightnessev[] = {
1656 	{ 0x80, SONYPI_EVENT_BRIGHTNESS_PRESSED },
1657 	{ 0, 0 }
1658 };
1659 
1660 static struct sonypi_eventtypes type1_events[] = {
1661 	{ 0, 0xffffffff, sonypi_releaseev },
1662 	{ 0x70, SONYPI_MEYE_MASK, sonypi_meyeev },
1663 	{ 0x30, SONYPI_LID_MASK, sonypi_lidev },
1664 	{ 0x60, SONYPI_CAPTURE_MASK, sonypi_captureev },
1665 	{ 0x10, SONYPI_JOGGER_MASK, sonypi_joggerev },
1666 	{ 0x20, SONYPI_FNKEY_MASK, sonypi_fnkeyev },
1667 	{ 0x30, SONYPI_BLUETOOTH_MASK, sonypi_blueev },
1668 	{ 0x40, SONYPI_PKEY_MASK, sonypi_pkeyev },
1669 	{ 0x30, SONYPI_MEMORYSTICK_MASK, sonypi_memorystickev },
1670 	{ 0x40, SONYPI_BATTERY_MASK, sonypi_batteryev },
1671 	{ 0 },
1672 };
1673 static struct sonypi_eventtypes type2_events[] = {
1674 	{ 0, 0xffffffff, sonypi_releaseev },
1675 	{ 0x38, SONYPI_LID_MASK, sonypi_lidev },
1676 	{ 0x11, SONYPI_JOGGER_MASK, sonypi_joggerev },
1677 	{ 0x61, SONYPI_CAPTURE_MASK, sonypi_captureev },
1678 	{ 0x21, SONYPI_FNKEY_MASK, sonypi_fnkeyev },
1679 	{ 0x31, SONYPI_BLUETOOTH_MASK, sonypi_blueev },
1680 	{ 0x08, SONYPI_PKEY_MASK, sonypi_pkeyev },
1681 	{ 0x11, SONYPI_BACK_MASK, sonypi_backev },
1682 	{ 0x21, SONYPI_HELP_MASK, sonypi_helpev },
1683 	{ 0x21, SONYPI_ZOOM_MASK, sonypi_zoomev },
1684 	{ 0x20, SONYPI_THUMBPHRASE_MASK, sonypi_thumbphraseev },
1685 	{ 0x31, SONYPI_MEMORYSTICK_MASK, sonypi_memorystickev },
1686 	{ 0x41, SONYPI_BATTERY_MASK, sonypi_batteryev },
1687 	{ 0x31, SONYPI_PKEY_MASK, sonypi_pkeyev },
1688 	{ 0 },
1689 };
1690 static struct sonypi_eventtypes type3_events[] = {
1691 	{ 0, 0xffffffff, sonypi_releaseev },
1692 	{ 0x21, SONYPI_FNKEY_MASK, sonypi_fnkeyev },
1693 	{ 0x31, SONYPI_WIRELESS_MASK, sonypi_wlessev },
1694 	{ 0x31, SONYPI_MEMORYSTICK_MASK, sonypi_memorystickev },
1695 	{ 0x41, SONYPI_BATTERY_MASK, sonypi_batteryev },
1696 	{ 0x31, SONYPI_PKEY_MASK, sonypi_pkeyev },
1697 	{ 0x05, SONYPI_PKEY_MASK, sonypi_pkeyev },
1698 	{ 0x05, SONYPI_ZOOM_MASK, sonypi_zoomev },
1699 	{ 0x05, SONYPI_CAPTURE_MASK, sonypi_captureev },
1700 	{ 0x05, SONYPI_PKEY_MASK, sonypi_volumeev },
1701 	{ 0x05, SONYPI_PKEY_MASK, sonypi_brightnessev },
1702 	{ 0 },
1703 };
1704 
1705 /* low level spic calls */
1706 #define ITERATIONS_LONG		10000
1707 #define ITERATIONS_SHORT	10
1708 #define wait_on_command(command, iterations) {				\
1709 	unsigned int n = iterations;					\
1710 	while (--n && (command))					\
1711 		udelay(1);						\
1712 	if (!n)								\
1713 		dprintk("command failed at %s : %s (line %d)\n",	\
1714 				__FILE__, __func__, __LINE__);	\
1715 }
1716 
1717 static u8 sony_pic_call1(u8 dev)
1718 {
1719 	u8 v1, v2;
1720 
1721 	wait_on_command(inb_p(spic_dev.cur_ioport->io1.minimum + 4) & 2,
1722 			ITERATIONS_LONG);
1723 	outb(dev, spic_dev.cur_ioport->io1.minimum + 4);
1724 	v1 = inb_p(spic_dev.cur_ioport->io1.minimum + 4);
1725 	v2 = inb_p(spic_dev.cur_ioport->io1.minimum);
1726 	dprintk("sony_pic_call1(0x%.2x): 0x%.4x\n", dev, (v2 << 8) | v1);
1727 	return v2;
1728 }
1729 
1730 static u8 sony_pic_call2(u8 dev, u8 fn)
1731 {
1732 	u8 v1;
1733 
1734 	wait_on_command(inb_p(spic_dev.cur_ioport->io1.minimum + 4) & 2,
1735 			ITERATIONS_LONG);
1736 	outb(dev, spic_dev.cur_ioport->io1.minimum + 4);
1737 	wait_on_command(inb_p(spic_dev.cur_ioport->io1.minimum + 4) & 2,
1738 			ITERATIONS_LONG);
1739 	outb(fn, spic_dev.cur_ioport->io1.minimum);
1740 	v1 = inb_p(spic_dev.cur_ioport->io1.minimum);
1741 	dprintk("sony_pic_call2(0x%.2x - 0x%.2x): 0x%.4x\n", dev, fn, v1);
1742 	return v1;
1743 }
1744 
1745 static u8 sony_pic_call3(u8 dev, u8 fn, u8 v)
1746 {
1747 	u8 v1;
1748 
1749 	wait_on_command(inb_p(spic_dev.cur_ioport->io1.minimum + 4) & 2, ITERATIONS_LONG);
1750 	outb(dev, spic_dev.cur_ioport->io1.minimum + 4);
1751 	wait_on_command(inb_p(spic_dev.cur_ioport->io1.minimum + 4) & 2, ITERATIONS_LONG);
1752 	outb(fn, spic_dev.cur_ioport->io1.minimum);
1753 	wait_on_command(inb_p(spic_dev.cur_ioport->io1.minimum + 4) & 2, ITERATIONS_LONG);
1754 	outb(v, spic_dev.cur_ioport->io1.minimum);
1755 	v1 = inb_p(spic_dev.cur_ioport->io1.minimum);
1756 	dprintk("sony_pic_call3(0x%.2x - 0x%.2x - 0x%.2x): 0x%.4x\n",
1757 			dev, fn, v, v1);
1758 	return v1;
1759 }
1760 
1761 /*
1762  * minidrivers for SPIC models
1763  */
1764 static int type3_handle_irq(const u8 data_mask, const u8 ev)
1765 {
1766 	/*
1767 	 * 0x31 could mean we have to take some extra action and wait for
1768 	 * the next irq for some Type3 models, it will generate a new
1769 	 * irq and we can read new data from the device:
1770 	 *  - 0x5c and 0x5f requires 0xA0
1771 	 *  - 0x61 requires 0xB3
1772 	 */
1773 	if (data_mask == 0x31) {
1774 		if (ev == 0x5c || ev == 0x5f)
1775 			sony_pic_call1(0xA0);
1776 		else if (ev == 0x61)
1777 			sony_pic_call1(0xB3);
1778 		return 0;
1779 	}
1780 	return 1;
1781 }
1782 
1783 static void sony_pic_detect_device_type(struct sony_pic_dev *dev)
1784 {
1785 	struct pci_dev *pcidev;
1786 
1787 	pcidev = pci_get_device(PCI_VENDOR_ID_INTEL,
1788 			PCI_DEVICE_ID_INTEL_82371AB_3, NULL);
1789 	if (pcidev) {
1790 		dev->model = SONYPI_DEVICE_TYPE1;
1791 		dev->evport_offset = SONYPI_TYPE1_OFFSET;
1792 		dev->event_types = type1_events;
1793 		goto out;
1794 	}
1795 
1796 	pcidev = pci_get_device(PCI_VENDOR_ID_INTEL,
1797 			PCI_DEVICE_ID_INTEL_ICH6_1, NULL);
1798 	if (pcidev) {
1799 		dev->model = SONYPI_DEVICE_TYPE2;
1800 		dev->evport_offset = SONYPI_TYPE2_OFFSET;
1801 		dev->event_types = type2_events;
1802 		goto out;
1803 	}
1804 
1805 	pcidev = pci_get_device(PCI_VENDOR_ID_INTEL,
1806 			PCI_DEVICE_ID_INTEL_ICH7_1, NULL);
1807 	if (pcidev) {
1808 		dev->model = SONYPI_DEVICE_TYPE3;
1809 		dev->handle_irq = type3_handle_irq;
1810 		dev->evport_offset = SONYPI_TYPE3_OFFSET;
1811 		dev->event_types = type3_events;
1812 		goto out;
1813 	}
1814 
1815 	pcidev = pci_get_device(PCI_VENDOR_ID_INTEL,
1816 			PCI_DEVICE_ID_INTEL_ICH8_4, NULL);
1817 	if (pcidev) {
1818 		dev->model = SONYPI_DEVICE_TYPE3;
1819 		dev->handle_irq = type3_handle_irq;
1820 		dev->evport_offset = SONYPI_TYPE3_OFFSET;
1821 		dev->event_types = type3_events;
1822 		goto out;
1823 	}
1824 
1825 	pcidev = pci_get_device(PCI_VENDOR_ID_INTEL,
1826 			PCI_DEVICE_ID_INTEL_ICH9_1, NULL);
1827 	if (pcidev) {
1828 		dev->model = SONYPI_DEVICE_TYPE3;
1829 		dev->handle_irq = type3_handle_irq;
1830 		dev->evport_offset = SONYPI_TYPE3_OFFSET;
1831 		dev->event_types = type3_events;
1832 		goto out;
1833 	}
1834 
1835 	/* default */
1836 	dev->model = SONYPI_DEVICE_TYPE2;
1837 	dev->evport_offset = SONYPI_TYPE2_OFFSET;
1838 	dev->event_types = type2_events;
1839 
1840 out:
1841 	if (pcidev)
1842 		pci_dev_put(pcidev);
1843 
1844 	printk(KERN_INFO DRV_PFX "detected Type%d model\n",
1845 			dev->model == SONYPI_DEVICE_TYPE1 ? 1 :
1846 			dev->model == SONYPI_DEVICE_TYPE2 ? 2 : 3);
1847 }
1848 
1849 /* camera tests and poweron/poweroff */
1850 #define SONYPI_CAMERA_PICTURE		5
1851 #define SONYPI_CAMERA_CONTROL		0x10
1852 
1853 #define SONYPI_CAMERA_BRIGHTNESS		0
1854 #define SONYPI_CAMERA_CONTRAST			1
1855 #define SONYPI_CAMERA_HUE			2
1856 #define SONYPI_CAMERA_COLOR			3
1857 #define SONYPI_CAMERA_SHARPNESS			4
1858 
1859 #define SONYPI_CAMERA_EXPOSURE_MASK		0xC
1860 #define SONYPI_CAMERA_WHITE_BALANCE_MASK	0x3
1861 #define SONYPI_CAMERA_PICTURE_MODE_MASK		0x30
1862 #define SONYPI_CAMERA_MUTE_MASK			0x40
1863 
1864 /* the rest don't need a loop until not 0xff */
1865 #define SONYPI_CAMERA_AGC			6
1866 #define SONYPI_CAMERA_AGC_MASK			0x30
1867 #define SONYPI_CAMERA_SHUTTER_MASK 		0x7
1868 
1869 #define SONYPI_CAMERA_SHUTDOWN_REQUEST		7
1870 #define SONYPI_CAMERA_CONTROL			0x10
1871 
1872 #define SONYPI_CAMERA_STATUS 			7
1873 #define SONYPI_CAMERA_STATUS_READY 		0x2
1874 #define SONYPI_CAMERA_STATUS_POSITION		0x4
1875 
1876 #define SONYPI_DIRECTION_BACKWARDS 		0x4
1877 
1878 #define SONYPI_CAMERA_REVISION 			8
1879 #define SONYPI_CAMERA_ROMVERSION 		9
1880 
1881 static int __sony_pic_camera_ready(void)
1882 {
1883 	u8 v;
1884 
1885 	v = sony_pic_call2(0x8f, SONYPI_CAMERA_STATUS);
1886 	return (v != 0xff && (v & SONYPI_CAMERA_STATUS_READY));
1887 }
1888 
1889 static int __sony_pic_camera_off(void)
1890 {
1891 	if (!camera) {
1892 		printk(KERN_WARNING DRV_PFX "camera control not enabled\n");
1893 		return -ENODEV;
1894 	}
1895 
1896 	wait_on_command(sony_pic_call3(0x90, SONYPI_CAMERA_PICTURE,
1897 				SONYPI_CAMERA_MUTE_MASK),
1898 			ITERATIONS_SHORT);
1899 
1900 	if (spic_dev.camera_power) {
1901 		sony_pic_call2(0x91, 0);
1902 		spic_dev.camera_power = 0;
1903 	}
1904 	return 0;
1905 }
1906 
1907 static int __sony_pic_camera_on(void)
1908 {
1909 	int i, j, x;
1910 
1911 	if (!camera) {
1912 		printk(KERN_WARNING DRV_PFX "camera control not enabled\n");
1913 		return -ENODEV;
1914 	}
1915 
1916 	if (spic_dev.camera_power)
1917 		return 0;
1918 
1919 	for (j = 5; j > 0; j--) {
1920 
1921 		for (x = 0; x < 100 && sony_pic_call2(0x91, 0x1); x++)
1922 			msleep(10);
1923 		sony_pic_call1(0x93);
1924 
1925 		for (i = 400; i > 0; i--) {
1926 			if (__sony_pic_camera_ready())
1927 				break;
1928 			msleep(10);
1929 		}
1930 		if (i)
1931 			break;
1932 	}
1933 
1934 	if (j == 0) {
1935 		printk(KERN_WARNING DRV_PFX "failed to power on camera\n");
1936 		return -ENODEV;
1937 	}
1938 
1939 	wait_on_command(sony_pic_call3(0x90, SONYPI_CAMERA_CONTROL,
1940 				0x5a),
1941 			ITERATIONS_SHORT);
1942 
1943 	spic_dev.camera_power = 1;
1944 	return 0;
1945 }
1946 
1947 /* External camera command (exported to the motion eye v4l driver) */
1948 int sony_pic_camera_command(int command, u8 value)
1949 {
1950 	if (!camera)
1951 		return -EIO;
1952 
1953 	mutex_lock(&spic_dev.lock);
1954 
1955 	switch (command) {
1956 	case SONY_PIC_COMMAND_SETCAMERA:
1957 		if (value)
1958 			__sony_pic_camera_on();
1959 		else
1960 			__sony_pic_camera_off();
1961 		break;
1962 	case SONY_PIC_COMMAND_SETCAMERABRIGHTNESS:
1963 		wait_on_command(sony_pic_call3(0x90, SONYPI_CAMERA_BRIGHTNESS, value),
1964 				ITERATIONS_SHORT);
1965 		break;
1966 	case SONY_PIC_COMMAND_SETCAMERACONTRAST:
1967 		wait_on_command(sony_pic_call3(0x90, SONYPI_CAMERA_CONTRAST, value),
1968 				ITERATIONS_SHORT);
1969 		break;
1970 	case SONY_PIC_COMMAND_SETCAMERAHUE:
1971 		wait_on_command(sony_pic_call3(0x90, SONYPI_CAMERA_HUE, value),
1972 				ITERATIONS_SHORT);
1973 		break;
1974 	case SONY_PIC_COMMAND_SETCAMERACOLOR:
1975 		wait_on_command(sony_pic_call3(0x90, SONYPI_CAMERA_COLOR, value),
1976 				ITERATIONS_SHORT);
1977 		break;
1978 	case SONY_PIC_COMMAND_SETCAMERASHARPNESS:
1979 		wait_on_command(sony_pic_call3(0x90, SONYPI_CAMERA_SHARPNESS, value),
1980 				ITERATIONS_SHORT);
1981 		break;
1982 	case SONY_PIC_COMMAND_SETCAMERAPICTURE:
1983 		wait_on_command(sony_pic_call3(0x90, SONYPI_CAMERA_PICTURE, value),
1984 				ITERATIONS_SHORT);
1985 		break;
1986 	case SONY_PIC_COMMAND_SETCAMERAAGC:
1987 		wait_on_command(sony_pic_call3(0x90, SONYPI_CAMERA_AGC, value),
1988 				ITERATIONS_SHORT);
1989 		break;
1990 	default:
1991 		printk(KERN_ERR DRV_PFX "sony_pic_camera_command invalid: %d\n",
1992 		       command);
1993 		break;
1994 	}
1995 	mutex_unlock(&spic_dev.lock);
1996 	return 0;
1997 }
1998 EXPORT_SYMBOL(sony_pic_camera_command);
1999 
2000 /* gprs/edge modem (SZ460N and SZ210P), thanks to Joshua Wise */
2001 static void __sony_pic_set_wwanpower(u8 state)
2002 {
2003 	state = !!state;
2004 	if (spic_dev.wwan_power == state)
2005 		return;
2006 	sony_pic_call2(0xB0, state);
2007 	sony_pic_call1(0x82);
2008 	spic_dev.wwan_power = state;
2009 }
2010 
2011 static ssize_t sony_pic_wwanpower_store(struct device *dev,
2012 		struct device_attribute *attr,
2013 		const char *buffer, size_t count)
2014 {
2015 	unsigned long value;
2016 	if (count > 31)
2017 		return -EINVAL;
2018 
2019 	value = simple_strtoul(buffer, NULL, 10);
2020 	mutex_lock(&spic_dev.lock);
2021 	__sony_pic_set_wwanpower(value);
2022 	mutex_unlock(&spic_dev.lock);
2023 
2024 	return count;
2025 }
2026 
2027 static ssize_t sony_pic_wwanpower_show(struct device *dev,
2028 		struct device_attribute *attr, char *buffer)
2029 {
2030 	ssize_t count;
2031 	mutex_lock(&spic_dev.lock);
2032 	count = snprintf(buffer, PAGE_SIZE, "%d\n", spic_dev.wwan_power);
2033 	mutex_unlock(&spic_dev.lock);
2034 	return count;
2035 }
2036 
2037 /* bluetooth subsystem power state */
2038 static void __sony_pic_set_bluetoothpower(u8 state)
2039 {
2040 	state = !!state;
2041 	if (spic_dev.bluetooth_power == state)
2042 		return;
2043 	sony_pic_call2(0x96, state);
2044 	sony_pic_call1(0x82);
2045 	spic_dev.bluetooth_power = state;
2046 }
2047 
2048 static ssize_t sony_pic_bluetoothpower_store(struct device *dev,
2049 		struct device_attribute *attr,
2050 		const char *buffer, size_t count)
2051 {
2052 	unsigned long value;
2053 	if (count > 31)
2054 		return -EINVAL;
2055 
2056 	value = simple_strtoul(buffer, NULL, 10);
2057 	mutex_lock(&spic_dev.lock);
2058 	__sony_pic_set_bluetoothpower(value);
2059 	mutex_unlock(&spic_dev.lock);
2060 
2061 	return count;
2062 }
2063 
2064 static ssize_t sony_pic_bluetoothpower_show(struct device *dev,
2065 		struct device_attribute *attr, char *buffer)
2066 {
2067 	ssize_t count = 0;
2068 	mutex_lock(&spic_dev.lock);
2069 	count = snprintf(buffer, PAGE_SIZE, "%d\n", spic_dev.bluetooth_power);
2070 	mutex_unlock(&spic_dev.lock);
2071 	return count;
2072 }
2073 
2074 /* fan speed */
2075 /* FAN0 information (reverse engineered from ACPI tables) */
2076 #define SONY_PIC_FAN0_STATUS	0x93
2077 static int sony_pic_set_fanspeed(unsigned long value)
2078 {
2079 	return ec_write(SONY_PIC_FAN0_STATUS, value);
2080 }
2081 
2082 static int sony_pic_get_fanspeed(u8 *value)
2083 {
2084 	return ec_read(SONY_PIC_FAN0_STATUS, value);
2085 }
2086 
2087 static ssize_t sony_pic_fanspeed_store(struct device *dev,
2088 		struct device_attribute *attr,
2089 		const char *buffer, size_t count)
2090 {
2091 	unsigned long value;
2092 	if (count > 31)
2093 		return -EINVAL;
2094 
2095 	value = simple_strtoul(buffer, NULL, 10);
2096 	if (sony_pic_set_fanspeed(value))
2097 		return -EIO;
2098 
2099 	return count;
2100 }
2101 
2102 static ssize_t sony_pic_fanspeed_show(struct device *dev,
2103 		struct device_attribute *attr, char *buffer)
2104 {
2105 	u8 value = 0;
2106 	if (sony_pic_get_fanspeed(&value))
2107 		return -EIO;
2108 
2109 	return snprintf(buffer, PAGE_SIZE, "%d\n", value);
2110 }
2111 
2112 #define SPIC_ATTR(_name, _mode)					\
2113 struct device_attribute spic_attr_##_name = __ATTR(_name,	\
2114 		_mode, sony_pic_## _name ##_show,		\
2115 		sony_pic_## _name ##_store)
2116 
2117 static SPIC_ATTR(bluetoothpower, 0644);
2118 static SPIC_ATTR(wwanpower, 0644);
2119 static SPIC_ATTR(fanspeed, 0644);
2120 
2121 static struct attribute *spic_attributes[] = {
2122 	&spic_attr_bluetoothpower.attr,
2123 	&spic_attr_wwanpower.attr,
2124 	&spic_attr_fanspeed.attr,
2125 	NULL
2126 };
2127 
2128 static struct attribute_group spic_attribute_group = {
2129 	.attrs = spic_attributes
2130 };
2131 
2132 /******** SONYPI compatibility **********/
2133 #ifdef CONFIG_SONYPI_COMPAT
2134 
2135 /* battery / brightness / temperature  addresses */
2136 #define SONYPI_BAT_FLAGS	0x81
2137 #define SONYPI_LCD_LIGHT	0x96
2138 #define SONYPI_BAT1_PCTRM	0xa0
2139 #define SONYPI_BAT1_LEFT	0xa2
2140 #define SONYPI_BAT1_MAXRT	0xa4
2141 #define SONYPI_BAT2_PCTRM	0xa8
2142 #define SONYPI_BAT2_LEFT	0xaa
2143 #define SONYPI_BAT2_MAXRT	0xac
2144 #define SONYPI_BAT1_MAXTK	0xb0
2145 #define SONYPI_BAT1_FULL	0xb2
2146 #define SONYPI_BAT2_MAXTK	0xb8
2147 #define SONYPI_BAT2_FULL	0xba
2148 #define SONYPI_TEMP_STATUS	0xC1
2149 
2150 struct sonypi_compat_s {
2151 	struct fasync_struct	*fifo_async;
2152 	struct kfifo		fifo;
2153 	spinlock_t		fifo_lock;
2154 	wait_queue_head_t	fifo_proc_list;
2155 	atomic_t		open_count;
2156 };
2157 static struct sonypi_compat_s sonypi_compat = {
2158 	.open_count = ATOMIC_INIT(0),
2159 };
2160 
2161 static int sonypi_misc_fasync(int fd, struct file *filp, int on)
2162 {
2163 	return fasync_helper(fd, filp, on, &sonypi_compat.fifo_async);
2164 }
2165 
2166 static int sonypi_misc_release(struct inode *inode, struct file *file)
2167 {
2168 	atomic_dec(&sonypi_compat.open_count);
2169 	return 0;
2170 }
2171 
2172 static int sonypi_misc_open(struct inode *inode, struct file *file)
2173 {
2174 	/* Flush input queue on first open */
2175 	unsigned long flags;
2176 
2177 	spin_lock_irqsave(&sonypi_compat.fifo_lock, flags);
2178 
2179 	if (atomic_inc_return(&sonypi_compat.open_count) == 1)
2180 		kfifo_reset(&sonypi_compat.fifo);
2181 
2182 	spin_unlock_irqrestore(&sonypi_compat.fifo_lock, flags);
2183 
2184 	return 0;
2185 }
2186 
2187 static ssize_t sonypi_misc_read(struct file *file, char __user *buf,
2188 				size_t count, loff_t *pos)
2189 {
2190 	ssize_t ret;
2191 	unsigned char c;
2192 
2193 	if ((kfifo_len(&sonypi_compat.fifo) == 0) &&
2194 	    (file->f_flags & O_NONBLOCK))
2195 		return -EAGAIN;
2196 
2197 	ret = wait_event_interruptible(sonypi_compat.fifo_proc_list,
2198 				       kfifo_len(&sonypi_compat.fifo) != 0);
2199 	if (ret)
2200 		return ret;
2201 
2202 	while (ret < count &&
2203 	       (kfifo_out_locked(&sonypi_compat.fifo, &c, sizeof(c),
2204 			  &sonypi_compat.fifo_lock) == sizeof(c))) {
2205 		if (put_user(c, buf++))
2206 			return -EFAULT;
2207 		ret++;
2208 	}
2209 
2210 	if (ret > 0) {
2211 		struct inode *inode = file->f_path.dentry->d_inode;
2212 		inode->i_atime = current_fs_time(inode->i_sb);
2213 	}
2214 
2215 	return ret;
2216 }
2217 
2218 static unsigned int sonypi_misc_poll(struct file *file, poll_table *wait)
2219 {
2220 	poll_wait(file, &sonypi_compat.fifo_proc_list, wait);
2221 	if (kfifo_len(&sonypi_compat.fifo))
2222 		return POLLIN | POLLRDNORM;
2223 	return 0;
2224 }
2225 
2226 static int ec_read16(u8 addr, u16 *value)
2227 {
2228 	u8 val_lb, val_hb;
2229 	if (ec_read(addr, &val_lb))
2230 		return -1;
2231 	if (ec_read(addr + 1, &val_hb))
2232 		return -1;
2233 	*value = val_lb | (val_hb << 8);
2234 	return 0;
2235 }
2236 
2237 static long sonypi_misc_ioctl(struct file *fp, unsigned int cmd,
2238 							unsigned long arg)
2239 {
2240 	int ret = 0;
2241 	void __user *argp = (void __user *)arg;
2242 	u8 val8;
2243 	u16 val16;
2244 	int value;
2245 
2246 	mutex_lock(&spic_dev.lock);
2247 	switch (cmd) {
2248 	case SONYPI_IOCGBRT:
2249 		if (sony_backlight_device == NULL) {
2250 			ret = -EIO;
2251 			break;
2252 		}
2253 		if (acpi_callgetfunc(sony_nc_acpi_handle, "GBRT", &value)) {
2254 			ret = -EIO;
2255 			break;
2256 		}
2257 		val8 = ((value & 0xff) - 1) << 5;
2258 		if (copy_to_user(argp, &val8, sizeof(val8)))
2259 				ret = -EFAULT;
2260 		break;
2261 	case SONYPI_IOCSBRT:
2262 		if (sony_backlight_device == NULL) {
2263 			ret = -EIO;
2264 			break;
2265 		}
2266 		if (copy_from_user(&val8, argp, sizeof(val8))) {
2267 			ret = -EFAULT;
2268 			break;
2269 		}
2270 		if (acpi_callsetfunc(sony_nc_acpi_handle, "SBRT",
2271 				(val8 >> 5) + 1, NULL)) {
2272 			ret = -EIO;
2273 			break;
2274 		}
2275 		/* sync the backlight device status */
2276 		sony_backlight_device->props.brightness =
2277 		    sony_backlight_get_brightness(sony_backlight_device);
2278 		break;
2279 	case SONYPI_IOCGBAT1CAP:
2280 		if (ec_read16(SONYPI_BAT1_FULL, &val16)) {
2281 			ret = -EIO;
2282 			break;
2283 		}
2284 		if (copy_to_user(argp, &val16, sizeof(val16)))
2285 			ret = -EFAULT;
2286 		break;
2287 	case SONYPI_IOCGBAT1REM:
2288 		if (ec_read16(SONYPI_BAT1_LEFT, &val16)) {
2289 			ret = -EIO;
2290 			break;
2291 		}
2292 		if (copy_to_user(argp, &val16, sizeof(val16)))
2293 			ret = -EFAULT;
2294 		break;
2295 	case SONYPI_IOCGBAT2CAP:
2296 		if (ec_read16(SONYPI_BAT2_FULL, &val16)) {
2297 			ret = -EIO;
2298 			break;
2299 		}
2300 		if (copy_to_user(argp, &val16, sizeof(val16)))
2301 			ret = -EFAULT;
2302 		break;
2303 	case SONYPI_IOCGBAT2REM:
2304 		if (ec_read16(SONYPI_BAT2_LEFT, &val16)) {
2305 			ret = -EIO;
2306 			break;
2307 		}
2308 		if (copy_to_user(argp, &val16, sizeof(val16)))
2309 			ret = -EFAULT;
2310 		break;
2311 	case SONYPI_IOCGBATFLAGS:
2312 		if (ec_read(SONYPI_BAT_FLAGS, &val8)) {
2313 			ret = -EIO;
2314 			break;
2315 		}
2316 		val8 &= 0x07;
2317 		if (copy_to_user(argp, &val8, sizeof(val8)))
2318 			ret = -EFAULT;
2319 		break;
2320 	case SONYPI_IOCGBLUE:
2321 		val8 = spic_dev.bluetooth_power;
2322 		if (copy_to_user(argp, &val8, sizeof(val8)))
2323 			ret = -EFAULT;
2324 		break;
2325 	case SONYPI_IOCSBLUE:
2326 		if (copy_from_user(&val8, argp, sizeof(val8))) {
2327 			ret = -EFAULT;
2328 			break;
2329 		}
2330 		__sony_pic_set_bluetoothpower(val8);
2331 		break;
2332 	/* FAN Controls */
2333 	case SONYPI_IOCGFAN:
2334 		if (sony_pic_get_fanspeed(&val8)) {
2335 			ret = -EIO;
2336 			break;
2337 		}
2338 		if (copy_to_user(argp, &val8, sizeof(val8)))
2339 			ret = -EFAULT;
2340 		break;
2341 	case SONYPI_IOCSFAN:
2342 		if (copy_from_user(&val8, argp, sizeof(val8))) {
2343 			ret = -EFAULT;
2344 			break;
2345 		}
2346 		if (sony_pic_set_fanspeed(val8))
2347 			ret = -EIO;
2348 		break;
2349 	/* GET Temperature (useful under APM) */
2350 	case SONYPI_IOCGTEMP:
2351 		if (ec_read(SONYPI_TEMP_STATUS, &val8)) {
2352 			ret = -EIO;
2353 			break;
2354 		}
2355 		if (copy_to_user(argp, &val8, sizeof(val8)))
2356 			ret = -EFAULT;
2357 		break;
2358 	default:
2359 		ret = -EINVAL;
2360 	}
2361 	mutex_unlock(&spic_dev.lock);
2362 	return ret;
2363 }
2364 
2365 static const struct file_operations sonypi_misc_fops = {
2366 	.owner		= THIS_MODULE,
2367 	.read		= sonypi_misc_read,
2368 	.poll		= sonypi_misc_poll,
2369 	.open		= sonypi_misc_open,
2370 	.release	= sonypi_misc_release,
2371 	.fasync		= sonypi_misc_fasync,
2372 	.unlocked_ioctl	= sonypi_misc_ioctl,
2373 	.llseek		= noop_llseek,
2374 };
2375 
2376 static struct miscdevice sonypi_misc_device = {
2377 	.minor		= MISC_DYNAMIC_MINOR,
2378 	.name		= "sonypi",
2379 	.fops		= &sonypi_misc_fops,
2380 };
2381 
2382 static void sonypi_compat_report_event(u8 event)
2383 {
2384 	kfifo_in_locked(&sonypi_compat.fifo, (unsigned char *)&event,
2385 			sizeof(event), &sonypi_compat.fifo_lock);
2386 	kill_fasync(&sonypi_compat.fifo_async, SIGIO, POLL_IN);
2387 	wake_up_interruptible(&sonypi_compat.fifo_proc_list);
2388 }
2389 
2390 static int sonypi_compat_init(void)
2391 {
2392 	int error;
2393 
2394 	spin_lock_init(&sonypi_compat.fifo_lock);
2395 	error =
2396 	 kfifo_alloc(&sonypi_compat.fifo, SONY_LAPTOP_BUF_SIZE, GFP_KERNEL);
2397 	if (error) {
2398 		printk(KERN_ERR DRV_PFX "kfifo_alloc failed\n");
2399 		return error;
2400 	}
2401 
2402 	init_waitqueue_head(&sonypi_compat.fifo_proc_list);
2403 
2404 	if (minor != -1)
2405 		sonypi_misc_device.minor = minor;
2406 	error = misc_register(&sonypi_misc_device);
2407 	if (error) {
2408 		printk(KERN_ERR DRV_PFX "misc_register failed\n");
2409 		goto err_free_kfifo;
2410 	}
2411 	if (minor == -1)
2412 		printk(KERN_INFO DRV_PFX "device allocated minor is %d\n",
2413 		       sonypi_misc_device.minor);
2414 
2415 	return 0;
2416 
2417 err_free_kfifo:
2418 	kfifo_free(&sonypi_compat.fifo);
2419 	return error;
2420 }
2421 
2422 static void sonypi_compat_exit(void)
2423 {
2424 	misc_deregister(&sonypi_misc_device);
2425 	kfifo_free(&sonypi_compat.fifo);
2426 }
2427 #else
2428 static int sonypi_compat_init(void) { return 0; }
2429 static void sonypi_compat_exit(void) { }
2430 static void sonypi_compat_report_event(u8 event) { }
2431 #endif /* CONFIG_SONYPI_COMPAT */
2432 
2433 /*
2434  * ACPI callbacks
2435  */
2436 static acpi_status
2437 sony_pic_read_possible_resource(struct acpi_resource *resource, void *context)
2438 {
2439 	u32 i;
2440 	struct sony_pic_dev *dev = (struct sony_pic_dev *)context;
2441 
2442 	switch (resource->type) {
2443 	case ACPI_RESOURCE_TYPE_START_DEPENDENT:
2444 		{
2445 			/* start IO enumeration */
2446 			struct sony_pic_ioport *ioport = kzalloc(sizeof(*ioport), GFP_KERNEL);
2447 			if (!ioport)
2448 				return AE_ERROR;
2449 
2450 			list_add(&ioport->list, &dev->ioports);
2451 			return AE_OK;
2452 		}
2453 
2454 	case ACPI_RESOURCE_TYPE_END_DEPENDENT:
2455 		/* end IO enumeration */
2456 		return AE_OK;
2457 
2458 	case ACPI_RESOURCE_TYPE_IRQ:
2459 		{
2460 			struct acpi_resource_irq *p = &resource->data.irq;
2461 			struct sony_pic_irq *interrupt = NULL;
2462 			if (!p || !p->interrupt_count) {
2463 				/*
2464 				 * IRQ descriptors may have no IRQ# bits set,
2465 				 * particularly those those w/ _STA disabled
2466 				 */
2467 				dprintk("Blank IRQ resource\n");
2468 				return AE_OK;
2469 			}
2470 			for (i = 0; i < p->interrupt_count; i++) {
2471 				if (!p->interrupts[i]) {
2472 					printk(KERN_WARNING DRV_PFX
2473 							"Invalid IRQ %d\n",
2474 							p->interrupts[i]);
2475 					continue;
2476 				}
2477 				interrupt = kzalloc(sizeof(*interrupt),
2478 						GFP_KERNEL);
2479 				if (!interrupt)
2480 					return AE_ERROR;
2481 
2482 				list_add(&interrupt->list, &dev->interrupts);
2483 				interrupt->irq.triggering = p->triggering;
2484 				interrupt->irq.polarity = p->polarity;
2485 				interrupt->irq.sharable = p->sharable;
2486 				interrupt->irq.interrupt_count = 1;
2487 				interrupt->irq.interrupts[0] = p->interrupts[i];
2488 			}
2489 			return AE_OK;
2490 		}
2491 	case ACPI_RESOURCE_TYPE_IO:
2492 		{
2493 			struct acpi_resource_io *io = &resource->data.io;
2494 			struct sony_pic_ioport *ioport =
2495 				list_first_entry(&dev->ioports, struct sony_pic_ioport, list);
2496 			if (!io) {
2497 				dprintk("Blank IO resource\n");
2498 				return AE_OK;
2499 			}
2500 
2501 			if (!ioport->io1.minimum) {
2502 				memcpy(&ioport->io1, io, sizeof(*io));
2503 				dprintk("IO1 at 0x%.4x (0x%.2x)\n", ioport->io1.minimum,
2504 						ioport->io1.address_length);
2505 			}
2506 			else if (!ioport->io2.minimum) {
2507 				memcpy(&ioport->io2, io, sizeof(*io));
2508 				dprintk("IO2 at 0x%.4x (0x%.2x)\n", ioport->io2.minimum,
2509 						ioport->io2.address_length);
2510 			}
2511 			else {
2512 				printk(KERN_ERR DRV_PFX "Unknown SPIC Type, more than 2 IO Ports\n");
2513 				return AE_ERROR;
2514 			}
2515 			return AE_OK;
2516 		}
2517 	default:
2518 		dprintk("Resource %d isn't an IRQ nor an IO port\n",
2519 				resource->type);
2520 
2521 	case ACPI_RESOURCE_TYPE_END_TAG:
2522 		return AE_OK;
2523 	}
2524 	return AE_CTRL_TERMINATE;
2525 }
2526 
2527 static int sony_pic_possible_resources(struct acpi_device *device)
2528 {
2529 	int result = 0;
2530 	acpi_status status = AE_OK;
2531 
2532 	if (!device)
2533 		return -EINVAL;
2534 
2535 	/* get device status */
2536 	/* see acpi_pci_link_get_current acpi_pci_link_get_possible */
2537 	dprintk("Evaluating _STA\n");
2538 	result = acpi_bus_get_status(device);
2539 	if (result) {
2540 		printk(KERN_WARNING DRV_PFX "Unable to read status\n");
2541 		goto end;
2542 	}
2543 
2544 	if (!device->status.enabled)
2545 		dprintk("Device disabled\n");
2546 	else
2547 		dprintk("Device enabled\n");
2548 
2549 	/*
2550 	 * Query and parse 'method'
2551 	 */
2552 	dprintk("Evaluating %s\n", METHOD_NAME__PRS);
2553 	status = acpi_walk_resources(device->handle, METHOD_NAME__PRS,
2554 			sony_pic_read_possible_resource, &spic_dev);
2555 	if (ACPI_FAILURE(status)) {
2556 		printk(KERN_WARNING DRV_PFX
2557 				"Failure evaluating %s\n",
2558 				METHOD_NAME__PRS);
2559 		result = -ENODEV;
2560 	}
2561 end:
2562 	return result;
2563 }
2564 
2565 /*
2566  *  Disable the spic device by calling its _DIS method
2567  */
2568 static int sony_pic_disable(struct acpi_device *device)
2569 {
2570 	acpi_status ret = acpi_evaluate_object(device->handle, "_DIS", NULL,
2571 					       NULL);
2572 
2573 	if (ACPI_FAILURE(ret) && ret != AE_NOT_FOUND)
2574 		return -ENXIO;
2575 
2576 	dprintk("Device disabled\n");
2577 	return 0;
2578 }
2579 
2580 
2581 /*
2582  *  Based on drivers/acpi/pci_link.c:acpi_pci_link_set
2583  *
2584  *  Call _SRS to set current resources
2585  */
2586 static int sony_pic_enable(struct acpi_device *device,
2587 		struct sony_pic_ioport *ioport, struct sony_pic_irq *irq)
2588 {
2589 	acpi_status status;
2590 	int result = 0;
2591 	/* Type 1 resource layout is:
2592 	 *    IO
2593 	 *    IO
2594 	 *    IRQNoFlags
2595 	 *    End
2596 	 *
2597 	 * Type 2 and 3 resource layout is:
2598 	 *    IO
2599 	 *    IRQNoFlags
2600 	 *    End
2601 	 */
2602 	struct {
2603 		struct acpi_resource res1;
2604 		struct acpi_resource res2;
2605 		struct acpi_resource res3;
2606 		struct acpi_resource res4;
2607 	} *resource;
2608 	struct acpi_buffer buffer = { 0, NULL };
2609 
2610 	if (!ioport || !irq)
2611 		return -EINVAL;
2612 
2613 	/* init acpi_buffer */
2614 	resource = kzalloc(sizeof(*resource) + 1, GFP_KERNEL);
2615 	if (!resource)
2616 		return -ENOMEM;
2617 
2618 	buffer.length = sizeof(*resource) + 1;
2619 	buffer.pointer = resource;
2620 
2621 	/* setup Type 1 resources */
2622 	if (spic_dev.model == SONYPI_DEVICE_TYPE1) {
2623 
2624 		/* setup io resources */
2625 		resource->res1.type = ACPI_RESOURCE_TYPE_IO;
2626 		resource->res1.length = sizeof(struct acpi_resource);
2627 		memcpy(&resource->res1.data.io, &ioport->io1,
2628 				sizeof(struct acpi_resource_io));
2629 
2630 		resource->res2.type = ACPI_RESOURCE_TYPE_IO;
2631 		resource->res2.length = sizeof(struct acpi_resource);
2632 		memcpy(&resource->res2.data.io, &ioport->io2,
2633 				sizeof(struct acpi_resource_io));
2634 
2635 		/* setup irq resource */
2636 		resource->res3.type = ACPI_RESOURCE_TYPE_IRQ;
2637 		resource->res3.length = sizeof(struct acpi_resource);
2638 		memcpy(&resource->res3.data.irq, &irq->irq,
2639 				sizeof(struct acpi_resource_irq));
2640 		/* we requested a shared irq */
2641 		resource->res3.data.irq.sharable = ACPI_SHARED;
2642 
2643 		resource->res4.type = ACPI_RESOURCE_TYPE_END_TAG;
2644 
2645 	}
2646 	/* setup Type 2/3 resources */
2647 	else {
2648 		/* setup io resource */
2649 		resource->res1.type = ACPI_RESOURCE_TYPE_IO;
2650 		resource->res1.length = sizeof(struct acpi_resource);
2651 		memcpy(&resource->res1.data.io, &ioport->io1,
2652 				sizeof(struct acpi_resource_io));
2653 
2654 		/* setup irq resource */
2655 		resource->res2.type = ACPI_RESOURCE_TYPE_IRQ;
2656 		resource->res2.length = sizeof(struct acpi_resource);
2657 		memcpy(&resource->res2.data.irq, &irq->irq,
2658 				sizeof(struct acpi_resource_irq));
2659 		/* we requested a shared irq */
2660 		resource->res2.data.irq.sharable = ACPI_SHARED;
2661 
2662 		resource->res3.type = ACPI_RESOURCE_TYPE_END_TAG;
2663 	}
2664 
2665 	/* Attempt to set the resource */
2666 	dprintk("Evaluating _SRS\n");
2667 	status = acpi_set_current_resources(device->handle, &buffer);
2668 
2669 	/* check for total failure */
2670 	if (ACPI_FAILURE(status)) {
2671 		printk(KERN_ERR DRV_PFX "Error evaluating _SRS\n");
2672 		result = -ENODEV;
2673 		goto end;
2674 	}
2675 
2676 	/* Necessary device initializations calls (from sonypi) */
2677 	sony_pic_call1(0x82);
2678 	sony_pic_call2(0x81, 0xff);
2679 	sony_pic_call1(compat ? 0x92 : 0x82);
2680 
2681 end:
2682 	kfree(resource);
2683 	return result;
2684 }
2685 
2686 /*****************
2687  *
2688  * ISR: some event is available
2689  *
2690  *****************/
2691 static irqreturn_t sony_pic_irq(int irq, void *dev_id)
2692 {
2693 	int i, j;
2694 	u8 ev = 0;
2695 	u8 data_mask = 0;
2696 	u8 device_event = 0;
2697 
2698 	struct sony_pic_dev *dev = (struct sony_pic_dev *) dev_id;
2699 
2700 	ev = inb_p(dev->cur_ioport->io1.minimum);
2701 	if (dev->cur_ioport->io2.minimum)
2702 		data_mask = inb_p(dev->cur_ioport->io2.minimum);
2703 	else
2704 		data_mask = inb_p(dev->cur_ioport->io1.minimum +
2705 				dev->evport_offset);
2706 
2707 	dprintk("event ([%.2x] [%.2x]) at port 0x%.4x(+0x%.2x)\n",
2708 			ev, data_mask, dev->cur_ioport->io1.minimum,
2709 			dev->evport_offset);
2710 
2711 	if (ev == 0x00 || ev == 0xff)
2712 		return IRQ_HANDLED;
2713 
2714 	for (i = 0; dev->event_types[i].mask; i++) {
2715 
2716 		if ((data_mask & dev->event_types[i].data) !=
2717 		    dev->event_types[i].data)
2718 			continue;
2719 
2720 		if (!(mask & dev->event_types[i].mask))
2721 			continue;
2722 
2723 		for (j = 0; dev->event_types[i].events[j].event; j++) {
2724 			if (ev == dev->event_types[i].events[j].data) {
2725 				device_event =
2726 					dev->event_types[i].events[j].event;
2727 				goto found;
2728 			}
2729 		}
2730 	}
2731 	/* Still not able to decode the event try to pass
2732 	 * it over to the minidriver
2733 	 */
2734 	if (dev->handle_irq && dev->handle_irq(data_mask, ev) == 0)
2735 		return IRQ_HANDLED;
2736 
2737 	dprintk("unknown event ([%.2x] [%.2x]) at port 0x%.4x(+0x%.2x)\n",
2738 			ev, data_mask, dev->cur_ioport->io1.minimum,
2739 			dev->evport_offset);
2740 	return IRQ_HANDLED;
2741 
2742 found:
2743 	sony_laptop_report_input_event(device_event);
2744 	acpi_bus_generate_proc_event(dev->acpi_dev, 1, device_event);
2745 	sonypi_compat_report_event(device_event);
2746 
2747 	return IRQ_HANDLED;
2748 }
2749 
2750 /*****************
2751  *
2752  *  ACPI driver
2753  *
2754  *****************/
2755 static int sony_pic_remove(struct acpi_device *device, int type)
2756 {
2757 	struct sony_pic_ioport *io, *tmp_io;
2758 	struct sony_pic_irq *irq, *tmp_irq;
2759 
2760 	if (sony_pic_disable(device)) {
2761 		printk(KERN_ERR DRV_PFX "Couldn't disable device.\n");
2762 		return -ENXIO;
2763 	}
2764 
2765 	free_irq(spic_dev.cur_irq->irq.interrupts[0], &spic_dev);
2766 	release_region(spic_dev.cur_ioport->io1.minimum,
2767 			spic_dev.cur_ioport->io1.address_length);
2768 	if (spic_dev.cur_ioport->io2.minimum)
2769 		release_region(spic_dev.cur_ioport->io2.minimum,
2770 				spic_dev.cur_ioport->io2.address_length);
2771 
2772 	sonypi_compat_exit();
2773 
2774 	sony_laptop_remove_input();
2775 
2776 	/* pf attrs */
2777 	sysfs_remove_group(&sony_pf_device->dev.kobj, &spic_attribute_group);
2778 	sony_pf_remove();
2779 
2780 	list_for_each_entry_safe(io, tmp_io, &spic_dev.ioports, list) {
2781 		list_del(&io->list);
2782 		kfree(io);
2783 	}
2784 	list_for_each_entry_safe(irq, tmp_irq, &spic_dev.interrupts, list) {
2785 		list_del(&irq->list);
2786 		kfree(irq);
2787 	}
2788 	spic_dev.cur_ioport = NULL;
2789 	spic_dev.cur_irq = NULL;
2790 
2791 	dprintk(SONY_PIC_DRIVER_NAME " removed.\n");
2792 	return 0;
2793 }
2794 
2795 static int sony_pic_add(struct acpi_device *device)
2796 {
2797 	int result;
2798 	struct sony_pic_ioport *io, *tmp_io;
2799 	struct sony_pic_irq *irq, *tmp_irq;
2800 
2801 	printk(KERN_INFO DRV_PFX "%s v%s.\n",
2802 		SONY_PIC_DRIVER_NAME, SONY_LAPTOP_DRIVER_VERSION);
2803 
2804 	spic_dev.acpi_dev = device;
2805 	strcpy(acpi_device_class(device), "sony/hotkey");
2806 	sony_pic_detect_device_type(&spic_dev);
2807 	mutex_init(&spic_dev.lock);
2808 
2809 	/* read _PRS resources */
2810 	result = sony_pic_possible_resources(device);
2811 	if (result) {
2812 		printk(KERN_ERR DRV_PFX
2813 				"Unable to read possible resources.\n");
2814 		goto err_free_resources;
2815 	}
2816 
2817 	/* setup input devices and helper fifo */
2818 	result = sony_laptop_setup_input(device);
2819 	if (result) {
2820 		printk(KERN_ERR DRV_PFX
2821 				"Unable to create input devices.\n");
2822 		goto err_free_resources;
2823 	}
2824 
2825 	if (sonypi_compat_init())
2826 		goto err_remove_input;
2827 
2828 	/* request io port */
2829 	list_for_each_entry_reverse(io, &spic_dev.ioports, list) {
2830 		if (request_region(io->io1.minimum, io->io1.address_length,
2831 					"Sony Programable I/O Device")) {
2832 			dprintk("I/O port1: 0x%.4x (0x%.4x) + 0x%.2x\n",
2833 					io->io1.minimum, io->io1.maximum,
2834 					io->io1.address_length);
2835 			/* Type 1 have 2 ioports */
2836 			if (io->io2.minimum) {
2837 				if (request_region(io->io2.minimum,
2838 						io->io2.address_length,
2839 						"Sony Programable I/O Device")) {
2840 					dprintk("I/O port2: 0x%.4x (0x%.4x) + 0x%.2x\n",
2841 							io->io2.minimum, io->io2.maximum,
2842 							io->io2.address_length);
2843 					spic_dev.cur_ioport = io;
2844 					break;
2845 				}
2846 				else {
2847 					dprintk("Unable to get I/O port2: "
2848 							"0x%.4x (0x%.4x) + 0x%.2x\n",
2849 							io->io2.minimum, io->io2.maximum,
2850 							io->io2.address_length);
2851 					release_region(io->io1.minimum,
2852 							io->io1.address_length);
2853 				}
2854 			}
2855 			else {
2856 				spic_dev.cur_ioport = io;
2857 				break;
2858 			}
2859 		}
2860 	}
2861 	if (!spic_dev.cur_ioport) {
2862 		printk(KERN_ERR DRV_PFX "Failed to request_region.\n");
2863 		result = -ENODEV;
2864 		goto err_remove_compat;
2865 	}
2866 
2867 	/* request IRQ */
2868 	list_for_each_entry_reverse(irq, &spic_dev.interrupts, list) {
2869 		if (!request_irq(irq->irq.interrupts[0], sony_pic_irq,
2870 					IRQF_DISABLED, "sony-laptop", &spic_dev)) {
2871 			dprintk("IRQ: %d - triggering: %d - "
2872 					"polarity: %d - shr: %d\n",
2873 					irq->irq.interrupts[0],
2874 					irq->irq.triggering,
2875 					irq->irq.polarity,
2876 					irq->irq.sharable);
2877 			spic_dev.cur_irq = irq;
2878 			break;
2879 		}
2880 	}
2881 	if (!spic_dev.cur_irq) {
2882 		printk(KERN_ERR DRV_PFX "Failed to request_irq.\n");
2883 		result = -ENODEV;
2884 		goto err_release_region;
2885 	}
2886 
2887 	/* set resource status _SRS */
2888 	result = sony_pic_enable(device, spic_dev.cur_ioport, spic_dev.cur_irq);
2889 	if (result) {
2890 		printk(KERN_ERR DRV_PFX "Couldn't enable device.\n");
2891 		goto err_free_irq;
2892 	}
2893 
2894 	spic_dev.bluetooth_power = -1;
2895 	/* create device attributes */
2896 	result = sony_pf_add();
2897 	if (result)
2898 		goto err_disable_device;
2899 
2900 	result = sysfs_create_group(&sony_pf_device->dev.kobj, &spic_attribute_group);
2901 	if (result)
2902 		goto err_remove_pf;
2903 
2904 	return 0;
2905 
2906 err_remove_pf:
2907 	sony_pf_remove();
2908 
2909 err_disable_device:
2910 	sony_pic_disable(device);
2911 
2912 err_free_irq:
2913 	free_irq(spic_dev.cur_irq->irq.interrupts[0], &spic_dev);
2914 
2915 err_release_region:
2916 	release_region(spic_dev.cur_ioport->io1.minimum,
2917 			spic_dev.cur_ioport->io1.address_length);
2918 	if (spic_dev.cur_ioport->io2.minimum)
2919 		release_region(spic_dev.cur_ioport->io2.minimum,
2920 				spic_dev.cur_ioport->io2.address_length);
2921 
2922 err_remove_compat:
2923 	sonypi_compat_exit();
2924 
2925 err_remove_input:
2926 	sony_laptop_remove_input();
2927 
2928 err_free_resources:
2929 	list_for_each_entry_safe(io, tmp_io, &spic_dev.ioports, list) {
2930 		list_del(&io->list);
2931 		kfree(io);
2932 	}
2933 	list_for_each_entry_safe(irq, tmp_irq, &spic_dev.interrupts, list) {
2934 		list_del(&irq->list);
2935 		kfree(irq);
2936 	}
2937 	spic_dev.cur_ioport = NULL;
2938 	spic_dev.cur_irq = NULL;
2939 
2940 	return result;
2941 }
2942 
2943 static int sony_pic_suspend(struct acpi_device *device, pm_message_t state)
2944 {
2945 	if (sony_pic_disable(device))
2946 		return -ENXIO;
2947 	return 0;
2948 }
2949 
2950 static int sony_pic_resume(struct acpi_device *device)
2951 {
2952 	sony_pic_enable(device, spic_dev.cur_ioport, spic_dev.cur_irq);
2953 	return 0;
2954 }
2955 
2956 static const struct acpi_device_id sony_pic_device_ids[] = {
2957 	{SONY_PIC_HID, 0},
2958 	{"", 0},
2959 };
2960 
2961 static struct acpi_driver sony_pic_driver = {
2962 	.name = SONY_PIC_DRIVER_NAME,
2963 	.class = SONY_PIC_CLASS,
2964 	.ids = sony_pic_device_ids,
2965 	.owner = THIS_MODULE,
2966 	.ops = {
2967 		.add = sony_pic_add,
2968 		.remove = sony_pic_remove,
2969 		.suspend = sony_pic_suspend,
2970 		.resume = sony_pic_resume,
2971 		},
2972 };
2973 
2974 static struct dmi_system_id __initdata sonypi_dmi_table[] = {
2975 	{
2976 		.ident = "Sony Vaio",
2977 		.matches = {
2978 			DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
2979 			DMI_MATCH(DMI_PRODUCT_NAME, "PCG-"),
2980 		},
2981 	},
2982 	{
2983 		.ident = "Sony Vaio",
2984 		.matches = {
2985 			DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
2986 			DMI_MATCH(DMI_PRODUCT_NAME, "VGN-"),
2987 		},
2988 	},
2989 	{ }
2990 };
2991 
2992 static int __init sony_laptop_init(void)
2993 {
2994 	int result;
2995 
2996 	if (!no_spic && dmi_check_system(sonypi_dmi_table)) {
2997 		result = acpi_bus_register_driver(&sony_pic_driver);
2998 		if (result) {
2999 			printk(KERN_ERR DRV_PFX
3000 					"Unable to register SPIC driver.");
3001 			goto out;
3002 		}
3003 		spic_drv_registered = 1;
3004 	}
3005 
3006 	result = acpi_bus_register_driver(&sony_nc_driver);
3007 	if (result) {
3008 		printk(KERN_ERR DRV_PFX "Unable to register SNC driver.");
3009 		goto out_unregister_pic;
3010 	}
3011 
3012 	return 0;
3013 
3014 out_unregister_pic:
3015 	if (spic_drv_registered)
3016 		acpi_bus_unregister_driver(&sony_pic_driver);
3017 out:
3018 	return result;
3019 }
3020 
3021 static void __exit sony_laptop_exit(void)
3022 {
3023 	acpi_bus_unregister_driver(&sony_nc_driver);
3024 	if (spic_drv_registered)
3025 		acpi_bus_unregister_driver(&sony_pic_driver);
3026 }
3027 
3028 module_init(sony_laptop_init);
3029 module_exit(sony_laptop_exit);
3030