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