1 /* 2 * toshiba_acpi.c - Toshiba Laptop ACPI Extras 3 * 4 * 5 * Copyright (C) 2002-2004 John Belmonte 6 * Copyright (C) 2008 Philip Langdale 7 * Copyright (C) 2010 Pierre Ducroquet 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License as published by 11 * the Free Software Foundation; either version 2 of the License, or 12 * (at your option) any later version. 13 * 14 * This program is distributed in the hope that it will be useful, 15 * but WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 * GNU General Public License for more details. 18 * 19 * You should have received a copy of the GNU General Public License 20 * along with this program; if not, write to the Free Software 21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 22 * 23 * 24 * The devolpment page for this driver is located at 25 * http://memebeam.org/toys/ToshibaAcpiDriver. 26 * 27 * Credits: 28 * Jonathan A. Buzzard - Toshiba HCI info, and critical tips on reverse 29 * engineering the Windows drivers 30 * Yasushi Nagato - changes for linux kernel 2.4 -> 2.5 31 * Rob Miller - TV out and hotkeys help 32 * 33 * 34 * TODO 35 * 36 */ 37 38 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 39 40 #define TOSHIBA_ACPI_VERSION "0.19" 41 #define PROC_INTERFACE_VERSION 1 42 43 #include <linux/kernel.h> 44 #include <linux/module.h> 45 #include <linux/init.h> 46 #include <linux/types.h> 47 #include <linux/proc_fs.h> 48 #include <linux/seq_file.h> 49 #include <linux/backlight.h> 50 #include <linux/rfkill.h> 51 #include <linux/input.h> 52 #include <linux/input/sparse-keymap.h> 53 #include <linux/leds.h> 54 #include <linux/slab.h> 55 #include <linux/workqueue.h> 56 #include <linux/i8042.h> 57 58 #include <asm/uaccess.h> 59 60 #include <acpi/acpi_drivers.h> 61 62 MODULE_AUTHOR("John Belmonte"); 63 MODULE_DESCRIPTION("Toshiba Laptop ACPI Extras Driver"); 64 MODULE_LICENSE("GPL"); 65 66 #define TOSHIBA_WMI_EVENT_GUID "59142400-C6A3-40FA-BADB-8A2652834100" 67 68 /* Scan code for Fn key on TOS1900 models */ 69 #define TOS1900_FN_SCAN 0x6e 70 71 /* Toshiba ACPI method paths */ 72 #define METHOD_VIDEO_OUT "\\_SB_.VALX.DSSX" 73 74 /* Toshiba HCI interface definitions 75 * 76 * HCI is Toshiba's "Hardware Control Interface" which is supposed to 77 * be uniform across all their models. Ideally we would just call 78 * dedicated ACPI methods instead of using this primitive interface. 79 * However the ACPI methods seem to be incomplete in some areas (for 80 * example they allow setting, but not reading, the LCD brightness value), 81 * so this is still useful. 82 */ 83 84 #define HCI_WORDS 6 85 86 /* operations */ 87 #define HCI_SET 0xff00 88 #define HCI_GET 0xfe00 89 90 /* return codes */ 91 #define HCI_SUCCESS 0x0000 92 #define HCI_FAILURE 0x1000 93 #define HCI_NOT_SUPPORTED 0x8000 94 #define HCI_EMPTY 0x8c00 95 96 /* registers */ 97 #define HCI_FAN 0x0004 98 #define HCI_TR_BACKLIGHT 0x0005 99 #define HCI_SYSTEM_EVENT 0x0016 100 #define HCI_VIDEO_OUT 0x001c 101 #define HCI_HOTKEY_EVENT 0x001e 102 #define HCI_LCD_BRIGHTNESS 0x002a 103 #define HCI_WIRELESS 0x0056 104 105 /* field definitions */ 106 #define HCI_HOTKEY_DISABLE 0x0b 107 #define HCI_HOTKEY_ENABLE 0x09 108 #define HCI_LCD_BRIGHTNESS_BITS 3 109 #define HCI_LCD_BRIGHTNESS_SHIFT (16-HCI_LCD_BRIGHTNESS_BITS) 110 #define HCI_LCD_BRIGHTNESS_LEVELS (1 << HCI_LCD_BRIGHTNESS_BITS) 111 #define HCI_VIDEO_OUT_LCD 0x1 112 #define HCI_VIDEO_OUT_CRT 0x2 113 #define HCI_VIDEO_OUT_TV 0x4 114 #define HCI_WIRELESS_KILL_SWITCH 0x01 115 #define HCI_WIRELESS_BT_PRESENT 0x0f 116 #define HCI_WIRELESS_BT_ATTACH 0x40 117 #define HCI_WIRELESS_BT_POWER 0x80 118 119 struct toshiba_acpi_dev { 120 struct acpi_device *acpi_dev; 121 const char *method_hci; 122 struct rfkill *bt_rfk; 123 struct input_dev *hotkey_dev; 124 struct work_struct hotkey_work; 125 struct backlight_device *backlight_dev; 126 struct led_classdev led_dev; 127 128 int force_fan; 129 int last_key_event; 130 int key_event_valid; 131 132 unsigned int illumination_supported:1; 133 unsigned int video_supported:1; 134 unsigned int fan_supported:1; 135 unsigned int system_event_supported:1; 136 unsigned int ntfy_supported:1; 137 unsigned int info_supported:1; 138 unsigned int tr_backlight_supported:1; 139 140 struct mutex mutex; 141 }; 142 143 static struct toshiba_acpi_dev *toshiba_acpi; 144 145 static const struct acpi_device_id toshiba_device_ids[] = { 146 {"TOS6200", 0}, 147 {"TOS6208", 0}, 148 {"TOS1900", 0}, 149 {"", 0}, 150 }; 151 MODULE_DEVICE_TABLE(acpi, toshiba_device_ids); 152 153 static const struct key_entry toshiba_acpi_keymap[] = { 154 { KE_KEY, 0x101, { KEY_MUTE } }, 155 { KE_KEY, 0x102, { KEY_ZOOMOUT } }, 156 { KE_KEY, 0x103, { KEY_ZOOMIN } }, 157 { KE_KEY, 0x12c, { KEY_KBDILLUMTOGGLE } }, 158 { KE_KEY, 0x139, { KEY_ZOOMRESET } }, 159 { KE_KEY, 0x13b, { KEY_COFFEE } }, 160 { KE_KEY, 0x13c, { KEY_BATTERY } }, 161 { KE_KEY, 0x13d, { KEY_SLEEP } }, 162 { KE_KEY, 0x13e, { KEY_SUSPEND } }, 163 { KE_KEY, 0x13f, { KEY_SWITCHVIDEOMODE } }, 164 { KE_KEY, 0x140, { KEY_BRIGHTNESSDOWN } }, 165 { KE_KEY, 0x141, { KEY_BRIGHTNESSUP } }, 166 { KE_KEY, 0x142, { KEY_WLAN } }, 167 { KE_KEY, 0x143, { KEY_TOUCHPAD_TOGGLE } }, 168 { KE_KEY, 0x17f, { KEY_FN } }, 169 { KE_KEY, 0xb05, { KEY_PROG2 } }, 170 { KE_KEY, 0xb06, { KEY_WWW } }, 171 { KE_KEY, 0xb07, { KEY_MAIL } }, 172 { KE_KEY, 0xb30, { KEY_STOP } }, 173 { KE_KEY, 0xb31, { KEY_PREVIOUSSONG } }, 174 { KE_KEY, 0xb32, { KEY_NEXTSONG } }, 175 { KE_KEY, 0xb33, { KEY_PLAYPAUSE } }, 176 { KE_KEY, 0xb5a, { KEY_MEDIA } }, 177 { KE_IGNORE, 0x1430, { KEY_RESERVED } }, 178 { KE_END, 0 }, 179 }; 180 181 /* utility 182 */ 183 184 static __inline__ void _set_bit(u32 * word, u32 mask, int value) 185 { 186 *word = (*word & ~mask) | (mask * value); 187 } 188 189 /* acpi interface wrappers 190 */ 191 192 static int write_acpi_int(const char *methodName, int val) 193 { 194 struct acpi_object_list params; 195 union acpi_object in_objs[1]; 196 acpi_status status; 197 198 params.count = ARRAY_SIZE(in_objs); 199 params.pointer = in_objs; 200 in_objs[0].type = ACPI_TYPE_INTEGER; 201 in_objs[0].integer.value = val; 202 203 status = acpi_evaluate_object(NULL, (char *)methodName, ¶ms, NULL); 204 return (status == AE_OK) ? 0 : -EIO; 205 } 206 207 /* Perform a raw HCI call. Here we don't care about input or output buffer 208 * format. 209 */ 210 static acpi_status hci_raw(struct toshiba_acpi_dev *dev, 211 const u32 in[HCI_WORDS], u32 out[HCI_WORDS]) 212 { 213 struct acpi_object_list params; 214 union acpi_object in_objs[HCI_WORDS]; 215 struct acpi_buffer results; 216 union acpi_object out_objs[HCI_WORDS + 1]; 217 acpi_status status; 218 int i; 219 220 params.count = HCI_WORDS; 221 params.pointer = in_objs; 222 for (i = 0; i < HCI_WORDS; ++i) { 223 in_objs[i].type = ACPI_TYPE_INTEGER; 224 in_objs[i].integer.value = in[i]; 225 } 226 227 results.length = sizeof(out_objs); 228 results.pointer = out_objs; 229 230 status = acpi_evaluate_object(dev->acpi_dev->handle, 231 (char *)dev->method_hci, ¶ms, 232 &results); 233 if ((status == AE_OK) && (out_objs->package.count <= HCI_WORDS)) { 234 for (i = 0; i < out_objs->package.count; ++i) { 235 out[i] = out_objs->package.elements[i].integer.value; 236 } 237 } 238 239 return status; 240 } 241 242 /* common hci tasks (get or set one or two value) 243 * 244 * In addition to the ACPI status, the HCI system returns a result which 245 * may be useful (such as "not supported"). 246 */ 247 248 static acpi_status hci_write1(struct toshiba_acpi_dev *dev, u32 reg, 249 u32 in1, u32 *result) 250 { 251 u32 in[HCI_WORDS] = { HCI_SET, reg, in1, 0, 0, 0 }; 252 u32 out[HCI_WORDS]; 253 acpi_status status = hci_raw(dev, in, out); 254 *result = (status == AE_OK) ? out[0] : HCI_FAILURE; 255 return status; 256 } 257 258 static acpi_status hci_read1(struct toshiba_acpi_dev *dev, u32 reg, 259 u32 *out1, u32 *result) 260 { 261 u32 in[HCI_WORDS] = { HCI_GET, reg, 0, 0, 0, 0 }; 262 u32 out[HCI_WORDS]; 263 acpi_status status = hci_raw(dev, in, out); 264 *out1 = out[2]; 265 *result = (status == AE_OK) ? out[0] : HCI_FAILURE; 266 return status; 267 } 268 269 static acpi_status hci_write2(struct toshiba_acpi_dev *dev, u32 reg, 270 u32 in1, u32 in2, u32 *result) 271 { 272 u32 in[HCI_WORDS] = { HCI_SET, reg, in1, in2, 0, 0 }; 273 u32 out[HCI_WORDS]; 274 acpi_status status = hci_raw(dev, in, out); 275 *result = (status == AE_OK) ? out[0] : HCI_FAILURE; 276 return status; 277 } 278 279 static acpi_status hci_read2(struct toshiba_acpi_dev *dev, u32 reg, 280 u32 *out1, u32 *out2, u32 *result) 281 { 282 u32 in[HCI_WORDS] = { HCI_GET, reg, *out1, *out2, 0, 0 }; 283 u32 out[HCI_WORDS]; 284 acpi_status status = hci_raw(dev, in, out); 285 *out1 = out[2]; 286 *out2 = out[3]; 287 *result = (status == AE_OK) ? out[0] : HCI_FAILURE; 288 return status; 289 } 290 291 /* Illumination support */ 292 static int toshiba_illumination_available(struct toshiba_acpi_dev *dev) 293 { 294 u32 in[HCI_WORDS] = { 0, 0, 0, 0, 0, 0 }; 295 u32 out[HCI_WORDS]; 296 acpi_status status; 297 298 in[0] = 0xf100; 299 status = hci_raw(dev, in, out); 300 if (ACPI_FAILURE(status)) { 301 pr_info("Illumination device not available\n"); 302 return 0; 303 } 304 in[0] = 0xf400; 305 status = hci_raw(dev, in, out); 306 return 1; 307 } 308 309 static void toshiba_illumination_set(struct led_classdev *cdev, 310 enum led_brightness brightness) 311 { 312 struct toshiba_acpi_dev *dev = container_of(cdev, 313 struct toshiba_acpi_dev, led_dev); 314 u32 in[HCI_WORDS] = { 0, 0, 0, 0, 0, 0 }; 315 u32 out[HCI_WORDS]; 316 acpi_status status; 317 318 /* First request : initialize communication. */ 319 in[0] = 0xf100; 320 status = hci_raw(dev, in, out); 321 if (ACPI_FAILURE(status)) { 322 pr_info("Illumination device not available\n"); 323 return; 324 } 325 326 if (brightness) { 327 /* Switch the illumination on */ 328 in[0] = 0xf400; 329 in[1] = 0x14e; 330 in[2] = 1; 331 status = hci_raw(dev, in, out); 332 if (ACPI_FAILURE(status)) { 333 pr_info("ACPI call for illumination failed\n"); 334 return; 335 } 336 } else { 337 /* Switch the illumination off */ 338 in[0] = 0xf400; 339 in[1] = 0x14e; 340 in[2] = 0; 341 status = hci_raw(dev, in, out); 342 if (ACPI_FAILURE(status)) { 343 pr_info("ACPI call for illumination failed.\n"); 344 return; 345 } 346 } 347 348 /* Last request : close communication. */ 349 in[0] = 0xf200; 350 in[1] = 0; 351 in[2] = 0; 352 hci_raw(dev, in, out); 353 } 354 355 static enum led_brightness toshiba_illumination_get(struct led_classdev *cdev) 356 { 357 struct toshiba_acpi_dev *dev = container_of(cdev, 358 struct toshiba_acpi_dev, led_dev); 359 u32 in[HCI_WORDS] = { 0, 0, 0, 0, 0, 0 }; 360 u32 out[HCI_WORDS]; 361 acpi_status status; 362 enum led_brightness result; 363 364 /* First request : initialize communication. */ 365 in[0] = 0xf100; 366 status = hci_raw(dev, in, out); 367 if (ACPI_FAILURE(status)) { 368 pr_info("Illumination device not available\n"); 369 return LED_OFF; 370 } 371 372 /* Check the illumination */ 373 in[0] = 0xf300; 374 in[1] = 0x14e; 375 status = hci_raw(dev, in, out); 376 if (ACPI_FAILURE(status)) { 377 pr_info("ACPI call for illumination failed.\n"); 378 return LED_OFF; 379 } 380 381 result = out[2] ? LED_FULL : LED_OFF; 382 383 /* Last request : close communication. */ 384 in[0] = 0xf200; 385 in[1] = 0; 386 in[2] = 0; 387 hci_raw(dev, in, out); 388 389 return result; 390 } 391 392 /* Bluetooth rfkill handlers */ 393 394 static u32 hci_get_bt_present(struct toshiba_acpi_dev *dev, bool *present) 395 { 396 u32 hci_result; 397 u32 value, value2; 398 399 value = 0; 400 value2 = 0; 401 hci_read2(dev, HCI_WIRELESS, &value, &value2, &hci_result); 402 if (hci_result == HCI_SUCCESS) 403 *present = (value & HCI_WIRELESS_BT_PRESENT) ? true : false; 404 405 return hci_result; 406 } 407 408 static u32 hci_get_radio_state(struct toshiba_acpi_dev *dev, bool *radio_state) 409 { 410 u32 hci_result; 411 u32 value, value2; 412 413 value = 0; 414 value2 = 0x0001; 415 hci_read2(dev, HCI_WIRELESS, &value, &value2, &hci_result); 416 417 *radio_state = value & HCI_WIRELESS_KILL_SWITCH; 418 return hci_result; 419 } 420 421 static int bt_rfkill_set_block(void *data, bool blocked) 422 { 423 struct toshiba_acpi_dev *dev = data; 424 u32 result1, result2; 425 u32 value; 426 int err; 427 bool radio_state; 428 429 value = (blocked == false); 430 431 mutex_lock(&dev->mutex); 432 if (hci_get_radio_state(dev, &radio_state) != HCI_SUCCESS) { 433 err = -EIO; 434 goto out; 435 } 436 437 if (!radio_state) { 438 err = 0; 439 goto out; 440 } 441 442 hci_write2(dev, HCI_WIRELESS, value, HCI_WIRELESS_BT_POWER, &result1); 443 hci_write2(dev, HCI_WIRELESS, value, HCI_WIRELESS_BT_ATTACH, &result2); 444 445 if (result1 != HCI_SUCCESS || result2 != HCI_SUCCESS) 446 err = -EIO; 447 else 448 err = 0; 449 out: 450 mutex_unlock(&dev->mutex); 451 return err; 452 } 453 454 static void bt_rfkill_poll(struct rfkill *rfkill, void *data) 455 { 456 bool new_rfk_state; 457 bool value; 458 u32 hci_result; 459 struct toshiba_acpi_dev *dev = data; 460 461 mutex_lock(&dev->mutex); 462 463 hci_result = hci_get_radio_state(dev, &value); 464 if (hci_result != HCI_SUCCESS) { 465 /* Can't do anything useful */ 466 mutex_unlock(&dev->mutex); 467 return; 468 } 469 470 new_rfk_state = value; 471 472 mutex_unlock(&dev->mutex); 473 474 if (rfkill_set_hw_state(rfkill, !new_rfk_state)) 475 bt_rfkill_set_block(data, true); 476 } 477 478 static const struct rfkill_ops toshiba_rfk_ops = { 479 .set_block = bt_rfkill_set_block, 480 .poll = bt_rfkill_poll, 481 }; 482 483 static int get_tr_backlight_status(struct toshiba_acpi_dev *dev, bool *enabled) 484 { 485 u32 hci_result; 486 u32 status; 487 488 hci_read1(dev, HCI_TR_BACKLIGHT, &status, &hci_result); 489 *enabled = !status; 490 return hci_result == HCI_SUCCESS ? 0 : -EIO; 491 } 492 493 static int set_tr_backlight_status(struct toshiba_acpi_dev *dev, bool enable) 494 { 495 u32 hci_result; 496 u32 value = !enable; 497 498 hci_write1(dev, HCI_TR_BACKLIGHT, value, &hci_result); 499 return hci_result == HCI_SUCCESS ? 0 : -EIO; 500 } 501 502 static struct proc_dir_entry *toshiba_proc_dir /*= 0*/ ; 503 504 static int __get_lcd_brightness(struct toshiba_acpi_dev *dev) 505 { 506 u32 hci_result; 507 u32 value; 508 int brightness = 0; 509 510 if (dev->tr_backlight_supported) { 511 bool enabled; 512 int ret = get_tr_backlight_status(dev, &enabled); 513 if (ret) 514 return ret; 515 if (enabled) 516 return 0; 517 brightness++; 518 } 519 520 hci_read1(dev, HCI_LCD_BRIGHTNESS, &value, &hci_result); 521 if (hci_result == HCI_SUCCESS) 522 return brightness + (value >> HCI_LCD_BRIGHTNESS_SHIFT); 523 524 return -EIO; 525 } 526 527 static int get_lcd_brightness(struct backlight_device *bd) 528 { 529 struct toshiba_acpi_dev *dev = bl_get_data(bd); 530 return __get_lcd_brightness(dev); 531 } 532 533 static int lcd_proc_show(struct seq_file *m, void *v) 534 { 535 struct toshiba_acpi_dev *dev = m->private; 536 int value; 537 int levels; 538 539 if (!dev->backlight_dev) 540 return -ENODEV; 541 542 levels = dev->backlight_dev->props.max_brightness + 1; 543 value = get_lcd_brightness(dev->backlight_dev); 544 if (value >= 0) { 545 seq_printf(m, "brightness: %d\n", value); 546 seq_printf(m, "brightness_levels: %d\n", levels); 547 return 0; 548 } 549 550 pr_err("Error reading LCD brightness\n"); 551 return -EIO; 552 } 553 554 static int lcd_proc_open(struct inode *inode, struct file *file) 555 { 556 return single_open(file, lcd_proc_show, PDE(inode)->data); 557 } 558 559 static int set_lcd_brightness(struct toshiba_acpi_dev *dev, int value) 560 { 561 u32 hci_result; 562 563 if (dev->tr_backlight_supported) { 564 bool enable = !value; 565 int ret = set_tr_backlight_status(dev, enable); 566 if (ret) 567 return ret; 568 if (value) 569 value--; 570 } 571 572 value = value << HCI_LCD_BRIGHTNESS_SHIFT; 573 hci_write1(dev, HCI_LCD_BRIGHTNESS, value, &hci_result); 574 return hci_result == HCI_SUCCESS ? 0 : -EIO; 575 } 576 577 static int set_lcd_status(struct backlight_device *bd) 578 { 579 struct toshiba_acpi_dev *dev = bl_get_data(bd); 580 return set_lcd_brightness(dev, bd->props.brightness); 581 } 582 583 static ssize_t lcd_proc_write(struct file *file, const char __user *buf, 584 size_t count, loff_t *pos) 585 { 586 struct toshiba_acpi_dev *dev = PDE(file->f_path.dentry->d_inode)->data; 587 char cmd[42]; 588 size_t len; 589 int value; 590 int ret; 591 int levels = dev->backlight_dev->props.max_brightness + 1; 592 593 len = min(count, sizeof(cmd) - 1); 594 if (copy_from_user(cmd, buf, len)) 595 return -EFAULT; 596 cmd[len] = '\0'; 597 598 if (sscanf(cmd, " brightness : %i", &value) == 1 && 599 value >= 0 && value < levels) { 600 ret = set_lcd_brightness(dev, value); 601 if (ret == 0) 602 ret = count; 603 } else { 604 ret = -EINVAL; 605 } 606 return ret; 607 } 608 609 static const struct file_operations lcd_proc_fops = { 610 .owner = THIS_MODULE, 611 .open = lcd_proc_open, 612 .read = seq_read, 613 .llseek = seq_lseek, 614 .release = single_release, 615 .write = lcd_proc_write, 616 }; 617 618 static int get_video_status(struct toshiba_acpi_dev *dev, u32 *status) 619 { 620 u32 hci_result; 621 622 hci_read1(dev, HCI_VIDEO_OUT, status, &hci_result); 623 return hci_result == HCI_SUCCESS ? 0 : -EIO; 624 } 625 626 static int video_proc_show(struct seq_file *m, void *v) 627 { 628 struct toshiba_acpi_dev *dev = m->private; 629 u32 value; 630 int ret; 631 632 ret = get_video_status(dev, &value); 633 if (!ret) { 634 int is_lcd = (value & HCI_VIDEO_OUT_LCD) ? 1 : 0; 635 int is_crt = (value & HCI_VIDEO_OUT_CRT) ? 1 : 0; 636 int is_tv = (value & HCI_VIDEO_OUT_TV) ? 1 : 0; 637 seq_printf(m, "lcd_out: %d\n", is_lcd); 638 seq_printf(m, "crt_out: %d\n", is_crt); 639 seq_printf(m, "tv_out: %d\n", is_tv); 640 } 641 642 return ret; 643 } 644 645 static int video_proc_open(struct inode *inode, struct file *file) 646 { 647 return single_open(file, video_proc_show, PDE(inode)->data); 648 } 649 650 static ssize_t video_proc_write(struct file *file, const char __user *buf, 651 size_t count, loff_t *pos) 652 { 653 struct toshiba_acpi_dev *dev = PDE(file->f_path.dentry->d_inode)->data; 654 char *cmd, *buffer; 655 int ret; 656 int value; 657 int remain = count; 658 int lcd_out = -1; 659 int crt_out = -1; 660 int tv_out = -1; 661 u32 video_out; 662 663 cmd = kmalloc(count + 1, GFP_KERNEL); 664 if (!cmd) 665 return -ENOMEM; 666 if (copy_from_user(cmd, buf, count)) { 667 kfree(cmd); 668 return -EFAULT; 669 } 670 cmd[count] = '\0'; 671 672 buffer = cmd; 673 674 /* scan expression. Multiple expressions may be delimited with ; 675 * 676 * NOTE: to keep scanning simple, invalid fields are ignored 677 */ 678 while (remain) { 679 if (sscanf(buffer, " lcd_out : %i", &value) == 1) 680 lcd_out = value & 1; 681 else if (sscanf(buffer, " crt_out : %i", &value) == 1) 682 crt_out = value & 1; 683 else if (sscanf(buffer, " tv_out : %i", &value) == 1) 684 tv_out = value & 1; 685 /* advance to one character past the next ; */ 686 do { 687 ++buffer; 688 --remain; 689 } 690 while (remain && *(buffer - 1) != ';'); 691 } 692 693 kfree(cmd); 694 695 ret = get_video_status(dev, &video_out); 696 if (!ret) { 697 unsigned int new_video_out = video_out; 698 if (lcd_out != -1) 699 _set_bit(&new_video_out, HCI_VIDEO_OUT_LCD, lcd_out); 700 if (crt_out != -1) 701 _set_bit(&new_video_out, HCI_VIDEO_OUT_CRT, crt_out); 702 if (tv_out != -1) 703 _set_bit(&new_video_out, HCI_VIDEO_OUT_TV, tv_out); 704 /* To avoid unnecessary video disruption, only write the new 705 * video setting if something changed. */ 706 if (new_video_out != video_out) 707 ret = write_acpi_int(METHOD_VIDEO_OUT, new_video_out); 708 } 709 710 return ret ? ret : count; 711 } 712 713 static const struct file_operations video_proc_fops = { 714 .owner = THIS_MODULE, 715 .open = video_proc_open, 716 .read = seq_read, 717 .llseek = seq_lseek, 718 .release = single_release, 719 .write = video_proc_write, 720 }; 721 722 static int get_fan_status(struct toshiba_acpi_dev *dev, u32 *status) 723 { 724 u32 hci_result; 725 726 hci_read1(dev, HCI_FAN, status, &hci_result); 727 return hci_result == HCI_SUCCESS ? 0 : -EIO; 728 } 729 730 static int fan_proc_show(struct seq_file *m, void *v) 731 { 732 struct toshiba_acpi_dev *dev = m->private; 733 int ret; 734 u32 value; 735 736 ret = get_fan_status(dev, &value); 737 if (!ret) { 738 seq_printf(m, "running: %d\n", (value > 0)); 739 seq_printf(m, "force_on: %d\n", dev->force_fan); 740 } 741 742 return ret; 743 } 744 745 static int fan_proc_open(struct inode *inode, struct file *file) 746 { 747 return single_open(file, fan_proc_show, PDE(inode)->data); 748 } 749 750 static ssize_t fan_proc_write(struct file *file, const char __user *buf, 751 size_t count, loff_t *pos) 752 { 753 struct toshiba_acpi_dev *dev = PDE(file->f_path.dentry->d_inode)->data; 754 char cmd[42]; 755 size_t len; 756 int value; 757 u32 hci_result; 758 759 len = min(count, sizeof(cmd) - 1); 760 if (copy_from_user(cmd, buf, len)) 761 return -EFAULT; 762 cmd[len] = '\0'; 763 764 if (sscanf(cmd, " force_on : %i", &value) == 1 && 765 value >= 0 && value <= 1) { 766 hci_write1(dev, HCI_FAN, value, &hci_result); 767 if (hci_result != HCI_SUCCESS) 768 return -EIO; 769 else 770 dev->force_fan = value; 771 } else { 772 return -EINVAL; 773 } 774 775 return count; 776 } 777 778 static const struct file_operations fan_proc_fops = { 779 .owner = THIS_MODULE, 780 .open = fan_proc_open, 781 .read = seq_read, 782 .llseek = seq_lseek, 783 .release = single_release, 784 .write = fan_proc_write, 785 }; 786 787 static int keys_proc_show(struct seq_file *m, void *v) 788 { 789 struct toshiba_acpi_dev *dev = m->private; 790 u32 hci_result; 791 u32 value; 792 793 if (!dev->key_event_valid && dev->system_event_supported) { 794 hci_read1(dev, HCI_SYSTEM_EVENT, &value, &hci_result); 795 if (hci_result == HCI_SUCCESS) { 796 dev->key_event_valid = 1; 797 dev->last_key_event = value; 798 } else if (hci_result == HCI_EMPTY) { 799 /* better luck next time */ 800 } else if (hci_result == HCI_NOT_SUPPORTED) { 801 /* This is a workaround for an unresolved issue on 802 * some machines where system events sporadically 803 * become disabled. */ 804 hci_write1(dev, HCI_SYSTEM_EVENT, 1, &hci_result); 805 pr_notice("Re-enabled hotkeys\n"); 806 } else { 807 pr_err("Error reading hotkey status\n"); 808 return -EIO; 809 } 810 } 811 812 seq_printf(m, "hotkey_ready: %d\n", dev->key_event_valid); 813 seq_printf(m, "hotkey: 0x%04x\n", dev->last_key_event); 814 return 0; 815 } 816 817 static int keys_proc_open(struct inode *inode, struct file *file) 818 { 819 return single_open(file, keys_proc_show, PDE(inode)->data); 820 } 821 822 static ssize_t keys_proc_write(struct file *file, const char __user *buf, 823 size_t count, loff_t *pos) 824 { 825 struct toshiba_acpi_dev *dev = PDE(file->f_path.dentry->d_inode)->data; 826 char cmd[42]; 827 size_t len; 828 int value; 829 830 len = min(count, sizeof(cmd) - 1); 831 if (copy_from_user(cmd, buf, len)) 832 return -EFAULT; 833 cmd[len] = '\0'; 834 835 if (sscanf(cmd, " hotkey_ready : %i", &value) == 1 && value == 0) { 836 dev->key_event_valid = 0; 837 } else { 838 return -EINVAL; 839 } 840 841 return count; 842 } 843 844 static const struct file_operations keys_proc_fops = { 845 .owner = THIS_MODULE, 846 .open = keys_proc_open, 847 .read = seq_read, 848 .llseek = seq_lseek, 849 .release = single_release, 850 .write = keys_proc_write, 851 }; 852 853 static int version_proc_show(struct seq_file *m, void *v) 854 { 855 seq_printf(m, "driver: %s\n", TOSHIBA_ACPI_VERSION); 856 seq_printf(m, "proc_interface: %d\n", PROC_INTERFACE_VERSION); 857 return 0; 858 } 859 860 static int version_proc_open(struct inode *inode, struct file *file) 861 { 862 return single_open(file, version_proc_show, PDE(inode)->data); 863 } 864 865 static const struct file_operations version_proc_fops = { 866 .owner = THIS_MODULE, 867 .open = version_proc_open, 868 .read = seq_read, 869 .llseek = seq_lseek, 870 .release = single_release, 871 }; 872 873 /* proc and module init 874 */ 875 876 #define PROC_TOSHIBA "toshiba" 877 878 static void create_toshiba_proc_entries(struct toshiba_acpi_dev *dev) 879 { 880 if (dev->backlight_dev) 881 proc_create_data("lcd", S_IRUGO | S_IWUSR, toshiba_proc_dir, 882 &lcd_proc_fops, dev); 883 if (dev->video_supported) 884 proc_create_data("video", S_IRUGO | S_IWUSR, toshiba_proc_dir, 885 &video_proc_fops, dev); 886 if (dev->fan_supported) 887 proc_create_data("fan", S_IRUGO | S_IWUSR, toshiba_proc_dir, 888 &fan_proc_fops, dev); 889 if (dev->hotkey_dev) 890 proc_create_data("keys", S_IRUGO | S_IWUSR, toshiba_proc_dir, 891 &keys_proc_fops, dev); 892 proc_create_data("version", S_IRUGO, toshiba_proc_dir, 893 &version_proc_fops, dev); 894 } 895 896 static void remove_toshiba_proc_entries(struct toshiba_acpi_dev *dev) 897 { 898 if (dev->backlight_dev) 899 remove_proc_entry("lcd", toshiba_proc_dir); 900 if (dev->video_supported) 901 remove_proc_entry("video", toshiba_proc_dir); 902 if (dev->fan_supported) 903 remove_proc_entry("fan", toshiba_proc_dir); 904 if (dev->hotkey_dev) 905 remove_proc_entry("keys", toshiba_proc_dir); 906 remove_proc_entry("version", toshiba_proc_dir); 907 } 908 909 static const struct backlight_ops toshiba_backlight_data = { 910 .options = BL_CORE_SUSPENDRESUME, 911 .get_brightness = get_lcd_brightness, 912 .update_status = set_lcd_status, 913 }; 914 915 static bool toshiba_acpi_i8042_filter(unsigned char data, unsigned char str, 916 struct serio *port) 917 { 918 if (str & 0x20) 919 return false; 920 921 if (unlikely(data == 0xe0)) 922 return false; 923 924 if ((data & 0x7f) == TOS1900_FN_SCAN) { 925 schedule_work(&toshiba_acpi->hotkey_work); 926 return true; 927 } 928 929 return false; 930 } 931 932 static void toshiba_acpi_hotkey_work(struct work_struct *work) 933 { 934 acpi_handle ec_handle = ec_get_handle(); 935 acpi_status status; 936 937 if (!ec_handle) 938 return; 939 940 status = acpi_evaluate_object(ec_handle, "NTFY", NULL, NULL); 941 if (ACPI_FAILURE(status)) 942 pr_err("ACPI NTFY method execution failed\n"); 943 } 944 945 /* 946 * Returns hotkey scancode, or < 0 on failure. 947 */ 948 static int toshiba_acpi_query_hotkey(struct toshiba_acpi_dev *dev) 949 { 950 struct acpi_buffer buf; 951 union acpi_object out_obj; 952 acpi_status status; 953 954 buf.pointer = &out_obj; 955 buf.length = sizeof(out_obj); 956 957 status = acpi_evaluate_object(dev->acpi_dev->handle, "INFO", 958 NULL, &buf); 959 if (ACPI_FAILURE(status) || out_obj.type != ACPI_TYPE_INTEGER) { 960 pr_err("ACPI INFO method execution failed\n"); 961 return -EIO; 962 } 963 964 return out_obj.integer.value; 965 } 966 967 static void toshiba_acpi_report_hotkey(struct toshiba_acpi_dev *dev, 968 int scancode) 969 { 970 if (scancode == 0x100) 971 return; 972 973 /* act on key press; ignore key release */ 974 if (scancode & 0x80) 975 return; 976 977 if (!sparse_keymap_report_event(dev->hotkey_dev, scancode, 1, true)) 978 pr_info("Unknown key %x\n", scancode); 979 } 980 981 static int toshiba_acpi_setup_keyboard(struct toshiba_acpi_dev *dev) 982 { 983 acpi_status status; 984 acpi_handle ec_handle, handle; 985 int error; 986 u32 hci_result; 987 988 dev->hotkey_dev = input_allocate_device(); 989 if (!dev->hotkey_dev) { 990 pr_info("Unable to register input device\n"); 991 return -ENOMEM; 992 } 993 994 dev->hotkey_dev->name = "Toshiba input device"; 995 dev->hotkey_dev->phys = "toshiba_acpi/input0"; 996 dev->hotkey_dev->id.bustype = BUS_HOST; 997 998 error = sparse_keymap_setup(dev->hotkey_dev, toshiba_acpi_keymap, NULL); 999 if (error) 1000 goto err_free_dev; 1001 1002 /* 1003 * For some machines the SCI responsible for providing hotkey 1004 * notification doesn't fire. We can trigger the notification 1005 * whenever the Fn key is pressed using the NTFY method, if 1006 * supported, so if it's present set up an i8042 key filter 1007 * for this purpose. 1008 */ 1009 status = AE_ERROR; 1010 ec_handle = ec_get_handle(); 1011 if (ec_handle) 1012 status = acpi_get_handle(ec_handle, "NTFY", &handle); 1013 1014 if (ACPI_SUCCESS(status)) { 1015 INIT_WORK(&dev->hotkey_work, toshiba_acpi_hotkey_work); 1016 1017 error = i8042_install_filter(toshiba_acpi_i8042_filter); 1018 if (error) { 1019 pr_err("Error installing key filter\n"); 1020 goto err_free_keymap; 1021 } 1022 1023 dev->ntfy_supported = 1; 1024 } 1025 1026 /* 1027 * Determine hotkey query interface. Prefer using the INFO 1028 * method when it is available. 1029 */ 1030 status = acpi_get_handle(dev->acpi_dev->handle, "INFO", &handle); 1031 if (ACPI_SUCCESS(status)) { 1032 dev->info_supported = 1; 1033 } else { 1034 hci_write1(dev, HCI_SYSTEM_EVENT, 1, &hci_result); 1035 if (hci_result == HCI_SUCCESS) 1036 dev->system_event_supported = 1; 1037 } 1038 1039 if (!dev->info_supported && !dev->system_event_supported) { 1040 pr_warn("No hotkey query interface found\n"); 1041 goto err_remove_filter; 1042 } 1043 1044 status = acpi_evaluate_object(dev->acpi_dev->handle, "ENAB", NULL, NULL); 1045 if (ACPI_FAILURE(status)) { 1046 pr_info("Unable to enable hotkeys\n"); 1047 error = -ENODEV; 1048 goto err_remove_filter; 1049 } 1050 1051 error = input_register_device(dev->hotkey_dev); 1052 if (error) { 1053 pr_info("Unable to register input device\n"); 1054 goto err_remove_filter; 1055 } 1056 1057 hci_write1(dev, HCI_HOTKEY_EVENT, HCI_HOTKEY_ENABLE, &hci_result); 1058 return 0; 1059 1060 err_remove_filter: 1061 if (dev->ntfy_supported) 1062 i8042_remove_filter(toshiba_acpi_i8042_filter); 1063 err_free_keymap: 1064 sparse_keymap_free(dev->hotkey_dev); 1065 err_free_dev: 1066 input_free_device(dev->hotkey_dev); 1067 dev->hotkey_dev = NULL; 1068 return error; 1069 } 1070 1071 static int toshiba_acpi_setup_backlight(struct toshiba_acpi_dev *dev) 1072 { 1073 struct backlight_properties props; 1074 int brightness; 1075 int ret; 1076 bool enabled; 1077 1078 /* 1079 * Some machines don't support the backlight methods at all, and 1080 * others support it read-only. Either of these is pretty useless, 1081 * so only register the backlight device if the backlight method 1082 * supports both reads and writes. 1083 */ 1084 brightness = __get_lcd_brightness(dev); 1085 if (brightness < 0) 1086 return 0; 1087 ret = set_lcd_brightness(dev, brightness); 1088 if (ret) { 1089 pr_debug("Backlight method is read-only, disabling backlight support\n"); 1090 return 0; 1091 } 1092 1093 /* Determine whether or not BIOS supports transflective backlight */ 1094 ret = get_tr_backlight_status(dev, &enabled); 1095 dev->tr_backlight_supported = !ret; 1096 1097 memset(&props, 0, sizeof(props)); 1098 props.type = BACKLIGHT_PLATFORM; 1099 props.max_brightness = HCI_LCD_BRIGHTNESS_LEVELS - 1; 1100 1101 /* adding an extra level and having 0 change to transflective mode */ 1102 if (dev->tr_backlight_supported) 1103 props.max_brightness++; 1104 1105 dev->backlight_dev = backlight_device_register("toshiba", 1106 &dev->acpi_dev->dev, 1107 dev, 1108 &toshiba_backlight_data, 1109 &props); 1110 if (IS_ERR(dev->backlight_dev)) { 1111 ret = PTR_ERR(dev->backlight_dev); 1112 pr_err("Could not register toshiba backlight device\n"); 1113 dev->backlight_dev = NULL; 1114 return ret; 1115 } 1116 1117 dev->backlight_dev->props.brightness = brightness; 1118 return 0; 1119 } 1120 1121 static int toshiba_acpi_remove(struct acpi_device *acpi_dev, int type) 1122 { 1123 struct toshiba_acpi_dev *dev = acpi_driver_data(acpi_dev); 1124 1125 remove_toshiba_proc_entries(dev); 1126 1127 if (dev->ntfy_supported) { 1128 i8042_remove_filter(toshiba_acpi_i8042_filter); 1129 cancel_work_sync(&dev->hotkey_work); 1130 } 1131 1132 if (dev->hotkey_dev) { 1133 input_unregister_device(dev->hotkey_dev); 1134 sparse_keymap_free(dev->hotkey_dev); 1135 } 1136 1137 if (dev->bt_rfk) { 1138 rfkill_unregister(dev->bt_rfk); 1139 rfkill_destroy(dev->bt_rfk); 1140 } 1141 1142 if (dev->backlight_dev) 1143 backlight_device_unregister(dev->backlight_dev); 1144 1145 if (dev->illumination_supported) 1146 led_classdev_unregister(&dev->led_dev); 1147 1148 if (toshiba_acpi) 1149 toshiba_acpi = NULL; 1150 1151 kfree(dev); 1152 1153 return 0; 1154 } 1155 1156 static const char *find_hci_method(acpi_handle handle) 1157 { 1158 acpi_status status; 1159 acpi_handle hci_handle; 1160 1161 status = acpi_get_handle(handle, "GHCI", &hci_handle); 1162 if (ACPI_SUCCESS(status)) 1163 return "GHCI"; 1164 1165 status = acpi_get_handle(handle, "SPFC", &hci_handle); 1166 if (ACPI_SUCCESS(status)) 1167 return "SPFC"; 1168 1169 return NULL; 1170 } 1171 1172 static int toshiba_acpi_add(struct acpi_device *acpi_dev) 1173 { 1174 struct toshiba_acpi_dev *dev; 1175 const char *hci_method; 1176 u32 dummy; 1177 bool bt_present; 1178 int ret = 0; 1179 1180 if (toshiba_acpi) 1181 return -EBUSY; 1182 1183 pr_info("Toshiba Laptop ACPI Extras version %s\n", 1184 TOSHIBA_ACPI_VERSION); 1185 1186 hci_method = find_hci_method(acpi_dev->handle); 1187 if (!hci_method) { 1188 pr_err("HCI interface not found\n"); 1189 return -ENODEV; 1190 } 1191 1192 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 1193 if (!dev) 1194 return -ENOMEM; 1195 dev->acpi_dev = acpi_dev; 1196 dev->method_hci = hci_method; 1197 acpi_dev->driver_data = dev; 1198 1199 if (toshiba_acpi_setup_keyboard(dev)) 1200 pr_info("Unable to activate hotkeys\n"); 1201 1202 mutex_init(&dev->mutex); 1203 1204 ret = toshiba_acpi_setup_backlight(dev); 1205 if (ret) 1206 goto error; 1207 1208 /* Register rfkill switch for Bluetooth */ 1209 if (hci_get_bt_present(dev, &bt_present) == HCI_SUCCESS && bt_present) { 1210 dev->bt_rfk = rfkill_alloc("Toshiba Bluetooth", 1211 &acpi_dev->dev, 1212 RFKILL_TYPE_BLUETOOTH, 1213 &toshiba_rfk_ops, 1214 dev); 1215 if (!dev->bt_rfk) { 1216 pr_err("unable to allocate rfkill device\n"); 1217 ret = -ENOMEM; 1218 goto error; 1219 } 1220 1221 ret = rfkill_register(dev->bt_rfk); 1222 if (ret) { 1223 pr_err("unable to register rfkill device\n"); 1224 rfkill_destroy(dev->bt_rfk); 1225 goto error; 1226 } 1227 } 1228 1229 if (toshiba_illumination_available(dev)) { 1230 dev->led_dev.name = "toshiba::illumination"; 1231 dev->led_dev.max_brightness = 1; 1232 dev->led_dev.brightness_set = toshiba_illumination_set; 1233 dev->led_dev.brightness_get = toshiba_illumination_get; 1234 if (!led_classdev_register(&acpi_dev->dev, &dev->led_dev)) 1235 dev->illumination_supported = 1; 1236 } 1237 1238 /* Determine whether or not BIOS supports fan and video interfaces */ 1239 1240 ret = get_video_status(dev, &dummy); 1241 dev->video_supported = !ret; 1242 1243 ret = get_fan_status(dev, &dummy); 1244 dev->fan_supported = !ret; 1245 1246 create_toshiba_proc_entries(dev); 1247 1248 toshiba_acpi = dev; 1249 1250 return 0; 1251 1252 error: 1253 toshiba_acpi_remove(acpi_dev, 0); 1254 return ret; 1255 } 1256 1257 static void toshiba_acpi_notify(struct acpi_device *acpi_dev, u32 event) 1258 { 1259 struct toshiba_acpi_dev *dev = acpi_driver_data(acpi_dev); 1260 u32 hci_result, value; 1261 int retries = 3; 1262 int scancode; 1263 1264 if (event != 0x80) 1265 return; 1266 1267 if (dev->info_supported) { 1268 scancode = toshiba_acpi_query_hotkey(dev); 1269 if (scancode < 0) 1270 pr_err("Failed to query hotkey event\n"); 1271 else if (scancode != 0) 1272 toshiba_acpi_report_hotkey(dev, scancode); 1273 } else if (dev->system_event_supported) { 1274 do { 1275 hci_read1(dev, HCI_SYSTEM_EVENT, &value, &hci_result); 1276 switch (hci_result) { 1277 case HCI_SUCCESS: 1278 toshiba_acpi_report_hotkey(dev, (int)value); 1279 break; 1280 case HCI_NOT_SUPPORTED: 1281 /* 1282 * This is a workaround for an unresolved 1283 * issue on some machines where system events 1284 * sporadically become disabled. 1285 */ 1286 hci_write1(dev, HCI_SYSTEM_EVENT, 1, 1287 &hci_result); 1288 pr_notice("Re-enabled hotkeys\n"); 1289 /* fall through */ 1290 default: 1291 retries--; 1292 break; 1293 } 1294 } while (retries && hci_result != HCI_EMPTY); 1295 } 1296 } 1297 1298 #ifdef CONFIG_PM_SLEEP 1299 static int toshiba_acpi_suspend(struct device *device) 1300 { 1301 struct toshiba_acpi_dev *dev = acpi_driver_data(to_acpi_device(device)); 1302 u32 result; 1303 1304 if (dev->hotkey_dev) 1305 hci_write1(dev, HCI_HOTKEY_EVENT, HCI_HOTKEY_DISABLE, &result); 1306 1307 return 0; 1308 } 1309 1310 static int toshiba_acpi_resume(struct device *device) 1311 { 1312 struct toshiba_acpi_dev *dev = acpi_driver_data(to_acpi_device(device)); 1313 u32 result; 1314 1315 if (dev->hotkey_dev) 1316 hci_write1(dev, HCI_HOTKEY_EVENT, HCI_HOTKEY_ENABLE, &result); 1317 1318 return 0; 1319 } 1320 #endif 1321 1322 static SIMPLE_DEV_PM_OPS(toshiba_acpi_pm, 1323 toshiba_acpi_suspend, toshiba_acpi_resume); 1324 1325 static struct acpi_driver toshiba_acpi_driver = { 1326 .name = "Toshiba ACPI driver", 1327 .owner = THIS_MODULE, 1328 .ids = toshiba_device_ids, 1329 .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS, 1330 .ops = { 1331 .add = toshiba_acpi_add, 1332 .remove = toshiba_acpi_remove, 1333 .notify = toshiba_acpi_notify, 1334 }, 1335 .drv.pm = &toshiba_acpi_pm, 1336 }; 1337 1338 static int __init toshiba_acpi_init(void) 1339 { 1340 int ret; 1341 1342 /* 1343 * Machines with this WMI guid aren't supported due to bugs in 1344 * their AML. This check relies on wmi initializing before 1345 * toshiba_acpi to guarantee guids have been identified. 1346 */ 1347 if (wmi_has_guid(TOSHIBA_WMI_EVENT_GUID)) 1348 return -ENODEV; 1349 1350 toshiba_proc_dir = proc_mkdir(PROC_TOSHIBA, acpi_root_dir); 1351 if (!toshiba_proc_dir) { 1352 pr_err("Unable to create proc dir " PROC_TOSHIBA "\n"); 1353 return -ENODEV; 1354 } 1355 1356 ret = acpi_bus_register_driver(&toshiba_acpi_driver); 1357 if (ret) { 1358 pr_err("Failed to register ACPI driver: %d\n", ret); 1359 remove_proc_entry(PROC_TOSHIBA, acpi_root_dir); 1360 } 1361 1362 return ret; 1363 } 1364 1365 static void __exit toshiba_acpi_exit(void) 1366 { 1367 acpi_bus_unregister_driver(&toshiba_acpi_driver); 1368 if (toshiba_proc_dir) 1369 remove_proc_entry(PROC_TOSHIBA, acpi_root_dir); 1370 } 1371 1372 module_init(toshiba_acpi_init); 1373 module_exit(toshiba_acpi_exit); 1374