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