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 * Copyright (C) 2014 Azael Avalos 9 * 10 * This program is free software; you can redistribute it and/or modify 11 * it under the terms of the GNU General Public License as published by 12 * the Free Software Foundation; either version 2 of the License, or 13 * (at your option) any later version. 14 * 15 * This program is distributed in the hope that it will be useful, 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 * GNU General Public License for more details. 19 * 20 * You should have received a copy of the GNU General Public License 21 * along with this program; if not, write to the Free Software 22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 23 * 24 * 25 * The devolpment page for this driver is located at 26 * http://memebeam.org/toys/ToshibaAcpiDriver. 27 * 28 * Credits: 29 * Jonathan A. Buzzard - Toshiba HCI info, and critical tips on reverse 30 * engineering the Windows drivers 31 * Yasushi Nagato - changes for linux kernel 2.4 -> 2.5 32 * Rob Miller - TV out and hotkeys help 33 * 34 * 35 * TODO 36 * 37 */ 38 39 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 40 41 #define TOSHIBA_ACPI_VERSION "0.20" 42 #define PROC_INTERFACE_VERSION 1 43 44 #include <linux/kernel.h> 45 #include <linux/module.h> 46 #include <linux/init.h> 47 #include <linux/types.h> 48 #include <linux/proc_fs.h> 49 #include <linux/seq_file.h> 50 #include <linux/backlight.h> 51 #include <linux/rfkill.h> 52 #include <linux/input.h> 53 #include <linux/input/sparse-keymap.h> 54 #include <linux/leds.h> 55 #include <linux/slab.h> 56 #include <linux/workqueue.h> 57 #include <linux/i8042.h> 58 #include <linux/acpi.h> 59 #include <linux/dmi.h> 60 #include <asm/uaccess.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 * SCI stands for "System Configuration Interface" which aim is to 84 * conceal differences in hardware between different models. 85 */ 86 87 #define HCI_WORDS 6 88 89 /* operations */ 90 #define HCI_SET 0xff00 91 #define HCI_GET 0xfe00 92 #define SCI_OPEN 0xf100 93 #define SCI_CLOSE 0xf200 94 #define SCI_GET 0xf300 95 #define SCI_SET 0xf400 96 97 /* return codes */ 98 #define HCI_SUCCESS 0x0000 99 #define HCI_FAILURE 0x1000 100 #define HCI_NOT_SUPPORTED 0x8000 101 #define HCI_EMPTY 0x8c00 102 #define HCI_DATA_NOT_AVAILABLE 0x8d20 103 #define HCI_NOT_INITIALIZED 0x8d50 104 #define SCI_OPEN_CLOSE_OK 0x0044 105 #define SCI_ALREADY_OPEN 0x8100 106 #define SCI_NOT_OPENED 0x8200 107 #define SCI_INPUT_DATA_ERROR 0x8300 108 #define SCI_NOT_PRESENT 0x8600 109 110 /* registers */ 111 #define HCI_FAN 0x0004 112 #define HCI_TR_BACKLIGHT 0x0005 113 #define HCI_SYSTEM_EVENT 0x0016 114 #define HCI_VIDEO_OUT 0x001c 115 #define HCI_HOTKEY_EVENT 0x001e 116 #define HCI_LCD_BRIGHTNESS 0x002a 117 #define HCI_WIRELESS 0x0056 118 #define HCI_ACCELEROMETER 0x006d 119 #define HCI_KBD_ILLUMINATION 0x0095 120 #define HCI_ECO_MODE 0x0097 121 #define HCI_ACCELEROMETER2 0x00a6 122 #define SCI_ILLUMINATION 0x014e 123 #define SCI_KBD_ILLUM_STATUS 0x015c 124 #define SCI_TOUCHPAD 0x050e 125 126 /* field definitions */ 127 #define HCI_ACCEL_MASK 0x7fff 128 #define HCI_HOTKEY_DISABLE 0x0b 129 #define HCI_HOTKEY_ENABLE 0x09 130 #define HCI_LCD_BRIGHTNESS_BITS 3 131 #define HCI_LCD_BRIGHTNESS_SHIFT (16-HCI_LCD_BRIGHTNESS_BITS) 132 #define HCI_LCD_BRIGHTNESS_LEVELS (1 << HCI_LCD_BRIGHTNESS_BITS) 133 #define HCI_MISC_SHIFT 0x10 134 #define HCI_VIDEO_OUT_LCD 0x1 135 #define HCI_VIDEO_OUT_CRT 0x2 136 #define HCI_VIDEO_OUT_TV 0x4 137 #define HCI_WIRELESS_KILL_SWITCH 0x01 138 #define HCI_WIRELESS_BT_PRESENT 0x0f 139 #define HCI_WIRELESS_BT_ATTACH 0x40 140 #define HCI_WIRELESS_BT_POWER 0x80 141 #define SCI_KBD_MODE_FNZ 0x1 142 #define SCI_KBD_MODE_AUTO 0x2 143 144 struct toshiba_acpi_dev { 145 struct acpi_device *acpi_dev; 146 const char *method_hci; 147 struct rfkill *bt_rfk; 148 struct input_dev *hotkey_dev; 149 struct work_struct hotkey_work; 150 struct backlight_device *backlight_dev; 151 struct led_classdev led_dev; 152 struct led_classdev kbd_led; 153 struct led_classdev eco_led; 154 155 int force_fan; 156 int last_key_event; 157 int key_event_valid; 158 int kbd_mode; 159 int kbd_time; 160 161 unsigned int illumination_supported:1; 162 unsigned int video_supported:1; 163 unsigned int fan_supported:1; 164 unsigned int system_event_supported:1; 165 unsigned int ntfy_supported:1; 166 unsigned int info_supported:1; 167 unsigned int tr_backlight_supported:1; 168 unsigned int kbd_illum_supported:1; 169 unsigned int kbd_led_registered:1; 170 unsigned int touchpad_supported:1; 171 unsigned int eco_supported:1; 172 unsigned int accelerometer_supported:1; 173 unsigned int sysfs_created:1; 174 175 struct mutex mutex; 176 }; 177 178 static struct toshiba_acpi_dev *toshiba_acpi; 179 180 static const struct acpi_device_id toshiba_device_ids[] = { 181 {"TOS6200", 0}, 182 {"TOS6208", 0}, 183 {"TOS1900", 0}, 184 {"", 0}, 185 }; 186 MODULE_DEVICE_TABLE(acpi, toshiba_device_ids); 187 188 static const struct key_entry toshiba_acpi_keymap[] = { 189 { KE_KEY, 0x9e, { KEY_RFKILL } }, 190 { KE_KEY, 0x101, { KEY_MUTE } }, 191 { KE_KEY, 0x102, { KEY_ZOOMOUT } }, 192 { KE_KEY, 0x103, { KEY_ZOOMIN } }, 193 { KE_KEY, 0x12c, { KEY_KBDILLUMTOGGLE } }, 194 { KE_KEY, 0x139, { KEY_ZOOMRESET } }, 195 { KE_KEY, 0x13b, { KEY_COFFEE } }, 196 { KE_KEY, 0x13c, { KEY_BATTERY } }, 197 { KE_KEY, 0x13d, { KEY_SLEEP } }, 198 { KE_KEY, 0x13e, { KEY_SUSPEND } }, 199 { KE_KEY, 0x13f, { KEY_SWITCHVIDEOMODE } }, 200 { KE_KEY, 0x140, { KEY_BRIGHTNESSDOWN } }, 201 { KE_KEY, 0x141, { KEY_BRIGHTNESSUP } }, 202 { KE_KEY, 0x142, { KEY_WLAN } }, 203 { KE_KEY, 0x143, { KEY_TOUCHPAD_TOGGLE } }, 204 { KE_KEY, 0x17f, { KEY_FN } }, 205 { KE_KEY, 0xb05, { KEY_PROG2 } }, 206 { KE_KEY, 0xb06, { KEY_WWW } }, 207 { KE_KEY, 0xb07, { KEY_MAIL } }, 208 { KE_KEY, 0xb30, { KEY_STOP } }, 209 { KE_KEY, 0xb31, { KEY_PREVIOUSSONG } }, 210 { KE_KEY, 0xb32, { KEY_NEXTSONG } }, 211 { KE_KEY, 0xb33, { KEY_PLAYPAUSE } }, 212 { KE_KEY, 0xb5a, { KEY_MEDIA } }, 213 { KE_IGNORE, 0x1430, { KEY_RESERVED } }, 214 { KE_END, 0 }, 215 }; 216 217 /* alternative keymap */ 218 static const struct dmi_system_id toshiba_alt_keymap_dmi[] = { 219 { 220 .matches = { 221 DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"), 222 DMI_MATCH(DMI_PRODUCT_NAME, "Satellite M840"), 223 }, 224 }, 225 { 226 .matches = { 227 DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"), 228 DMI_MATCH(DMI_PRODUCT_NAME, "Qosmio X75-A"), 229 }, 230 }, 231 {} 232 }; 233 234 static const struct key_entry toshiba_acpi_alt_keymap[] = { 235 { KE_KEY, 0x157, { KEY_MUTE } }, 236 { KE_KEY, 0x102, { KEY_ZOOMOUT } }, 237 { KE_KEY, 0x103, { KEY_ZOOMIN } }, 238 { KE_KEY, 0x12c, { KEY_KBDILLUMTOGGLE } }, 239 { KE_KEY, 0x139, { KEY_ZOOMRESET } }, 240 { KE_KEY, 0x13e, { KEY_SWITCHVIDEOMODE } }, 241 { KE_KEY, 0x13c, { KEY_BRIGHTNESSDOWN } }, 242 { KE_KEY, 0x13d, { KEY_BRIGHTNESSUP } }, 243 { KE_KEY, 0x158, { KEY_WLAN } }, 244 { KE_KEY, 0x13f, { KEY_TOUCHPAD_TOGGLE } }, 245 { KE_END, 0 }, 246 }; 247 248 /* utility 249 */ 250 251 static __inline__ void _set_bit(u32 * word, u32 mask, int value) 252 { 253 *word = (*word & ~mask) | (mask * value); 254 } 255 256 /* acpi interface wrappers 257 */ 258 259 static int write_acpi_int(const char *methodName, int val) 260 { 261 acpi_status status; 262 263 status = acpi_execute_simple_method(NULL, (char *)methodName, val); 264 return (status == AE_OK) ? 0 : -EIO; 265 } 266 267 /* Perform a raw HCI call. Here we don't care about input or output buffer 268 * format. 269 */ 270 static acpi_status hci_raw(struct toshiba_acpi_dev *dev, 271 const u32 in[HCI_WORDS], u32 out[HCI_WORDS]) 272 { 273 struct acpi_object_list params; 274 union acpi_object in_objs[HCI_WORDS]; 275 struct acpi_buffer results; 276 union acpi_object out_objs[HCI_WORDS + 1]; 277 acpi_status status; 278 int i; 279 280 params.count = HCI_WORDS; 281 params.pointer = in_objs; 282 for (i = 0; i < HCI_WORDS; ++i) { 283 in_objs[i].type = ACPI_TYPE_INTEGER; 284 in_objs[i].integer.value = in[i]; 285 } 286 287 results.length = sizeof(out_objs); 288 results.pointer = out_objs; 289 290 status = acpi_evaluate_object(dev->acpi_dev->handle, 291 (char *)dev->method_hci, ¶ms, 292 &results); 293 if ((status == AE_OK) && (out_objs->package.count <= HCI_WORDS)) { 294 for (i = 0; i < out_objs->package.count; ++i) { 295 out[i] = out_objs->package.elements[i].integer.value; 296 } 297 } 298 299 return status; 300 } 301 302 /* common hci tasks (get or set one or two value) 303 * 304 * In addition to the ACPI status, the HCI system returns a result which 305 * may be useful (such as "not supported"). 306 */ 307 308 static acpi_status hci_write1(struct toshiba_acpi_dev *dev, u32 reg, 309 u32 in1, u32 *result) 310 { 311 u32 in[HCI_WORDS] = { HCI_SET, reg, in1, 0, 0, 0 }; 312 u32 out[HCI_WORDS]; 313 acpi_status status = hci_raw(dev, in, out); 314 *result = (status == AE_OK) ? out[0] : HCI_FAILURE; 315 return status; 316 } 317 318 static acpi_status hci_read1(struct toshiba_acpi_dev *dev, u32 reg, 319 u32 *out1, u32 *result) 320 { 321 u32 in[HCI_WORDS] = { HCI_GET, reg, 0, 0, 0, 0 }; 322 u32 out[HCI_WORDS]; 323 acpi_status status = hci_raw(dev, in, out); 324 *out1 = out[2]; 325 *result = (status == AE_OK) ? out[0] : HCI_FAILURE; 326 return status; 327 } 328 329 static acpi_status hci_write2(struct toshiba_acpi_dev *dev, u32 reg, 330 u32 in1, u32 in2, u32 *result) 331 { 332 u32 in[HCI_WORDS] = { HCI_SET, reg, in1, in2, 0, 0 }; 333 u32 out[HCI_WORDS]; 334 acpi_status status = hci_raw(dev, in, out); 335 *result = (status == AE_OK) ? out[0] : HCI_FAILURE; 336 return status; 337 } 338 339 static acpi_status hci_read2(struct toshiba_acpi_dev *dev, u32 reg, 340 u32 *out1, u32 *out2, u32 *result) 341 { 342 u32 in[HCI_WORDS] = { HCI_GET, reg, *out1, *out2, 0, 0 }; 343 u32 out[HCI_WORDS]; 344 acpi_status status = hci_raw(dev, in, out); 345 *out1 = out[2]; 346 *out2 = out[3]; 347 *result = (status == AE_OK) ? out[0] : HCI_FAILURE; 348 return status; 349 } 350 351 /* common sci tasks 352 */ 353 354 static int sci_open(struct toshiba_acpi_dev *dev) 355 { 356 u32 in[HCI_WORDS] = { SCI_OPEN, 0, 0, 0, 0, 0 }; 357 u32 out[HCI_WORDS]; 358 acpi_status status; 359 360 status = hci_raw(dev, in, out); 361 if (ACPI_FAILURE(status) || out[0] == HCI_FAILURE) { 362 pr_err("ACPI call to open SCI failed\n"); 363 return 0; 364 } 365 366 if (out[0] == SCI_OPEN_CLOSE_OK) { 367 return 1; 368 } else if (out[0] == SCI_ALREADY_OPEN) { 369 pr_info("Toshiba SCI already opened\n"); 370 return 1; 371 } else if (out[0] == SCI_NOT_PRESENT) { 372 pr_info("Toshiba SCI is not present\n"); 373 } 374 375 return 0; 376 } 377 378 static void sci_close(struct toshiba_acpi_dev *dev) 379 { 380 u32 in[HCI_WORDS] = { SCI_CLOSE, 0, 0, 0, 0, 0 }; 381 u32 out[HCI_WORDS]; 382 acpi_status status; 383 384 status = hci_raw(dev, in, out); 385 if (ACPI_FAILURE(status) || out[0] == HCI_FAILURE) { 386 pr_err("ACPI call to close SCI failed\n"); 387 return; 388 } 389 390 if (out[0] == SCI_OPEN_CLOSE_OK) 391 return; 392 else if (out[0] == SCI_NOT_OPENED) 393 pr_info("Toshiba SCI not opened\n"); 394 else if (out[0] == SCI_NOT_PRESENT) 395 pr_info("Toshiba SCI is not present\n"); 396 } 397 398 static acpi_status sci_read(struct toshiba_acpi_dev *dev, u32 reg, 399 u32 *out1, u32 *result) 400 { 401 u32 in[HCI_WORDS] = { SCI_GET, reg, 0, 0, 0, 0 }; 402 u32 out[HCI_WORDS]; 403 acpi_status status = hci_raw(dev, in, out); 404 *out1 = out[2]; 405 *result = (ACPI_SUCCESS(status)) ? out[0] : HCI_FAILURE; 406 return status; 407 } 408 409 static acpi_status sci_write(struct toshiba_acpi_dev *dev, u32 reg, 410 u32 in1, u32 *result) 411 { 412 u32 in[HCI_WORDS] = { SCI_SET, reg, in1, 0, 0, 0 }; 413 u32 out[HCI_WORDS]; 414 acpi_status status = hci_raw(dev, in, out); 415 *result = (ACPI_SUCCESS(status)) ? out[0] : HCI_FAILURE; 416 return status; 417 } 418 419 /* Illumination support */ 420 static int toshiba_illumination_available(struct toshiba_acpi_dev *dev) 421 { 422 u32 in[HCI_WORDS] = { SCI_GET, SCI_ILLUMINATION, 0, 0, 0, 0 }; 423 u32 out[HCI_WORDS]; 424 acpi_status status; 425 426 if (!sci_open(dev)) 427 return 0; 428 429 status = hci_raw(dev, in, out); 430 sci_close(dev); 431 if (ACPI_FAILURE(status) || out[0] == HCI_FAILURE) { 432 pr_err("ACPI call to query Illumination support failed\n"); 433 return 0; 434 } else if (out[0] == HCI_NOT_SUPPORTED || out[1] != 1) { 435 pr_info("Illumination device not available\n"); 436 return 0; 437 } 438 439 return 1; 440 } 441 442 static void toshiba_illumination_set(struct led_classdev *cdev, 443 enum led_brightness brightness) 444 { 445 struct toshiba_acpi_dev *dev = container_of(cdev, 446 struct toshiba_acpi_dev, led_dev); 447 u32 state, result; 448 acpi_status status; 449 450 /* First request : initialize communication. */ 451 if (!sci_open(dev)) 452 return; 453 454 /* Switch the illumination on/off */ 455 state = brightness ? 1 : 0; 456 status = sci_write(dev, SCI_ILLUMINATION, state, &result); 457 sci_close(dev); 458 if (ACPI_FAILURE(status)) { 459 pr_err("ACPI call for illumination failed\n"); 460 return; 461 } else if (result == HCI_NOT_SUPPORTED) { 462 pr_info("Illumination not supported\n"); 463 return; 464 } 465 } 466 467 static enum led_brightness toshiba_illumination_get(struct led_classdev *cdev) 468 { 469 struct toshiba_acpi_dev *dev = container_of(cdev, 470 struct toshiba_acpi_dev, led_dev); 471 u32 state, result; 472 acpi_status status; 473 474 /* First request : initialize communication. */ 475 if (!sci_open(dev)) 476 return LED_OFF; 477 478 /* Check the illumination */ 479 status = sci_read(dev, SCI_ILLUMINATION, &state, &result); 480 sci_close(dev); 481 if (ACPI_FAILURE(status) || result == SCI_INPUT_DATA_ERROR) { 482 pr_err("ACPI call for illumination failed\n"); 483 return LED_OFF; 484 } else if (result == HCI_NOT_SUPPORTED) { 485 pr_info("Illumination not supported\n"); 486 return LED_OFF; 487 } 488 489 return state ? LED_FULL : LED_OFF; 490 } 491 492 /* KBD Illumination */ 493 static int toshiba_kbd_illum_status_set(struct toshiba_acpi_dev *dev, u32 time) 494 { 495 u32 result; 496 acpi_status status; 497 498 if (!sci_open(dev)) 499 return -EIO; 500 501 status = sci_write(dev, SCI_KBD_ILLUM_STATUS, time, &result); 502 sci_close(dev); 503 if (ACPI_FAILURE(status) || result == SCI_INPUT_DATA_ERROR) { 504 pr_err("ACPI call to set KBD backlight status failed\n"); 505 return -EIO; 506 } else if (result == HCI_NOT_SUPPORTED) { 507 pr_info("Keyboard backlight status not supported\n"); 508 return -ENODEV; 509 } 510 511 return 0; 512 } 513 514 static int toshiba_kbd_illum_status_get(struct toshiba_acpi_dev *dev, u32 *time) 515 { 516 u32 result; 517 acpi_status status; 518 519 if (!sci_open(dev)) 520 return -EIO; 521 522 status = sci_read(dev, SCI_KBD_ILLUM_STATUS, time, &result); 523 sci_close(dev); 524 if (ACPI_FAILURE(status) || result == SCI_INPUT_DATA_ERROR) { 525 pr_err("ACPI call to get KBD backlight status failed\n"); 526 return -EIO; 527 } else if (result == HCI_NOT_SUPPORTED) { 528 pr_info("Keyboard backlight status not supported\n"); 529 return -ENODEV; 530 } 531 532 return 0; 533 } 534 535 static enum led_brightness toshiba_kbd_backlight_get(struct led_classdev *cdev) 536 { 537 struct toshiba_acpi_dev *dev = container_of(cdev, 538 struct toshiba_acpi_dev, kbd_led); 539 u32 state, result; 540 acpi_status status; 541 542 /* Check the keyboard backlight state */ 543 status = hci_read1(dev, HCI_KBD_ILLUMINATION, &state, &result); 544 if (ACPI_FAILURE(status) || result == SCI_INPUT_DATA_ERROR) { 545 pr_err("ACPI call to get the keyboard backlight failed\n"); 546 return LED_OFF; 547 } else if (result == HCI_NOT_SUPPORTED) { 548 pr_info("Keyboard backlight not supported\n"); 549 return LED_OFF; 550 } 551 552 return state ? LED_FULL : LED_OFF; 553 } 554 555 static void toshiba_kbd_backlight_set(struct led_classdev *cdev, 556 enum led_brightness brightness) 557 { 558 struct toshiba_acpi_dev *dev = container_of(cdev, 559 struct toshiba_acpi_dev, kbd_led); 560 u32 state, result; 561 acpi_status status; 562 563 /* Set the keyboard backlight state */ 564 state = brightness ? 1 : 0; 565 status = hci_write1(dev, HCI_KBD_ILLUMINATION, state, &result); 566 if (ACPI_FAILURE(status) || result == SCI_INPUT_DATA_ERROR) { 567 pr_err("ACPI call to set KBD Illumination mode failed\n"); 568 return; 569 } else if (result == HCI_NOT_SUPPORTED) { 570 pr_info("Keyboard backlight not supported\n"); 571 return; 572 } 573 } 574 575 /* TouchPad support */ 576 static int toshiba_touchpad_set(struct toshiba_acpi_dev *dev, u32 state) 577 { 578 u32 result; 579 acpi_status status; 580 581 if (!sci_open(dev)) 582 return -EIO; 583 584 status = sci_write(dev, SCI_TOUCHPAD, state, &result); 585 sci_close(dev); 586 if (ACPI_FAILURE(status)) { 587 pr_err("ACPI call to set the touchpad failed\n"); 588 return -EIO; 589 } else if (result == HCI_NOT_SUPPORTED) { 590 return -ENODEV; 591 } 592 593 return 0; 594 } 595 596 static int toshiba_touchpad_get(struct toshiba_acpi_dev *dev, u32 *state) 597 { 598 u32 result; 599 acpi_status status; 600 601 if (!sci_open(dev)) 602 return -EIO; 603 604 status = sci_read(dev, SCI_TOUCHPAD, state, &result); 605 sci_close(dev); 606 if (ACPI_FAILURE(status)) { 607 pr_err("ACPI call to query the touchpad failed\n"); 608 return -EIO; 609 } else if (result == HCI_NOT_SUPPORTED) { 610 return -ENODEV; 611 } 612 613 return 0; 614 } 615 616 /* Eco Mode support */ 617 static int toshiba_eco_mode_available(struct toshiba_acpi_dev *dev) 618 { 619 acpi_status status; 620 u32 in[HCI_WORDS] = { HCI_GET, HCI_ECO_MODE, 0, 1, 0, 0 }; 621 u32 out[HCI_WORDS]; 622 623 status = hci_raw(dev, in, out); 624 if (ACPI_FAILURE(status) || out[0] == SCI_INPUT_DATA_ERROR) { 625 pr_info("ACPI call to get ECO led failed\n"); 626 return 0; 627 } 628 629 return 1; 630 } 631 632 static enum led_brightness toshiba_eco_mode_get_status(struct led_classdev *cdev) 633 { 634 struct toshiba_acpi_dev *dev = container_of(cdev, 635 struct toshiba_acpi_dev, eco_led); 636 u32 in[HCI_WORDS] = { HCI_GET, HCI_ECO_MODE, 0, 1, 0, 0 }; 637 u32 out[HCI_WORDS]; 638 acpi_status status; 639 640 status = hci_raw(dev, in, out); 641 if (ACPI_FAILURE(status) || out[0] == SCI_INPUT_DATA_ERROR) { 642 pr_err("ACPI call to get ECO led failed\n"); 643 return LED_OFF; 644 } 645 646 return out[2] ? LED_FULL : LED_OFF; 647 } 648 649 static void toshiba_eco_mode_set_status(struct led_classdev *cdev, 650 enum led_brightness brightness) 651 { 652 struct toshiba_acpi_dev *dev = container_of(cdev, 653 struct toshiba_acpi_dev, eco_led); 654 u32 in[HCI_WORDS] = { HCI_SET, HCI_ECO_MODE, 0, 1, 0, 0 }; 655 u32 out[HCI_WORDS]; 656 acpi_status status; 657 658 /* Switch the Eco Mode led on/off */ 659 in[2] = (brightness) ? 1 : 0; 660 status = hci_raw(dev, in, out); 661 if (ACPI_FAILURE(status) || out[0] == SCI_INPUT_DATA_ERROR) { 662 pr_err("ACPI call to set ECO led failed\n"); 663 return; 664 } 665 } 666 667 /* Accelerometer support */ 668 static int toshiba_accelerometer_supported(struct toshiba_acpi_dev *dev) 669 { 670 u32 in[HCI_WORDS] = { HCI_GET, HCI_ACCELEROMETER2, 0, 0, 0, 0 }; 671 u32 out[HCI_WORDS]; 672 acpi_status status; 673 674 /* Check if the accelerometer call exists, 675 * this call also serves as initialization 676 */ 677 status = hci_raw(dev, in, out); 678 if (ACPI_FAILURE(status) || out[0] == SCI_INPUT_DATA_ERROR) { 679 pr_err("ACPI call to query the accelerometer failed\n"); 680 return -EIO; 681 } else if (out[0] == HCI_DATA_NOT_AVAILABLE || 682 out[0] == HCI_NOT_INITIALIZED) { 683 pr_err("Accelerometer not initialized\n"); 684 return -EIO; 685 } else if (out[0] == HCI_NOT_SUPPORTED) { 686 pr_info("Accelerometer not supported\n"); 687 return -ENODEV; 688 } 689 690 return 0; 691 } 692 693 static int toshiba_accelerometer_get(struct toshiba_acpi_dev *dev, 694 u32 *xy, u32 *z) 695 { 696 u32 in[HCI_WORDS] = { HCI_GET, HCI_ACCELEROMETER, 0, 1, 0, 0 }; 697 u32 out[HCI_WORDS]; 698 acpi_status status; 699 700 /* Check the Accelerometer status */ 701 status = hci_raw(dev, in, out); 702 if (ACPI_FAILURE(status) || out[0] == SCI_INPUT_DATA_ERROR) { 703 pr_err("ACPI call to query the accelerometer failed\n"); 704 return -EIO; 705 } 706 707 *xy = out[2]; 708 *z = out[4]; 709 710 return 0; 711 } 712 713 /* Bluetooth rfkill handlers */ 714 715 static u32 hci_get_bt_present(struct toshiba_acpi_dev *dev, bool *present) 716 { 717 u32 hci_result; 718 u32 value, value2; 719 720 value = 0; 721 value2 = 0; 722 hci_read2(dev, HCI_WIRELESS, &value, &value2, &hci_result); 723 if (hci_result == HCI_SUCCESS) 724 *present = (value & HCI_WIRELESS_BT_PRESENT) ? true : false; 725 726 return hci_result; 727 } 728 729 static u32 hci_get_radio_state(struct toshiba_acpi_dev *dev, bool *radio_state) 730 { 731 u32 hci_result; 732 u32 value, value2; 733 734 value = 0; 735 value2 = 0x0001; 736 hci_read2(dev, HCI_WIRELESS, &value, &value2, &hci_result); 737 738 *radio_state = value & HCI_WIRELESS_KILL_SWITCH; 739 return hci_result; 740 } 741 742 static int bt_rfkill_set_block(void *data, bool blocked) 743 { 744 struct toshiba_acpi_dev *dev = data; 745 u32 result1, result2; 746 u32 value; 747 int err; 748 bool radio_state; 749 750 value = (blocked == false); 751 752 mutex_lock(&dev->mutex); 753 if (hci_get_radio_state(dev, &radio_state) != HCI_SUCCESS) { 754 err = -EIO; 755 goto out; 756 } 757 758 if (!radio_state) { 759 err = 0; 760 goto out; 761 } 762 763 hci_write2(dev, HCI_WIRELESS, value, HCI_WIRELESS_BT_POWER, &result1); 764 hci_write2(dev, HCI_WIRELESS, value, HCI_WIRELESS_BT_ATTACH, &result2); 765 766 if (result1 != HCI_SUCCESS || result2 != HCI_SUCCESS) 767 err = -EIO; 768 else 769 err = 0; 770 out: 771 mutex_unlock(&dev->mutex); 772 return err; 773 } 774 775 static void bt_rfkill_poll(struct rfkill *rfkill, void *data) 776 { 777 bool new_rfk_state; 778 bool value; 779 u32 hci_result; 780 struct toshiba_acpi_dev *dev = data; 781 782 mutex_lock(&dev->mutex); 783 784 hci_result = hci_get_radio_state(dev, &value); 785 if (hci_result != HCI_SUCCESS) { 786 /* Can't do anything useful */ 787 mutex_unlock(&dev->mutex); 788 return; 789 } 790 791 new_rfk_state = value; 792 793 mutex_unlock(&dev->mutex); 794 795 if (rfkill_set_hw_state(rfkill, !new_rfk_state)) 796 bt_rfkill_set_block(data, true); 797 } 798 799 static const struct rfkill_ops toshiba_rfk_ops = { 800 .set_block = bt_rfkill_set_block, 801 .poll = bt_rfkill_poll, 802 }; 803 804 static int get_tr_backlight_status(struct toshiba_acpi_dev *dev, bool *enabled) 805 { 806 u32 hci_result; 807 u32 status; 808 809 hci_read1(dev, HCI_TR_BACKLIGHT, &status, &hci_result); 810 *enabled = !status; 811 return hci_result == HCI_SUCCESS ? 0 : -EIO; 812 } 813 814 static int set_tr_backlight_status(struct toshiba_acpi_dev *dev, bool enable) 815 { 816 u32 hci_result; 817 u32 value = !enable; 818 819 hci_write1(dev, HCI_TR_BACKLIGHT, value, &hci_result); 820 return hci_result == HCI_SUCCESS ? 0 : -EIO; 821 } 822 823 static struct proc_dir_entry *toshiba_proc_dir /*= 0*/ ; 824 825 static int __get_lcd_brightness(struct toshiba_acpi_dev *dev) 826 { 827 u32 hci_result; 828 u32 value; 829 int brightness = 0; 830 831 if (dev->tr_backlight_supported) { 832 bool enabled; 833 int ret = get_tr_backlight_status(dev, &enabled); 834 if (ret) 835 return ret; 836 if (enabled) 837 return 0; 838 brightness++; 839 } 840 841 hci_read1(dev, HCI_LCD_BRIGHTNESS, &value, &hci_result); 842 if (hci_result == HCI_SUCCESS) 843 return brightness + (value >> HCI_LCD_BRIGHTNESS_SHIFT); 844 845 return -EIO; 846 } 847 848 static int get_lcd_brightness(struct backlight_device *bd) 849 { 850 struct toshiba_acpi_dev *dev = bl_get_data(bd); 851 return __get_lcd_brightness(dev); 852 } 853 854 static int lcd_proc_show(struct seq_file *m, void *v) 855 { 856 struct toshiba_acpi_dev *dev = m->private; 857 int value; 858 int levels; 859 860 if (!dev->backlight_dev) 861 return -ENODEV; 862 863 levels = dev->backlight_dev->props.max_brightness + 1; 864 value = get_lcd_brightness(dev->backlight_dev); 865 if (value >= 0) { 866 seq_printf(m, "brightness: %d\n", value); 867 seq_printf(m, "brightness_levels: %d\n", levels); 868 return 0; 869 } 870 871 pr_err("Error reading LCD brightness\n"); 872 return -EIO; 873 } 874 875 static int lcd_proc_open(struct inode *inode, struct file *file) 876 { 877 return single_open(file, lcd_proc_show, PDE_DATA(inode)); 878 } 879 880 static int set_lcd_brightness(struct toshiba_acpi_dev *dev, int value) 881 { 882 u32 in[HCI_WORDS] = { HCI_SET, HCI_LCD_BRIGHTNESS, 0, 0, 0, 0 }; 883 u32 out[HCI_WORDS]; 884 acpi_status status; 885 886 if (dev->tr_backlight_supported) { 887 bool enable = !value; 888 int ret = set_tr_backlight_status(dev, enable); 889 if (ret) 890 return ret; 891 if (value) 892 value--; 893 } 894 895 in[2] = value << HCI_LCD_BRIGHTNESS_SHIFT; 896 status = hci_raw(dev, in, out); 897 if (ACPI_FAILURE(status) || out[0] == HCI_FAILURE) { 898 pr_err("ACPI call to set brightness failed"); 899 return -EIO; 900 } 901 /* Extra check for "incomplete" backlight method, where the AML code 902 * doesn't check for HCI_SET or HCI_GET and returns HCI_SUCCESS, 903 * the actual brightness, and in some cases the max brightness. 904 */ 905 if (out[2] > 0 || out[3] == 0xE000) 906 return -ENODEV; 907 908 return out[0] == HCI_SUCCESS ? 0 : -EIO; 909 } 910 911 static int set_lcd_status(struct backlight_device *bd) 912 { 913 struct toshiba_acpi_dev *dev = bl_get_data(bd); 914 return set_lcd_brightness(dev, bd->props.brightness); 915 } 916 917 static ssize_t lcd_proc_write(struct file *file, const char __user *buf, 918 size_t count, loff_t *pos) 919 { 920 struct toshiba_acpi_dev *dev = PDE_DATA(file_inode(file)); 921 char cmd[42]; 922 size_t len; 923 int value; 924 int ret; 925 int levels = dev->backlight_dev->props.max_brightness + 1; 926 927 len = min(count, sizeof(cmd) - 1); 928 if (copy_from_user(cmd, buf, len)) 929 return -EFAULT; 930 cmd[len] = '\0'; 931 932 if (sscanf(cmd, " brightness : %i", &value) == 1 && 933 value >= 0 && value < levels) { 934 ret = set_lcd_brightness(dev, value); 935 if (ret == 0) 936 ret = count; 937 } else { 938 ret = -EINVAL; 939 } 940 return ret; 941 } 942 943 static const struct file_operations lcd_proc_fops = { 944 .owner = THIS_MODULE, 945 .open = lcd_proc_open, 946 .read = seq_read, 947 .llseek = seq_lseek, 948 .release = single_release, 949 .write = lcd_proc_write, 950 }; 951 952 static int get_video_status(struct toshiba_acpi_dev *dev, u32 *status) 953 { 954 u32 hci_result; 955 956 hci_read1(dev, HCI_VIDEO_OUT, status, &hci_result); 957 return hci_result == HCI_SUCCESS ? 0 : -EIO; 958 } 959 960 static int video_proc_show(struct seq_file *m, void *v) 961 { 962 struct toshiba_acpi_dev *dev = m->private; 963 u32 value; 964 int ret; 965 966 ret = get_video_status(dev, &value); 967 if (!ret) { 968 int is_lcd = (value & HCI_VIDEO_OUT_LCD) ? 1 : 0; 969 int is_crt = (value & HCI_VIDEO_OUT_CRT) ? 1 : 0; 970 int is_tv = (value & HCI_VIDEO_OUT_TV) ? 1 : 0; 971 seq_printf(m, "lcd_out: %d\n", is_lcd); 972 seq_printf(m, "crt_out: %d\n", is_crt); 973 seq_printf(m, "tv_out: %d\n", is_tv); 974 } 975 976 return ret; 977 } 978 979 static int video_proc_open(struct inode *inode, struct file *file) 980 { 981 return single_open(file, video_proc_show, PDE_DATA(inode)); 982 } 983 984 static ssize_t video_proc_write(struct file *file, const char __user *buf, 985 size_t count, loff_t *pos) 986 { 987 struct toshiba_acpi_dev *dev = PDE_DATA(file_inode(file)); 988 char *cmd, *buffer; 989 int ret; 990 int value; 991 int remain = count; 992 int lcd_out = -1; 993 int crt_out = -1; 994 int tv_out = -1; 995 u32 video_out; 996 997 cmd = kmalloc(count + 1, GFP_KERNEL); 998 if (!cmd) 999 return -ENOMEM; 1000 if (copy_from_user(cmd, buf, count)) { 1001 kfree(cmd); 1002 return -EFAULT; 1003 } 1004 cmd[count] = '\0'; 1005 1006 buffer = cmd; 1007 1008 /* scan expression. Multiple expressions may be delimited with ; 1009 * 1010 * NOTE: to keep scanning simple, invalid fields are ignored 1011 */ 1012 while (remain) { 1013 if (sscanf(buffer, " lcd_out : %i", &value) == 1) 1014 lcd_out = value & 1; 1015 else if (sscanf(buffer, " crt_out : %i", &value) == 1) 1016 crt_out = value & 1; 1017 else if (sscanf(buffer, " tv_out : %i", &value) == 1) 1018 tv_out = value & 1; 1019 /* advance to one character past the next ; */ 1020 do { 1021 ++buffer; 1022 --remain; 1023 } 1024 while (remain && *(buffer - 1) != ';'); 1025 } 1026 1027 kfree(cmd); 1028 1029 ret = get_video_status(dev, &video_out); 1030 if (!ret) { 1031 unsigned int new_video_out = video_out; 1032 if (lcd_out != -1) 1033 _set_bit(&new_video_out, HCI_VIDEO_OUT_LCD, lcd_out); 1034 if (crt_out != -1) 1035 _set_bit(&new_video_out, HCI_VIDEO_OUT_CRT, crt_out); 1036 if (tv_out != -1) 1037 _set_bit(&new_video_out, HCI_VIDEO_OUT_TV, tv_out); 1038 /* To avoid unnecessary video disruption, only write the new 1039 * video setting if something changed. */ 1040 if (new_video_out != video_out) 1041 ret = write_acpi_int(METHOD_VIDEO_OUT, new_video_out); 1042 } 1043 1044 return ret ? ret : count; 1045 } 1046 1047 static const struct file_operations video_proc_fops = { 1048 .owner = THIS_MODULE, 1049 .open = video_proc_open, 1050 .read = seq_read, 1051 .llseek = seq_lseek, 1052 .release = single_release, 1053 .write = video_proc_write, 1054 }; 1055 1056 static int get_fan_status(struct toshiba_acpi_dev *dev, u32 *status) 1057 { 1058 u32 hci_result; 1059 1060 hci_read1(dev, HCI_FAN, status, &hci_result); 1061 return hci_result == HCI_SUCCESS ? 0 : -EIO; 1062 } 1063 1064 static int fan_proc_show(struct seq_file *m, void *v) 1065 { 1066 struct toshiba_acpi_dev *dev = m->private; 1067 int ret; 1068 u32 value; 1069 1070 ret = get_fan_status(dev, &value); 1071 if (!ret) { 1072 seq_printf(m, "running: %d\n", (value > 0)); 1073 seq_printf(m, "force_on: %d\n", dev->force_fan); 1074 } 1075 1076 return ret; 1077 } 1078 1079 static int fan_proc_open(struct inode *inode, struct file *file) 1080 { 1081 return single_open(file, fan_proc_show, PDE_DATA(inode)); 1082 } 1083 1084 static ssize_t fan_proc_write(struct file *file, const char __user *buf, 1085 size_t count, loff_t *pos) 1086 { 1087 struct toshiba_acpi_dev *dev = PDE_DATA(file_inode(file)); 1088 char cmd[42]; 1089 size_t len; 1090 int value; 1091 u32 hci_result; 1092 1093 len = min(count, sizeof(cmd) - 1); 1094 if (copy_from_user(cmd, buf, len)) 1095 return -EFAULT; 1096 cmd[len] = '\0'; 1097 1098 if (sscanf(cmd, " force_on : %i", &value) == 1 && 1099 value >= 0 && value <= 1) { 1100 hci_write1(dev, HCI_FAN, value, &hci_result); 1101 if (hci_result != HCI_SUCCESS) 1102 return -EIO; 1103 else 1104 dev->force_fan = value; 1105 } else { 1106 return -EINVAL; 1107 } 1108 1109 return count; 1110 } 1111 1112 static const struct file_operations fan_proc_fops = { 1113 .owner = THIS_MODULE, 1114 .open = fan_proc_open, 1115 .read = seq_read, 1116 .llseek = seq_lseek, 1117 .release = single_release, 1118 .write = fan_proc_write, 1119 }; 1120 1121 static int keys_proc_show(struct seq_file *m, void *v) 1122 { 1123 struct toshiba_acpi_dev *dev = m->private; 1124 u32 hci_result; 1125 u32 value; 1126 1127 if (!dev->key_event_valid && dev->system_event_supported) { 1128 hci_read1(dev, HCI_SYSTEM_EVENT, &value, &hci_result); 1129 if (hci_result == HCI_SUCCESS) { 1130 dev->key_event_valid = 1; 1131 dev->last_key_event = value; 1132 } else if (hci_result == HCI_EMPTY) { 1133 /* better luck next time */ 1134 } else if (hci_result == HCI_NOT_SUPPORTED) { 1135 /* This is a workaround for an unresolved issue on 1136 * some machines where system events sporadically 1137 * become disabled. */ 1138 hci_write1(dev, HCI_SYSTEM_EVENT, 1, &hci_result); 1139 pr_notice("Re-enabled hotkeys\n"); 1140 } else { 1141 pr_err("Error reading hotkey status\n"); 1142 return -EIO; 1143 } 1144 } 1145 1146 seq_printf(m, "hotkey_ready: %d\n", dev->key_event_valid); 1147 seq_printf(m, "hotkey: 0x%04x\n", dev->last_key_event); 1148 return 0; 1149 } 1150 1151 static int keys_proc_open(struct inode *inode, struct file *file) 1152 { 1153 return single_open(file, keys_proc_show, PDE_DATA(inode)); 1154 } 1155 1156 static ssize_t keys_proc_write(struct file *file, const char __user *buf, 1157 size_t count, loff_t *pos) 1158 { 1159 struct toshiba_acpi_dev *dev = PDE_DATA(file_inode(file)); 1160 char cmd[42]; 1161 size_t len; 1162 int value; 1163 1164 len = min(count, sizeof(cmd) - 1); 1165 if (copy_from_user(cmd, buf, len)) 1166 return -EFAULT; 1167 cmd[len] = '\0'; 1168 1169 if (sscanf(cmd, " hotkey_ready : %i", &value) == 1 && value == 0) { 1170 dev->key_event_valid = 0; 1171 } else { 1172 return -EINVAL; 1173 } 1174 1175 return count; 1176 } 1177 1178 static const struct file_operations keys_proc_fops = { 1179 .owner = THIS_MODULE, 1180 .open = keys_proc_open, 1181 .read = seq_read, 1182 .llseek = seq_lseek, 1183 .release = single_release, 1184 .write = keys_proc_write, 1185 }; 1186 1187 static int version_proc_show(struct seq_file *m, void *v) 1188 { 1189 seq_printf(m, "driver: %s\n", TOSHIBA_ACPI_VERSION); 1190 seq_printf(m, "proc_interface: %d\n", PROC_INTERFACE_VERSION); 1191 return 0; 1192 } 1193 1194 static int version_proc_open(struct inode *inode, struct file *file) 1195 { 1196 return single_open(file, version_proc_show, PDE_DATA(inode)); 1197 } 1198 1199 static const struct file_operations version_proc_fops = { 1200 .owner = THIS_MODULE, 1201 .open = version_proc_open, 1202 .read = seq_read, 1203 .llseek = seq_lseek, 1204 .release = single_release, 1205 }; 1206 1207 /* proc and module init 1208 */ 1209 1210 #define PROC_TOSHIBA "toshiba" 1211 1212 static void create_toshiba_proc_entries(struct toshiba_acpi_dev *dev) 1213 { 1214 if (dev->backlight_dev) 1215 proc_create_data("lcd", S_IRUGO | S_IWUSR, toshiba_proc_dir, 1216 &lcd_proc_fops, dev); 1217 if (dev->video_supported) 1218 proc_create_data("video", S_IRUGO | S_IWUSR, toshiba_proc_dir, 1219 &video_proc_fops, dev); 1220 if (dev->fan_supported) 1221 proc_create_data("fan", S_IRUGO | S_IWUSR, toshiba_proc_dir, 1222 &fan_proc_fops, dev); 1223 if (dev->hotkey_dev) 1224 proc_create_data("keys", S_IRUGO | S_IWUSR, toshiba_proc_dir, 1225 &keys_proc_fops, dev); 1226 proc_create_data("version", S_IRUGO, toshiba_proc_dir, 1227 &version_proc_fops, dev); 1228 } 1229 1230 static void remove_toshiba_proc_entries(struct toshiba_acpi_dev *dev) 1231 { 1232 if (dev->backlight_dev) 1233 remove_proc_entry("lcd", toshiba_proc_dir); 1234 if (dev->video_supported) 1235 remove_proc_entry("video", toshiba_proc_dir); 1236 if (dev->fan_supported) 1237 remove_proc_entry("fan", toshiba_proc_dir); 1238 if (dev->hotkey_dev) 1239 remove_proc_entry("keys", toshiba_proc_dir); 1240 remove_proc_entry("version", toshiba_proc_dir); 1241 } 1242 1243 static const struct backlight_ops toshiba_backlight_data = { 1244 .options = BL_CORE_SUSPENDRESUME, 1245 .get_brightness = get_lcd_brightness, 1246 .update_status = set_lcd_status, 1247 }; 1248 1249 /* 1250 * Sysfs files 1251 */ 1252 1253 static ssize_t toshiba_kbd_bl_mode_store(struct device *dev, 1254 struct device_attribute *attr, 1255 const char *buf, size_t count) 1256 { 1257 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 1258 int mode; 1259 int time; 1260 int ret; 1261 1262 1263 ret = kstrtoint(buf, 0, &mode); 1264 if (ret) 1265 return ret; 1266 if (mode != SCI_KBD_MODE_FNZ && mode != SCI_KBD_MODE_AUTO) 1267 return -EINVAL; 1268 1269 /* Set the Keyboard Backlight Mode where: 1270 * Mode - Auto (2) | FN-Z (1) 1271 * Auto - KBD backlight turns off automatically in given time 1272 * FN-Z - KBD backlight "toggles" when hotkey pressed 1273 */ 1274 if (toshiba->kbd_mode != mode) { 1275 time = toshiba->kbd_time << HCI_MISC_SHIFT; 1276 time = time + toshiba->kbd_mode; 1277 ret = toshiba_kbd_illum_status_set(toshiba, time); 1278 if (ret) 1279 return ret; 1280 toshiba->kbd_mode = mode; 1281 } 1282 1283 return count; 1284 } 1285 1286 static ssize_t toshiba_kbd_bl_mode_show(struct device *dev, 1287 struct device_attribute *attr, 1288 char *buf) 1289 { 1290 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 1291 u32 time; 1292 1293 if (toshiba_kbd_illum_status_get(toshiba, &time) < 0) 1294 return -EIO; 1295 1296 return sprintf(buf, "%i\n", time & 0x07); 1297 } 1298 1299 static ssize_t toshiba_kbd_bl_timeout_store(struct device *dev, 1300 struct device_attribute *attr, 1301 const char *buf, size_t count) 1302 { 1303 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 1304 int time = -1; 1305 1306 if (sscanf(buf, "%i", &time) != 1 && (time < 0 || time > 60)) 1307 return -EINVAL; 1308 1309 /* Set the Keyboard Backlight Timeout: 0-60 seconds */ 1310 if (time != -1 && toshiba->kbd_time != time) { 1311 time = time << HCI_MISC_SHIFT; 1312 time = (toshiba->kbd_mode == SCI_KBD_MODE_AUTO) ? 1313 time + 1 : time + 2; 1314 if (toshiba_kbd_illum_status_set(toshiba, time) < 0) 1315 return -EIO; 1316 toshiba->kbd_time = time >> HCI_MISC_SHIFT; 1317 } 1318 1319 return count; 1320 } 1321 1322 static ssize_t toshiba_kbd_bl_timeout_show(struct device *dev, 1323 struct device_attribute *attr, 1324 char *buf) 1325 { 1326 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 1327 u32 time; 1328 1329 if (toshiba_kbd_illum_status_get(toshiba, &time) < 0) 1330 return -EIO; 1331 1332 return sprintf(buf, "%i\n", time >> HCI_MISC_SHIFT); 1333 } 1334 1335 static ssize_t toshiba_touchpad_store(struct device *dev, 1336 struct device_attribute *attr, 1337 const char *buf, size_t count) 1338 { 1339 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 1340 int state; 1341 1342 /* Set the TouchPad on/off, 0 - Disable | 1 - Enable */ 1343 if (sscanf(buf, "%i", &state) == 1 && (state == 0 || state == 1)) { 1344 if (toshiba_touchpad_set(toshiba, state) < 0) 1345 return -EIO; 1346 } 1347 1348 return count; 1349 } 1350 1351 static ssize_t toshiba_touchpad_show(struct device *dev, 1352 struct device_attribute *attr, char *buf) 1353 { 1354 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 1355 u32 state; 1356 int ret; 1357 1358 ret = toshiba_touchpad_get(toshiba, &state); 1359 if (ret < 0) 1360 return ret; 1361 1362 return sprintf(buf, "%i\n", state); 1363 } 1364 1365 static ssize_t toshiba_position_show(struct device *dev, 1366 struct device_attribute *attr, char *buf) 1367 { 1368 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 1369 u32 xyval, zval, tmp; 1370 u16 x, y, z; 1371 int ret; 1372 1373 xyval = zval = 0; 1374 ret = toshiba_accelerometer_get(toshiba, &xyval, &zval); 1375 if (ret < 0) 1376 return ret; 1377 1378 x = xyval & HCI_ACCEL_MASK; 1379 tmp = xyval >> HCI_MISC_SHIFT; 1380 y = tmp & HCI_ACCEL_MASK; 1381 z = zval & HCI_ACCEL_MASK; 1382 1383 return sprintf(buf, "%d %d %d\n", x, y, z); 1384 } 1385 1386 static DEVICE_ATTR(kbd_backlight_mode, S_IRUGO | S_IWUSR, 1387 toshiba_kbd_bl_mode_show, toshiba_kbd_bl_mode_store); 1388 static DEVICE_ATTR(kbd_backlight_timeout, S_IRUGO | S_IWUSR, 1389 toshiba_kbd_bl_timeout_show, toshiba_kbd_bl_timeout_store); 1390 static DEVICE_ATTR(touchpad, S_IRUGO | S_IWUSR, 1391 toshiba_touchpad_show, toshiba_touchpad_store); 1392 static DEVICE_ATTR(position, S_IRUGO, toshiba_position_show, NULL); 1393 1394 static struct attribute *toshiba_attributes[] = { 1395 &dev_attr_kbd_backlight_mode.attr, 1396 &dev_attr_kbd_backlight_timeout.attr, 1397 &dev_attr_touchpad.attr, 1398 &dev_attr_position.attr, 1399 NULL, 1400 }; 1401 1402 static umode_t toshiba_sysfs_is_visible(struct kobject *kobj, 1403 struct attribute *attr, int idx) 1404 { 1405 struct device *dev = container_of(kobj, struct device, kobj); 1406 struct toshiba_acpi_dev *drv = dev_get_drvdata(dev); 1407 bool exists = true; 1408 1409 if (attr == &dev_attr_kbd_backlight_mode.attr) 1410 exists = (drv->kbd_illum_supported) ? true : false; 1411 else if (attr == &dev_attr_kbd_backlight_timeout.attr) 1412 exists = (drv->kbd_mode == SCI_KBD_MODE_AUTO) ? true : false; 1413 else if (attr == &dev_attr_touchpad.attr) 1414 exists = (drv->touchpad_supported) ? true : false; 1415 else if (attr == &dev_attr_position.attr) 1416 exists = (drv->accelerometer_supported) ? true : false; 1417 1418 return exists ? attr->mode : 0; 1419 } 1420 1421 static struct attribute_group toshiba_attr_group = { 1422 .is_visible = toshiba_sysfs_is_visible, 1423 .attrs = toshiba_attributes, 1424 }; 1425 1426 static bool toshiba_acpi_i8042_filter(unsigned char data, unsigned char str, 1427 struct serio *port) 1428 { 1429 if (str & 0x20) 1430 return false; 1431 1432 if (unlikely(data == 0xe0)) 1433 return false; 1434 1435 if ((data & 0x7f) == TOS1900_FN_SCAN) { 1436 schedule_work(&toshiba_acpi->hotkey_work); 1437 return true; 1438 } 1439 1440 return false; 1441 } 1442 1443 static void toshiba_acpi_hotkey_work(struct work_struct *work) 1444 { 1445 acpi_handle ec_handle = ec_get_handle(); 1446 acpi_status status; 1447 1448 if (!ec_handle) 1449 return; 1450 1451 status = acpi_evaluate_object(ec_handle, "NTFY", NULL, NULL); 1452 if (ACPI_FAILURE(status)) 1453 pr_err("ACPI NTFY method execution failed\n"); 1454 } 1455 1456 /* 1457 * Returns hotkey scancode, or < 0 on failure. 1458 */ 1459 static int toshiba_acpi_query_hotkey(struct toshiba_acpi_dev *dev) 1460 { 1461 unsigned long long value; 1462 acpi_status status; 1463 1464 status = acpi_evaluate_integer(dev->acpi_dev->handle, "INFO", 1465 NULL, &value); 1466 if (ACPI_FAILURE(status)) { 1467 pr_err("ACPI INFO method execution failed\n"); 1468 return -EIO; 1469 } 1470 1471 return value; 1472 } 1473 1474 static void toshiba_acpi_report_hotkey(struct toshiba_acpi_dev *dev, 1475 int scancode) 1476 { 1477 if (scancode == 0x100) 1478 return; 1479 1480 /* act on key press; ignore key release */ 1481 if (scancode & 0x80) 1482 return; 1483 1484 if (!sparse_keymap_report_event(dev->hotkey_dev, scancode, 1, true)) 1485 pr_info("Unknown key %x\n", scancode); 1486 } 1487 1488 static int toshiba_acpi_setup_keyboard(struct toshiba_acpi_dev *dev) 1489 { 1490 acpi_status status; 1491 acpi_handle ec_handle; 1492 int error; 1493 u32 hci_result; 1494 const struct key_entry *keymap = toshiba_acpi_keymap; 1495 1496 dev->hotkey_dev = input_allocate_device(); 1497 if (!dev->hotkey_dev) 1498 return -ENOMEM; 1499 1500 dev->hotkey_dev->name = "Toshiba input device"; 1501 dev->hotkey_dev->phys = "toshiba_acpi/input0"; 1502 dev->hotkey_dev->id.bustype = BUS_HOST; 1503 1504 if (dmi_check_system(toshiba_alt_keymap_dmi)) 1505 keymap = toshiba_acpi_alt_keymap; 1506 error = sparse_keymap_setup(dev->hotkey_dev, keymap, NULL); 1507 if (error) 1508 goto err_free_dev; 1509 1510 /* 1511 * For some machines the SCI responsible for providing hotkey 1512 * notification doesn't fire. We can trigger the notification 1513 * whenever the Fn key is pressed using the NTFY method, if 1514 * supported, so if it's present set up an i8042 key filter 1515 * for this purpose. 1516 */ 1517 status = AE_ERROR; 1518 ec_handle = ec_get_handle(); 1519 if (ec_handle && acpi_has_method(ec_handle, "NTFY")) { 1520 INIT_WORK(&dev->hotkey_work, toshiba_acpi_hotkey_work); 1521 1522 error = i8042_install_filter(toshiba_acpi_i8042_filter); 1523 if (error) { 1524 pr_err("Error installing key filter\n"); 1525 goto err_free_keymap; 1526 } 1527 1528 dev->ntfy_supported = 1; 1529 } 1530 1531 /* 1532 * Determine hotkey query interface. Prefer using the INFO 1533 * method when it is available. 1534 */ 1535 if (acpi_has_method(dev->acpi_dev->handle, "INFO")) 1536 dev->info_supported = 1; 1537 else { 1538 hci_write1(dev, HCI_SYSTEM_EVENT, 1, &hci_result); 1539 if (hci_result == HCI_SUCCESS) 1540 dev->system_event_supported = 1; 1541 } 1542 1543 if (!dev->info_supported && !dev->system_event_supported) { 1544 pr_warn("No hotkey query interface found\n"); 1545 goto err_remove_filter; 1546 } 1547 1548 status = acpi_evaluate_object(dev->acpi_dev->handle, "ENAB", NULL, NULL); 1549 if (ACPI_FAILURE(status)) { 1550 pr_info("Unable to enable hotkeys\n"); 1551 error = -ENODEV; 1552 goto err_remove_filter; 1553 } 1554 1555 error = input_register_device(dev->hotkey_dev); 1556 if (error) { 1557 pr_info("Unable to register input device\n"); 1558 goto err_remove_filter; 1559 } 1560 1561 hci_write1(dev, HCI_HOTKEY_EVENT, HCI_HOTKEY_ENABLE, &hci_result); 1562 return 0; 1563 1564 err_remove_filter: 1565 if (dev->ntfy_supported) 1566 i8042_remove_filter(toshiba_acpi_i8042_filter); 1567 err_free_keymap: 1568 sparse_keymap_free(dev->hotkey_dev); 1569 err_free_dev: 1570 input_free_device(dev->hotkey_dev); 1571 dev->hotkey_dev = NULL; 1572 return error; 1573 } 1574 1575 static int toshiba_acpi_setup_backlight(struct toshiba_acpi_dev *dev) 1576 { 1577 struct backlight_properties props; 1578 int brightness; 1579 int ret; 1580 bool enabled; 1581 1582 /* 1583 * Some machines don't support the backlight methods at all, and 1584 * others support it read-only. Either of these is pretty useless, 1585 * so only register the backlight device if the backlight method 1586 * supports both reads and writes. 1587 */ 1588 brightness = __get_lcd_brightness(dev); 1589 if (brightness < 0) 1590 return 0; 1591 ret = set_lcd_brightness(dev, brightness); 1592 if (ret) { 1593 pr_debug("Backlight method is read-only, disabling backlight support\n"); 1594 return 0; 1595 } 1596 1597 /* Determine whether or not BIOS supports transflective backlight */ 1598 ret = get_tr_backlight_status(dev, &enabled); 1599 dev->tr_backlight_supported = !ret; 1600 1601 memset(&props, 0, sizeof(props)); 1602 props.type = BACKLIGHT_PLATFORM; 1603 props.max_brightness = HCI_LCD_BRIGHTNESS_LEVELS - 1; 1604 1605 /* adding an extra level and having 0 change to transflective mode */ 1606 if (dev->tr_backlight_supported) 1607 props.max_brightness++; 1608 1609 dev->backlight_dev = backlight_device_register("toshiba", 1610 &dev->acpi_dev->dev, 1611 dev, 1612 &toshiba_backlight_data, 1613 &props); 1614 if (IS_ERR(dev->backlight_dev)) { 1615 ret = PTR_ERR(dev->backlight_dev); 1616 pr_err("Could not register toshiba backlight device\n"); 1617 dev->backlight_dev = NULL; 1618 return ret; 1619 } 1620 1621 dev->backlight_dev->props.brightness = brightness; 1622 return 0; 1623 } 1624 1625 static int toshiba_acpi_remove(struct acpi_device *acpi_dev) 1626 { 1627 struct toshiba_acpi_dev *dev = acpi_driver_data(acpi_dev); 1628 1629 remove_toshiba_proc_entries(dev); 1630 1631 if (dev->sysfs_created) 1632 sysfs_remove_group(&dev->acpi_dev->dev.kobj, 1633 &toshiba_attr_group); 1634 1635 if (dev->ntfy_supported) { 1636 i8042_remove_filter(toshiba_acpi_i8042_filter); 1637 cancel_work_sync(&dev->hotkey_work); 1638 } 1639 1640 if (dev->hotkey_dev) { 1641 input_unregister_device(dev->hotkey_dev); 1642 sparse_keymap_free(dev->hotkey_dev); 1643 } 1644 1645 if (dev->bt_rfk) { 1646 rfkill_unregister(dev->bt_rfk); 1647 rfkill_destroy(dev->bt_rfk); 1648 } 1649 1650 if (dev->backlight_dev) 1651 backlight_device_unregister(dev->backlight_dev); 1652 1653 if (dev->illumination_supported) 1654 led_classdev_unregister(&dev->led_dev); 1655 1656 if (dev->kbd_led_registered) 1657 led_classdev_unregister(&dev->kbd_led); 1658 1659 if (dev->eco_supported) 1660 led_classdev_unregister(&dev->eco_led); 1661 1662 if (toshiba_acpi) 1663 toshiba_acpi = NULL; 1664 1665 kfree(dev); 1666 1667 return 0; 1668 } 1669 1670 static const char *find_hci_method(acpi_handle handle) 1671 { 1672 if (acpi_has_method(handle, "GHCI")) 1673 return "GHCI"; 1674 1675 if (acpi_has_method(handle, "SPFC")) 1676 return "SPFC"; 1677 1678 return NULL; 1679 } 1680 1681 static int toshiba_acpi_add(struct acpi_device *acpi_dev) 1682 { 1683 struct toshiba_acpi_dev *dev; 1684 const char *hci_method; 1685 u32 dummy; 1686 bool bt_present; 1687 int ret = 0; 1688 1689 if (toshiba_acpi) 1690 return -EBUSY; 1691 1692 pr_info("Toshiba Laptop ACPI Extras version %s\n", 1693 TOSHIBA_ACPI_VERSION); 1694 1695 hci_method = find_hci_method(acpi_dev->handle); 1696 if (!hci_method) { 1697 pr_err("HCI interface not found\n"); 1698 return -ENODEV; 1699 } 1700 1701 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 1702 if (!dev) 1703 return -ENOMEM; 1704 dev->acpi_dev = acpi_dev; 1705 dev->method_hci = hci_method; 1706 acpi_dev->driver_data = dev; 1707 dev_set_drvdata(&acpi_dev->dev, dev); 1708 1709 if (toshiba_acpi_setup_keyboard(dev)) 1710 pr_info("Unable to activate hotkeys\n"); 1711 1712 mutex_init(&dev->mutex); 1713 1714 ret = toshiba_acpi_setup_backlight(dev); 1715 if (ret) 1716 goto error; 1717 1718 /* Register rfkill switch for Bluetooth */ 1719 if (hci_get_bt_present(dev, &bt_present) == HCI_SUCCESS && bt_present) { 1720 dev->bt_rfk = rfkill_alloc("Toshiba Bluetooth", 1721 &acpi_dev->dev, 1722 RFKILL_TYPE_BLUETOOTH, 1723 &toshiba_rfk_ops, 1724 dev); 1725 if (!dev->bt_rfk) { 1726 pr_err("unable to allocate rfkill device\n"); 1727 ret = -ENOMEM; 1728 goto error; 1729 } 1730 1731 ret = rfkill_register(dev->bt_rfk); 1732 if (ret) { 1733 pr_err("unable to register rfkill device\n"); 1734 rfkill_destroy(dev->bt_rfk); 1735 goto error; 1736 } 1737 } 1738 1739 if (toshiba_illumination_available(dev)) { 1740 dev->led_dev.name = "toshiba::illumination"; 1741 dev->led_dev.max_brightness = 1; 1742 dev->led_dev.brightness_set = toshiba_illumination_set; 1743 dev->led_dev.brightness_get = toshiba_illumination_get; 1744 if (!led_classdev_register(&acpi_dev->dev, &dev->led_dev)) 1745 dev->illumination_supported = 1; 1746 } 1747 1748 if (toshiba_eco_mode_available(dev)) { 1749 dev->eco_led.name = "toshiba::eco_mode"; 1750 dev->eco_led.max_brightness = 1; 1751 dev->eco_led.brightness_set = toshiba_eco_mode_set_status; 1752 dev->eco_led.brightness_get = toshiba_eco_mode_get_status; 1753 if (!led_classdev_register(&dev->acpi_dev->dev, &dev->eco_led)) 1754 dev->eco_supported = 1; 1755 } 1756 1757 ret = toshiba_kbd_illum_status_get(dev, &dummy); 1758 if (!ret) { 1759 dev->kbd_time = dummy >> HCI_MISC_SHIFT; 1760 dev->kbd_mode = dummy & 0x07; 1761 } 1762 dev->kbd_illum_supported = !ret; 1763 /* 1764 * Only register the LED if KBD illumination is supported 1765 * and the keyboard backlight operation mode is set to FN-Z 1766 */ 1767 if (dev->kbd_illum_supported && dev->kbd_mode == SCI_KBD_MODE_FNZ) { 1768 dev->kbd_led.name = "toshiba::kbd_backlight"; 1769 dev->kbd_led.max_brightness = 1; 1770 dev->kbd_led.brightness_set = toshiba_kbd_backlight_set; 1771 dev->kbd_led.brightness_get = toshiba_kbd_backlight_get; 1772 if (!led_classdev_register(&dev->acpi_dev->dev, &dev->kbd_led)) 1773 dev->kbd_led_registered = 1; 1774 } 1775 1776 ret = toshiba_touchpad_get(dev, &dummy); 1777 dev->touchpad_supported = !ret; 1778 1779 ret = toshiba_accelerometer_supported(dev); 1780 dev->accelerometer_supported = !ret; 1781 1782 /* Determine whether or not BIOS supports fan and video interfaces */ 1783 1784 ret = get_video_status(dev, &dummy); 1785 dev->video_supported = !ret; 1786 1787 ret = get_fan_status(dev, &dummy); 1788 dev->fan_supported = !ret; 1789 1790 ret = sysfs_create_group(&dev->acpi_dev->dev.kobj, 1791 &toshiba_attr_group); 1792 if (ret) { 1793 dev->sysfs_created = 0; 1794 goto error; 1795 } 1796 dev->sysfs_created = !ret; 1797 1798 create_toshiba_proc_entries(dev); 1799 1800 toshiba_acpi = dev; 1801 1802 return 0; 1803 1804 error: 1805 toshiba_acpi_remove(acpi_dev); 1806 return ret; 1807 } 1808 1809 static void toshiba_acpi_notify(struct acpi_device *acpi_dev, u32 event) 1810 { 1811 struct toshiba_acpi_dev *dev = acpi_driver_data(acpi_dev); 1812 u32 hci_result, value; 1813 int retries = 3; 1814 int scancode; 1815 1816 if (event != 0x80) 1817 return; 1818 1819 if (dev->info_supported) { 1820 scancode = toshiba_acpi_query_hotkey(dev); 1821 if (scancode < 0) 1822 pr_err("Failed to query hotkey event\n"); 1823 else if (scancode != 0) 1824 toshiba_acpi_report_hotkey(dev, scancode); 1825 } else if (dev->system_event_supported) { 1826 do { 1827 hci_read1(dev, HCI_SYSTEM_EVENT, &value, &hci_result); 1828 switch (hci_result) { 1829 case HCI_SUCCESS: 1830 toshiba_acpi_report_hotkey(dev, (int)value); 1831 break; 1832 case HCI_NOT_SUPPORTED: 1833 /* 1834 * This is a workaround for an unresolved 1835 * issue on some machines where system events 1836 * sporadically become disabled. 1837 */ 1838 hci_write1(dev, HCI_SYSTEM_EVENT, 1, 1839 &hci_result); 1840 pr_notice("Re-enabled hotkeys\n"); 1841 /* fall through */ 1842 default: 1843 retries--; 1844 break; 1845 } 1846 } while (retries && hci_result != HCI_EMPTY); 1847 } 1848 } 1849 1850 #ifdef CONFIG_PM_SLEEP 1851 static int toshiba_acpi_suspend(struct device *device) 1852 { 1853 struct toshiba_acpi_dev *dev = acpi_driver_data(to_acpi_device(device)); 1854 u32 result; 1855 1856 if (dev->hotkey_dev) 1857 hci_write1(dev, HCI_HOTKEY_EVENT, HCI_HOTKEY_DISABLE, &result); 1858 1859 return 0; 1860 } 1861 1862 static int toshiba_acpi_resume(struct device *device) 1863 { 1864 struct toshiba_acpi_dev *dev = acpi_driver_data(to_acpi_device(device)); 1865 u32 result; 1866 acpi_status status; 1867 1868 if (dev->hotkey_dev) { 1869 status = acpi_evaluate_object(dev->acpi_dev->handle, "ENAB", 1870 NULL, NULL); 1871 if (ACPI_FAILURE(status)) 1872 pr_info("Unable to re-enable hotkeys\n"); 1873 1874 hci_write1(dev, HCI_HOTKEY_EVENT, HCI_HOTKEY_ENABLE, &result); 1875 } 1876 1877 return 0; 1878 } 1879 #endif 1880 1881 static SIMPLE_DEV_PM_OPS(toshiba_acpi_pm, 1882 toshiba_acpi_suspend, toshiba_acpi_resume); 1883 1884 static struct acpi_driver toshiba_acpi_driver = { 1885 .name = "Toshiba ACPI driver", 1886 .owner = THIS_MODULE, 1887 .ids = toshiba_device_ids, 1888 .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS, 1889 .ops = { 1890 .add = toshiba_acpi_add, 1891 .remove = toshiba_acpi_remove, 1892 .notify = toshiba_acpi_notify, 1893 }, 1894 .drv.pm = &toshiba_acpi_pm, 1895 }; 1896 1897 static int __init toshiba_acpi_init(void) 1898 { 1899 int ret; 1900 1901 /* 1902 * Machines with this WMI guid aren't supported due to bugs in 1903 * their AML. This check relies on wmi initializing before 1904 * toshiba_acpi to guarantee guids have been identified. 1905 */ 1906 if (wmi_has_guid(TOSHIBA_WMI_EVENT_GUID)) 1907 return -ENODEV; 1908 1909 toshiba_proc_dir = proc_mkdir(PROC_TOSHIBA, acpi_root_dir); 1910 if (!toshiba_proc_dir) { 1911 pr_err("Unable to create proc dir " PROC_TOSHIBA "\n"); 1912 return -ENODEV; 1913 } 1914 1915 ret = acpi_bus_register_driver(&toshiba_acpi_driver); 1916 if (ret) { 1917 pr_err("Failed to register ACPI driver: %d\n", ret); 1918 remove_proc_entry(PROC_TOSHIBA, acpi_root_dir); 1919 } 1920 1921 return ret; 1922 } 1923 1924 static void __exit toshiba_acpi_exit(void) 1925 { 1926 acpi_bus_unregister_driver(&toshiba_acpi_driver); 1927 if (toshiba_proc_dir) 1928 remove_proc_entry(PROC_TOSHIBA, acpi_root_dir); 1929 } 1930 1931 module_init(toshiba_acpi_init); 1932 module_exit(toshiba_acpi_exit); 1933