2 * Sony Programmable I/O Control Device driver for VAIO
4 * Copyright (C) 2007 Mattia Dongili <malattia@linux.it>
6 * Copyright (C) 2001-2005 Stelian Pop <stelian@popies.net>
8 * Copyright (C) 2005 Narayanan R S <nars@kadamba.org>
10 * Copyright (C) 2001-2002 AlcĂ´ve <www.alcove.com>
12 * Copyright (C) 2001 Michael Ashley <m.ashley@unsw.edu.au>
14 * Copyright (C) 2001 Junichi Morita <jun1m@mars.dti.ne.jp>
16 * Copyright (C) 2000 Takaya Kinjo <t-kinjo@tc4.so-net.ne.jp>
18 * Copyright (C) 2000 Andrew Tridgell <tridge@valinux.com>
20 * Earlier work by Werner Almesberger, Paul `Rusty' Russell and Paul Mackerras.
22 * This program is free software; you can redistribute it and/or modify
23 * it under the terms of the GNU General Public License as published by
24 * the Free Software Foundation; either version 2 of the License, or
25 * (at your option) any later version.
27 * This program is distributed in the hope that it will be useful,
28 * but WITHOUT ANY WARRANTY; without even the implied warranty of
29 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
30 * GNU General Public License for more details.
32 * You should have received a copy of the GNU General Public License
33 * along with this program; if not, write to the Free Software
34 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
38 #include <linux/module.h>
39 #include <linux/sched.h>
40 #include <linux/input.h>
41 #include <linux/pci.h>
42 #include <linux/init.h>
43 #include <linux/interrupt.h>
44 #include <linux/miscdevice.h>
45 #include <linux/poll.h>
46 #include <linux/delay.h>
47 #include <linux/wait.h>
48 #include <linux/acpi.h>
49 #include <linux/dmi.h>
50 #include <linux/err.h>
51 #include <linux/kfifo.h>
52 #include <linux/platform_device.h>
53 #include <linux/gfp.h>
55 #include <asm/uaccess.h>
57 #include <asm/system.h>
59 #include <linux/sonypi.h>
61 #define SONYPI_DRIVER_VERSION "1.26"
63 MODULE_AUTHOR("Stelian Pop <stelian@popies.net>");
64 MODULE_DESCRIPTION("Sony Programmable I/O Control Device driver");
65 MODULE_LICENSE("GPL");
66 MODULE_VERSION(SONYPI_DRIVER_VERSION
);
68 static int minor
= -1;
69 module_param(minor
, int, 0);
70 MODULE_PARM_DESC(minor
,
71 "minor number of the misc device, default is -1 (automatic)");
73 static int verbose
; /* = 0 */
74 module_param(verbose
, int, 0644);
75 MODULE_PARM_DESC(verbose
, "be verbose, default is 0 (no)");
77 static int fnkeyinit
; /* = 0 */
78 module_param(fnkeyinit
, int, 0444);
79 MODULE_PARM_DESC(fnkeyinit
,
80 "set this if your Fn keys do not generate any event");
82 static int camera
; /* = 0 */
83 module_param(camera
, int, 0444);
84 MODULE_PARM_DESC(camera
,
85 "set this if you have a MotionEye camera (PictureBook series)");
87 static int compat
; /* = 0 */
88 module_param(compat
, int, 0444);
89 MODULE_PARM_DESC(compat
,
90 "set this if you want to enable backward compatibility mode");
92 static unsigned long mask
= 0xffffffff;
93 module_param(mask
, ulong
, 0644);
94 MODULE_PARM_DESC(mask
,
95 "set this to the mask of event you want to enable (see doc)");
97 static int useinput
= 1;
98 module_param(useinput
, int, 0444);
99 MODULE_PARM_DESC(useinput
,
100 "set this if you would like sonypi to feed events to the input subsystem");
102 static int check_ioport
= 1;
103 module_param(check_ioport
, int, 0444);
104 MODULE_PARM_DESC(check_ioport
,
105 "set this to 0 if you think the automatic ioport check for sony-laptop is wrong");
107 #define SONYPI_DEVICE_MODEL_TYPE1 1
108 #define SONYPI_DEVICE_MODEL_TYPE2 2
109 #define SONYPI_DEVICE_MODEL_TYPE3 3
111 /* type1 models use those */
112 #define SONYPI_IRQ_PORT 0x8034
113 #define SONYPI_IRQ_SHIFT 22
114 #define SONYPI_TYPE1_BASE 0x50
115 #define SONYPI_G10A (SONYPI_TYPE1_BASE+0x14)
116 #define SONYPI_TYPE1_REGION_SIZE 0x08
117 #define SONYPI_TYPE1_EVTYPE_OFFSET 0x04
119 /* type2 series specifics */
120 #define SONYPI_SIRQ 0x9b
121 #define SONYPI_SLOB 0x9c
122 #define SONYPI_SHIB 0x9d
123 #define SONYPI_TYPE2_REGION_SIZE 0x20
124 #define SONYPI_TYPE2_EVTYPE_OFFSET 0x12
126 /* type3 series specifics */
127 #define SONYPI_TYPE3_BASE 0x40
128 #define SONYPI_TYPE3_GID2 (SONYPI_TYPE3_BASE+0x48) /* 16 bits */
129 #define SONYPI_TYPE3_MISC (SONYPI_TYPE3_BASE+0x6d) /* 8 bits */
130 #define SONYPI_TYPE3_REGION_SIZE 0x20
131 #define SONYPI_TYPE3_EVTYPE_OFFSET 0x12
133 /* battery / brightness addresses */
134 #define SONYPI_BAT_FLAGS 0x81
135 #define SONYPI_LCD_LIGHT 0x96
136 #define SONYPI_BAT1_PCTRM 0xa0
137 #define SONYPI_BAT1_LEFT 0xa2
138 #define SONYPI_BAT1_MAXRT 0xa4
139 #define SONYPI_BAT2_PCTRM 0xa8
140 #define SONYPI_BAT2_LEFT 0xaa
141 #define SONYPI_BAT2_MAXRT 0xac
142 #define SONYPI_BAT1_MAXTK 0xb0
143 #define SONYPI_BAT1_FULL 0xb2
144 #define SONYPI_BAT2_MAXTK 0xb8
145 #define SONYPI_BAT2_FULL 0xba
147 /* FAN0 information (reverse engineered from ACPI tables) */
148 #define SONYPI_FAN0_STATUS 0x93
149 #define SONYPI_TEMP_STATUS 0xC1
151 /* ioports used for brightness and type2 events */
152 #define SONYPI_DATA_IOPORT 0x62
153 #define SONYPI_CST_IOPORT 0x66
155 /* The set of possible ioports */
156 struct sonypi_ioport_list
{
161 static struct sonypi_ioport_list sonypi_type1_ioport_list
[] = {
162 { 0x10c0, 0x10c4 }, /* looks like the default on C1Vx */
170 static struct sonypi_ioport_list sonypi_type2_ioport_list
[] = {
178 /* same as in type 2 models */
179 static struct sonypi_ioport_list
*sonypi_type3_ioport_list
=
180 sonypi_type2_ioport_list
;
182 /* The set of possible interrupts */
183 struct sonypi_irq_list
{
188 static struct sonypi_irq_list sonypi_type1_irq_list
[] = {
189 { 11, 0x2 }, /* IRQ 11, GO22=0,GO23=1 in AML */
190 { 10, 0x1 }, /* IRQ 10, GO22=1,GO23=0 in AML */
191 { 5, 0x0 }, /* IRQ 5, GO22=0,GO23=0 in AML */
192 { 0, 0x3 } /* no IRQ, GO22=1,GO23=1 in AML */
195 static struct sonypi_irq_list sonypi_type2_irq_list
[] = {
196 { 11, 0x80 }, /* IRQ 11, 0x80 in SIRQ in AML */
197 { 10, 0x40 }, /* IRQ 10, 0x40 in SIRQ in AML */
198 { 9, 0x20 }, /* IRQ 9, 0x20 in SIRQ in AML */
199 { 6, 0x10 }, /* IRQ 6, 0x10 in SIRQ in AML */
200 { 0, 0x00 } /* no IRQ, 0x00 in SIRQ in AML */
203 /* same as in type2 models */
204 static struct sonypi_irq_list
*sonypi_type3_irq_list
= sonypi_type2_irq_list
;
206 #define SONYPI_CAMERA_BRIGHTNESS 0
207 #define SONYPI_CAMERA_CONTRAST 1
208 #define SONYPI_CAMERA_HUE 2
209 #define SONYPI_CAMERA_COLOR 3
210 #define SONYPI_CAMERA_SHARPNESS 4
212 #define SONYPI_CAMERA_PICTURE 5
213 #define SONYPI_CAMERA_EXPOSURE_MASK 0xC
214 #define SONYPI_CAMERA_WHITE_BALANCE_MASK 0x3
215 #define SONYPI_CAMERA_PICTURE_MODE_MASK 0x30
216 #define SONYPI_CAMERA_MUTE_MASK 0x40
218 /* the rest don't need a loop until not 0xff */
219 #define SONYPI_CAMERA_AGC 6
220 #define SONYPI_CAMERA_AGC_MASK 0x30
221 #define SONYPI_CAMERA_SHUTTER_MASK 0x7
223 #define SONYPI_CAMERA_SHUTDOWN_REQUEST 7
224 #define SONYPI_CAMERA_CONTROL 0x10
226 #define SONYPI_CAMERA_STATUS 7
227 #define SONYPI_CAMERA_STATUS_READY 0x2
228 #define SONYPI_CAMERA_STATUS_POSITION 0x4
230 #define SONYPI_DIRECTION_BACKWARDS 0x4
232 #define SONYPI_CAMERA_REVISION 8
233 #define SONYPI_CAMERA_ROMVERSION 9
236 #define SONYPI_JOGGER_MASK 0x00000001
237 #define SONYPI_CAPTURE_MASK 0x00000002
238 #define SONYPI_FNKEY_MASK 0x00000004
239 #define SONYPI_BLUETOOTH_MASK 0x00000008
240 #define SONYPI_PKEY_MASK 0x00000010
241 #define SONYPI_BACK_MASK 0x00000020
242 #define SONYPI_HELP_MASK 0x00000040
243 #define SONYPI_LID_MASK 0x00000080
244 #define SONYPI_ZOOM_MASK 0x00000100
245 #define SONYPI_THUMBPHRASE_MASK 0x00000200
246 #define SONYPI_MEYE_MASK 0x00000400
247 #define SONYPI_MEMORYSTICK_MASK 0x00000800
248 #define SONYPI_BATTERY_MASK 0x00001000
249 #define SONYPI_WIRELESS_MASK 0x00002000
251 struct sonypi_event
{
256 /* The set of possible button release events */
257 static struct sonypi_event sonypi_releaseev
[] = {
258 { 0x00, SONYPI_EVENT_ANYBUTTON_RELEASED
},
262 /* The set of possible jogger events */
263 static struct sonypi_event sonypi_joggerev
[] = {
264 { 0x1f, SONYPI_EVENT_JOGDIAL_UP
},
265 { 0x01, SONYPI_EVENT_JOGDIAL_DOWN
},
266 { 0x5f, SONYPI_EVENT_JOGDIAL_UP_PRESSED
},
267 { 0x41, SONYPI_EVENT_JOGDIAL_DOWN_PRESSED
},
268 { 0x1e, SONYPI_EVENT_JOGDIAL_FAST_UP
},
269 { 0x02, SONYPI_EVENT_JOGDIAL_FAST_DOWN
},
270 { 0x5e, SONYPI_EVENT_JOGDIAL_FAST_UP_PRESSED
},
271 { 0x42, SONYPI_EVENT_JOGDIAL_FAST_DOWN_PRESSED
},
272 { 0x1d, SONYPI_EVENT_JOGDIAL_VFAST_UP
},
273 { 0x03, SONYPI_EVENT_JOGDIAL_VFAST_DOWN
},
274 { 0x5d, SONYPI_EVENT_JOGDIAL_VFAST_UP_PRESSED
},
275 { 0x43, SONYPI_EVENT_JOGDIAL_VFAST_DOWN_PRESSED
},
276 { 0x40, SONYPI_EVENT_JOGDIAL_PRESSED
},
280 /* The set of possible capture button events */
281 static struct sonypi_event sonypi_captureev
[] = {
282 { 0x05, SONYPI_EVENT_CAPTURE_PARTIALPRESSED
},
283 { 0x07, SONYPI_EVENT_CAPTURE_PRESSED
},
284 { 0x01, SONYPI_EVENT_CAPTURE_PARTIALRELEASED
},
288 /* The set of possible fnkeys events */
289 static struct sonypi_event sonypi_fnkeyev
[] = {
290 { 0x10, SONYPI_EVENT_FNKEY_ESC
},
291 { 0x11, SONYPI_EVENT_FNKEY_F1
},
292 { 0x12, SONYPI_EVENT_FNKEY_F2
},
293 { 0x13, SONYPI_EVENT_FNKEY_F3
},
294 { 0x14, SONYPI_EVENT_FNKEY_F4
},
295 { 0x15, SONYPI_EVENT_FNKEY_F5
},
296 { 0x16, SONYPI_EVENT_FNKEY_F6
},
297 { 0x17, SONYPI_EVENT_FNKEY_F7
},
298 { 0x18, SONYPI_EVENT_FNKEY_F8
},
299 { 0x19, SONYPI_EVENT_FNKEY_F9
},
300 { 0x1a, SONYPI_EVENT_FNKEY_F10
},
301 { 0x1b, SONYPI_EVENT_FNKEY_F11
},
302 { 0x1c, SONYPI_EVENT_FNKEY_F12
},
303 { 0x1f, SONYPI_EVENT_FNKEY_RELEASED
},
304 { 0x21, SONYPI_EVENT_FNKEY_1
},
305 { 0x22, SONYPI_EVENT_FNKEY_2
},
306 { 0x31, SONYPI_EVENT_FNKEY_D
},
307 { 0x32, SONYPI_EVENT_FNKEY_E
},
308 { 0x33, SONYPI_EVENT_FNKEY_F
},
309 { 0x34, SONYPI_EVENT_FNKEY_S
},
310 { 0x35, SONYPI_EVENT_FNKEY_B
},
311 { 0x36, SONYPI_EVENT_FNKEY_ONLY
},
315 /* The set of possible program key events */
316 static struct sonypi_event sonypi_pkeyev
[] = {
317 { 0x01, SONYPI_EVENT_PKEY_P1
},
318 { 0x02, SONYPI_EVENT_PKEY_P2
},
319 { 0x04, SONYPI_EVENT_PKEY_P3
},
320 { 0x5c, SONYPI_EVENT_PKEY_P1
},
324 /* The set of possible bluetooth events */
325 static struct sonypi_event sonypi_blueev
[] = {
326 { 0x55, SONYPI_EVENT_BLUETOOTH_PRESSED
},
327 { 0x59, SONYPI_EVENT_BLUETOOTH_ON
},
328 { 0x5a, SONYPI_EVENT_BLUETOOTH_OFF
},
332 /* The set of possible wireless events */
333 static struct sonypi_event sonypi_wlessev
[] = {
334 { 0x59, SONYPI_EVENT_WIRELESS_ON
},
335 { 0x5a, SONYPI_EVENT_WIRELESS_OFF
},
339 /* The set of possible back button events */
340 static struct sonypi_event sonypi_backev
[] = {
341 { 0x20, SONYPI_EVENT_BACK_PRESSED
},
345 /* The set of possible help button events */
346 static struct sonypi_event sonypi_helpev
[] = {
347 { 0x3b, SONYPI_EVENT_HELP_PRESSED
},
352 /* The set of possible lid events */
353 static struct sonypi_event sonypi_lidev
[] = {
354 { 0x51, SONYPI_EVENT_LID_CLOSED
},
355 { 0x50, SONYPI_EVENT_LID_OPENED
},
359 /* The set of possible zoom events */
360 static struct sonypi_event sonypi_zoomev
[] = {
361 { 0x39, SONYPI_EVENT_ZOOM_PRESSED
},
365 /* The set of possible thumbphrase events */
366 static struct sonypi_event sonypi_thumbphraseev
[] = {
367 { 0x3a, SONYPI_EVENT_THUMBPHRASE_PRESSED
},
371 /* The set of possible motioneye camera events */
372 static struct sonypi_event sonypi_meyeev
[] = {
373 { 0x00, SONYPI_EVENT_MEYE_FACE
},
374 { 0x01, SONYPI_EVENT_MEYE_OPPOSITE
},
378 /* The set of possible memorystick events */
379 static struct sonypi_event sonypi_memorystickev
[] = {
380 { 0x53, SONYPI_EVENT_MEMORYSTICK_INSERT
},
381 { 0x54, SONYPI_EVENT_MEMORYSTICK_EJECT
},
385 /* The set of possible battery events */
386 static struct sonypi_event sonypi_batteryev
[] = {
387 { 0x20, SONYPI_EVENT_BATTERY_INSERT
},
388 { 0x30, SONYPI_EVENT_BATTERY_REMOVE
},
392 static struct sonypi_eventtypes
{
396 struct sonypi_event
* events
;
397 } sonypi_eventtypes
[] = {
398 { SONYPI_DEVICE_MODEL_TYPE1
, 0, 0xffffffff, sonypi_releaseev
},
399 { SONYPI_DEVICE_MODEL_TYPE1
, 0x70, SONYPI_MEYE_MASK
, sonypi_meyeev
},
400 { SONYPI_DEVICE_MODEL_TYPE1
, 0x30, SONYPI_LID_MASK
, sonypi_lidev
},
401 { SONYPI_DEVICE_MODEL_TYPE1
, 0x60, SONYPI_CAPTURE_MASK
, sonypi_captureev
},
402 { SONYPI_DEVICE_MODEL_TYPE1
, 0x10, SONYPI_JOGGER_MASK
, sonypi_joggerev
},
403 { SONYPI_DEVICE_MODEL_TYPE1
, 0x20, SONYPI_FNKEY_MASK
, sonypi_fnkeyev
},
404 { SONYPI_DEVICE_MODEL_TYPE1
, 0x30, SONYPI_BLUETOOTH_MASK
, sonypi_blueev
},
405 { SONYPI_DEVICE_MODEL_TYPE1
, 0x40, SONYPI_PKEY_MASK
, sonypi_pkeyev
},
406 { SONYPI_DEVICE_MODEL_TYPE1
, 0x30, SONYPI_MEMORYSTICK_MASK
, sonypi_memorystickev
},
407 { SONYPI_DEVICE_MODEL_TYPE1
, 0x40, SONYPI_BATTERY_MASK
, sonypi_batteryev
},
409 { SONYPI_DEVICE_MODEL_TYPE2
, 0, 0xffffffff, sonypi_releaseev
},
410 { SONYPI_DEVICE_MODEL_TYPE2
, 0x38, SONYPI_LID_MASK
, sonypi_lidev
},
411 { SONYPI_DEVICE_MODEL_TYPE2
, 0x11, SONYPI_JOGGER_MASK
, sonypi_joggerev
},
412 { SONYPI_DEVICE_MODEL_TYPE2
, 0x61, SONYPI_CAPTURE_MASK
, sonypi_captureev
},
413 { SONYPI_DEVICE_MODEL_TYPE2
, 0x21, SONYPI_FNKEY_MASK
, sonypi_fnkeyev
},
414 { SONYPI_DEVICE_MODEL_TYPE2
, 0x31, SONYPI_BLUETOOTH_MASK
, sonypi_blueev
},
415 { SONYPI_DEVICE_MODEL_TYPE2
, 0x08, SONYPI_PKEY_MASK
, sonypi_pkeyev
},
416 { SONYPI_DEVICE_MODEL_TYPE2
, 0x11, SONYPI_BACK_MASK
, sonypi_backev
},
417 { SONYPI_DEVICE_MODEL_TYPE2
, 0x21, SONYPI_HELP_MASK
, sonypi_helpev
},
418 { SONYPI_DEVICE_MODEL_TYPE2
, 0x21, SONYPI_ZOOM_MASK
, sonypi_zoomev
},
419 { SONYPI_DEVICE_MODEL_TYPE2
, 0x20, SONYPI_THUMBPHRASE_MASK
, sonypi_thumbphraseev
},
420 { SONYPI_DEVICE_MODEL_TYPE2
, 0x31, SONYPI_MEMORYSTICK_MASK
, sonypi_memorystickev
},
421 { SONYPI_DEVICE_MODEL_TYPE2
, 0x41, SONYPI_BATTERY_MASK
, sonypi_batteryev
},
422 { SONYPI_DEVICE_MODEL_TYPE2
, 0x31, SONYPI_PKEY_MASK
, sonypi_pkeyev
},
424 { SONYPI_DEVICE_MODEL_TYPE3
, 0, 0xffffffff, sonypi_releaseev
},
425 { SONYPI_DEVICE_MODEL_TYPE3
, 0x21, SONYPI_FNKEY_MASK
, sonypi_fnkeyev
},
426 { SONYPI_DEVICE_MODEL_TYPE3
, 0x31, SONYPI_WIRELESS_MASK
, sonypi_wlessev
},
427 { SONYPI_DEVICE_MODEL_TYPE3
, 0x31, SONYPI_MEMORYSTICK_MASK
, sonypi_memorystickev
},
428 { SONYPI_DEVICE_MODEL_TYPE3
, 0x41, SONYPI_BATTERY_MASK
, sonypi_batteryev
},
429 { SONYPI_DEVICE_MODEL_TYPE3
, 0x31, SONYPI_PKEY_MASK
, sonypi_pkeyev
},
433 #define SONYPI_BUF_SIZE 128
435 /* Correspondance table between sonypi events and input layer events */
439 } sonypi_inputkeys
[] = {
440 { SONYPI_EVENT_CAPTURE_PRESSED
, KEY_CAMERA
},
441 { SONYPI_EVENT_FNKEY_ONLY
, KEY_FN
},
442 { SONYPI_EVENT_FNKEY_ESC
, KEY_FN_ESC
},
443 { SONYPI_EVENT_FNKEY_F1
, KEY_FN_F1
},
444 { SONYPI_EVENT_FNKEY_F2
, KEY_FN_F2
},
445 { SONYPI_EVENT_FNKEY_F3
, KEY_FN_F3
},
446 { SONYPI_EVENT_FNKEY_F4
, KEY_FN_F4
},
447 { SONYPI_EVENT_FNKEY_F5
, KEY_FN_F5
},
448 { SONYPI_EVENT_FNKEY_F6
, KEY_FN_F6
},
449 { SONYPI_EVENT_FNKEY_F7
, KEY_FN_F7
},
450 { SONYPI_EVENT_FNKEY_F8
, KEY_FN_F8
},
451 { SONYPI_EVENT_FNKEY_F9
, KEY_FN_F9
},
452 { SONYPI_EVENT_FNKEY_F10
, KEY_FN_F10
},
453 { SONYPI_EVENT_FNKEY_F11
, KEY_FN_F11
},
454 { SONYPI_EVENT_FNKEY_F12
, KEY_FN_F12
},
455 { SONYPI_EVENT_FNKEY_1
, KEY_FN_1
},
456 { SONYPI_EVENT_FNKEY_2
, KEY_FN_2
},
457 { SONYPI_EVENT_FNKEY_D
, KEY_FN_D
},
458 { SONYPI_EVENT_FNKEY_E
, KEY_FN_E
},
459 { SONYPI_EVENT_FNKEY_F
, KEY_FN_F
},
460 { SONYPI_EVENT_FNKEY_S
, KEY_FN_S
},
461 { SONYPI_EVENT_FNKEY_B
, KEY_FN_B
},
462 { SONYPI_EVENT_BLUETOOTH_PRESSED
, KEY_BLUE
},
463 { SONYPI_EVENT_BLUETOOTH_ON
, KEY_BLUE
},
464 { SONYPI_EVENT_PKEY_P1
, KEY_PROG1
},
465 { SONYPI_EVENT_PKEY_P2
, KEY_PROG2
},
466 { SONYPI_EVENT_PKEY_P3
, KEY_PROG3
},
467 { SONYPI_EVENT_BACK_PRESSED
, KEY_BACK
},
468 { SONYPI_EVENT_HELP_PRESSED
, KEY_HELP
},
469 { SONYPI_EVENT_ZOOM_PRESSED
, KEY_ZOOM
},
470 { SONYPI_EVENT_THUMBPHRASE_PRESSED
, BTN_THUMB
},
474 struct sonypi_keypress
{
475 struct input_dev
*dev
;
479 static struct sonypi_device
{
491 spinlock_t fifo_lock
;
492 wait_queue_head_t fifo_proc_list
;
493 struct fasync_struct
*fifo_async
;
496 struct input_dev
*input_jog_dev
;
497 struct input_dev
*input_key_dev
;
498 struct work_struct input_work
;
499 struct kfifo input_fifo
;
500 spinlock_t input_fifo_lock
;
503 #define ITERATIONS_LONG 10000
504 #define ITERATIONS_SHORT 10
506 #define wait_on_command(quiet, command, iterations) { \
507 unsigned int n = iterations; \
508 while (--n && (command)) \
510 if (!n && (verbose || !quiet)) \
511 printk(KERN_WARNING "sonypi command failed at %s : %s (line %d)\n", __FILE__, __func__, __LINE__); \
515 #define SONYPI_ACPI_ACTIVE (!acpi_disabled)
517 #define SONYPI_ACPI_ACTIVE 0
518 #endif /* CONFIG_ACPI */
521 static struct acpi_device
*sonypi_acpi_device
;
522 static int acpi_driver_registered
;
525 static int sonypi_ec_write(u8 addr
, u8 value
)
528 if (SONYPI_ACPI_ACTIVE
)
529 return ec_write(addr
, value
);
531 wait_on_command(1, inb_p(SONYPI_CST_IOPORT
) & 3, ITERATIONS_LONG
);
532 outb_p(0x81, SONYPI_CST_IOPORT
);
533 wait_on_command(0, inb_p(SONYPI_CST_IOPORT
) & 2, ITERATIONS_LONG
);
534 outb_p(addr
, SONYPI_DATA_IOPORT
);
535 wait_on_command(0, inb_p(SONYPI_CST_IOPORT
) & 2, ITERATIONS_LONG
);
536 outb_p(value
, SONYPI_DATA_IOPORT
);
537 wait_on_command(0, inb_p(SONYPI_CST_IOPORT
) & 2, ITERATIONS_LONG
);
541 static int sonypi_ec_read(u8 addr
, u8
*value
)
544 if (SONYPI_ACPI_ACTIVE
)
545 return ec_read(addr
, value
);
547 wait_on_command(1, inb_p(SONYPI_CST_IOPORT
) & 3, ITERATIONS_LONG
);
548 outb_p(0x80, SONYPI_CST_IOPORT
);
549 wait_on_command(0, inb_p(SONYPI_CST_IOPORT
) & 2, ITERATIONS_LONG
);
550 outb_p(addr
, SONYPI_DATA_IOPORT
);
551 wait_on_command(0, inb_p(SONYPI_CST_IOPORT
) & 2, ITERATIONS_LONG
);
552 *value
= inb_p(SONYPI_DATA_IOPORT
);
556 static int ec_read16(u8 addr
, u16
*value
)
559 if (sonypi_ec_read(addr
, &val_lb
))
561 if (sonypi_ec_read(addr
+ 1, &val_hb
))
563 *value
= val_lb
| (val_hb
<< 8);
567 /* Initializes the device - this comes from the AML code in the ACPI bios */
568 static void sonypi_type1_srs(void)
572 pci_read_config_dword(sonypi_device
.dev
, SONYPI_G10A
, &v
);
573 v
= (v
& 0xFFFF0000) | ((u32
) sonypi_device
.ioport1
);
574 pci_write_config_dword(sonypi_device
.dev
, SONYPI_G10A
, v
);
576 pci_read_config_dword(sonypi_device
.dev
, SONYPI_G10A
, &v
);
577 v
= (v
& 0xFFF0FFFF) |
578 (((u32
) sonypi_device
.ioport1
^ sonypi_device
.ioport2
) << 16);
579 pci_write_config_dword(sonypi_device
.dev
, SONYPI_G10A
, v
);
581 v
= inl(SONYPI_IRQ_PORT
);
582 v
&= ~(((u32
) 0x3) << SONYPI_IRQ_SHIFT
);
583 v
|= (((u32
) sonypi_device
.bits
) << SONYPI_IRQ_SHIFT
);
584 outl(v
, SONYPI_IRQ_PORT
);
586 pci_read_config_dword(sonypi_device
.dev
, SONYPI_G10A
, &v
);
587 v
= (v
& 0xFF1FFFFF) | 0x00C00000;
588 pci_write_config_dword(sonypi_device
.dev
, SONYPI_G10A
, v
);
591 static void sonypi_type2_srs(void)
593 if (sonypi_ec_write(SONYPI_SHIB
, (sonypi_device
.ioport1
& 0xFF00) >> 8))
594 printk(KERN_WARNING
"ec_write failed\n");
595 if (sonypi_ec_write(SONYPI_SLOB
, sonypi_device
.ioport1
& 0x00FF))
596 printk(KERN_WARNING
"ec_write failed\n");
597 if (sonypi_ec_write(SONYPI_SIRQ
, sonypi_device
.bits
))
598 printk(KERN_WARNING
"ec_write failed\n");
602 static void sonypi_type3_srs(void)
607 /* This model type uses the same initialiazation of
608 * the embedded controller as the type2 models. */
611 /* Initialization of PCI config space of the LPC interface bridge. */
612 v16
= (sonypi_device
.ioport1
& 0xFFF0) | 0x01;
613 pci_write_config_word(sonypi_device
.dev
, SONYPI_TYPE3_GID2
, v16
);
614 pci_read_config_byte(sonypi_device
.dev
, SONYPI_TYPE3_MISC
, &v8
);
615 v8
= (v8
& 0xCF) | 0x10;
616 pci_write_config_byte(sonypi_device
.dev
, SONYPI_TYPE3_MISC
, v8
);
619 /* Disables the device - this comes from the AML code in the ACPI bios */
620 static void sonypi_type1_dis(void)
624 pci_read_config_dword(sonypi_device
.dev
, SONYPI_G10A
, &v
);
626 pci_write_config_dword(sonypi_device
.dev
, SONYPI_G10A
, v
);
628 v
= inl(SONYPI_IRQ_PORT
);
629 v
|= (0x3 << SONYPI_IRQ_SHIFT
);
630 outl(v
, SONYPI_IRQ_PORT
);
633 static void sonypi_type2_dis(void)
635 if (sonypi_ec_write(SONYPI_SHIB
, 0))
636 printk(KERN_WARNING
"ec_write failed\n");
637 if (sonypi_ec_write(SONYPI_SLOB
, 0))
638 printk(KERN_WARNING
"ec_write failed\n");
639 if (sonypi_ec_write(SONYPI_SIRQ
, 0))
640 printk(KERN_WARNING
"ec_write failed\n");
643 static void sonypi_type3_dis(void)
647 pci_write_config_word(sonypi_device
.dev
, SONYPI_TYPE3_GID2
, 0);
650 static u8
sonypi_call1(u8 dev
)
654 wait_on_command(0, inb_p(sonypi_device
.ioport2
) & 2, ITERATIONS_LONG
);
655 outb(dev
, sonypi_device
.ioport2
);
656 v1
= inb_p(sonypi_device
.ioport2
);
657 v2
= inb_p(sonypi_device
.ioport1
);
661 static u8
sonypi_call2(u8 dev
, u8 fn
)
665 wait_on_command(0, inb_p(sonypi_device
.ioport2
) & 2, ITERATIONS_LONG
);
666 outb(dev
, sonypi_device
.ioport2
);
667 wait_on_command(0, inb_p(sonypi_device
.ioport2
) & 2, ITERATIONS_LONG
);
668 outb(fn
, sonypi_device
.ioport1
);
669 v1
= inb_p(sonypi_device
.ioport1
);
673 static u8
sonypi_call3(u8 dev
, u8 fn
, u8 v
)
677 wait_on_command(0, inb_p(sonypi_device
.ioport2
) & 2, ITERATIONS_LONG
);
678 outb(dev
, sonypi_device
.ioport2
);
679 wait_on_command(0, inb_p(sonypi_device
.ioport2
) & 2, ITERATIONS_LONG
);
680 outb(fn
, sonypi_device
.ioport1
);
681 wait_on_command(0, inb_p(sonypi_device
.ioport2
) & 2, ITERATIONS_LONG
);
682 outb(v
, sonypi_device
.ioport1
);
683 v1
= inb_p(sonypi_device
.ioport1
);
688 /* Set brightness, hue etc */
689 static void sonypi_set(u8 fn
, u8 v
)
691 wait_on_command(0, sonypi_call3(0x90, fn
, v
), ITERATIONS_SHORT
);
694 /* Tests if the camera is ready */
695 static int sonypi_camera_ready(void)
699 v
= sonypi_call2(0x8f, SONYPI_CAMERA_STATUS
);
700 return (v
!= 0xff && (v
& SONYPI_CAMERA_STATUS_READY
));
703 /* Turns the camera off */
704 static void sonypi_camera_off(void)
706 sonypi_set(SONYPI_CAMERA_PICTURE
, SONYPI_CAMERA_MUTE_MASK
);
708 if (!sonypi_device
.camera_power
)
711 sonypi_call2(0x91, 0);
712 sonypi_device
.camera_power
= 0;
715 /* Turns the camera on */
716 static void sonypi_camera_on(void)
720 if (sonypi_device
.camera_power
)
723 for (j
= 5; j
> 0; j
--) {
725 while (sonypi_call2(0x91, 0x1))
729 for (i
= 400; i
> 0; i
--) {
730 if (sonypi_camera_ready())
739 printk(KERN_WARNING
"sonypi: failed to power on camera\n");
743 sonypi_set(0x10, 0x5a);
744 sonypi_device
.camera_power
= 1;
747 /* sets the bluetooth subsystem power state */
748 static void sonypi_setbluetoothpower(u8 state
)
752 if (sonypi_device
.bluetooth_power
== state
)
755 sonypi_call2(0x96, state
);
757 sonypi_device
.bluetooth_power
= state
;
760 static void input_keyrelease(struct work_struct
*work
)
762 struct sonypi_keypress kp
;
764 while (kfifo_out_locked(&sonypi_device
.input_fifo
, (unsigned char *)&kp
,
765 sizeof(kp
), &sonypi_device
.input_fifo_lock
)
768 input_report_key(kp
.dev
, kp
.key
, 0);
773 static void sonypi_report_input_event(u8 event
)
775 struct input_dev
*jog_dev
= sonypi_device
.input_jog_dev
;
776 struct input_dev
*key_dev
= sonypi_device
.input_key_dev
;
777 struct sonypi_keypress kp
= { NULL
};
781 case SONYPI_EVENT_JOGDIAL_UP
:
782 case SONYPI_EVENT_JOGDIAL_UP_PRESSED
:
783 input_report_rel(jog_dev
, REL_WHEEL
, 1);
787 case SONYPI_EVENT_JOGDIAL_DOWN
:
788 case SONYPI_EVENT_JOGDIAL_DOWN_PRESSED
:
789 input_report_rel(jog_dev
, REL_WHEEL
, -1);
793 case SONYPI_EVENT_JOGDIAL_PRESSED
:
798 case SONYPI_EVENT_FNKEY_RELEASED
:
799 /* Nothing, not all VAIOs generate this event */
803 for (i
= 0; sonypi_inputkeys
[i
].sonypiev
; i
++)
804 if (event
== sonypi_inputkeys
[i
].sonypiev
) {
806 kp
.key
= sonypi_inputkeys
[i
].inputev
;
813 input_report_key(kp
.dev
, kp
.key
, 1);
815 kfifo_in_locked(&sonypi_device
.input_fifo
,
816 (unsigned char *)&kp
, sizeof(kp
),
817 &sonypi_device
.input_fifo_lock
);
818 schedule_work(&sonypi_device
.input_work
);
822 /* Interrupt handler: some event is available */
823 static irqreturn_t
sonypi_irq(int irq
, void *dev_id
)
825 u8 v1
, v2
, event
= 0;
828 v1
= inb_p(sonypi_device
.ioport1
);
829 v2
= inb_p(sonypi_device
.ioport1
+ sonypi_device
.evtype_offset
);
831 for (i
= 0; sonypi_eventtypes
[i
].model
; i
++) {
832 if (sonypi_device
.model
!= sonypi_eventtypes
[i
].model
)
834 if ((v2
& sonypi_eventtypes
[i
].data
) !=
835 sonypi_eventtypes
[i
].data
)
837 if (!(mask
& sonypi_eventtypes
[i
].mask
))
839 for (j
= 0; sonypi_eventtypes
[i
].events
[j
].event
; j
++) {
840 if (v1
== sonypi_eventtypes
[i
].events
[j
].data
) {
841 event
= sonypi_eventtypes
[i
].events
[j
].event
;
849 "sonypi: unknown event port1=0x%02x,port2=0x%02x\n",
851 /* We need to return IRQ_HANDLED here because there *are*
852 * events belonging to the sonypi device we don't know about,
853 * but we still don't want those to pollute the logs... */
859 "sonypi: event port1=0x%02x,port2=0x%02x\n", v1
, v2
);
862 sonypi_report_input_event(event
);
865 if (sonypi_acpi_device
)
866 acpi_bus_generate_proc_event(sonypi_acpi_device
, 1, event
);
869 kfifo_in_locked(&sonypi_device
.fifo
, (unsigned char *)&event
,
870 sizeof(event
), &sonypi_device
.fifo_lock
);
871 kill_fasync(&sonypi_device
.fifo_async
, SIGIO
, POLL_IN
);
872 wake_up_interruptible(&sonypi_device
.fifo_proc_list
);
877 static int sonypi_misc_fasync(int fd
, struct file
*filp
, int on
)
879 return fasync_helper(fd
, filp
, on
, &sonypi_device
.fifo_async
);
882 static int sonypi_misc_release(struct inode
*inode
, struct file
*file
)
884 mutex_lock(&sonypi_device
.lock
);
885 sonypi_device
.open_count
--;
886 mutex_unlock(&sonypi_device
.lock
);
890 static int sonypi_misc_open(struct inode
*inode
, struct file
*file
)
892 mutex_lock(&sonypi_device
.lock
);
893 /* Flush input queue on first open */
894 if (!sonypi_device
.open_count
)
895 kfifo_reset(&sonypi_device
.fifo
);
896 sonypi_device
.open_count
++;
897 mutex_unlock(&sonypi_device
.lock
);
902 static ssize_t
sonypi_misc_read(struct file
*file
, char __user
*buf
,
903 size_t count
, loff_t
*pos
)
908 if ((kfifo_len(&sonypi_device
.fifo
) == 0) &&
909 (file
->f_flags
& O_NONBLOCK
))
912 ret
= wait_event_interruptible(sonypi_device
.fifo_proc_list
,
913 kfifo_len(&sonypi_device
.fifo
) != 0);
917 while (ret
< count
&&
918 (kfifo_out_locked(&sonypi_device
.fifo
, &c
, sizeof(c
),
919 &sonypi_device
.fifo_lock
) == sizeof(c
))) {
920 if (put_user(c
, buf
++))
926 struct inode
*inode
= file
->f_path
.dentry
->d_inode
;
927 inode
->i_atime
= current_fs_time(inode
->i_sb
);
933 static unsigned int sonypi_misc_poll(struct file
*file
, poll_table
*wait
)
935 poll_wait(file
, &sonypi_device
.fifo_proc_list
, wait
);
936 if (kfifo_len(&sonypi_device
.fifo
))
937 return POLLIN
| POLLRDNORM
;
941 static long sonypi_misc_ioctl(struct file
*fp
,
942 unsigned int cmd
, unsigned long arg
)
945 void __user
*argp
= (void __user
*)arg
;
949 mutex_lock(&sonypi_device
.lock
);
952 if (sonypi_ec_read(SONYPI_LCD_LIGHT
, &val8
)) {
956 if (copy_to_user(argp
, &val8
, sizeof(val8
)))
960 if (copy_from_user(&val8
, argp
, sizeof(val8
))) {
964 if (sonypi_ec_write(SONYPI_LCD_LIGHT
, val8
))
967 case SONYPI_IOCGBAT1CAP
:
968 if (ec_read16(SONYPI_BAT1_FULL
, &val16
)) {
972 if (copy_to_user(argp
, &val16
, sizeof(val16
)))
975 case SONYPI_IOCGBAT1REM
:
976 if (ec_read16(SONYPI_BAT1_LEFT
, &val16
)) {
980 if (copy_to_user(argp
, &val16
, sizeof(val16
)))
983 case SONYPI_IOCGBAT2CAP
:
984 if (ec_read16(SONYPI_BAT2_FULL
, &val16
)) {
988 if (copy_to_user(argp
, &val16
, sizeof(val16
)))
991 case SONYPI_IOCGBAT2REM
:
992 if (ec_read16(SONYPI_BAT2_LEFT
, &val16
)) {
996 if (copy_to_user(argp
, &val16
, sizeof(val16
)))
999 case SONYPI_IOCGBATFLAGS
:
1000 if (sonypi_ec_read(SONYPI_BAT_FLAGS
, &val8
)) {
1005 if (copy_to_user(argp
, &val8
, sizeof(val8
)))
1008 case SONYPI_IOCGBLUE
:
1009 val8
= sonypi_device
.bluetooth_power
;
1010 if (copy_to_user(argp
, &val8
, sizeof(val8
)))
1013 case SONYPI_IOCSBLUE
:
1014 if (copy_from_user(&val8
, argp
, sizeof(val8
))) {
1018 sonypi_setbluetoothpower(val8
);
1021 case SONYPI_IOCGFAN
:
1022 if (sonypi_ec_read(SONYPI_FAN0_STATUS
, &val8
)) {
1026 if (copy_to_user(argp
, &val8
, sizeof(val8
)))
1029 case SONYPI_IOCSFAN
:
1030 if (copy_from_user(&val8
, argp
, sizeof(val8
))) {
1034 if (sonypi_ec_write(SONYPI_FAN0_STATUS
, val8
))
1037 /* GET Temperature (useful under APM) */
1038 case SONYPI_IOCGTEMP
:
1039 if (sonypi_ec_read(SONYPI_TEMP_STATUS
, &val8
)) {
1043 if (copy_to_user(argp
, &val8
, sizeof(val8
)))
1049 mutex_unlock(&sonypi_device
.lock
);
1053 static const struct file_operations sonypi_misc_fops
= {
1054 .owner
= THIS_MODULE
,
1055 .read
= sonypi_misc_read
,
1056 .poll
= sonypi_misc_poll
,
1057 .open
= sonypi_misc_open
,
1058 .release
= sonypi_misc_release
,
1059 .fasync
= sonypi_misc_fasync
,
1060 .unlocked_ioctl
= sonypi_misc_ioctl
,
1061 .llseek
= no_llseek
,
1064 static struct miscdevice sonypi_misc_device
= {
1065 .minor
= MISC_DYNAMIC_MINOR
,
1067 .fops
= &sonypi_misc_fops
,
1070 static void sonypi_enable(unsigned int camera_on
)
1072 switch (sonypi_device
.model
) {
1073 case SONYPI_DEVICE_MODEL_TYPE1
:
1076 case SONYPI_DEVICE_MODEL_TYPE2
:
1079 case SONYPI_DEVICE_MODEL_TYPE3
:
1085 sonypi_call2(0x81, 0xff);
1086 sonypi_call1(compat
? 0x92 : 0x82);
1088 /* Enable ACPI mode to get Fn key events */
1089 if (!SONYPI_ACPI_ACTIVE
&& fnkeyinit
)
1092 if (camera
&& camera_on
)
1096 static int sonypi_disable(void)
1098 sonypi_call2(0x81, 0); /* make sure we don't get any more events */
1100 sonypi_camera_off();
1102 /* disable ACPI mode */
1103 if (!SONYPI_ACPI_ACTIVE
&& fnkeyinit
)
1106 switch (sonypi_device
.model
) {
1107 case SONYPI_DEVICE_MODEL_TYPE1
:
1110 case SONYPI_DEVICE_MODEL_TYPE2
:
1113 case SONYPI_DEVICE_MODEL_TYPE3
:
1122 static int sonypi_acpi_add(struct acpi_device
*device
)
1124 sonypi_acpi_device
= device
;
1125 strcpy(acpi_device_name(device
), "Sony laptop hotkeys");
1126 strcpy(acpi_device_class(device
), "sony/hotkey");
1130 static int sonypi_acpi_remove(struct acpi_device
*device
, int type
)
1132 sonypi_acpi_device
= NULL
;
1136 static const struct acpi_device_id sonypi_device_ids
[] = {
1141 static struct acpi_driver sonypi_acpi_driver
= {
1144 .ids
= sonypi_device_ids
,
1146 .add
= sonypi_acpi_add
,
1147 .remove
= sonypi_acpi_remove
,
1152 static int __devinit
sonypi_create_input_devices(struct platform_device
*pdev
)
1154 struct input_dev
*jog_dev
;
1155 struct input_dev
*key_dev
;
1159 sonypi_device
.input_jog_dev
= jog_dev
= input_allocate_device();
1163 jog_dev
->name
= "Sony Vaio Jogdial";
1164 jog_dev
->id
.bustype
= BUS_ISA
;
1165 jog_dev
->id
.vendor
= PCI_VENDOR_ID_SONY
;
1166 jog_dev
->dev
.parent
= &pdev
->dev
;
1168 jog_dev
->evbit
[0] = BIT_MASK(EV_KEY
) | BIT_MASK(EV_REL
);
1169 jog_dev
->keybit
[BIT_WORD(BTN_MOUSE
)] = BIT_MASK(BTN_MIDDLE
);
1170 jog_dev
->relbit
[0] = BIT_MASK(REL_WHEEL
);
1172 sonypi_device
.input_key_dev
= key_dev
= input_allocate_device();
1175 goto err_free_jogdev
;
1178 key_dev
->name
= "Sony Vaio Keys";
1179 key_dev
->id
.bustype
= BUS_ISA
;
1180 key_dev
->id
.vendor
= PCI_VENDOR_ID_SONY
;
1181 key_dev
->dev
.parent
= &pdev
->dev
;
1183 /* Initialize the Input Drivers: special keys */
1184 key_dev
->evbit
[0] = BIT_MASK(EV_KEY
);
1185 for (i
= 0; sonypi_inputkeys
[i
].sonypiev
; i
++)
1186 if (sonypi_inputkeys
[i
].inputev
)
1187 set_bit(sonypi_inputkeys
[i
].inputev
, key_dev
->keybit
);
1189 error
= input_register_device(jog_dev
);
1191 goto err_free_keydev
;
1193 error
= input_register_device(key_dev
);
1195 goto err_unregister_jogdev
;
1199 err_unregister_jogdev
:
1200 input_unregister_device(jog_dev
);
1201 /* Set to NULL so we don't free it again below */
1204 input_free_device(key_dev
);
1205 sonypi_device
.input_key_dev
= NULL
;
1207 input_free_device(jog_dev
);
1208 sonypi_device
.input_jog_dev
= NULL
;
1213 static int __devinit
sonypi_setup_ioports(struct sonypi_device
*dev
,
1214 const struct sonypi_ioport_list
*ioport_list
)
1216 /* try to detect if sony-laptop is being used and thus
1217 * has already requested one of the known ioports.
1218 * As in the deprecated check_region this is racy has we have
1219 * multiple ioports available and one of them can be requested
1220 * between this check and the subsequent request. Anyway, as an
1221 * attempt to be some more user-friendly as we currently are,
1224 const struct sonypi_ioport_list
*check
= ioport_list
;
1225 while (check_ioport
&& check
->port1
) {
1226 if (!request_region(check
->port1
,
1227 sonypi_device
.region_size
,
1228 "Sony Programable I/O Device Check")) {
1229 printk(KERN_ERR
"sonypi: ioport 0x%.4x busy, using sony-laptop? "
1230 "if not use check_ioport=0\n",
1234 release_region(check
->port1
, sonypi_device
.region_size
);
1238 while (ioport_list
->port1
) {
1240 if (request_region(ioport_list
->port1
,
1241 sonypi_device
.region_size
,
1242 "Sony Programable I/O Device")) {
1243 dev
->ioport1
= ioport_list
->port1
;
1244 dev
->ioport2
= ioport_list
->port2
;
1253 static int __devinit
sonypi_setup_irq(struct sonypi_device
*dev
,
1254 const struct sonypi_irq_list
*irq_list
)
1256 while (irq_list
->irq
) {
1258 if (!request_irq(irq_list
->irq
, sonypi_irq
,
1259 IRQF_SHARED
, "sonypi", sonypi_irq
)) {
1260 dev
->irq
= irq_list
->irq
;
1261 dev
->bits
= irq_list
->bits
;
1270 static void __devinit
sonypi_display_info(void)
1272 printk(KERN_INFO
"sonypi: detected type%d model, "
1273 "verbose = %d, fnkeyinit = %s, camera = %s, "
1274 "compat = %s, mask = 0x%08lx, useinput = %s, acpi = %s\n",
1275 sonypi_device
.model
,
1277 fnkeyinit
? "on" : "off",
1278 camera
? "on" : "off",
1279 compat
? "on" : "off",
1281 useinput
? "on" : "off",
1282 SONYPI_ACPI_ACTIVE
? "on" : "off");
1283 printk(KERN_INFO
"sonypi: enabled at irq=%d, port1=0x%x, port2=0x%x\n",
1285 sonypi_device
.ioport1
, sonypi_device
.ioport2
);
1288 printk(KERN_INFO
"sonypi: device allocated minor is %d\n",
1289 sonypi_misc_device
.minor
);
1292 static int __devinit
sonypi_probe(struct platform_device
*dev
)
1294 const struct sonypi_ioport_list
*ioport_list
;
1295 const struct sonypi_irq_list
*irq_list
;
1296 struct pci_dev
*pcidev
;
1299 printk(KERN_WARNING
"sonypi: please try the sony-laptop module instead "
1300 "and report failures, see also "
1301 "http://www.linux.it/~malattia/wiki/index.php/Sony_drivers\n");
1303 spin_lock_init(&sonypi_device
.fifo_lock
);
1304 error
= kfifo_alloc(&sonypi_device
.fifo
, SONYPI_BUF_SIZE
, GFP_KERNEL
);
1306 printk(KERN_ERR
"sonypi: kfifo_alloc failed\n");
1310 init_waitqueue_head(&sonypi_device
.fifo_proc_list
);
1311 mutex_init(&sonypi_device
.lock
);
1312 sonypi_device
.bluetooth_power
= -1;
1314 if ((pcidev
= pci_get_device(PCI_VENDOR_ID_INTEL
,
1315 PCI_DEVICE_ID_INTEL_82371AB_3
, NULL
)))
1316 sonypi_device
.model
= SONYPI_DEVICE_MODEL_TYPE1
;
1317 else if ((pcidev
= pci_get_device(PCI_VENDOR_ID_INTEL
,
1318 PCI_DEVICE_ID_INTEL_ICH6_1
, NULL
)))
1319 sonypi_device
.model
= SONYPI_DEVICE_MODEL_TYPE3
;
1320 else if ((pcidev
= pci_get_device(PCI_VENDOR_ID_INTEL
,
1321 PCI_DEVICE_ID_INTEL_ICH7_1
, NULL
)))
1322 sonypi_device
.model
= SONYPI_DEVICE_MODEL_TYPE3
;
1324 sonypi_device
.model
= SONYPI_DEVICE_MODEL_TYPE2
;
1326 if (pcidev
&& pci_enable_device(pcidev
)) {
1327 printk(KERN_ERR
"sonypi: pci_enable_device failed\n");
1329 goto err_put_pcidev
;
1332 sonypi_device
.dev
= pcidev
;
1334 if (sonypi_device
.model
== SONYPI_DEVICE_MODEL_TYPE1
) {
1335 ioport_list
= sonypi_type1_ioport_list
;
1336 sonypi_device
.region_size
= SONYPI_TYPE1_REGION_SIZE
;
1337 sonypi_device
.evtype_offset
= SONYPI_TYPE1_EVTYPE_OFFSET
;
1338 irq_list
= sonypi_type1_irq_list
;
1339 } else if (sonypi_device
.model
== SONYPI_DEVICE_MODEL_TYPE2
) {
1340 ioport_list
= sonypi_type2_ioport_list
;
1341 sonypi_device
.region_size
= SONYPI_TYPE2_REGION_SIZE
;
1342 sonypi_device
.evtype_offset
= SONYPI_TYPE2_EVTYPE_OFFSET
;
1343 irq_list
= sonypi_type2_irq_list
;
1345 ioport_list
= sonypi_type3_ioport_list
;
1346 sonypi_device
.region_size
= SONYPI_TYPE3_REGION_SIZE
;
1347 sonypi_device
.evtype_offset
= SONYPI_TYPE3_EVTYPE_OFFSET
;
1348 irq_list
= sonypi_type3_irq_list
;
1351 error
= sonypi_setup_ioports(&sonypi_device
, ioport_list
);
1353 printk(KERN_ERR
"sonypi: failed to request ioports\n");
1354 goto err_disable_pcidev
;
1357 error
= sonypi_setup_irq(&sonypi_device
, irq_list
);
1359 printk(KERN_ERR
"sonypi: request_irq failed\n");
1360 goto err_free_ioports
;
1364 sonypi_misc_device
.minor
= minor
;
1365 error
= misc_register(&sonypi_misc_device
);
1367 printk(KERN_ERR
"sonypi: misc_register failed\n");
1371 sonypi_display_info();
1375 error
= sonypi_create_input_devices(dev
);
1378 "sonypi: failed to create input devices\n");
1379 goto err_miscdev_unregister
;
1382 spin_lock_init(&sonypi_device
.input_fifo_lock
);
1383 error
= kfifo_alloc(&sonypi_device
.input_fifo
, SONYPI_BUF_SIZE
,
1386 printk(KERN_ERR
"sonypi: kfifo_alloc failed\n");
1387 goto err_inpdev_unregister
;
1390 INIT_WORK(&sonypi_device
.input_work
, input_keyrelease
);
1397 err_inpdev_unregister
:
1398 input_unregister_device(sonypi_device
.input_key_dev
);
1399 input_unregister_device(sonypi_device
.input_jog_dev
);
1400 err_miscdev_unregister
:
1401 misc_deregister(&sonypi_misc_device
);
1403 free_irq(sonypi_device
.irq
, sonypi_irq
);
1405 release_region(sonypi_device
.ioport1
, sonypi_device
.region_size
);
1408 pci_disable_device(pcidev
);
1410 pci_dev_put(pcidev
);
1411 kfifo_free(&sonypi_device
.fifo
);
1416 static int __devexit
sonypi_remove(struct platform_device
*dev
)
1420 synchronize_irq(sonypi_device
.irq
);
1421 flush_scheduled_work();
1424 input_unregister_device(sonypi_device
.input_key_dev
);
1425 input_unregister_device(sonypi_device
.input_jog_dev
);
1426 kfifo_free(&sonypi_device
.input_fifo
);
1429 misc_deregister(&sonypi_misc_device
);
1431 free_irq(sonypi_device
.irq
, sonypi_irq
);
1432 release_region(sonypi_device
.ioport1
, sonypi_device
.region_size
);
1434 if (sonypi_device
.dev
) {
1435 pci_disable_device(sonypi_device
.dev
);
1436 pci_dev_put(sonypi_device
.dev
);
1439 kfifo_free(&sonypi_device
.fifo
);
1445 static int old_camera_power
;
1447 static int sonypi_suspend(struct platform_device
*dev
, pm_message_t state
)
1449 old_camera_power
= sonypi_device
.camera_power
;
1455 static int sonypi_resume(struct platform_device
*dev
)
1457 sonypi_enable(old_camera_power
);
1461 #define sonypi_suspend NULL
1462 #define sonypi_resume NULL
1465 static void sonypi_shutdown(struct platform_device
*dev
)
1470 static struct platform_driver sonypi_driver
= {
1473 .owner
= THIS_MODULE
,
1475 .probe
= sonypi_probe
,
1476 .remove
= __devexit_p(sonypi_remove
),
1477 .shutdown
= sonypi_shutdown
,
1478 .suspend
= sonypi_suspend
,
1479 .resume
= sonypi_resume
,
1482 static struct platform_device
*sonypi_platform_device
;
1484 static struct dmi_system_id __initdata sonypi_dmi_table
[] = {
1486 .ident
= "Sony Vaio",
1488 DMI_MATCH(DMI_SYS_VENDOR
, "Sony Corporation"),
1489 DMI_MATCH(DMI_PRODUCT_NAME
, "PCG-"),
1493 .ident
= "Sony Vaio",
1495 DMI_MATCH(DMI_SYS_VENDOR
, "Sony Corporation"),
1496 DMI_MATCH(DMI_PRODUCT_NAME
, "VGN-"),
1502 static int __init
sonypi_init(void)
1507 "sonypi: Sony Programmable I/O Controller Driver v%s.\n",
1508 SONYPI_DRIVER_VERSION
);
1510 if (!dmi_check_system(sonypi_dmi_table
))
1513 error
= platform_driver_register(&sonypi_driver
);
1517 sonypi_platform_device
= platform_device_alloc("sonypi", -1);
1518 if (!sonypi_platform_device
) {
1520 goto err_driver_unregister
;
1523 error
= platform_device_add(sonypi_platform_device
);
1525 goto err_free_device
;
1528 if (acpi_bus_register_driver(&sonypi_acpi_driver
) >= 0)
1529 acpi_driver_registered
= 1;
1535 platform_device_put(sonypi_platform_device
);
1536 err_driver_unregister
:
1537 platform_driver_unregister(&sonypi_driver
);
1541 static void __exit
sonypi_exit(void)
1544 if (acpi_driver_registered
)
1545 acpi_bus_unregister_driver(&sonypi_acpi_driver
);
1547 platform_device_unregister(sonypi_platform_device
);
1548 platform_driver_unregister(&sonypi_driver
);
1549 printk(KERN_INFO
"sonypi: removed.\n");
1552 module_init(sonypi_init
);
1553 module_exit(sonypi_exit
);