1 /* 2 * ACPI Sony Notebook Control Driver (SNC and SPIC) 3 * 4 * Copyright (C) 2004-2005 Stelian Pop <stelian@popies.net> 5 * Copyright (C) 2007-2009 Mattia Dongili <malattia@linux.it> 6 * 7 * Parts of this driver inspired from asus_acpi.c and ibm_acpi.c 8 * which are copyrighted by their respective authors. 9 * 10 * The SNY6001 driver part is based on the sonypi driver which includes 11 * material from: 12 * 13 * Copyright (C) 2001-2005 Stelian Pop <stelian@popies.net> 14 * 15 * Copyright (C) 2005 Narayanan R S <nars@kadamba.org> 16 * 17 * Copyright (C) 2001-2002 Alcôve <www.alcove.com> 18 * 19 * Copyright (C) 2001 Michael Ashley <m.ashley@unsw.edu.au> 20 * 21 * Copyright (C) 2001 Junichi Morita <jun1m@mars.dti.ne.jp> 22 * 23 * Copyright (C) 2000 Takaya Kinjo <t-kinjo@tc4.so-net.ne.jp> 24 * 25 * Copyright (C) 2000 Andrew Tridgell <tridge@valinux.com> 26 * 27 * Earlier work by Werner Almesberger, Paul `Rusty' Russell and Paul Mackerras. 28 * 29 * This program is free software; you can redistribute it and/or modify 30 * it under the terms of the GNU General Public License as published by 31 * the Free Software Foundation; either version 2 of the License, or 32 * (at your option) any later version. 33 * 34 * This program is distributed in the hope that it will be useful, 35 * but WITHOUT ANY WARRANTY; without even the implied warranty of 36 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 37 * GNU General Public License for more details. 38 * 39 * You should have received a copy of the GNU General Public License 40 * along with this program; if not, write to the Free Software 41 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 42 * 43 */ 44 45 #include <linux/kernel.h> 46 #include <linux/module.h> 47 #include <linux/moduleparam.h> 48 #include <linux/init.h> 49 #include <linux/types.h> 50 #include <linux/backlight.h> 51 #include <linux/platform_device.h> 52 #include <linux/err.h> 53 #include <linux/dmi.h> 54 #include <linux/pci.h> 55 #include <linux/interrupt.h> 56 #include <linux/delay.h> 57 #include <linux/input.h> 58 #include <linux/kfifo.h> 59 #include <linux/workqueue.h> 60 #include <linux/acpi.h> 61 #include <linux/slab.h> 62 #include <acpi/acpi_drivers.h> 63 #include <acpi/acpi_bus.h> 64 #include <asm/uaccess.h> 65 #include <linux/sonypi.h> 66 #include <linux/sony-laptop.h> 67 #include <linux/rfkill.h> 68 #ifdef CONFIG_SONYPI_COMPAT 69 #include <linux/poll.h> 70 #include <linux/miscdevice.h> 71 #endif 72 73 #define DRV_PFX "sony-laptop: " 74 #define dprintk(msg...) do { \ 75 if (debug) printk(KERN_WARNING DRV_PFX msg); \ 76 } while (0) 77 78 #define SONY_LAPTOP_DRIVER_VERSION "0.6" 79 80 #define SONY_NC_CLASS "sony-nc" 81 #define SONY_NC_HID "SNY5001" 82 #define SONY_NC_DRIVER_NAME "Sony Notebook Control Driver" 83 84 #define SONY_PIC_CLASS "sony-pic" 85 #define SONY_PIC_HID "SNY6001" 86 #define SONY_PIC_DRIVER_NAME "Sony Programmable IO Control Driver" 87 88 MODULE_AUTHOR("Stelian Pop, Mattia Dongili"); 89 MODULE_DESCRIPTION("Sony laptop extras driver (SPIC and SNC ACPI device)"); 90 MODULE_LICENSE("GPL"); 91 MODULE_VERSION(SONY_LAPTOP_DRIVER_VERSION); 92 93 static int debug; 94 module_param(debug, int, 0); 95 MODULE_PARM_DESC(debug, "set this to 1 (and RTFM) if you want to help " 96 "the development of this driver"); 97 98 static int no_spic; /* = 0 */ 99 module_param(no_spic, int, 0444); 100 MODULE_PARM_DESC(no_spic, 101 "set this if you don't want to enable the SPIC device"); 102 103 static int compat; /* = 0 */ 104 module_param(compat, int, 0444); 105 MODULE_PARM_DESC(compat, 106 "set this if you want to enable backward compatibility mode"); 107 108 static unsigned long mask = 0xffffffff; 109 module_param(mask, ulong, 0644); 110 MODULE_PARM_DESC(mask, 111 "set this to the mask of event you want to enable (see doc)"); 112 113 static int camera; /* = 0 */ 114 module_param(camera, int, 0444); 115 MODULE_PARM_DESC(camera, 116 "set this to 1 to enable Motion Eye camera controls " 117 "(only use it if you have a C1VE or C1VN model)"); 118 119 #ifdef CONFIG_SONYPI_COMPAT 120 static int minor = -1; 121 module_param(minor, int, 0); 122 MODULE_PARM_DESC(minor, 123 "minor number of the misc device for the SPIC compatibility code, " 124 "default is -1 (automatic)"); 125 #endif 126 127 enum sony_nc_rfkill { 128 SONY_WIFI, 129 SONY_BLUETOOTH, 130 SONY_WWAN, 131 SONY_WIMAX, 132 N_SONY_RFKILL, 133 }; 134 135 static int sony_rfkill_handle; 136 static struct rfkill *sony_rfkill_devices[N_SONY_RFKILL]; 137 static int sony_rfkill_address[N_SONY_RFKILL] = {0x300, 0x500, 0x700, 0x900}; 138 static void sony_nc_rfkill_update(void); 139 140 /*********** Input Devices ***********/ 141 142 #define SONY_LAPTOP_BUF_SIZE 128 143 struct sony_laptop_input_s { 144 atomic_t users; 145 struct input_dev *jog_dev; 146 struct input_dev *key_dev; 147 struct kfifo fifo; 148 spinlock_t fifo_lock; 149 struct timer_list release_key_timer; 150 }; 151 152 static struct sony_laptop_input_s sony_laptop_input = { 153 .users = ATOMIC_INIT(0), 154 }; 155 156 struct sony_laptop_keypress { 157 struct input_dev *dev; 158 int key; 159 }; 160 161 /* Correspondance table between sonypi events 162 * and input layer indexes in the keymap 163 */ 164 static int sony_laptop_input_index[] = { 165 -1, /* 0 no event */ 166 -1, /* 1 SONYPI_EVENT_JOGDIAL_DOWN */ 167 -1, /* 2 SONYPI_EVENT_JOGDIAL_UP */ 168 -1, /* 3 SONYPI_EVENT_JOGDIAL_DOWN_PRESSED */ 169 -1, /* 4 SONYPI_EVENT_JOGDIAL_UP_PRESSED */ 170 -1, /* 5 SONYPI_EVENT_JOGDIAL_PRESSED */ 171 -1, /* 6 SONYPI_EVENT_JOGDIAL_RELEASED */ 172 0, /* 7 SONYPI_EVENT_CAPTURE_PRESSED */ 173 1, /* 8 SONYPI_EVENT_CAPTURE_RELEASED */ 174 2, /* 9 SONYPI_EVENT_CAPTURE_PARTIALPRESSED */ 175 3, /* 10 SONYPI_EVENT_CAPTURE_PARTIALRELEASED */ 176 4, /* 11 SONYPI_EVENT_FNKEY_ESC */ 177 5, /* 12 SONYPI_EVENT_FNKEY_F1 */ 178 6, /* 13 SONYPI_EVENT_FNKEY_F2 */ 179 7, /* 14 SONYPI_EVENT_FNKEY_F3 */ 180 8, /* 15 SONYPI_EVENT_FNKEY_F4 */ 181 9, /* 16 SONYPI_EVENT_FNKEY_F5 */ 182 10, /* 17 SONYPI_EVENT_FNKEY_F6 */ 183 11, /* 18 SONYPI_EVENT_FNKEY_F7 */ 184 12, /* 19 SONYPI_EVENT_FNKEY_F8 */ 185 13, /* 20 SONYPI_EVENT_FNKEY_F9 */ 186 14, /* 21 SONYPI_EVENT_FNKEY_F10 */ 187 15, /* 22 SONYPI_EVENT_FNKEY_F11 */ 188 16, /* 23 SONYPI_EVENT_FNKEY_F12 */ 189 17, /* 24 SONYPI_EVENT_FNKEY_1 */ 190 18, /* 25 SONYPI_EVENT_FNKEY_2 */ 191 19, /* 26 SONYPI_EVENT_FNKEY_D */ 192 20, /* 27 SONYPI_EVENT_FNKEY_E */ 193 21, /* 28 SONYPI_EVENT_FNKEY_F */ 194 22, /* 29 SONYPI_EVENT_FNKEY_S */ 195 23, /* 30 SONYPI_EVENT_FNKEY_B */ 196 24, /* 31 SONYPI_EVENT_BLUETOOTH_PRESSED */ 197 25, /* 32 SONYPI_EVENT_PKEY_P1 */ 198 26, /* 33 SONYPI_EVENT_PKEY_P2 */ 199 27, /* 34 SONYPI_EVENT_PKEY_P3 */ 200 28, /* 35 SONYPI_EVENT_BACK_PRESSED */ 201 -1, /* 36 SONYPI_EVENT_LID_CLOSED */ 202 -1, /* 37 SONYPI_EVENT_LID_OPENED */ 203 29, /* 38 SONYPI_EVENT_BLUETOOTH_ON */ 204 30, /* 39 SONYPI_EVENT_BLUETOOTH_OFF */ 205 31, /* 40 SONYPI_EVENT_HELP_PRESSED */ 206 32, /* 41 SONYPI_EVENT_FNKEY_ONLY */ 207 33, /* 42 SONYPI_EVENT_JOGDIAL_FAST_DOWN */ 208 34, /* 43 SONYPI_EVENT_JOGDIAL_FAST_UP */ 209 35, /* 44 SONYPI_EVENT_JOGDIAL_FAST_DOWN_PRESSED */ 210 36, /* 45 SONYPI_EVENT_JOGDIAL_FAST_UP_PRESSED */ 211 37, /* 46 SONYPI_EVENT_JOGDIAL_VFAST_DOWN */ 212 38, /* 47 SONYPI_EVENT_JOGDIAL_VFAST_UP */ 213 39, /* 48 SONYPI_EVENT_JOGDIAL_VFAST_DOWN_PRESSED */ 214 40, /* 49 SONYPI_EVENT_JOGDIAL_VFAST_UP_PRESSED */ 215 41, /* 50 SONYPI_EVENT_ZOOM_PRESSED */ 216 42, /* 51 SONYPI_EVENT_THUMBPHRASE_PRESSED */ 217 43, /* 52 SONYPI_EVENT_MEYE_FACE */ 218 44, /* 53 SONYPI_EVENT_MEYE_OPPOSITE */ 219 45, /* 54 SONYPI_EVENT_MEMORYSTICK_INSERT */ 220 46, /* 55 SONYPI_EVENT_MEMORYSTICK_EJECT */ 221 -1, /* 56 SONYPI_EVENT_ANYBUTTON_RELEASED */ 222 -1, /* 57 SONYPI_EVENT_BATTERY_INSERT */ 223 -1, /* 58 SONYPI_EVENT_BATTERY_REMOVE */ 224 -1, /* 59 SONYPI_EVENT_FNKEY_RELEASED */ 225 47, /* 60 SONYPI_EVENT_WIRELESS_ON */ 226 48, /* 61 SONYPI_EVENT_WIRELESS_OFF */ 227 49, /* 62 SONYPI_EVENT_ZOOM_IN_PRESSED */ 228 50, /* 63 SONYPI_EVENT_ZOOM_OUT_PRESSED */ 229 51, /* 64 SONYPI_EVENT_CD_EJECT_PRESSED */ 230 52, /* 65 SONYPI_EVENT_MODEKEY_PRESSED */ 231 53, /* 66 SONYPI_EVENT_PKEY_P4 */ 232 54, /* 67 SONYPI_EVENT_PKEY_P5 */ 233 55, /* 68 SONYPI_EVENT_SETTINGKEY_PRESSED */ 234 56, /* 69 SONYPI_EVENT_VOLUME_INC_PRESSED */ 235 57, /* 70 SONYPI_EVENT_VOLUME_DEC_PRESSED */ 236 -1, /* 71 SONYPI_EVENT_BRIGHTNESS_PRESSED */ 237 58, /* 72 SONYPI_EVENT_MEDIA_PRESSED */ 238 }; 239 240 static 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 */ 303 static 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 */ 325 static 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 387 static 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 462 err_free_jogdev: 463 input_free_device(jog_dev); 464 465 err_unregister_keydev: 466 input_unregister_device(key_dev); 467 /* to avoid kref underflow below at input_free_device */ 468 key_dev = NULL; 469 470 err_free_keydev: 471 input_free_device(key_dev); 472 473 err_free_kfifo: 474 kfifo_free(&sony_laptop_input.fifo); 475 476 err_dec_users: 477 atomic_dec(&sony_laptop_input.users); 478 return error; 479 } 480 481 static 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 515 static atomic_t sony_pf_users = ATOMIC_INIT(0); 516 static struct platform_driver sony_pf_driver = { 517 .driver = { 518 .name = "sony-laptop", 519 .owner = THIS_MODULE, 520 } 521 }; 522 static struct platform_device *sony_pf_device; 523 524 static 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 558 static 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 577 static ssize_t sony_nc_sysfs_show(struct device *, struct device_attribute *, 578 char *); 579 static ssize_t sony_nc_sysfs_store(struct device *, struct device_attribute *, 580 const char *, size_t); 581 static int boolean_validate(const int, const int); 582 static int brightness_default_validate(const int, const int); 583 584 struct 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 610 SNC_HANDLE_NAMES(fnkey_get, "GHKE"); 611 612 SNC_HANDLE_NAMES(brightness_def_get, "GPBR"); 613 SNC_HANDLE_NAMES(brightness_def_set, "SPBR"); 614 615 SNC_HANDLE_NAMES(cdpower_get, "GCDP"); 616 SNC_HANDLE_NAMES(cdpower_set, "SCDP", "CDPW"); 617 618 SNC_HANDLE_NAMES(audiopower_get, "GAZP"); 619 SNC_HANDLE_NAMES(audiopower_set, "AZPW"); 620 621 SNC_HANDLE_NAMES(lanpower_get, "GLNP"); 622 SNC_HANDLE_NAMES(lanpower_set, "LNPW"); 623 624 SNC_HANDLE_NAMES(lidstate_get, "GLID"); 625 626 SNC_HANDLE_NAMES(indicatorlamp_get, "GILS"); 627 SNC_HANDLE_NAMES(indicatorlamp_set, "SILS"); 628 629 SNC_HANDLE_NAMES(gainbass_get, "GMGB"); 630 SNC_HANDLE_NAMES(gainbass_set, "CMGB"); 631 632 SNC_HANDLE_NAMES(PID_get, "GPID"); 633 634 SNC_HANDLE_NAMES(CTR_get, "GCTR"); 635 SNC_HANDLE_NAMES(CTR_set, "SCTR"); 636 637 SNC_HANDLE_NAMES(PCR_get, "GPCR"); 638 SNC_HANDLE_NAMES(PCR_set, "SPCR"); 639 640 SNC_HANDLE_NAMES(CMI_get, "GCMI"); 641 SNC_HANDLE_NAMES(CMI_set, "SCMI"); 642 643 static 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 666 static acpi_handle sony_nc_acpi_handle; 667 static struct acpi_device *sony_nc_acpi_device = NULL; 668 669 /* 670 * acpi_evaluate_object wrappers 671 */ 672 static 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 692 static 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 727 static 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 741 static 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 */ 761 static 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 */ 778 static 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 */ 790 static 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 809 static 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 */ 842 static 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 848 static 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 858 static struct backlight_device *sony_backlight_device; 859 static 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 */ 867 struct sony_nc_event { 868 u8 data; 869 u8 event; 870 }; 871 872 static 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 904 static 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 */ 925 static 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 983 static 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 */ 1001 static 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 1017 static 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 1058 static 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 1070 static 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 1081 static const struct rfkill_ops sony_rfkill_ops = { 1082 .set_block = sony_nc_rfkill_set, 1083 }; 1084 1085 static 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 1134 static 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 1162 static 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 1233 out_no_enum: 1234 kfree(buffer.pointer); 1235 return; 1236 } 1237 1238 static 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 1379 static 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 1400 static const struct acpi_device_id sony_device_ids[] = { 1401 {SONY_NC_HID, 0}, 1402 {SONY_PIC_HID, 0}, 1403 {"", 0}, 1404 }; 1405 MODULE_DEVICE_TABLE(acpi, sony_device_ids); 1406 1407 static const struct acpi_device_id sony_nc_device_ids[] = { 1408 {SONY_NC_HID, 0}, 1409 {"", 0}, 1410 }; 1411 1412 static 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 1436 struct sony_pic_ioport { 1437 struct acpi_resource_io io1; 1438 struct acpi_resource_io io2; 1439 struct list_head list; 1440 }; 1441 1442 struct sony_pic_irq { 1443 struct acpi_resource_irq irq; 1444 struct list_head list; 1445 }; 1446 1447 struct sonypi_eventtypes { 1448 u8 data; 1449 unsigned long mask; 1450 struct sonypi_event *events; 1451 }; 1452 1453 struct 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 1469 static struct sony_pic_dev spic_dev = { 1470 .interrupts = LIST_HEAD_INIT(spic_dev.interrupts), 1471 .ioports = LIST_HEAD_INIT(spic_dev.ioports), 1472 }; 1473 1474 static 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 1492 struct sonypi_event { 1493 u8 data; 1494 u8 event; 1495 }; 1496 1497 /* The set of possible button release events */ 1498 static struct sonypi_event sonypi_releaseev[] = { 1499 { 0x00, SONYPI_EVENT_ANYBUTTON_RELEASED }, 1500 { 0, 0 } 1501 }; 1502 1503 /* The set of possible jogger events */ 1504 static 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 */ 1522 static 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 */ 1531 static 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 */ 1558 static 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 */ 1567 static 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 */ 1575 static 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 */ 1582 static struct sonypi_event sonypi_backev[] = { 1583 { 0x20, SONYPI_EVENT_BACK_PRESSED }, 1584 { 0, 0 } 1585 }; 1586 1587 /* The set of possible help button events */ 1588 static struct sonypi_event sonypi_helpev[] = { 1589 { 0x3b, SONYPI_EVENT_HELP_PRESSED }, 1590 { 0, 0 } 1591 }; 1592 1593 1594 /* The set of possible lid events */ 1595 static 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 */ 1602 static 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 */ 1611 static struct sonypi_event sonypi_thumbphraseev[] = { 1612 { 0x3a, SONYPI_EVENT_THUMBPHRASE_PRESSED }, 1613 { 0, 0 } 1614 }; 1615 1616 /* The set of possible motioneye camera events */ 1617 static 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 */ 1624 static 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 */ 1631 static 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 */ 1638 static 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 */ 1645 static struct sonypi_event sonypi_brightnessev[] = { 1646 { 0x80, SONYPI_EVENT_BRIGHTNESS_PRESSED }, 1647 { 0, 0 } 1648 }; 1649 1650 static 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 }; 1663 static 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 }; 1680 static 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 1707 static 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 1720 static 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 1735 static 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 */ 1754 static 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 1773 static 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 1830 out: 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 1871 static 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 1879 static 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 1897 static 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) */ 1938 int 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 } 1988 EXPORT_SYMBOL(sony_pic_camera_command); 1989 1990 /* gprs/edge modem (SZ460N and SZ210P), thanks to Joshua Wise */ 1991 static 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 2001 static 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 2017 static 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 */ 2028 static 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 2038 static 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 2054 static 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 2067 static int sony_pic_set_fanspeed(unsigned long value) 2068 { 2069 return ec_write(SONY_PIC_FAN0_STATUS, value); 2070 } 2071 2072 static int sony_pic_get_fanspeed(u8 *value) 2073 { 2074 return ec_read(SONY_PIC_FAN0_STATUS, value); 2075 } 2076 2077 static 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 2092 static 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) \ 2103 struct device_attribute spic_attr_##_name = __ATTR(_name, \ 2104 _mode, sony_pic_## _name ##_show, \ 2105 sony_pic_## _name ##_store) 2106 2107 static SPIC_ATTR(bluetoothpower, 0644); 2108 static SPIC_ATTR(wwanpower, 0644); 2109 static SPIC_ATTR(fanspeed, 0644); 2110 2111 static struct attribute *spic_attributes[] = { 2112 &spic_attr_bluetoothpower.attr, 2113 &spic_attr_wwanpower.attr, 2114 &spic_attr_fanspeed.attr, 2115 NULL 2116 }; 2117 2118 static 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 2140 struct 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 }; 2147 static struct sonypi_compat_s sonypi_compat = { 2148 .open_count = ATOMIC_INIT(0), 2149 }; 2150 2151 static 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 2156 static int sonypi_misc_release(struct inode *inode, struct file *file) 2157 { 2158 atomic_dec(&sonypi_compat.open_count); 2159 return 0; 2160 } 2161 2162 static 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 2177 static 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 2208 static 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 2216 static 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 2227 static 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 2355 static 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 .llseek = noop_llseek, 2364 }; 2365 2366 static struct miscdevice sonypi_misc_device = { 2367 .minor = MISC_DYNAMIC_MINOR, 2368 .name = "sonypi", 2369 .fops = &sonypi_misc_fops, 2370 }; 2371 2372 static void sonypi_compat_report_event(u8 event) 2373 { 2374 kfifo_in_locked(&sonypi_compat.fifo, (unsigned char *)&event, 2375 sizeof(event), &sonypi_compat.fifo_lock); 2376 kill_fasync(&sonypi_compat.fifo_async, SIGIO, POLL_IN); 2377 wake_up_interruptible(&sonypi_compat.fifo_proc_list); 2378 } 2379 2380 static int sonypi_compat_init(void) 2381 { 2382 int error; 2383 2384 spin_lock_init(&sonypi_compat.fifo_lock); 2385 error = 2386 kfifo_alloc(&sonypi_compat.fifo, SONY_LAPTOP_BUF_SIZE, GFP_KERNEL); 2387 if (error) { 2388 printk(KERN_ERR DRV_PFX "kfifo_alloc failed\n"); 2389 return error; 2390 } 2391 2392 init_waitqueue_head(&sonypi_compat.fifo_proc_list); 2393 2394 if (minor != -1) 2395 sonypi_misc_device.minor = minor; 2396 error = misc_register(&sonypi_misc_device); 2397 if (error) { 2398 printk(KERN_ERR DRV_PFX "misc_register failed\n"); 2399 goto err_free_kfifo; 2400 } 2401 if (minor == -1) 2402 printk(KERN_INFO DRV_PFX "device allocated minor is %d\n", 2403 sonypi_misc_device.minor); 2404 2405 return 0; 2406 2407 err_free_kfifo: 2408 kfifo_free(&sonypi_compat.fifo); 2409 return error; 2410 } 2411 2412 static void sonypi_compat_exit(void) 2413 { 2414 misc_deregister(&sonypi_misc_device); 2415 kfifo_free(&sonypi_compat.fifo); 2416 } 2417 #else 2418 static int sonypi_compat_init(void) { return 0; } 2419 static void sonypi_compat_exit(void) { } 2420 static void sonypi_compat_report_event(u8 event) { } 2421 #endif /* CONFIG_SONYPI_COMPAT */ 2422 2423 /* 2424 * ACPI callbacks 2425 */ 2426 static acpi_status 2427 sony_pic_read_possible_resource(struct acpi_resource *resource, void *context) 2428 { 2429 u32 i; 2430 struct sony_pic_dev *dev = (struct sony_pic_dev *)context; 2431 2432 switch (resource->type) { 2433 case ACPI_RESOURCE_TYPE_START_DEPENDENT: 2434 { 2435 /* start IO enumeration */ 2436 struct sony_pic_ioport *ioport = kzalloc(sizeof(*ioport), GFP_KERNEL); 2437 if (!ioport) 2438 return AE_ERROR; 2439 2440 list_add(&ioport->list, &dev->ioports); 2441 return AE_OK; 2442 } 2443 2444 case ACPI_RESOURCE_TYPE_END_DEPENDENT: 2445 /* end IO enumeration */ 2446 return AE_OK; 2447 2448 case ACPI_RESOURCE_TYPE_IRQ: 2449 { 2450 struct acpi_resource_irq *p = &resource->data.irq; 2451 struct sony_pic_irq *interrupt = NULL; 2452 if (!p || !p->interrupt_count) { 2453 /* 2454 * IRQ descriptors may have no IRQ# bits set, 2455 * particularly those those w/ _STA disabled 2456 */ 2457 dprintk("Blank IRQ resource\n"); 2458 return AE_OK; 2459 } 2460 for (i = 0; i < p->interrupt_count; i++) { 2461 if (!p->interrupts[i]) { 2462 printk(KERN_WARNING DRV_PFX 2463 "Invalid IRQ %d\n", 2464 p->interrupts[i]); 2465 continue; 2466 } 2467 interrupt = kzalloc(sizeof(*interrupt), 2468 GFP_KERNEL); 2469 if (!interrupt) 2470 return AE_ERROR; 2471 2472 list_add(&interrupt->list, &dev->interrupts); 2473 interrupt->irq.triggering = p->triggering; 2474 interrupt->irq.polarity = p->polarity; 2475 interrupt->irq.sharable = p->sharable; 2476 interrupt->irq.interrupt_count = 1; 2477 interrupt->irq.interrupts[0] = p->interrupts[i]; 2478 } 2479 return AE_OK; 2480 } 2481 case ACPI_RESOURCE_TYPE_IO: 2482 { 2483 struct acpi_resource_io *io = &resource->data.io; 2484 struct sony_pic_ioport *ioport = 2485 list_first_entry(&dev->ioports, struct sony_pic_ioport, list); 2486 if (!io) { 2487 dprintk("Blank IO resource\n"); 2488 return AE_OK; 2489 } 2490 2491 if (!ioport->io1.minimum) { 2492 memcpy(&ioport->io1, io, sizeof(*io)); 2493 dprintk("IO1 at 0x%.4x (0x%.2x)\n", ioport->io1.minimum, 2494 ioport->io1.address_length); 2495 } 2496 else if (!ioport->io2.minimum) { 2497 memcpy(&ioport->io2, io, sizeof(*io)); 2498 dprintk("IO2 at 0x%.4x (0x%.2x)\n", ioport->io2.minimum, 2499 ioport->io2.address_length); 2500 } 2501 else { 2502 printk(KERN_ERR DRV_PFX "Unknown SPIC Type, more than 2 IO Ports\n"); 2503 return AE_ERROR; 2504 } 2505 return AE_OK; 2506 } 2507 default: 2508 dprintk("Resource %d isn't an IRQ nor an IO port\n", 2509 resource->type); 2510 2511 case ACPI_RESOURCE_TYPE_END_TAG: 2512 return AE_OK; 2513 } 2514 return AE_CTRL_TERMINATE; 2515 } 2516 2517 static int sony_pic_possible_resources(struct acpi_device *device) 2518 { 2519 int result = 0; 2520 acpi_status status = AE_OK; 2521 2522 if (!device) 2523 return -EINVAL; 2524 2525 /* get device status */ 2526 /* see acpi_pci_link_get_current acpi_pci_link_get_possible */ 2527 dprintk("Evaluating _STA\n"); 2528 result = acpi_bus_get_status(device); 2529 if (result) { 2530 printk(KERN_WARNING DRV_PFX "Unable to read status\n"); 2531 goto end; 2532 } 2533 2534 if (!device->status.enabled) 2535 dprintk("Device disabled\n"); 2536 else 2537 dprintk("Device enabled\n"); 2538 2539 /* 2540 * Query and parse 'method' 2541 */ 2542 dprintk("Evaluating %s\n", METHOD_NAME__PRS); 2543 status = acpi_walk_resources(device->handle, METHOD_NAME__PRS, 2544 sony_pic_read_possible_resource, &spic_dev); 2545 if (ACPI_FAILURE(status)) { 2546 printk(KERN_WARNING DRV_PFX 2547 "Failure evaluating %s\n", 2548 METHOD_NAME__PRS); 2549 result = -ENODEV; 2550 } 2551 end: 2552 return result; 2553 } 2554 2555 /* 2556 * Disable the spic device by calling its _DIS method 2557 */ 2558 static int sony_pic_disable(struct acpi_device *device) 2559 { 2560 acpi_status ret = acpi_evaluate_object(device->handle, "_DIS", NULL, 2561 NULL); 2562 2563 if (ACPI_FAILURE(ret) && ret != AE_NOT_FOUND) 2564 return -ENXIO; 2565 2566 dprintk("Device disabled\n"); 2567 return 0; 2568 } 2569 2570 2571 /* 2572 * Based on drivers/acpi/pci_link.c:acpi_pci_link_set 2573 * 2574 * Call _SRS to set current resources 2575 */ 2576 static int sony_pic_enable(struct acpi_device *device, 2577 struct sony_pic_ioport *ioport, struct sony_pic_irq *irq) 2578 { 2579 acpi_status status; 2580 int result = 0; 2581 /* Type 1 resource layout is: 2582 * IO 2583 * IO 2584 * IRQNoFlags 2585 * End 2586 * 2587 * Type 2 and 3 resource layout is: 2588 * IO 2589 * IRQNoFlags 2590 * End 2591 */ 2592 struct { 2593 struct acpi_resource res1; 2594 struct acpi_resource res2; 2595 struct acpi_resource res3; 2596 struct acpi_resource res4; 2597 } *resource; 2598 struct acpi_buffer buffer = { 0, NULL }; 2599 2600 if (!ioport || !irq) 2601 return -EINVAL; 2602 2603 /* init acpi_buffer */ 2604 resource = kzalloc(sizeof(*resource) + 1, GFP_KERNEL); 2605 if (!resource) 2606 return -ENOMEM; 2607 2608 buffer.length = sizeof(*resource) + 1; 2609 buffer.pointer = resource; 2610 2611 /* setup Type 1 resources */ 2612 if (spic_dev.model == SONYPI_DEVICE_TYPE1) { 2613 2614 /* setup io resources */ 2615 resource->res1.type = ACPI_RESOURCE_TYPE_IO; 2616 resource->res1.length = sizeof(struct acpi_resource); 2617 memcpy(&resource->res1.data.io, &ioport->io1, 2618 sizeof(struct acpi_resource_io)); 2619 2620 resource->res2.type = ACPI_RESOURCE_TYPE_IO; 2621 resource->res2.length = sizeof(struct acpi_resource); 2622 memcpy(&resource->res2.data.io, &ioport->io2, 2623 sizeof(struct acpi_resource_io)); 2624 2625 /* setup irq resource */ 2626 resource->res3.type = ACPI_RESOURCE_TYPE_IRQ; 2627 resource->res3.length = sizeof(struct acpi_resource); 2628 memcpy(&resource->res3.data.irq, &irq->irq, 2629 sizeof(struct acpi_resource_irq)); 2630 /* we requested a shared irq */ 2631 resource->res3.data.irq.sharable = ACPI_SHARED; 2632 2633 resource->res4.type = ACPI_RESOURCE_TYPE_END_TAG; 2634 2635 } 2636 /* setup Type 2/3 resources */ 2637 else { 2638 /* setup io resource */ 2639 resource->res1.type = ACPI_RESOURCE_TYPE_IO; 2640 resource->res1.length = sizeof(struct acpi_resource); 2641 memcpy(&resource->res1.data.io, &ioport->io1, 2642 sizeof(struct acpi_resource_io)); 2643 2644 /* setup irq resource */ 2645 resource->res2.type = ACPI_RESOURCE_TYPE_IRQ; 2646 resource->res2.length = sizeof(struct acpi_resource); 2647 memcpy(&resource->res2.data.irq, &irq->irq, 2648 sizeof(struct acpi_resource_irq)); 2649 /* we requested a shared irq */ 2650 resource->res2.data.irq.sharable = ACPI_SHARED; 2651 2652 resource->res3.type = ACPI_RESOURCE_TYPE_END_TAG; 2653 } 2654 2655 /* Attempt to set the resource */ 2656 dprintk("Evaluating _SRS\n"); 2657 status = acpi_set_current_resources(device->handle, &buffer); 2658 2659 /* check for total failure */ 2660 if (ACPI_FAILURE(status)) { 2661 printk(KERN_ERR DRV_PFX "Error evaluating _SRS\n"); 2662 result = -ENODEV; 2663 goto end; 2664 } 2665 2666 /* Necessary device initializations calls (from sonypi) */ 2667 sony_pic_call1(0x82); 2668 sony_pic_call2(0x81, 0xff); 2669 sony_pic_call1(compat ? 0x92 : 0x82); 2670 2671 end: 2672 kfree(resource); 2673 return result; 2674 } 2675 2676 /***************** 2677 * 2678 * ISR: some event is available 2679 * 2680 *****************/ 2681 static irqreturn_t sony_pic_irq(int irq, void *dev_id) 2682 { 2683 int i, j; 2684 u8 ev = 0; 2685 u8 data_mask = 0; 2686 u8 device_event = 0; 2687 2688 struct sony_pic_dev *dev = (struct sony_pic_dev *) dev_id; 2689 2690 ev = inb_p(dev->cur_ioport->io1.minimum); 2691 if (dev->cur_ioport->io2.minimum) 2692 data_mask = inb_p(dev->cur_ioport->io2.minimum); 2693 else 2694 data_mask = inb_p(dev->cur_ioport->io1.minimum + 2695 dev->evport_offset); 2696 2697 dprintk("event ([%.2x] [%.2x]) at port 0x%.4x(+0x%.2x)\n", 2698 ev, data_mask, dev->cur_ioport->io1.minimum, 2699 dev->evport_offset); 2700 2701 if (ev == 0x00 || ev == 0xff) 2702 return IRQ_HANDLED; 2703 2704 for (i = 0; dev->event_types[i].mask; i++) { 2705 2706 if ((data_mask & dev->event_types[i].data) != 2707 dev->event_types[i].data) 2708 continue; 2709 2710 if (!(mask & dev->event_types[i].mask)) 2711 continue; 2712 2713 for (j = 0; dev->event_types[i].events[j].event; j++) { 2714 if (ev == dev->event_types[i].events[j].data) { 2715 device_event = 2716 dev->event_types[i].events[j].event; 2717 goto found; 2718 } 2719 } 2720 } 2721 /* Still not able to decode the event try to pass 2722 * it over to the minidriver 2723 */ 2724 if (dev->handle_irq && dev->handle_irq(data_mask, ev) == 0) 2725 return IRQ_HANDLED; 2726 2727 dprintk("unknown event ([%.2x] [%.2x]) at port 0x%.4x(+0x%.2x)\n", 2728 ev, data_mask, dev->cur_ioport->io1.minimum, 2729 dev->evport_offset); 2730 return IRQ_HANDLED; 2731 2732 found: 2733 sony_laptop_report_input_event(device_event); 2734 acpi_bus_generate_proc_event(dev->acpi_dev, 1, device_event); 2735 sonypi_compat_report_event(device_event); 2736 2737 return IRQ_HANDLED; 2738 } 2739 2740 /***************** 2741 * 2742 * ACPI driver 2743 * 2744 *****************/ 2745 static int sony_pic_remove(struct acpi_device *device, int type) 2746 { 2747 struct sony_pic_ioport *io, *tmp_io; 2748 struct sony_pic_irq *irq, *tmp_irq; 2749 2750 if (sony_pic_disable(device)) { 2751 printk(KERN_ERR DRV_PFX "Couldn't disable device.\n"); 2752 return -ENXIO; 2753 } 2754 2755 free_irq(spic_dev.cur_irq->irq.interrupts[0], &spic_dev); 2756 release_region(spic_dev.cur_ioport->io1.minimum, 2757 spic_dev.cur_ioport->io1.address_length); 2758 if (spic_dev.cur_ioport->io2.minimum) 2759 release_region(spic_dev.cur_ioport->io2.minimum, 2760 spic_dev.cur_ioport->io2.address_length); 2761 2762 sonypi_compat_exit(); 2763 2764 sony_laptop_remove_input(); 2765 2766 /* pf attrs */ 2767 sysfs_remove_group(&sony_pf_device->dev.kobj, &spic_attribute_group); 2768 sony_pf_remove(); 2769 2770 list_for_each_entry_safe(io, tmp_io, &spic_dev.ioports, list) { 2771 list_del(&io->list); 2772 kfree(io); 2773 } 2774 list_for_each_entry_safe(irq, tmp_irq, &spic_dev.interrupts, list) { 2775 list_del(&irq->list); 2776 kfree(irq); 2777 } 2778 spic_dev.cur_ioport = NULL; 2779 spic_dev.cur_irq = NULL; 2780 2781 dprintk(SONY_PIC_DRIVER_NAME " removed.\n"); 2782 return 0; 2783 } 2784 2785 static int sony_pic_add(struct acpi_device *device) 2786 { 2787 int result; 2788 struct sony_pic_ioport *io, *tmp_io; 2789 struct sony_pic_irq *irq, *tmp_irq; 2790 2791 printk(KERN_INFO DRV_PFX "%s v%s.\n", 2792 SONY_PIC_DRIVER_NAME, SONY_LAPTOP_DRIVER_VERSION); 2793 2794 spic_dev.acpi_dev = device; 2795 strcpy(acpi_device_class(device), "sony/hotkey"); 2796 sony_pic_detect_device_type(&spic_dev); 2797 mutex_init(&spic_dev.lock); 2798 2799 /* read _PRS resources */ 2800 result = sony_pic_possible_resources(device); 2801 if (result) { 2802 printk(KERN_ERR DRV_PFX 2803 "Unable to read possible resources.\n"); 2804 goto err_free_resources; 2805 } 2806 2807 /* setup input devices and helper fifo */ 2808 result = sony_laptop_setup_input(device); 2809 if (result) { 2810 printk(KERN_ERR DRV_PFX 2811 "Unable to create input devices.\n"); 2812 goto err_free_resources; 2813 } 2814 2815 if (sonypi_compat_init()) 2816 goto err_remove_input; 2817 2818 /* request io port */ 2819 list_for_each_entry_reverse(io, &spic_dev.ioports, list) { 2820 if (request_region(io->io1.minimum, io->io1.address_length, 2821 "Sony Programable I/O Device")) { 2822 dprintk("I/O port1: 0x%.4x (0x%.4x) + 0x%.2x\n", 2823 io->io1.minimum, io->io1.maximum, 2824 io->io1.address_length); 2825 /* Type 1 have 2 ioports */ 2826 if (io->io2.minimum) { 2827 if (request_region(io->io2.minimum, 2828 io->io2.address_length, 2829 "Sony Programable I/O Device")) { 2830 dprintk("I/O port2: 0x%.4x (0x%.4x) + 0x%.2x\n", 2831 io->io2.minimum, io->io2.maximum, 2832 io->io2.address_length); 2833 spic_dev.cur_ioport = io; 2834 break; 2835 } 2836 else { 2837 dprintk("Unable to get I/O port2: " 2838 "0x%.4x (0x%.4x) + 0x%.2x\n", 2839 io->io2.minimum, io->io2.maximum, 2840 io->io2.address_length); 2841 release_region(io->io1.minimum, 2842 io->io1.address_length); 2843 } 2844 } 2845 else { 2846 spic_dev.cur_ioport = io; 2847 break; 2848 } 2849 } 2850 } 2851 if (!spic_dev.cur_ioport) { 2852 printk(KERN_ERR DRV_PFX "Failed to request_region.\n"); 2853 result = -ENODEV; 2854 goto err_remove_compat; 2855 } 2856 2857 /* request IRQ */ 2858 list_for_each_entry_reverse(irq, &spic_dev.interrupts, list) { 2859 if (!request_irq(irq->irq.interrupts[0], sony_pic_irq, 2860 IRQF_DISABLED, "sony-laptop", &spic_dev)) { 2861 dprintk("IRQ: %d - triggering: %d - " 2862 "polarity: %d - shr: %d\n", 2863 irq->irq.interrupts[0], 2864 irq->irq.triggering, 2865 irq->irq.polarity, 2866 irq->irq.sharable); 2867 spic_dev.cur_irq = irq; 2868 break; 2869 } 2870 } 2871 if (!spic_dev.cur_irq) { 2872 printk(KERN_ERR DRV_PFX "Failed to request_irq.\n"); 2873 result = -ENODEV; 2874 goto err_release_region; 2875 } 2876 2877 /* set resource status _SRS */ 2878 result = sony_pic_enable(device, spic_dev.cur_ioport, spic_dev.cur_irq); 2879 if (result) { 2880 printk(KERN_ERR DRV_PFX "Couldn't enable device.\n"); 2881 goto err_free_irq; 2882 } 2883 2884 spic_dev.bluetooth_power = -1; 2885 /* create device attributes */ 2886 result = sony_pf_add(); 2887 if (result) 2888 goto err_disable_device; 2889 2890 result = sysfs_create_group(&sony_pf_device->dev.kobj, &spic_attribute_group); 2891 if (result) 2892 goto err_remove_pf; 2893 2894 return 0; 2895 2896 err_remove_pf: 2897 sony_pf_remove(); 2898 2899 err_disable_device: 2900 sony_pic_disable(device); 2901 2902 err_free_irq: 2903 free_irq(spic_dev.cur_irq->irq.interrupts[0], &spic_dev); 2904 2905 err_release_region: 2906 release_region(spic_dev.cur_ioport->io1.minimum, 2907 spic_dev.cur_ioport->io1.address_length); 2908 if (spic_dev.cur_ioport->io2.minimum) 2909 release_region(spic_dev.cur_ioport->io2.minimum, 2910 spic_dev.cur_ioport->io2.address_length); 2911 2912 err_remove_compat: 2913 sonypi_compat_exit(); 2914 2915 err_remove_input: 2916 sony_laptop_remove_input(); 2917 2918 err_free_resources: 2919 list_for_each_entry_safe(io, tmp_io, &spic_dev.ioports, list) { 2920 list_del(&io->list); 2921 kfree(io); 2922 } 2923 list_for_each_entry_safe(irq, tmp_irq, &spic_dev.interrupts, list) { 2924 list_del(&irq->list); 2925 kfree(irq); 2926 } 2927 spic_dev.cur_ioport = NULL; 2928 spic_dev.cur_irq = NULL; 2929 2930 return result; 2931 } 2932 2933 static int sony_pic_suspend(struct acpi_device *device, pm_message_t state) 2934 { 2935 if (sony_pic_disable(device)) 2936 return -ENXIO; 2937 return 0; 2938 } 2939 2940 static int sony_pic_resume(struct acpi_device *device) 2941 { 2942 sony_pic_enable(device, spic_dev.cur_ioport, spic_dev.cur_irq); 2943 return 0; 2944 } 2945 2946 static const struct acpi_device_id sony_pic_device_ids[] = { 2947 {SONY_PIC_HID, 0}, 2948 {"", 0}, 2949 }; 2950 2951 static struct acpi_driver sony_pic_driver = { 2952 .name = SONY_PIC_DRIVER_NAME, 2953 .class = SONY_PIC_CLASS, 2954 .ids = sony_pic_device_ids, 2955 .owner = THIS_MODULE, 2956 .ops = { 2957 .add = sony_pic_add, 2958 .remove = sony_pic_remove, 2959 .suspend = sony_pic_suspend, 2960 .resume = sony_pic_resume, 2961 }, 2962 }; 2963 2964 static struct dmi_system_id __initdata sonypi_dmi_table[] = { 2965 { 2966 .ident = "Sony Vaio", 2967 .matches = { 2968 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"), 2969 DMI_MATCH(DMI_PRODUCT_NAME, "PCG-"), 2970 }, 2971 }, 2972 { 2973 .ident = "Sony Vaio", 2974 .matches = { 2975 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"), 2976 DMI_MATCH(DMI_PRODUCT_NAME, "VGN-"), 2977 }, 2978 }, 2979 { } 2980 }; 2981 2982 static int __init sony_laptop_init(void) 2983 { 2984 int result; 2985 2986 if (!no_spic && dmi_check_system(sonypi_dmi_table)) { 2987 result = acpi_bus_register_driver(&sony_pic_driver); 2988 if (result) { 2989 printk(KERN_ERR DRV_PFX 2990 "Unable to register SPIC driver."); 2991 goto out; 2992 } 2993 spic_drv_registered = 1; 2994 } 2995 2996 result = acpi_bus_register_driver(&sony_nc_driver); 2997 if (result) { 2998 printk(KERN_ERR DRV_PFX "Unable to register SNC driver."); 2999 goto out_unregister_pic; 3000 } 3001 3002 return 0; 3003 3004 out_unregister_pic: 3005 if (spic_drv_registered) 3006 acpi_bus_unregister_driver(&sony_pic_driver); 3007 out: 3008 return result; 3009 } 3010 3011 static void __exit sony_laptop_exit(void) 3012 { 3013 acpi_bus_unregister_driver(&sony_nc_driver); 3014 if (spic_drv_registered) 3015 acpi_bus_unregister_driver(&sony_pic_driver); 3016 } 3017 3018 module_init(sony_laptop_init); 3019 module_exit(sony_laptop_exit); 3020