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