1 /* 2 * toshiba_acpi.c - Toshiba Laptop ACPI Extras 3 * 4 * Copyright (C) 2002-2004 John Belmonte 5 * Copyright (C) 2008 Philip Langdale 6 * Copyright (C) 2010 Pierre Ducroquet 7 * Copyright (C) 2014-2016 Azael Avalos 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 * The full GNU General Public License is included in this distribution in 20 * the file called "COPYING". 21 * 22 * The devolpment page for this driver is located at 23 * http://memebeam.org/toys/ToshibaAcpiDriver. 24 * 25 * Credits: 26 * Jonathan A. Buzzard - Toshiba HCI info, and critical tips on reverse 27 * engineering the Windows drivers 28 * Yasushi Nagato - changes for linux kernel 2.4 -> 2.5 29 * Rob Miller - TV out and hotkeys help 30 */ 31 32 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 33 34 #define TOSHIBA_ACPI_VERSION "0.24" 35 #define PROC_INTERFACE_VERSION 1 36 37 #include <linux/compiler.h> 38 #include <linux/kernel.h> 39 #include <linux/module.h> 40 #include <linux/moduleparam.h> 41 #include <linux/init.h> 42 #include <linux/types.h> 43 #include <linux/proc_fs.h> 44 #include <linux/seq_file.h> 45 #include <linux/backlight.h> 46 #include <linux/input.h> 47 #include <linux/input/sparse-keymap.h> 48 #include <linux/leds.h> 49 #include <linux/slab.h> 50 #include <linux/workqueue.h> 51 #include <linux/i8042.h> 52 #include <linux/acpi.h> 53 #include <linux/dmi.h> 54 #include <linux/uaccess.h> 55 #include <linux/miscdevice.h> 56 #include <linux/rfkill.h> 57 #include <linux/iio/iio.h> 58 #include <linux/toshiba.h> 59 #include <acpi/video.h> 60 61 MODULE_AUTHOR("John Belmonte"); 62 MODULE_DESCRIPTION("Toshiba Laptop ACPI Extras Driver"); 63 MODULE_LICENSE("GPL"); 64 65 #define TOSHIBA_WMI_EVENT_GUID "59142400-C6A3-40FA-BADB-8A2652834100" 66 67 /* Scan code for Fn key on TOS1900 models */ 68 #define TOS1900_FN_SCAN 0x6e 69 70 /* Toshiba ACPI method paths */ 71 #define METHOD_VIDEO_OUT "\\_SB_.VALX.DSSX" 72 73 /* 74 * The Toshiba configuration interface is composed of the HCI and the SCI, 75 * which are defined as follows: 76 * 77 * HCI is Toshiba's "Hardware Control Interface" which is supposed to 78 * be uniform across all their models. Ideally we would just call 79 * dedicated ACPI methods instead of using this primitive interface. 80 * However the ACPI methods seem to be incomplete in some areas (for 81 * example they allow setting, but not reading, the LCD brightness value), 82 * so this is still useful. 83 * 84 * SCI stands for "System Configuration Interface" which aim is to 85 * conceal differences in hardware between different models. 86 */ 87 88 #define TCI_WORDS 6 89 90 /* Operations */ 91 #define HCI_SET 0xff00 92 #define HCI_GET 0xfe00 93 #define SCI_OPEN 0xf100 94 #define SCI_CLOSE 0xf200 95 #define SCI_GET 0xf300 96 #define SCI_SET 0xf400 97 98 /* Return codes */ 99 #define TOS_SUCCESS 0x0000 100 #define TOS_SUCCESS2 0x0001 101 #define TOS_OPEN_CLOSE_OK 0x0044 102 #define TOS_FAILURE 0x1000 103 #define TOS_NOT_SUPPORTED 0x8000 104 #define TOS_ALREADY_OPEN 0x8100 105 #define TOS_NOT_OPENED 0x8200 106 #define TOS_INPUT_DATA_ERROR 0x8300 107 #define TOS_WRITE_PROTECTED 0x8400 108 #define TOS_NOT_PRESENT 0x8600 109 #define TOS_FIFO_EMPTY 0x8c00 110 #define TOS_DATA_NOT_AVAILABLE 0x8d20 111 #define TOS_NOT_INITIALIZED 0x8d50 112 #define TOS_NOT_INSTALLED 0x8e00 113 114 /* Registers */ 115 #define HCI_FAN 0x0004 116 #define HCI_TR_BACKLIGHT 0x0005 117 #define HCI_SYSTEM_EVENT 0x0016 118 #define HCI_VIDEO_OUT 0x001c 119 #define HCI_HOTKEY_EVENT 0x001e 120 #define HCI_LCD_BRIGHTNESS 0x002a 121 #define HCI_WIRELESS 0x0056 122 #define HCI_ACCELEROMETER 0x006d 123 #define HCI_COOLING_METHOD 0x007f 124 #define HCI_KBD_ILLUMINATION 0x0095 125 #define HCI_ECO_MODE 0x0097 126 #define HCI_ACCELEROMETER2 0x00a6 127 #define HCI_SYSTEM_INFO 0xc000 128 #define SCI_PANEL_POWER_ON 0x010d 129 #define SCI_ILLUMINATION 0x014e 130 #define SCI_USB_SLEEP_CHARGE 0x0150 131 #define SCI_KBD_ILLUM_STATUS 0x015c 132 #define SCI_USB_SLEEP_MUSIC 0x015e 133 #define SCI_USB_THREE 0x0169 134 #define SCI_TOUCHPAD 0x050e 135 #define SCI_KBD_FUNCTION_KEYS 0x0522 136 137 /* Field definitions */ 138 #define HCI_ACCEL_MASK 0x7fff 139 #define HCI_ACCEL_DIRECTION_MASK 0x8000 140 #define HCI_HOTKEY_DISABLE 0x0b 141 #define HCI_HOTKEY_ENABLE 0x09 142 #define HCI_HOTKEY_SPECIAL_FUNCTIONS 0x10 143 #define HCI_LCD_BRIGHTNESS_BITS 3 144 #define HCI_LCD_BRIGHTNESS_SHIFT (16-HCI_LCD_BRIGHTNESS_BITS) 145 #define HCI_LCD_BRIGHTNESS_LEVELS (1 << HCI_LCD_BRIGHTNESS_BITS) 146 #define HCI_MISC_SHIFT 0x10 147 #define HCI_SYSTEM_TYPE1 0x10 148 #define HCI_SYSTEM_TYPE2 0x11 149 #define HCI_VIDEO_OUT_LCD 0x1 150 #define HCI_VIDEO_OUT_CRT 0x2 151 #define HCI_VIDEO_OUT_TV 0x4 152 #define SCI_KBD_MODE_MASK 0x1f 153 #define SCI_KBD_MODE_FNZ 0x1 154 #define SCI_KBD_MODE_AUTO 0x2 155 #define SCI_KBD_MODE_ON 0x8 156 #define SCI_KBD_MODE_OFF 0x10 157 #define SCI_KBD_TIME_MAX 0x3c001a 158 #define HCI_WIRELESS_STATUS 0x1 159 #define HCI_WIRELESS_WWAN 0x3 160 #define HCI_WIRELESS_WWAN_STATUS 0x2000 161 #define HCI_WIRELESS_WWAN_POWER 0x4000 162 #define SCI_USB_CHARGE_MODE_MASK 0xff 163 #define SCI_USB_CHARGE_DISABLED 0x00 164 #define SCI_USB_CHARGE_ALTERNATE 0x09 165 #define SCI_USB_CHARGE_TYPICAL 0x11 166 #define SCI_USB_CHARGE_AUTO 0x21 167 #define SCI_USB_CHARGE_BAT_MASK 0x7 168 #define SCI_USB_CHARGE_BAT_LVL_OFF 0x1 169 #define SCI_USB_CHARGE_BAT_LVL_ON 0x4 170 #define SCI_USB_CHARGE_BAT_LVL 0x0200 171 #define SCI_USB_CHARGE_RAPID_DSP 0x0300 172 173 struct toshiba_acpi_dev { 174 struct acpi_device *acpi_dev; 175 const char *method_hci; 176 struct input_dev *hotkey_dev; 177 struct work_struct hotkey_work; 178 struct backlight_device *backlight_dev; 179 struct led_classdev led_dev; 180 struct led_classdev kbd_led; 181 struct led_classdev eco_led; 182 struct miscdevice miscdev; 183 struct rfkill *wwan_rfk; 184 struct iio_dev *indio_dev; 185 186 int force_fan; 187 int last_key_event; 188 int key_event_valid; 189 int kbd_type; 190 int kbd_mode; 191 int kbd_time; 192 int usbsc_bat_level; 193 int usbsc_mode_base; 194 int hotkey_event_type; 195 int max_cooling_method; 196 197 unsigned int illumination_supported:1; 198 unsigned int video_supported:1; 199 unsigned int fan_supported:1; 200 unsigned int system_event_supported:1; 201 unsigned int ntfy_supported:1; 202 unsigned int info_supported:1; 203 unsigned int tr_backlight_supported:1; 204 unsigned int kbd_illum_supported:1; 205 unsigned int touchpad_supported:1; 206 unsigned int eco_supported:1; 207 unsigned int accelerometer_supported:1; 208 unsigned int usb_sleep_charge_supported:1; 209 unsigned int usb_rapid_charge_supported:1; 210 unsigned int usb_sleep_music_supported:1; 211 unsigned int kbd_function_keys_supported:1; 212 unsigned int panel_power_on_supported:1; 213 unsigned int usb_three_supported:1; 214 unsigned int wwan_supported:1; 215 unsigned int cooling_method_supported:1; 216 unsigned int sysfs_created:1; 217 unsigned int special_functions; 218 219 bool kbd_event_generated; 220 bool kbd_led_registered; 221 bool illumination_led_registered; 222 bool eco_led_registered; 223 bool killswitch; 224 }; 225 226 static struct toshiba_acpi_dev *toshiba_acpi; 227 228 static bool disable_hotkeys; 229 module_param(disable_hotkeys, bool, 0444); 230 MODULE_PARM_DESC(disable_hotkeys, "Disables the hotkeys activation"); 231 232 static const struct acpi_device_id toshiba_device_ids[] = { 233 {"TOS6200", 0}, 234 {"TOS6207", 0}, 235 {"TOS6208", 0}, 236 {"TOS1900", 0}, 237 {"", 0}, 238 }; 239 MODULE_DEVICE_TABLE(acpi, toshiba_device_ids); 240 241 static const struct key_entry toshiba_acpi_keymap[] = { 242 { KE_KEY, 0x9e, { KEY_RFKILL } }, 243 { KE_KEY, 0x101, { KEY_MUTE } }, 244 { KE_KEY, 0x102, { KEY_ZOOMOUT } }, 245 { KE_KEY, 0x103, { KEY_ZOOMIN } }, 246 { KE_KEY, 0x10f, { KEY_TAB } }, 247 { KE_KEY, 0x12c, { KEY_KBDILLUMTOGGLE } }, 248 { KE_KEY, 0x139, { KEY_ZOOMRESET } }, 249 { KE_KEY, 0x13b, { KEY_COFFEE } }, 250 { KE_KEY, 0x13c, { KEY_BATTERY } }, 251 { KE_KEY, 0x13d, { KEY_SLEEP } }, 252 { KE_KEY, 0x13e, { KEY_SUSPEND } }, 253 { KE_KEY, 0x13f, { KEY_SWITCHVIDEOMODE } }, 254 { KE_KEY, 0x140, { KEY_BRIGHTNESSDOWN } }, 255 { KE_KEY, 0x141, { KEY_BRIGHTNESSUP } }, 256 { KE_KEY, 0x142, { KEY_WLAN } }, 257 { KE_KEY, 0x143, { KEY_TOUCHPAD_TOGGLE } }, 258 { KE_KEY, 0x17f, { KEY_FN } }, 259 { KE_KEY, 0xb05, { KEY_PROG2 } }, 260 { KE_KEY, 0xb06, { KEY_WWW } }, 261 { KE_KEY, 0xb07, { KEY_MAIL } }, 262 { KE_KEY, 0xb30, { KEY_STOP } }, 263 { KE_KEY, 0xb31, { KEY_PREVIOUSSONG } }, 264 { KE_KEY, 0xb32, { KEY_NEXTSONG } }, 265 { KE_KEY, 0xb33, { KEY_PLAYPAUSE } }, 266 { KE_KEY, 0xb5a, { KEY_MEDIA } }, 267 { KE_IGNORE, 0x1430, { KEY_RESERVED } }, /* Wake from sleep */ 268 { KE_IGNORE, 0x1501, { KEY_RESERVED } }, /* Output changed */ 269 { KE_IGNORE, 0x1502, { KEY_RESERVED } }, /* HDMI plugged/unplugged */ 270 { KE_IGNORE, 0x1ABE, { KEY_RESERVED } }, /* Protection level set */ 271 { KE_IGNORE, 0x1ABF, { KEY_RESERVED } }, /* Protection level off */ 272 { KE_END, 0 }, 273 }; 274 275 static const struct key_entry toshiba_acpi_alt_keymap[] = { 276 { KE_KEY, 0x102, { KEY_ZOOMOUT } }, 277 { KE_KEY, 0x103, { KEY_ZOOMIN } }, 278 { KE_KEY, 0x12c, { KEY_KBDILLUMTOGGLE } }, 279 { KE_KEY, 0x139, { KEY_ZOOMRESET } }, 280 { KE_KEY, 0x13c, { KEY_BRIGHTNESSDOWN } }, 281 { KE_KEY, 0x13d, { KEY_BRIGHTNESSUP } }, 282 { KE_KEY, 0x13e, { KEY_SWITCHVIDEOMODE } }, 283 { KE_KEY, 0x13f, { KEY_TOUCHPAD_TOGGLE } }, 284 { KE_KEY, 0x157, { KEY_MUTE } }, 285 { KE_KEY, 0x158, { KEY_WLAN } }, 286 { KE_END, 0 }, 287 }; 288 289 /* 290 * List of models which have a broken acpi-video backlight interface and thus 291 * need to use the toshiba (vendor) interface instead. 292 */ 293 static const struct dmi_system_id toshiba_vendor_backlight_dmi[] = { 294 {} 295 }; 296 297 /* 298 * Utility 299 */ 300 301 static inline void _set_bit(u32 *word, u32 mask, int value) 302 { 303 *word = (*word & ~mask) | (mask * value); 304 } 305 306 /* 307 * ACPI interface wrappers 308 */ 309 310 static int write_acpi_int(const char *methodName, int val) 311 { 312 acpi_status status; 313 314 status = acpi_execute_simple_method(NULL, (char *)methodName, val); 315 return (status == AE_OK) ? 0 : -EIO; 316 } 317 318 /* 319 * Perform a raw configuration call. Here we don't care about input or output 320 * buffer format. 321 */ 322 static acpi_status tci_raw(struct toshiba_acpi_dev *dev, 323 const u32 in[TCI_WORDS], u32 out[TCI_WORDS]) 324 { 325 union acpi_object in_objs[TCI_WORDS], out_objs[TCI_WORDS + 1]; 326 struct acpi_object_list params; 327 struct acpi_buffer results; 328 acpi_status status; 329 int i; 330 331 params.count = TCI_WORDS; 332 params.pointer = in_objs; 333 for (i = 0; i < TCI_WORDS; ++i) { 334 in_objs[i].type = ACPI_TYPE_INTEGER; 335 in_objs[i].integer.value = in[i]; 336 } 337 338 results.length = sizeof(out_objs); 339 results.pointer = out_objs; 340 341 status = acpi_evaluate_object(dev->acpi_dev->handle, 342 (char *)dev->method_hci, ¶ms, 343 &results); 344 if ((status == AE_OK) && (out_objs->package.count <= TCI_WORDS)) { 345 for (i = 0; i < out_objs->package.count; ++i) 346 out[i] = out_objs->package.elements[i].integer.value; 347 } 348 349 return status; 350 } 351 352 /* 353 * Common hci tasks 354 * 355 * In addition to the ACPI status, the HCI system returns a result which 356 * may be useful (such as "not supported"). 357 */ 358 359 static u32 hci_write(struct toshiba_acpi_dev *dev, u32 reg, u32 in1) 360 { 361 u32 in[TCI_WORDS] = { HCI_SET, reg, in1, 0, 0, 0 }; 362 u32 out[TCI_WORDS]; 363 acpi_status status = tci_raw(dev, in, out); 364 365 return ACPI_SUCCESS(status) ? out[0] : TOS_FAILURE; 366 } 367 368 static u32 hci_read(struct toshiba_acpi_dev *dev, u32 reg, u32 *out1) 369 { 370 u32 in[TCI_WORDS] = { HCI_GET, reg, 0, 0, 0, 0 }; 371 u32 out[TCI_WORDS]; 372 acpi_status status = tci_raw(dev, in, out); 373 374 if (ACPI_FAILURE(status)) 375 return TOS_FAILURE; 376 377 *out1 = out[2]; 378 379 return out[0]; 380 } 381 382 /* 383 * Common sci tasks 384 */ 385 386 static int sci_open(struct toshiba_acpi_dev *dev) 387 { 388 u32 in[TCI_WORDS] = { SCI_OPEN, 0, 0, 0, 0, 0 }; 389 u32 out[TCI_WORDS]; 390 acpi_status status = tci_raw(dev, in, out); 391 392 if (ACPI_FAILURE(status)) { 393 pr_err("ACPI call to open SCI failed\n"); 394 return 0; 395 } 396 397 if (out[0] == TOS_OPEN_CLOSE_OK) { 398 return 1; 399 } else if (out[0] == TOS_ALREADY_OPEN) { 400 pr_info("Toshiba SCI already opened\n"); 401 return 1; 402 } else if (out[0] == TOS_NOT_SUPPORTED) { 403 /* 404 * Some BIOSes do not have the SCI open/close functions 405 * implemented and return 0x8000 (Not Supported), failing to 406 * register some supported features. 407 * 408 * Simply return 1 if we hit those affected laptops to make the 409 * supported features work. 410 * 411 * In the case that some laptops really do not support the SCI, 412 * all the SCI dependent functions check for TOS_NOT_SUPPORTED, 413 * and thus, not registering support for the queried feature. 414 */ 415 return 1; 416 } else if (out[0] == TOS_NOT_PRESENT) { 417 pr_info("Toshiba SCI is not present\n"); 418 } 419 420 return 0; 421 } 422 423 static void sci_close(struct toshiba_acpi_dev *dev) 424 { 425 u32 in[TCI_WORDS] = { SCI_CLOSE, 0, 0, 0, 0, 0 }; 426 u32 out[TCI_WORDS]; 427 acpi_status status = tci_raw(dev, in, out); 428 429 if (ACPI_FAILURE(status)) { 430 pr_err("ACPI call to close SCI failed\n"); 431 return; 432 } 433 434 if (out[0] == TOS_OPEN_CLOSE_OK) 435 return; 436 else if (out[0] == TOS_NOT_OPENED) 437 pr_info("Toshiba SCI not opened\n"); 438 else if (out[0] == TOS_NOT_PRESENT) 439 pr_info("Toshiba SCI is not present\n"); 440 } 441 442 static u32 sci_read(struct toshiba_acpi_dev *dev, u32 reg, u32 *out1) 443 { 444 u32 in[TCI_WORDS] = { SCI_GET, reg, 0, 0, 0, 0 }; 445 u32 out[TCI_WORDS]; 446 acpi_status status = tci_raw(dev, in, out); 447 448 if (ACPI_FAILURE(status)) 449 return TOS_FAILURE; 450 451 *out1 = out[2]; 452 453 return out[0]; 454 } 455 456 static u32 sci_write(struct toshiba_acpi_dev *dev, u32 reg, u32 in1) 457 { 458 u32 in[TCI_WORDS] = { SCI_SET, reg, in1, 0, 0, 0 }; 459 u32 out[TCI_WORDS]; 460 acpi_status status = tci_raw(dev, in, out); 461 462 return ACPI_SUCCESS(status) ? out[0] : TOS_FAILURE; 463 } 464 465 /* Illumination support */ 466 static void toshiba_illumination_available(struct toshiba_acpi_dev *dev) 467 { 468 u32 in[TCI_WORDS] = { SCI_GET, SCI_ILLUMINATION, 0, 0, 0, 0 }; 469 u32 out[TCI_WORDS]; 470 acpi_status status; 471 472 dev->illumination_supported = 0; 473 dev->illumination_led_registered = false; 474 475 if (!sci_open(dev)) 476 return; 477 478 status = tci_raw(dev, in, out); 479 sci_close(dev); 480 if (ACPI_FAILURE(status)) { 481 pr_err("ACPI call to query Illumination support failed\n"); 482 return; 483 } 484 485 if (out[0] != TOS_SUCCESS) 486 return; 487 488 dev->illumination_supported = 1; 489 } 490 491 static void toshiba_illumination_set(struct led_classdev *cdev, 492 enum led_brightness brightness) 493 { 494 struct toshiba_acpi_dev *dev = container_of(cdev, 495 struct toshiba_acpi_dev, led_dev); 496 u32 result; 497 u32 state; 498 499 /* First request : initialize communication. */ 500 if (!sci_open(dev)) 501 return; 502 503 /* Switch the illumination on/off */ 504 state = brightness ? 1 : 0; 505 result = sci_write(dev, SCI_ILLUMINATION, state); 506 sci_close(dev); 507 if (result == TOS_FAILURE) 508 pr_err("ACPI call for illumination failed\n"); 509 } 510 511 static enum led_brightness toshiba_illumination_get(struct led_classdev *cdev) 512 { 513 struct toshiba_acpi_dev *dev = container_of(cdev, 514 struct toshiba_acpi_dev, led_dev); 515 u32 result; 516 u32 state; 517 518 /* First request : initialize communication. */ 519 if (!sci_open(dev)) 520 return LED_OFF; 521 522 /* Check the illumination */ 523 result = sci_read(dev, SCI_ILLUMINATION, &state); 524 sci_close(dev); 525 if (result == TOS_FAILURE) { 526 pr_err("ACPI call for illumination failed\n"); 527 return LED_OFF; 528 } else if (result != TOS_SUCCESS) { 529 return LED_OFF; 530 } 531 532 return state ? LED_FULL : LED_OFF; 533 } 534 535 /* KBD Illumination */ 536 static void toshiba_kbd_illum_available(struct toshiba_acpi_dev *dev) 537 { 538 u32 in[TCI_WORDS] = { SCI_GET, SCI_KBD_ILLUM_STATUS, 0, 0, 0, 0 }; 539 u32 out[TCI_WORDS]; 540 acpi_status status; 541 542 dev->kbd_illum_supported = 0; 543 dev->kbd_led_registered = false; 544 dev->kbd_event_generated = false; 545 546 if (!sci_open(dev)) 547 return; 548 549 status = tci_raw(dev, in, out); 550 sci_close(dev); 551 if (ACPI_FAILURE(status)) { 552 pr_err("ACPI call to query kbd illumination support failed\n"); 553 return; 554 } 555 556 if (out[0] != TOS_SUCCESS) 557 return; 558 559 /* 560 * Check for keyboard backlight timeout max value, 561 * previous kbd backlight implementation set this to 562 * 0x3c0003, and now the new implementation set this 563 * to 0x3c001a, use this to distinguish between them. 564 */ 565 if (out[3] == SCI_KBD_TIME_MAX) 566 dev->kbd_type = 2; 567 else 568 dev->kbd_type = 1; 569 /* Get the current keyboard backlight mode */ 570 dev->kbd_mode = out[2] & SCI_KBD_MODE_MASK; 571 /* Get the current time (1-60 seconds) */ 572 dev->kbd_time = out[2] >> HCI_MISC_SHIFT; 573 /* Flag as supported */ 574 dev->kbd_illum_supported = 1; 575 } 576 577 static int toshiba_kbd_illum_status_set(struct toshiba_acpi_dev *dev, u32 time) 578 { 579 u32 result; 580 581 if (!sci_open(dev)) 582 return -EIO; 583 584 result = sci_write(dev, SCI_KBD_ILLUM_STATUS, time); 585 sci_close(dev); 586 if (result == TOS_FAILURE) 587 pr_err("ACPI call to set KBD backlight status failed\n"); 588 else if (result == TOS_NOT_SUPPORTED) 589 return -ENODEV; 590 591 return result == TOS_SUCCESS ? 0 : -EIO; 592 } 593 594 static int toshiba_kbd_illum_status_get(struct toshiba_acpi_dev *dev, u32 *time) 595 { 596 u32 result; 597 598 if (!sci_open(dev)) 599 return -EIO; 600 601 result = sci_read(dev, SCI_KBD_ILLUM_STATUS, time); 602 sci_close(dev); 603 if (result == TOS_FAILURE) 604 pr_err("ACPI call to get KBD backlight status failed\n"); 605 else if (result == TOS_NOT_SUPPORTED) 606 return -ENODEV; 607 608 return result == TOS_SUCCESS ? 0 : -EIO; 609 } 610 611 static enum led_brightness toshiba_kbd_backlight_get(struct led_classdev *cdev) 612 { 613 struct toshiba_acpi_dev *dev = container_of(cdev, 614 struct toshiba_acpi_dev, kbd_led); 615 u32 result; 616 u32 state; 617 618 /* Check the keyboard backlight state */ 619 result = hci_read(dev, HCI_KBD_ILLUMINATION, &state); 620 if (result == TOS_FAILURE) { 621 pr_err("ACPI call to get the keyboard backlight failed\n"); 622 return LED_OFF; 623 } else if (result != TOS_SUCCESS) { 624 return LED_OFF; 625 } 626 627 return state ? LED_FULL : LED_OFF; 628 } 629 630 static void toshiba_kbd_backlight_set(struct led_classdev *cdev, 631 enum led_brightness brightness) 632 { 633 struct toshiba_acpi_dev *dev = container_of(cdev, 634 struct toshiba_acpi_dev, kbd_led); 635 u32 result; 636 u32 state; 637 638 /* Set the keyboard backlight state */ 639 state = brightness ? 1 : 0; 640 result = hci_write(dev, HCI_KBD_ILLUMINATION, state); 641 if (result == TOS_FAILURE) 642 pr_err("ACPI call to set KBD Illumination mode failed\n"); 643 } 644 645 /* TouchPad support */ 646 static int toshiba_touchpad_set(struct toshiba_acpi_dev *dev, u32 state) 647 { 648 u32 result; 649 650 if (!sci_open(dev)) 651 return -EIO; 652 653 result = sci_write(dev, SCI_TOUCHPAD, state); 654 sci_close(dev); 655 if (result == TOS_FAILURE) 656 pr_err("ACPI call to set the touchpad failed\n"); 657 else if (result == TOS_NOT_SUPPORTED) 658 return -ENODEV; 659 660 return result == TOS_SUCCESS ? 0 : -EIO; 661 } 662 663 static int toshiba_touchpad_get(struct toshiba_acpi_dev *dev, u32 *state) 664 { 665 u32 result; 666 667 if (!sci_open(dev)) 668 return -EIO; 669 670 result = sci_read(dev, SCI_TOUCHPAD, state); 671 sci_close(dev); 672 if (result == TOS_FAILURE) 673 pr_err("ACPI call to query the touchpad failed\n"); 674 else if (result == TOS_NOT_SUPPORTED) 675 return -ENODEV; 676 677 return result == TOS_SUCCESS ? 0 : -EIO; 678 } 679 680 /* Eco Mode support */ 681 static void toshiba_eco_mode_available(struct toshiba_acpi_dev *dev) 682 { 683 u32 in[TCI_WORDS] = { HCI_GET, HCI_ECO_MODE, 0, 0, 0, 0 }; 684 u32 out[TCI_WORDS]; 685 acpi_status status; 686 687 dev->eco_supported = 0; 688 dev->eco_led_registered = false; 689 690 status = tci_raw(dev, in, out); 691 if (ACPI_FAILURE(status)) { 692 pr_err("ACPI call to get ECO led failed\n"); 693 return; 694 } 695 696 if (out[0] == TOS_INPUT_DATA_ERROR) { 697 /* 698 * If we receive 0x8300 (Input Data Error), it means that the 699 * LED device is present, but that we just screwed the input 700 * parameters. 701 * 702 * Let's query the status of the LED to see if we really have a 703 * success response, indicating the actual presense of the LED, 704 * bail out otherwise. 705 */ 706 in[3] = 1; 707 status = tci_raw(dev, in, out); 708 if (ACPI_FAILURE(status)) { 709 pr_err("ACPI call to get ECO led failed\n"); 710 return; 711 } 712 713 if (out[0] != TOS_SUCCESS) 714 return; 715 716 dev->eco_supported = 1; 717 } 718 } 719 720 static enum led_brightness 721 toshiba_eco_mode_get_status(struct led_classdev *cdev) 722 { 723 struct toshiba_acpi_dev *dev = container_of(cdev, 724 struct toshiba_acpi_dev, eco_led); 725 u32 in[TCI_WORDS] = { HCI_GET, HCI_ECO_MODE, 0, 1, 0, 0 }; 726 u32 out[TCI_WORDS]; 727 acpi_status status; 728 729 status = tci_raw(dev, in, out); 730 if (ACPI_FAILURE(status)) { 731 pr_err("ACPI call to get ECO led failed\n"); 732 return LED_OFF; 733 } 734 735 if (out[0] != TOS_SUCCESS) 736 return LED_OFF; 737 738 return out[2] ? LED_FULL : LED_OFF; 739 } 740 741 static void toshiba_eco_mode_set_status(struct led_classdev *cdev, 742 enum led_brightness brightness) 743 { 744 struct toshiba_acpi_dev *dev = container_of(cdev, 745 struct toshiba_acpi_dev, eco_led); 746 u32 in[TCI_WORDS] = { HCI_SET, HCI_ECO_MODE, 0, 1, 0, 0 }; 747 u32 out[TCI_WORDS]; 748 acpi_status status; 749 750 /* Switch the Eco Mode led on/off */ 751 in[2] = (brightness) ? 1 : 0; 752 status = tci_raw(dev, in, out); 753 if (ACPI_FAILURE(status)) 754 pr_err("ACPI call to set ECO led failed\n"); 755 } 756 757 /* Accelerometer support */ 758 static void toshiba_accelerometer_available(struct toshiba_acpi_dev *dev) 759 { 760 u32 in[TCI_WORDS] = { HCI_GET, HCI_ACCELEROMETER2, 0, 0, 0, 0 }; 761 u32 out[TCI_WORDS]; 762 acpi_status status; 763 764 dev->accelerometer_supported = 0; 765 766 /* 767 * Check if the accelerometer call exists, 768 * this call also serves as initialization 769 */ 770 status = tci_raw(dev, in, out); 771 if (ACPI_FAILURE(status)) { 772 pr_err("ACPI call to query the accelerometer failed\n"); 773 return; 774 } 775 776 if (out[0] != TOS_SUCCESS) 777 return; 778 779 dev->accelerometer_supported = 1; 780 } 781 782 static int toshiba_accelerometer_get(struct toshiba_acpi_dev *dev, 783 u32 *xy, u32 *z) 784 { 785 u32 in[TCI_WORDS] = { HCI_GET, HCI_ACCELEROMETER, 0, 1, 0, 0 }; 786 u32 out[TCI_WORDS]; 787 acpi_status status; 788 789 /* Check the Accelerometer status */ 790 status = tci_raw(dev, in, out); 791 if (ACPI_FAILURE(status)) { 792 pr_err("ACPI call to query the accelerometer failed\n"); 793 return -EIO; 794 } 795 796 if (out[0] == TOS_NOT_SUPPORTED) 797 return -ENODEV; 798 799 if (out[0] != TOS_SUCCESS) 800 return -EIO; 801 802 *xy = out[2]; 803 *z = out[4]; 804 805 return 0; 806 } 807 808 /* Sleep (Charge and Music) utilities support */ 809 static void toshiba_usb_sleep_charge_available(struct toshiba_acpi_dev *dev) 810 { 811 u32 in[TCI_WORDS] = { SCI_GET, SCI_USB_SLEEP_CHARGE, 0, 0, 0, 0 }; 812 u32 out[TCI_WORDS]; 813 acpi_status status; 814 815 dev->usb_sleep_charge_supported = 0; 816 817 if (!sci_open(dev)) 818 return; 819 820 status = tci_raw(dev, in, out); 821 if (ACPI_FAILURE(status)) { 822 pr_err("ACPI call to get USB Sleep and Charge mode failed\n"); 823 sci_close(dev); 824 return; 825 } 826 827 if (out[0] != TOS_SUCCESS) { 828 sci_close(dev); 829 return; 830 } 831 832 dev->usbsc_mode_base = out[4]; 833 834 in[5] = SCI_USB_CHARGE_BAT_LVL; 835 status = tci_raw(dev, in, out); 836 sci_close(dev); 837 if (ACPI_FAILURE(status)) { 838 pr_err("ACPI call to get USB Sleep and Charge mode failed\n"); 839 return; 840 } 841 842 if (out[0] != TOS_SUCCESS) 843 return; 844 845 dev->usbsc_bat_level = out[2]; 846 /* Flag as supported */ 847 dev->usb_sleep_charge_supported = 1; 848 } 849 850 static int toshiba_usb_sleep_charge_get(struct toshiba_acpi_dev *dev, 851 u32 *mode) 852 { 853 u32 result; 854 855 if (!sci_open(dev)) 856 return -EIO; 857 858 result = sci_read(dev, SCI_USB_SLEEP_CHARGE, mode); 859 sci_close(dev); 860 if (result == TOS_FAILURE) 861 pr_err("ACPI call to set USB S&C mode failed\n"); 862 else if (result == TOS_NOT_SUPPORTED) 863 return -ENODEV; 864 865 return result == TOS_SUCCESS ? 0 : -EIO; 866 } 867 868 static int toshiba_usb_sleep_charge_set(struct toshiba_acpi_dev *dev, 869 u32 mode) 870 { 871 u32 result; 872 873 if (!sci_open(dev)) 874 return -EIO; 875 876 result = sci_write(dev, SCI_USB_SLEEP_CHARGE, mode); 877 sci_close(dev); 878 if (result == TOS_FAILURE) 879 pr_err("ACPI call to set USB S&C mode failed\n"); 880 else if (result == TOS_NOT_SUPPORTED) 881 return -ENODEV; 882 883 return result == TOS_SUCCESS ? 0 : -EIO; 884 } 885 886 static int toshiba_sleep_functions_status_get(struct toshiba_acpi_dev *dev, 887 u32 *mode) 888 { 889 u32 in[TCI_WORDS] = { SCI_GET, SCI_USB_SLEEP_CHARGE, 0, 0, 0, 0 }; 890 u32 out[TCI_WORDS]; 891 acpi_status status; 892 893 if (!sci_open(dev)) 894 return -EIO; 895 896 in[5] = SCI_USB_CHARGE_BAT_LVL; 897 status = tci_raw(dev, in, out); 898 sci_close(dev); 899 if (ACPI_FAILURE(status)) { 900 pr_err("ACPI call to get USB S&C battery level failed\n"); 901 return -EIO; 902 } 903 904 if (out[0] == TOS_NOT_SUPPORTED) 905 return -ENODEV; 906 907 if (out[0] != TOS_SUCCESS) 908 return -EIO; 909 910 *mode = out[2]; 911 912 return 0; 913 914 } 915 916 static int toshiba_sleep_functions_status_set(struct toshiba_acpi_dev *dev, 917 u32 mode) 918 { 919 u32 in[TCI_WORDS] = { SCI_SET, SCI_USB_SLEEP_CHARGE, 0, 0, 0, 0 }; 920 u32 out[TCI_WORDS]; 921 acpi_status status; 922 923 if (!sci_open(dev)) 924 return -EIO; 925 926 in[2] = mode; 927 in[5] = SCI_USB_CHARGE_BAT_LVL; 928 status = tci_raw(dev, in, out); 929 sci_close(dev); 930 if (ACPI_FAILURE(status)) { 931 pr_err("ACPI call to set USB S&C battery level failed\n"); 932 return -EIO; 933 } 934 935 if (out[0] == TOS_NOT_SUPPORTED) 936 return -ENODEV; 937 938 return out[0] == TOS_SUCCESS ? 0 : -EIO; 939 } 940 941 static int toshiba_usb_rapid_charge_get(struct toshiba_acpi_dev *dev, 942 u32 *state) 943 { 944 u32 in[TCI_WORDS] = { SCI_GET, SCI_USB_SLEEP_CHARGE, 0, 0, 0, 0 }; 945 u32 out[TCI_WORDS]; 946 acpi_status status; 947 948 if (!sci_open(dev)) 949 return -EIO; 950 951 in[5] = SCI_USB_CHARGE_RAPID_DSP; 952 status = tci_raw(dev, in, out); 953 sci_close(dev); 954 if (ACPI_FAILURE(status)) { 955 pr_err("ACPI call to get USB Rapid Charge failed\n"); 956 return -EIO; 957 } 958 959 if (out[0] == TOS_NOT_SUPPORTED) 960 return -ENODEV; 961 962 if (out[0] != TOS_SUCCESS && out[0] != TOS_SUCCESS2) 963 return -EIO; 964 965 *state = out[2]; 966 967 return 0; 968 } 969 970 static int toshiba_usb_rapid_charge_set(struct toshiba_acpi_dev *dev, 971 u32 state) 972 { 973 u32 in[TCI_WORDS] = { SCI_SET, SCI_USB_SLEEP_CHARGE, 0, 0, 0, 0 }; 974 u32 out[TCI_WORDS]; 975 acpi_status status; 976 977 if (!sci_open(dev)) 978 return -EIO; 979 980 in[2] = state; 981 in[5] = SCI_USB_CHARGE_RAPID_DSP; 982 status = tci_raw(dev, in, out); 983 sci_close(dev); 984 if (ACPI_FAILURE(status)) { 985 pr_err("ACPI call to set USB Rapid Charge failed\n"); 986 return -EIO; 987 } 988 989 if (out[0] == TOS_NOT_SUPPORTED) 990 return -ENODEV; 991 992 return (out[0] == TOS_SUCCESS || out[0] == TOS_SUCCESS2) ? 0 : -EIO; 993 } 994 995 static int toshiba_usb_sleep_music_get(struct toshiba_acpi_dev *dev, u32 *state) 996 { 997 u32 result; 998 999 if (!sci_open(dev)) 1000 return -EIO; 1001 1002 result = sci_read(dev, SCI_USB_SLEEP_MUSIC, state); 1003 sci_close(dev); 1004 if (result == TOS_FAILURE) 1005 pr_err("ACPI call to get Sleep and Music failed\n"); 1006 else if (result == TOS_NOT_SUPPORTED) 1007 return -ENODEV; 1008 1009 return result == TOS_SUCCESS ? 0 : -EIO; 1010 } 1011 1012 static int toshiba_usb_sleep_music_set(struct toshiba_acpi_dev *dev, u32 state) 1013 { 1014 u32 result; 1015 1016 if (!sci_open(dev)) 1017 return -EIO; 1018 1019 result = sci_write(dev, SCI_USB_SLEEP_MUSIC, state); 1020 sci_close(dev); 1021 if (result == TOS_FAILURE) 1022 pr_err("ACPI call to set Sleep and Music failed\n"); 1023 else if (result == TOS_NOT_SUPPORTED) 1024 return -ENODEV; 1025 1026 return result == TOS_SUCCESS ? 0 : -EIO; 1027 } 1028 1029 /* Keyboard function keys */ 1030 static int toshiba_function_keys_get(struct toshiba_acpi_dev *dev, u32 *mode) 1031 { 1032 u32 result; 1033 1034 if (!sci_open(dev)) 1035 return -EIO; 1036 1037 result = sci_read(dev, SCI_KBD_FUNCTION_KEYS, mode); 1038 sci_close(dev); 1039 if (result == TOS_FAILURE) 1040 pr_err("ACPI call to get KBD function keys failed\n"); 1041 else if (result == TOS_NOT_SUPPORTED) 1042 return -ENODEV; 1043 1044 return (result == TOS_SUCCESS || result == TOS_SUCCESS2) ? 0 : -EIO; 1045 } 1046 1047 static int toshiba_function_keys_set(struct toshiba_acpi_dev *dev, u32 mode) 1048 { 1049 u32 result; 1050 1051 if (!sci_open(dev)) 1052 return -EIO; 1053 1054 result = sci_write(dev, SCI_KBD_FUNCTION_KEYS, mode); 1055 sci_close(dev); 1056 if (result == TOS_FAILURE) 1057 pr_err("ACPI call to set KBD function keys failed\n"); 1058 else if (result == TOS_NOT_SUPPORTED) 1059 return -ENODEV; 1060 1061 return (result == TOS_SUCCESS || result == TOS_SUCCESS2) ? 0 : -EIO; 1062 } 1063 1064 /* Panel Power ON */ 1065 static int toshiba_panel_power_on_get(struct toshiba_acpi_dev *dev, u32 *state) 1066 { 1067 u32 result; 1068 1069 if (!sci_open(dev)) 1070 return -EIO; 1071 1072 result = sci_read(dev, SCI_PANEL_POWER_ON, state); 1073 sci_close(dev); 1074 if (result == TOS_FAILURE) 1075 pr_err("ACPI call to get Panel Power ON failed\n"); 1076 else if (result == TOS_NOT_SUPPORTED) 1077 return -ENODEV; 1078 1079 return result == TOS_SUCCESS ? 0 : -EIO; 1080 } 1081 1082 static int toshiba_panel_power_on_set(struct toshiba_acpi_dev *dev, u32 state) 1083 { 1084 u32 result; 1085 1086 if (!sci_open(dev)) 1087 return -EIO; 1088 1089 result = sci_write(dev, SCI_PANEL_POWER_ON, state); 1090 sci_close(dev); 1091 if (result == TOS_FAILURE) 1092 pr_err("ACPI call to set Panel Power ON failed\n"); 1093 else if (result == TOS_NOT_SUPPORTED) 1094 return -ENODEV; 1095 1096 return result == TOS_SUCCESS ? 0 : -EIO; 1097 } 1098 1099 /* USB Three */ 1100 static int toshiba_usb_three_get(struct toshiba_acpi_dev *dev, u32 *state) 1101 { 1102 u32 result; 1103 1104 if (!sci_open(dev)) 1105 return -EIO; 1106 1107 result = sci_read(dev, SCI_USB_THREE, state); 1108 sci_close(dev); 1109 if (result == TOS_FAILURE) 1110 pr_err("ACPI call to get USB 3 failed\n"); 1111 else if (result == TOS_NOT_SUPPORTED) 1112 return -ENODEV; 1113 1114 return (result == TOS_SUCCESS || result == TOS_SUCCESS2) ? 0 : -EIO; 1115 } 1116 1117 static int toshiba_usb_three_set(struct toshiba_acpi_dev *dev, u32 state) 1118 { 1119 u32 result; 1120 1121 if (!sci_open(dev)) 1122 return -EIO; 1123 1124 result = sci_write(dev, SCI_USB_THREE, state); 1125 sci_close(dev); 1126 if (result == TOS_FAILURE) 1127 pr_err("ACPI call to set USB 3 failed\n"); 1128 else if (result == TOS_NOT_SUPPORTED) 1129 return -ENODEV; 1130 1131 return (result == TOS_SUCCESS || result == TOS_SUCCESS2) ? 0 : -EIO; 1132 } 1133 1134 /* Hotkey Event type */ 1135 static int toshiba_hotkey_event_type_get(struct toshiba_acpi_dev *dev, 1136 u32 *type) 1137 { 1138 u32 in[TCI_WORDS] = { HCI_GET, HCI_SYSTEM_INFO, 0x03, 0, 0, 0 }; 1139 u32 out[TCI_WORDS]; 1140 acpi_status status; 1141 1142 status = tci_raw(dev, in, out); 1143 if (ACPI_FAILURE(status)) { 1144 pr_err("ACPI call to get System type failed\n"); 1145 return -EIO; 1146 } 1147 1148 if (out[0] == TOS_NOT_SUPPORTED) 1149 return -ENODEV; 1150 1151 if (out[0] != TOS_SUCCESS) 1152 return -EIO; 1153 1154 *type = out[3]; 1155 1156 return 0; 1157 } 1158 1159 /* Wireless status (RFKill, WLAN, BT, WWAN) */ 1160 static int toshiba_wireless_status(struct toshiba_acpi_dev *dev) 1161 { 1162 u32 in[TCI_WORDS] = { HCI_GET, HCI_WIRELESS, 0, 0, 0, 0 }; 1163 u32 out[TCI_WORDS]; 1164 acpi_status status; 1165 1166 in[3] = HCI_WIRELESS_STATUS; 1167 status = tci_raw(dev, in, out); 1168 1169 if (ACPI_FAILURE(status)) { 1170 pr_err("ACPI call to get Wireless status failed\n"); 1171 return -EIO; 1172 } 1173 1174 if (out[0] == TOS_NOT_SUPPORTED) 1175 return -ENODEV; 1176 1177 if (out[0] != TOS_SUCCESS) 1178 return -EIO; 1179 1180 dev->killswitch = !!(out[2] & HCI_WIRELESS_STATUS); 1181 1182 return 0; 1183 } 1184 1185 /* WWAN */ 1186 static void toshiba_wwan_available(struct toshiba_acpi_dev *dev) 1187 { 1188 u32 in[TCI_WORDS] = { HCI_GET, HCI_WIRELESS, 0, 0, 0, 0 }; 1189 u32 out[TCI_WORDS]; 1190 acpi_status status; 1191 1192 dev->wwan_supported = 0; 1193 1194 /* 1195 * WWAN support can be queried by setting the in[3] value to 1196 * HCI_WIRELESS_WWAN (0x03). 1197 * 1198 * If supported, out[0] contains TOS_SUCCESS and out[2] contains 1199 * HCI_WIRELESS_WWAN_STATUS (0x2000). 1200 * 1201 * If not supported, out[0] contains TOS_INPUT_DATA_ERROR (0x8300) 1202 * or TOS_NOT_SUPPORTED (0x8000). 1203 */ 1204 in[3] = HCI_WIRELESS_WWAN; 1205 status = tci_raw(dev, in, out); 1206 if (ACPI_FAILURE(status)) { 1207 pr_err("ACPI call to get WWAN status failed\n"); 1208 return; 1209 } 1210 1211 if (out[0] != TOS_SUCCESS) 1212 return; 1213 1214 dev->wwan_supported = (out[2] == HCI_WIRELESS_WWAN_STATUS); 1215 } 1216 1217 static int toshiba_wwan_set(struct toshiba_acpi_dev *dev, u32 state) 1218 { 1219 u32 in[TCI_WORDS] = { HCI_SET, HCI_WIRELESS, state, 0, 0, 0 }; 1220 u32 out[TCI_WORDS]; 1221 acpi_status status; 1222 1223 in[3] = HCI_WIRELESS_WWAN_STATUS; 1224 status = tci_raw(dev, in, out); 1225 if (ACPI_FAILURE(status)) { 1226 pr_err("ACPI call to set WWAN status failed\n"); 1227 return -EIO; 1228 } 1229 1230 if (out[0] == TOS_NOT_SUPPORTED) 1231 return -ENODEV; 1232 1233 if (out[0] != TOS_SUCCESS) 1234 return -EIO; 1235 1236 /* 1237 * Some devices only need to call HCI_WIRELESS_WWAN_STATUS to 1238 * (de)activate the device, but some others need the 1239 * HCI_WIRELESS_WWAN_POWER call as well. 1240 */ 1241 in[3] = HCI_WIRELESS_WWAN_POWER; 1242 status = tci_raw(dev, in, out); 1243 if (ACPI_FAILURE(status)) { 1244 pr_err("ACPI call to set WWAN power failed\n"); 1245 return -EIO; 1246 } 1247 1248 if (out[0] == TOS_NOT_SUPPORTED) 1249 return -ENODEV; 1250 1251 return out[0] == TOS_SUCCESS ? 0 : -EIO; 1252 } 1253 1254 /* Cooling Method */ 1255 static void toshiba_cooling_method_available(struct toshiba_acpi_dev *dev) 1256 { 1257 u32 in[TCI_WORDS] = { HCI_GET, HCI_COOLING_METHOD, 0, 0, 0, 0 }; 1258 u32 out[TCI_WORDS]; 1259 acpi_status status; 1260 1261 dev->cooling_method_supported = 0; 1262 dev->max_cooling_method = 0; 1263 1264 status = tci_raw(dev, in, out); 1265 if (ACPI_FAILURE(status)) { 1266 pr_err("ACPI call to get Cooling Method failed\n"); 1267 return; 1268 } 1269 1270 if (out[0] != TOS_SUCCESS && out[0] != TOS_SUCCESS2) 1271 return; 1272 1273 dev->cooling_method_supported = 1; 1274 dev->max_cooling_method = out[3]; 1275 } 1276 1277 static int toshiba_cooling_method_get(struct toshiba_acpi_dev *dev, u32 *state) 1278 { 1279 u32 result = hci_read(dev, HCI_COOLING_METHOD, state); 1280 1281 if (result == TOS_FAILURE) 1282 pr_err("ACPI call to get Cooling Method failed\n"); 1283 1284 if (result == TOS_NOT_SUPPORTED) 1285 return -ENODEV; 1286 1287 return (result == TOS_SUCCESS || result == TOS_SUCCESS2) ? 0 : -EIO; 1288 } 1289 1290 static int toshiba_cooling_method_set(struct toshiba_acpi_dev *dev, u32 state) 1291 { 1292 u32 result = hci_write(dev, HCI_COOLING_METHOD, state); 1293 1294 if (result == TOS_FAILURE) 1295 pr_err("ACPI call to set Cooling Method failed\n"); 1296 1297 if (result == TOS_NOT_SUPPORTED) 1298 return -ENODEV; 1299 1300 return (result == TOS_SUCCESS || result == TOS_SUCCESS2) ? 0 : -EIO; 1301 } 1302 1303 /* Transflective Backlight */ 1304 static int get_tr_backlight_status(struct toshiba_acpi_dev *dev, u32 *status) 1305 { 1306 u32 result = hci_read(dev, HCI_TR_BACKLIGHT, status); 1307 1308 if (result == TOS_FAILURE) 1309 pr_err("ACPI call to get Transflective Backlight failed\n"); 1310 else if (result == TOS_NOT_SUPPORTED) 1311 return -ENODEV; 1312 1313 return result == TOS_SUCCESS ? 0 : -EIO; 1314 } 1315 1316 static int set_tr_backlight_status(struct toshiba_acpi_dev *dev, u32 status) 1317 { 1318 u32 result = hci_write(dev, HCI_TR_BACKLIGHT, !status); 1319 1320 if (result == TOS_FAILURE) 1321 pr_err("ACPI call to set Transflective Backlight failed\n"); 1322 else if (result == TOS_NOT_SUPPORTED) 1323 return -ENODEV; 1324 1325 return result == TOS_SUCCESS ? 0 : -EIO; 1326 } 1327 1328 static struct proc_dir_entry *toshiba_proc_dir; 1329 1330 /* LCD Brightness */ 1331 static int __get_lcd_brightness(struct toshiba_acpi_dev *dev) 1332 { 1333 int brightness = 0; 1334 u32 result; 1335 u32 value; 1336 1337 if (dev->tr_backlight_supported) { 1338 int ret = get_tr_backlight_status(dev, &value); 1339 1340 if (ret) 1341 return ret; 1342 if (value) 1343 return 0; 1344 brightness++; 1345 } 1346 1347 result = hci_read(dev, HCI_LCD_BRIGHTNESS, &value); 1348 if (result == TOS_FAILURE) 1349 pr_err("ACPI call to get LCD Brightness failed\n"); 1350 else if (result == TOS_NOT_SUPPORTED) 1351 return -ENODEV; 1352 1353 return result == TOS_SUCCESS ? 1354 brightness + (value >> HCI_LCD_BRIGHTNESS_SHIFT) : 1355 -EIO; 1356 } 1357 1358 static int get_lcd_brightness(struct backlight_device *bd) 1359 { 1360 struct toshiba_acpi_dev *dev = bl_get_data(bd); 1361 1362 return __get_lcd_brightness(dev); 1363 } 1364 1365 static int lcd_proc_show(struct seq_file *m, void *v) 1366 { 1367 struct toshiba_acpi_dev *dev = m->private; 1368 int levels; 1369 int value; 1370 1371 if (!dev->backlight_dev) 1372 return -ENODEV; 1373 1374 levels = dev->backlight_dev->props.max_brightness + 1; 1375 value = get_lcd_brightness(dev->backlight_dev); 1376 if (value < 0) { 1377 pr_err("Error reading LCD brightness\n"); 1378 return value; 1379 } 1380 1381 seq_printf(m, "brightness: %d\n", value); 1382 seq_printf(m, "brightness_levels: %d\n", levels); 1383 1384 return 0; 1385 } 1386 1387 static int lcd_proc_open(struct inode *inode, struct file *file) 1388 { 1389 return single_open(file, lcd_proc_show, PDE_DATA(inode)); 1390 } 1391 1392 static int set_lcd_brightness(struct toshiba_acpi_dev *dev, int value) 1393 { 1394 u32 result; 1395 1396 if (dev->tr_backlight_supported) { 1397 int ret = set_tr_backlight_status(dev, !value); 1398 1399 if (ret) 1400 return ret; 1401 if (value) 1402 value--; 1403 } 1404 1405 value = value << HCI_LCD_BRIGHTNESS_SHIFT; 1406 result = hci_write(dev, HCI_LCD_BRIGHTNESS, value); 1407 if (result == TOS_FAILURE) 1408 pr_err("ACPI call to set LCD Brightness failed\n"); 1409 else if (result == TOS_NOT_SUPPORTED) 1410 return -ENODEV; 1411 1412 return result == TOS_SUCCESS ? 0 : -EIO; 1413 } 1414 1415 static int set_lcd_status(struct backlight_device *bd) 1416 { 1417 struct toshiba_acpi_dev *dev = bl_get_data(bd); 1418 1419 return set_lcd_brightness(dev, bd->props.brightness); 1420 } 1421 1422 static ssize_t lcd_proc_write(struct file *file, const char __user *buf, 1423 size_t count, loff_t *pos) 1424 { 1425 struct toshiba_acpi_dev *dev = PDE_DATA(file_inode(file)); 1426 char cmd[42]; 1427 size_t len; 1428 int levels; 1429 int value; 1430 1431 len = min(count, sizeof(cmd) - 1); 1432 if (copy_from_user(cmd, buf, len)) 1433 return -EFAULT; 1434 cmd[len] = '\0'; 1435 1436 levels = dev->backlight_dev->props.max_brightness + 1; 1437 if (sscanf(cmd, " brightness : %i", &value) != 1 && 1438 value < 0 && value > levels) 1439 return -EINVAL; 1440 1441 if (set_lcd_brightness(dev, value)) 1442 return -EIO; 1443 1444 return count; 1445 } 1446 1447 static const struct file_operations lcd_proc_fops = { 1448 .owner = THIS_MODULE, 1449 .open = lcd_proc_open, 1450 .read = seq_read, 1451 .llseek = seq_lseek, 1452 .release = single_release, 1453 .write = lcd_proc_write, 1454 }; 1455 1456 /* Video-Out */ 1457 static int get_video_status(struct toshiba_acpi_dev *dev, u32 *status) 1458 { 1459 u32 result = hci_read(dev, HCI_VIDEO_OUT, status); 1460 1461 if (result == TOS_FAILURE) 1462 pr_err("ACPI call to get Video-Out failed\n"); 1463 else if (result == TOS_NOT_SUPPORTED) 1464 return -ENODEV; 1465 1466 return result == TOS_SUCCESS ? 0 : -EIO; 1467 } 1468 1469 static int video_proc_show(struct seq_file *m, void *v) 1470 { 1471 struct toshiba_acpi_dev *dev = m->private; 1472 int is_lcd, is_crt, is_tv; 1473 u32 value; 1474 1475 if (get_video_status(dev, &value)) 1476 return -EIO; 1477 1478 is_lcd = (value & HCI_VIDEO_OUT_LCD) ? 1 : 0; 1479 is_crt = (value & HCI_VIDEO_OUT_CRT) ? 1 : 0; 1480 is_tv = (value & HCI_VIDEO_OUT_TV) ? 1 : 0; 1481 1482 seq_printf(m, "lcd_out: %d\n", is_lcd); 1483 seq_printf(m, "crt_out: %d\n", is_crt); 1484 seq_printf(m, "tv_out: %d\n", is_tv); 1485 1486 return 0; 1487 } 1488 1489 static int video_proc_open(struct inode *inode, struct file *file) 1490 { 1491 return single_open(file, video_proc_show, PDE_DATA(inode)); 1492 } 1493 1494 static ssize_t video_proc_write(struct file *file, const char __user *buf, 1495 size_t count, loff_t *pos) 1496 { 1497 struct toshiba_acpi_dev *dev = PDE_DATA(file_inode(file)); 1498 char *buffer; 1499 char *cmd; 1500 int lcd_out, crt_out, tv_out; 1501 int remain = count; 1502 int value; 1503 int ret; 1504 u32 video_out; 1505 1506 cmd = memdup_user_nul(buf, count); 1507 if (IS_ERR(cmd)) 1508 return PTR_ERR(cmd); 1509 1510 buffer = cmd; 1511 1512 /* 1513 * Scan expression. Multiple expressions may be delimited with ; 1514 * NOTE: To keep scanning simple, invalid fields are ignored. 1515 */ 1516 while (remain) { 1517 if (sscanf(buffer, " lcd_out : %i", &value) == 1) 1518 lcd_out = value & 1; 1519 else if (sscanf(buffer, " crt_out : %i", &value) == 1) 1520 crt_out = value & 1; 1521 else if (sscanf(buffer, " tv_out : %i", &value) == 1) 1522 tv_out = value & 1; 1523 /* Advance to one character past the next ; */ 1524 do { 1525 ++buffer; 1526 --remain; 1527 } while (remain && *(buffer - 1) != ';'); 1528 } 1529 1530 kfree(cmd); 1531 1532 lcd_out = crt_out = tv_out = -1; 1533 ret = get_video_status(dev, &video_out); 1534 if (!ret) { 1535 unsigned int new_video_out = video_out; 1536 1537 if (lcd_out != -1) 1538 _set_bit(&new_video_out, HCI_VIDEO_OUT_LCD, lcd_out); 1539 if (crt_out != -1) 1540 _set_bit(&new_video_out, HCI_VIDEO_OUT_CRT, crt_out); 1541 if (tv_out != -1) 1542 _set_bit(&new_video_out, HCI_VIDEO_OUT_TV, tv_out); 1543 /* 1544 * To avoid unnecessary video disruption, only write the new 1545 * video setting if something changed. 1546 */ 1547 if (new_video_out != video_out) 1548 ret = write_acpi_int(METHOD_VIDEO_OUT, new_video_out); 1549 } 1550 1551 return ret ? -EIO : count; 1552 } 1553 1554 static const struct file_operations video_proc_fops = { 1555 .owner = THIS_MODULE, 1556 .open = video_proc_open, 1557 .read = seq_read, 1558 .llseek = seq_lseek, 1559 .release = single_release, 1560 .write = video_proc_write, 1561 }; 1562 1563 /* Fan status */ 1564 static int get_fan_status(struct toshiba_acpi_dev *dev, u32 *status) 1565 { 1566 u32 result = hci_read(dev, HCI_FAN, status); 1567 1568 if (result == TOS_FAILURE) 1569 pr_err("ACPI call to get Fan status failed\n"); 1570 else if (result == TOS_NOT_SUPPORTED) 1571 return -ENODEV; 1572 1573 return result == TOS_SUCCESS ? 0 : -EIO; 1574 } 1575 1576 static int set_fan_status(struct toshiba_acpi_dev *dev, u32 status) 1577 { 1578 u32 result = hci_write(dev, HCI_FAN, status); 1579 1580 if (result == TOS_FAILURE) 1581 pr_err("ACPI call to set Fan status failed\n"); 1582 else if (result == TOS_NOT_SUPPORTED) 1583 return -ENODEV; 1584 1585 return result == TOS_SUCCESS ? 0 : -EIO; 1586 } 1587 1588 static int fan_proc_show(struct seq_file *m, void *v) 1589 { 1590 struct toshiba_acpi_dev *dev = m->private; 1591 u32 value; 1592 1593 if (get_fan_status(dev, &value)) 1594 return -EIO; 1595 1596 seq_printf(m, "running: %d\n", (value > 0)); 1597 seq_printf(m, "force_on: %d\n", dev->force_fan); 1598 1599 return 0; 1600 } 1601 1602 static int fan_proc_open(struct inode *inode, struct file *file) 1603 { 1604 return single_open(file, fan_proc_show, PDE_DATA(inode)); 1605 } 1606 1607 static ssize_t fan_proc_write(struct file *file, const char __user *buf, 1608 size_t count, loff_t *pos) 1609 { 1610 struct toshiba_acpi_dev *dev = PDE_DATA(file_inode(file)); 1611 char cmd[42]; 1612 size_t len; 1613 int value; 1614 1615 len = min(count, sizeof(cmd) - 1); 1616 if (copy_from_user(cmd, buf, len)) 1617 return -EFAULT; 1618 cmd[len] = '\0'; 1619 1620 if (sscanf(cmd, " force_on : %i", &value) != 1 && 1621 value != 0 && value != 1) 1622 return -EINVAL; 1623 1624 if (set_fan_status(dev, value)) 1625 return -EIO; 1626 1627 dev->force_fan = value; 1628 1629 return count; 1630 } 1631 1632 static const struct file_operations fan_proc_fops = { 1633 .owner = THIS_MODULE, 1634 .open = fan_proc_open, 1635 .read = seq_read, 1636 .llseek = seq_lseek, 1637 .release = single_release, 1638 .write = fan_proc_write, 1639 }; 1640 1641 static int keys_proc_show(struct seq_file *m, void *v) 1642 { 1643 struct toshiba_acpi_dev *dev = m->private; 1644 1645 seq_printf(m, "hotkey_ready: %d\n", dev->key_event_valid); 1646 seq_printf(m, "hotkey: 0x%04x\n", dev->last_key_event); 1647 1648 return 0; 1649 } 1650 1651 static int keys_proc_open(struct inode *inode, struct file *file) 1652 { 1653 return single_open(file, keys_proc_show, PDE_DATA(inode)); 1654 } 1655 1656 static ssize_t keys_proc_write(struct file *file, const char __user *buf, 1657 size_t count, loff_t *pos) 1658 { 1659 struct toshiba_acpi_dev *dev = PDE_DATA(file_inode(file)); 1660 char cmd[42]; 1661 size_t len; 1662 int value; 1663 1664 len = min(count, sizeof(cmd) - 1); 1665 if (copy_from_user(cmd, buf, len)) 1666 return -EFAULT; 1667 cmd[len] = '\0'; 1668 1669 if (sscanf(cmd, " hotkey_ready : %i", &value) == 1 && value == 0) 1670 dev->key_event_valid = 0; 1671 else 1672 return -EINVAL; 1673 1674 return count; 1675 } 1676 1677 static const struct file_operations keys_proc_fops = { 1678 .owner = THIS_MODULE, 1679 .open = keys_proc_open, 1680 .read = seq_read, 1681 .llseek = seq_lseek, 1682 .release = single_release, 1683 .write = keys_proc_write, 1684 }; 1685 1686 static int __maybe_unused version_proc_show(struct seq_file *m, void *v) 1687 { 1688 seq_printf(m, "driver: %s\n", TOSHIBA_ACPI_VERSION); 1689 seq_printf(m, "proc_interface: %d\n", PROC_INTERFACE_VERSION); 1690 return 0; 1691 } 1692 1693 /* 1694 * Proc and module init 1695 */ 1696 1697 #define PROC_TOSHIBA "toshiba" 1698 1699 static void create_toshiba_proc_entries(struct toshiba_acpi_dev *dev) 1700 { 1701 if (dev->backlight_dev) 1702 proc_create_data("lcd", S_IRUGO | S_IWUSR, toshiba_proc_dir, 1703 &lcd_proc_fops, dev); 1704 if (dev->video_supported) 1705 proc_create_data("video", S_IRUGO | S_IWUSR, toshiba_proc_dir, 1706 &video_proc_fops, dev); 1707 if (dev->fan_supported) 1708 proc_create_data("fan", S_IRUGO | S_IWUSR, toshiba_proc_dir, 1709 &fan_proc_fops, dev); 1710 if (dev->hotkey_dev) 1711 proc_create_data("keys", S_IRUGO | S_IWUSR, toshiba_proc_dir, 1712 &keys_proc_fops, dev); 1713 proc_create_single_data("version", S_IRUGO, toshiba_proc_dir, 1714 version_proc_show, dev); 1715 } 1716 1717 static void remove_toshiba_proc_entries(struct toshiba_acpi_dev *dev) 1718 { 1719 if (dev->backlight_dev) 1720 remove_proc_entry("lcd", toshiba_proc_dir); 1721 if (dev->video_supported) 1722 remove_proc_entry("video", toshiba_proc_dir); 1723 if (dev->fan_supported) 1724 remove_proc_entry("fan", toshiba_proc_dir); 1725 if (dev->hotkey_dev) 1726 remove_proc_entry("keys", toshiba_proc_dir); 1727 remove_proc_entry("version", toshiba_proc_dir); 1728 } 1729 1730 static const struct backlight_ops toshiba_backlight_data = { 1731 .options = BL_CORE_SUSPENDRESUME, 1732 .get_brightness = get_lcd_brightness, 1733 .update_status = set_lcd_status, 1734 }; 1735 1736 /* Keyboard backlight work */ 1737 static void toshiba_acpi_kbd_bl_work(struct work_struct *work); 1738 1739 static DECLARE_WORK(kbd_bl_work, toshiba_acpi_kbd_bl_work); 1740 1741 /* 1742 * Sysfs files 1743 */ 1744 static ssize_t version_show(struct device *dev, 1745 struct device_attribute *attr, char *buf) 1746 { 1747 return sprintf(buf, "%s\n", TOSHIBA_ACPI_VERSION); 1748 } 1749 static DEVICE_ATTR_RO(version); 1750 1751 static ssize_t fan_store(struct device *dev, 1752 struct device_attribute *attr, 1753 const char *buf, size_t count) 1754 { 1755 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 1756 int state; 1757 int ret; 1758 1759 ret = kstrtoint(buf, 0, &state); 1760 if (ret) 1761 return ret; 1762 1763 if (state != 0 && state != 1) 1764 return -EINVAL; 1765 1766 ret = set_fan_status(toshiba, state); 1767 if (ret) 1768 return ret; 1769 1770 return count; 1771 } 1772 1773 static ssize_t fan_show(struct device *dev, 1774 struct device_attribute *attr, char *buf) 1775 { 1776 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 1777 u32 value; 1778 int ret; 1779 1780 ret = get_fan_status(toshiba, &value); 1781 if (ret) 1782 return ret; 1783 1784 return sprintf(buf, "%d\n", value); 1785 } 1786 static DEVICE_ATTR_RW(fan); 1787 1788 static ssize_t kbd_backlight_mode_store(struct device *dev, 1789 struct device_attribute *attr, 1790 const char *buf, size_t count) 1791 { 1792 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 1793 int mode; 1794 int ret; 1795 1796 1797 ret = kstrtoint(buf, 0, &mode); 1798 if (ret) 1799 return ret; 1800 1801 /* Check for supported modes depending on keyboard backlight type */ 1802 if (toshiba->kbd_type == 1) { 1803 /* Type 1 supports SCI_KBD_MODE_FNZ and SCI_KBD_MODE_AUTO */ 1804 if (mode != SCI_KBD_MODE_FNZ && mode != SCI_KBD_MODE_AUTO) 1805 return -EINVAL; 1806 } else if (toshiba->kbd_type == 2) { 1807 /* Type 2 doesn't support SCI_KBD_MODE_FNZ */ 1808 if (mode != SCI_KBD_MODE_AUTO && mode != SCI_KBD_MODE_ON && 1809 mode != SCI_KBD_MODE_OFF) 1810 return -EINVAL; 1811 } 1812 1813 /* 1814 * Set the Keyboard Backlight Mode where: 1815 * Auto - KBD backlight turns off automatically in given time 1816 * FN-Z - KBD backlight "toggles" when hotkey pressed 1817 * ON - KBD backlight is always on 1818 * OFF - KBD backlight is always off 1819 */ 1820 1821 /* Only make a change if the actual mode has changed */ 1822 if (toshiba->kbd_mode != mode) { 1823 /* Shift the time to "base time" (0x3c0000 == 60 seconds) */ 1824 int time = toshiba->kbd_time << HCI_MISC_SHIFT; 1825 1826 /* OR the "base time" to the actual method format */ 1827 if (toshiba->kbd_type == 1) { 1828 /* Type 1 requires the current mode */ 1829 time |= toshiba->kbd_mode; 1830 } else if (toshiba->kbd_type == 2) { 1831 /* Type 2 requires the desired mode */ 1832 time |= mode; 1833 } 1834 1835 ret = toshiba_kbd_illum_status_set(toshiba, time); 1836 if (ret) 1837 return ret; 1838 1839 toshiba->kbd_mode = mode; 1840 toshiba_acpi->kbd_mode = mode; 1841 1842 /* 1843 * Some laptop models with the second generation backlit 1844 * keyboard (type 2) do not generate the keyboard backlight 1845 * changed event (0x92), and thus, the driver will never update 1846 * the sysfs entries. 1847 * 1848 * The event is generated right when changing the keyboard 1849 * backlight mode and the *notify function will set the 1850 * kbd_event_generated to true. 1851 * 1852 * In case the event is not generated, schedule the keyboard 1853 * backlight work to update the sysfs entries and emulate the 1854 * event via genetlink. 1855 */ 1856 if (toshiba->kbd_type == 2 && 1857 !toshiba->kbd_event_generated) 1858 schedule_work(&kbd_bl_work); 1859 } 1860 1861 return count; 1862 } 1863 1864 static ssize_t kbd_backlight_mode_show(struct device *dev, 1865 struct device_attribute *attr, 1866 char *buf) 1867 { 1868 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 1869 u32 time; 1870 1871 if (toshiba_kbd_illum_status_get(toshiba, &time) < 0) 1872 return -EIO; 1873 1874 return sprintf(buf, "%i\n", time & SCI_KBD_MODE_MASK); 1875 } 1876 static DEVICE_ATTR_RW(kbd_backlight_mode); 1877 1878 static ssize_t kbd_type_show(struct device *dev, 1879 struct device_attribute *attr, char *buf) 1880 { 1881 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 1882 1883 return sprintf(buf, "%d\n", toshiba->kbd_type); 1884 } 1885 static DEVICE_ATTR_RO(kbd_type); 1886 1887 static ssize_t available_kbd_modes_show(struct device *dev, 1888 struct device_attribute *attr, 1889 char *buf) 1890 { 1891 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 1892 1893 if (toshiba->kbd_type == 1) 1894 return sprintf(buf, "0x%x 0x%x\n", 1895 SCI_KBD_MODE_FNZ, SCI_KBD_MODE_AUTO); 1896 1897 return sprintf(buf, "0x%x 0x%x 0x%x\n", 1898 SCI_KBD_MODE_AUTO, SCI_KBD_MODE_ON, SCI_KBD_MODE_OFF); 1899 } 1900 static DEVICE_ATTR_RO(available_kbd_modes); 1901 1902 static ssize_t kbd_backlight_timeout_store(struct device *dev, 1903 struct device_attribute *attr, 1904 const char *buf, size_t count) 1905 { 1906 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 1907 int time; 1908 int ret; 1909 1910 ret = kstrtoint(buf, 0, &time); 1911 if (ret) 1912 return ret; 1913 1914 /* Check for supported values depending on kbd_type */ 1915 if (toshiba->kbd_type == 1) { 1916 if (time < 0 || time > 60) 1917 return -EINVAL; 1918 } else if (toshiba->kbd_type == 2) { 1919 if (time < 1 || time > 60) 1920 return -EINVAL; 1921 } 1922 1923 /* Set the Keyboard Backlight Timeout */ 1924 1925 /* Only make a change if the actual timeout has changed */ 1926 if (toshiba->kbd_time != time) { 1927 /* Shift the time to "base time" (0x3c0000 == 60 seconds) */ 1928 time = time << HCI_MISC_SHIFT; 1929 /* OR the "base time" to the actual method format */ 1930 if (toshiba->kbd_type == 1) 1931 time |= SCI_KBD_MODE_FNZ; 1932 else if (toshiba->kbd_type == 2) 1933 time |= SCI_KBD_MODE_AUTO; 1934 1935 ret = toshiba_kbd_illum_status_set(toshiba, time); 1936 if (ret) 1937 return ret; 1938 1939 toshiba->kbd_time = time >> HCI_MISC_SHIFT; 1940 } 1941 1942 return count; 1943 } 1944 1945 static ssize_t kbd_backlight_timeout_show(struct device *dev, 1946 struct device_attribute *attr, 1947 char *buf) 1948 { 1949 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 1950 u32 time; 1951 1952 if (toshiba_kbd_illum_status_get(toshiba, &time) < 0) 1953 return -EIO; 1954 1955 return sprintf(buf, "%i\n", time >> HCI_MISC_SHIFT); 1956 } 1957 static DEVICE_ATTR_RW(kbd_backlight_timeout); 1958 1959 static ssize_t touchpad_store(struct device *dev, 1960 struct device_attribute *attr, 1961 const char *buf, size_t count) 1962 { 1963 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 1964 int state; 1965 int ret; 1966 1967 /* Set the TouchPad on/off, 0 - Disable | 1 - Enable */ 1968 ret = kstrtoint(buf, 0, &state); 1969 if (ret) 1970 return ret; 1971 if (state != 0 && state != 1) 1972 return -EINVAL; 1973 1974 ret = toshiba_touchpad_set(toshiba, state); 1975 if (ret) 1976 return ret; 1977 1978 return count; 1979 } 1980 1981 static ssize_t touchpad_show(struct device *dev, 1982 struct device_attribute *attr, char *buf) 1983 { 1984 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 1985 u32 state; 1986 int ret; 1987 1988 ret = toshiba_touchpad_get(toshiba, &state); 1989 if (ret < 0) 1990 return ret; 1991 1992 return sprintf(buf, "%i\n", state); 1993 } 1994 static DEVICE_ATTR_RW(touchpad); 1995 1996 static ssize_t usb_sleep_charge_show(struct device *dev, 1997 struct device_attribute *attr, char *buf) 1998 { 1999 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 2000 u32 mode; 2001 int ret; 2002 2003 ret = toshiba_usb_sleep_charge_get(toshiba, &mode); 2004 if (ret < 0) 2005 return ret; 2006 2007 return sprintf(buf, "%x\n", mode & SCI_USB_CHARGE_MODE_MASK); 2008 } 2009 2010 static ssize_t usb_sleep_charge_store(struct device *dev, 2011 struct device_attribute *attr, 2012 const char *buf, size_t count) 2013 { 2014 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 2015 int state; 2016 u32 mode; 2017 int ret; 2018 2019 ret = kstrtoint(buf, 0, &state); 2020 if (ret) 2021 return ret; 2022 /* 2023 * Check for supported values, where: 2024 * 0 - Disabled 2025 * 1 - Alternate (Non USB conformant devices that require more power) 2026 * 2 - Auto (USB conformant devices) 2027 * 3 - Typical 2028 */ 2029 if (state != 0 && state != 1 && state != 2 && state != 3) 2030 return -EINVAL; 2031 2032 /* Set the USB charging mode to internal value */ 2033 mode = toshiba->usbsc_mode_base; 2034 if (state == 0) 2035 mode |= SCI_USB_CHARGE_DISABLED; 2036 else if (state == 1) 2037 mode |= SCI_USB_CHARGE_ALTERNATE; 2038 else if (state == 2) 2039 mode |= SCI_USB_CHARGE_AUTO; 2040 else if (state == 3) 2041 mode |= SCI_USB_CHARGE_TYPICAL; 2042 2043 ret = toshiba_usb_sleep_charge_set(toshiba, mode); 2044 if (ret) 2045 return ret; 2046 2047 return count; 2048 } 2049 static DEVICE_ATTR_RW(usb_sleep_charge); 2050 2051 static ssize_t sleep_functions_on_battery_show(struct device *dev, 2052 struct device_attribute *attr, 2053 char *buf) 2054 { 2055 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 2056 int bat_lvl, status; 2057 u32 state; 2058 int ret; 2059 int tmp; 2060 2061 ret = toshiba_sleep_functions_status_get(toshiba, &state); 2062 if (ret < 0) 2063 return ret; 2064 2065 /* Determine the status: 0x4 - Enabled | 0x1 - Disabled */ 2066 tmp = state & SCI_USB_CHARGE_BAT_MASK; 2067 status = (tmp == 0x4) ? 1 : 0; 2068 /* Determine the battery level set */ 2069 bat_lvl = state >> HCI_MISC_SHIFT; 2070 2071 return sprintf(buf, "%d %d\n", status, bat_lvl); 2072 } 2073 2074 static ssize_t sleep_functions_on_battery_store(struct device *dev, 2075 struct device_attribute *attr, 2076 const char *buf, size_t count) 2077 { 2078 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 2079 u32 status; 2080 int value; 2081 int ret; 2082 int tmp; 2083 2084 ret = kstrtoint(buf, 0, &value); 2085 if (ret) 2086 return ret; 2087 2088 /* 2089 * Set the status of the function: 2090 * 0 - Disabled 2091 * 1-100 - Enabled 2092 */ 2093 if (value < 0 || value > 100) 2094 return -EINVAL; 2095 2096 if (value == 0) { 2097 tmp = toshiba->usbsc_bat_level << HCI_MISC_SHIFT; 2098 status = tmp | SCI_USB_CHARGE_BAT_LVL_OFF; 2099 } else { 2100 tmp = value << HCI_MISC_SHIFT; 2101 status = tmp | SCI_USB_CHARGE_BAT_LVL_ON; 2102 } 2103 ret = toshiba_sleep_functions_status_set(toshiba, status); 2104 if (ret < 0) 2105 return ret; 2106 2107 toshiba->usbsc_bat_level = status >> HCI_MISC_SHIFT; 2108 2109 return count; 2110 } 2111 static DEVICE_ATTR_RW(sleep_functions_on_battery); 2112 2113 static ssize_t usb_rapid_charge_show(struct device *dev, 2114 struct device_attribute *attr, char *buf) 2115 { 2116 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 2117 u32 state; 2118 int ret; 2119 2120 ret = toshiba_usb_rapid_charge_get(toshiba, &state); 2121 if (ret < 0) 2122 return ret; 2123 2124 return sprintf(buf, "%d\n", state); 2125 } 2126 2127 static ssize_t usb_rapid_charge_store(struct device *dev, 2128 struct device_attribute *attr, 2129 const char *buf, size_t count) 2130 { 2131 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 2132 int state; 2133 int ret; 2134 2135 ret = kstrtoint(buf, 0, &state); 2136 if (ret) 2137 return ret; 2138 if (state != 0 && state != 1) 2139 return -EINVAL; 2140 2141 ret = toshiba_usb_rapid_charge_set(toshiba, state); 2142 if (ret) 2143 return ret; 2144 2145 return count; 2146 } 2147 static DEVICE_ATTR_RW(usb_rapid_charge); 2148 2149 static ssize_t usb_sleep_music_show(struct device *dev, 2150 struct device_attribute *attr, char *buf) 2151 { 2152 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 2153 u32 state; 2154 int ret; 2155 2156 ret = toshiba_usb_sleep_music_get(toshiba, &state); 2157 if (ret < 0) 2158 return ret; 2159 2160 return sprintf(buf, "%d\n", state); 2161 } 2162 2163 static ssize_t usb_sleep_music_store(struct device *dev, 2164 struct device_attribute *attr, 2165 const char *buf, size_t count) 2166 { 2167 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 2168 int state; 2169 int ret; 2170 2171 ret = kstrtoint(buf, 0, &state); 2172 if (ret) 2173 return ret; 2174 if (state != 0 && state != 1) 2175 return -EINVAL; 2176 2177 ret = toshiba_usb_sleep_music_set(toshiba, state); 2178 if (ret) 2179 return ret; 2180 2181 return count; 2182 } 2183 static DEVICE_ATTR_RW(usb_sleep_music); 2184 2185 static ssize_t kbd_function_keys_show(struct device *dev, 2186 struct device_attribute *attr, char *buf) 2187 { 2188 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 2189 int mode; 2190 int ret; 2191 2192 ret = toshiba_function_keys_get(toshiba, &mode); 2193 if (ret < 0) 2194 return ret; 2195 2196 return sprintf(buf, "%d\n", mode); 2197 } 2198 2199 static ssize_t kbd_function_keys_store(struct device *dev, 2200 struct device_attribute *attr, 2201 const char *buf, size_t count) 2202 { 2203 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 2204 int mode; 2205 int ret; 2206 2207 ret = kstrtoint(buf, 0, &mode); 2208 if (ret) 2209 return ret; 2210 /* 2211 * Check for the function keys mode where: 2212 * 0 - Normal operation (F{1-12} as usual and hotkeys via FN-F{1-12}) 2213 * 1 - Special functions (Opposite of the above setting) 2214 */ 2215 if (mode != 0 && mode != 1) 2216 return -EINVAL; 2217 2218 ret = toshiba_function_keys_set(toshiba, mode); 2219 if (ret) 2220 return ret; 2221 2222 pr_info("Reboot for changes to KBD Function Keys to take effect"); 2223 2224 return count; 2225 } 2226 static DEVICE_ATTR_RW(kbd_function_keys); 2227 2228 static ssize_t panel_power_on_show(struct device *dev, 2229 struct device_attribute *attr, char *buf) 2230 { 2231 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 2232 u32 state; 2233 int ret; 2234 2235 ret = toshiba_panel_power_on_get(toshiba, &state); 2236 if (ret < 0) 2237 return ret; 2238 2239 return sprintf(buf, "%d\n", state); 2240 } 2241 2242 static ssize_t panel_power_on_store(struct device *dev, 2243 struct device_attribute *attr, 2244 const char *buf, size_t count) 2245 { 2246 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 2247 int state; 2248 int ret; 2249 2250 ret = kstrtoint(buf, 0, &state); 2251 if (ret) 2252 return ret; 2253 if (state != 0 && state != 1) 2254 return -EINVAL; 2255 2256 ret = toshiba_panel_power_on_set(toshiba, state); 2257 if (ret) 2258 return ret; 2259 2260 pr_info("Reboot for changes to Panel Power ON to take effect"); 2261 2262 return count; 2263 } 2264 static DEVICE_ATTR_RW(panel_power_on); 2265 2266 static ssize_t usb_three_show(struct device *dev, 2267 struct device_attribute *attr, char *buf) 2268 { 2269 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 2270 u32 state; 2271 int ret; 2272 2273 ret = toshiba_usb_three_get(toshiba, &state); 2274 if (ret < 0) 2275 return ret; 2276 2277 return sprintf(buf, "%d\n", state); 2278 } 2279 2280 static ssize_t usb_three_store(struct device *dev, 2281 struct device_attribute *attr, 2282 const char *buf, size_t count) 2283 { 2284 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 2285 int state; 2286 int ret; 2287 2288 ret = kstrtoint(buf, 0, &state); 2289 if (ret) 2290 return ret; 2291 /* 2292 * Check for USB 3 mode where: 2293 * 0 - Disabled (Acts like a USB 2 port, saving power) 2294 * 1 - Enabled 2295 */ 2296 if (state != 0 && state != 1) 2297 return -EINVAL; 2298 2299 ret = toshiba_usb_three_set(toshiba, state); 2300 if (ret) 2301 return ret; 2302 2303 pr_info("Reboot for changes to USB 3 to take effect"); 2304 2305 return count; 2306 } 2307 static DEVICE_ATTR_RW(usb_three); 2308 2309 static ssize_t cooling_method_show(struct device *dev, 2310 struct device_attribute *attr, char *buf) 2311 { 2312 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 2313 int state; 2314 int ret; 2315 2316 ret = toshiba_cooling_method_get(toshiba, &state); 2317 if (ret < 0) 2318 return ret; 2319 2320 return sprintf(buf, "%d %d\n", state, toshiba->max_cooling_method); 2321 } 2322 2323 static ssize_t cooling_method_store(struct device *dev, 2324 struct device_attribute *attr, 2325 const char *buf, size_t count) 2326 { 2327 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 2328 int state; 2329 int ret; 2330 2331 ret = kstrtoint(buf, 0, &state); 2332 if (ret) 2333 return ret; 2334 2335 /* 2336 * Check for supported values 2337 * Depending on the laptop model, some only support these two: 2338 * 0 - Maximum Performance 2339 * 1 - Battery Optimized 2340 * 2341 * While some others support all three methods: 2342 * 0 - Maximum Performance 2343 * 1 - Performance 2344 * 2 - Battery Optimized 2345 */ 2346 if (state < 0 || state > toshiba->max_cooling_method) 2347 return -EINVAL; 2348 2349 ret = toshiba_cooling_method_set(toshiba, state); 2350 if (ret) 2351 return ret; 2352 2353 return count; 2354 } 2355 static DEVICE_ATTR_RW(cooling_method); 2356 2357 static struct attribute *toshiba_attributes[] = { 2358 &dev_attr_version.attr, 2359 &dev_attr_fan.attr, 2360 &dev_attr_kbd_backlight_mode.attr, 2361 &dev_attr_kbd_type.attr, 2362 &dev_attr_available_kbd_modes.attr, 2363 &dev_attr_kbd_backlight_timeout.attr, 2364 &dev_attr_touchpad.attr, 2365 &dev_attr_usb_sleep_charge.attr, 2366 &dev_attr_sleep_functions_on_battery.attr, 2367 &dev_attr_usb_rapid_charge.attr, 2368 &dev_attr_usb_sleep_music.attr, 2369 &dev_attr_kbd_function_keys.attr, 2370 &dev_attr_panel_power_on.attr, 2371 &dev_attr_usb_three.attr, 2372 &dev_attr_cooling_method.attr, 2373 NULL, 2374 }; 2375 2376 static umode_t toshiba_sysfs_is_visible(struct kobject *kobj, 2377 struct attribute *attr, int idx) 2378 { 2379 struct device *dev = container_of(kobj, struct device, kobj); 2380 struct toshiba_acpi_dev *drv = dev_get_drvdata(dev); 2381 bool exists = true; 2382 2383 if (attr == &dev_attr_fan.attr) 2384 exists = (drv->fan_supported) ? true : false; 2385 else if (attr == &dev_attr_kbd_backlight_mode.attr) 2386 exists = (drv->kbd_illum_supported) ? true : false; 2387 else if (attr == &dev_attr_kbd_backlight_timeout.attr) 2388 exists = (drv->kbd_mode == SCI_KBD_MODE_AUTO) ? true : false; 2389 else if (attr == &dev_attr_touchpad.attr) 2390 exists = (drv->touchpad_supported) ? true : false; 2391 else if (attr == &dev_attr_usb_sleep_charge.attr) 2392 exists = (drv->usb_sleep_charge_supported) ? true : false; 2393 else if (attr == &dev_attr_sleep_functions_on_battery.attr) 2394 exists = (drv->usb_sleep_charge_supported) ? true : false; 2395 else if (attr == &dev_attr_usb_rapid_charge.attr) 2396 exists = (drv->usb_rapid_charge_supported) ? true : false; 2397 else if (attr == &dev_attr_usb_sleep_music.attr) 2398 exists = (drv->usb_sleep_music_supported) ? true : false; 2399 else if (attr == &dev_attr_kbd_function_keys.attr) 2400 exists = (drv->kbd_function_keys_supported) ? true : false; 2401 else if (attr == &dev_attr_panel_power_on.attr) 2402 exists = (drv->panel_power_on_supported) ? true : false; 2403 else if (attr == &dev_attr_usb_three.attr) 2404 exists = (drv->usb_three_supported) ? true : false; 2405 else if (attr == &dev_attr_cooling_method.attr) 2406 exists = (drv->cooling_method_supported) ? true : false; 2407 2408 return exists ? attr->mode : 0; 2409 } 2410 2411 static const struct attribute_group toshiba_attr_group = { 2412 .is_visible = toshiba_sysfs_is_visible, 2413 .attrs = toshiba_attributes, 2414 }; 2415 2416 static void toshiba_acpi_kbd_bl_work(struct work_struct *work) 2417 { 2418 /* Update the sysfs entries */ 2419 if (sysfs_update_group(&toshiba_acpi->acpi_dev->dev.kobj, 2420 &toshiba_attr_group)) 2421 pr_err("Unable to update sysfs entries\n"); 2422 2423 /* Notify LED subsystem about keyboard backlight change */ 2424 if (toshiba_acpi->kbd_type == 2 && 2425 toshiba_acpi->kbd_mode != SCI_KBD_MODE_AUTO) 2426 led_classdev_notify_brightness_hw_changed(&toshiba_acpi->kbd_led, 2427 (toshiba_acpi->kbd_mode == SCI_KBD_MODE_ON) ? 2428 LED_FULL : LED_OFF); 2429 2430 /* Emulate the keyboard backlight event */ 2431 acpi_bus_generate_netlink_event(toshiba_acpi->acpi_dev->pnp.device_class, 2432 dev_name(&toshiba_acpi->acpi_dev->dev), 2433 0x92, 0); 2434 } 2435 2436 /* 2437 * IIO device 2438 */ 2439 2440 enum toshiba_iio_accel_chan { 2441 AXIS_X, 2442 AXIS_Y, 2443 AXIS_Z 2444 }; 2445 2446 static int toshiba_iio_accel_get_axis(enum toshiba_iio_accel_chan chan) 2447 { 2448 u32 xyval, zval; 2449 int ret; 2450 2451 ret = toshiba_accelerometer_get(toshiba_acpi, &xyval, &zval); 2452 if (ret < 0) 2453 return ret; 2454 2455 switch (chan) { 2456 case AXIS_X: 2457 return xyval & HCI_ACCEL_DIRECTION_MASK ? 2458 -(xyval & HCI_ACCEL_MASK) : xyval & HCI_ACCEL_MASK; 2459 case AXIS_Y: 2460 return (xyval >> HCI_MISC_SHIFT) & HCI_ACCEL_DIRECTION_MASK ? 2461 -((xyval >> HCI_MISC_SHIFT) & HCI_ACCEL_MASK) : 2462 (xyval >> HCI_MISC_SHIFT) & HCI_ACCEL_MASK; 2463 case AXIS_Z: 2464 return zval & HCI_ACCEL_DIRECTION_MASK ? 2465 -(zval & HCI_ACCEL_MASK) : zval & HCI_ACCEL_MASK; 2466 } 2467 2468 return ret; 2469 } 2470 2471 static int toshiba_iio_accel_read_raw(struct iio_dev *indio_dev, 2472 struct iio_chan_spec const *chan, 2473 int *val, int *val2, long mask) 2474 { 2475 int ret; 2476 2477 switch (mask) { 2478 case IIO_CHAN_INFO_RAW: 2479 ret = toshiba_iio_accel_get_axis(chan->channel); 2480 if (ret == -EIO || ret == -ENODEV) 2481 return ret; 2482 2483 *val = ret; 2484 2485 return IIO_VAL_INT; 2486 } 2487 2488 return -EINVAL; 2489 } 2490 2491 #define TOSHIBA_IIO_ACCEL_CHANNEL(axis, chan) { \ 2492 .type = IIO_ACCEL, \ 2493 .modified = 1, \ 2494 .channel = chan, \ 2495 .channel2 = IIO_MOD_##axis, \ 2496 .output = 1, \ 2497 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \ 2498 } 2499 2500 static const struct iio_chan_spec toshiba_iio_accel_channels[] = { 2501 TOSHIBA_IIO_ACCEL_CHANNEL(X, AXIS_X), 2502 TOSHIBA_IIO_ACCEL_CHANNEL(Y, AXIS_Y), 2503 TOSHIBA_IIO_ACCEL_CHANNEL(Z, AXIS_Z), 2504 }; 2505 2506 static const struct iio_info toshiba_iio_accel_info = { 2507 .read_raw = &toshiba_iio_accel_read_raw, 2508 }; 2509 2510 /* 2511 * Misc device 2512 */ 2513 static int toshiba_acpi_smm_bridge(SMMRegisters *regs) 2514 { 2515 u32 in[TCI_WORDS] = { regs->eax, regs->ebx, regs->ecx, 2516 regs->edx, regs->esi, regs->edi }; 2517 u32 out[TCI_WORDS]; 2518 acpi_status status; 2519 2520 status = tci_raw(toshiba_acpi, in, out); 2521 if (ACPI_FAILURE(status)) { 2522 pr_err("ACPI call to query SMM registers failed\n"); 2523 return -EIO; 2524 } 2525 2526 /* Fillout the SMM struct with the TCI call results */ 2527 regs->eax = out[0]; 2528 regs->ebx = out[1]; 2529 regs->ecx = out[2]; 2530 regs->edx = out[3]; 2531 regs->esi = out[4]; 2532 regs->edi = out[5]; 2533 2534 return 0; 2535 } 2536 2537 static long toshiba_acpi_ioctl(struct file *fp, unsigned int cmd, 2538 unsigned long arg) 2539 { 2540 SMMRegisters __user *argp = (SMMRegisters __user *)arg; 2541 SMMRegisters regs; 2542 int ret; 2543 2544 if (!argp) 2545 return -EINVAL; 2546 2547 switch (cmd) { 2548 case TOSH_SMM: 2549 if (copy_from_user(®s, argp, sizeof(SMMRegisters))) 2550 return -EFAULT; 2551 ret = toshiba_acpi_smm_bridge(®s); 2552 if (ret) 2553 return ret; 2554 if (copy_to_user(argp, ®s, sizeof(SMMRegisters))) 2555 return -EFAULT; 2556 break; 2557 case TOSHIBA_ACPI_SCI: 2558 if (copy_from_user(®s, argp, sizeof(SMMRegisters))) 2559 return -EFAULT; 2560 /* Ensure we are being called with a SCI_{GET, SET} register */ 2561 if (regs.eax != SCI_GET && regs.eax != SCI_SET) 2562 return -EINVAL; 2563 if (!sci_open(toshiba_acpi)) 2564 return -EIO; 2565 ret = toshiba_acpi_smm_bridge(®s); 2566 sci_close(toshiba_acpi); 2567 if (ret) 2568 return ret; 2569 if (copy_to_user(argp, ®s, sizeof(SMMRegisters))) 2570 return -EFAULT; 2571 break; 2572 default: 2573 return -EINVAL; 2574 } 2575 2576 return 0; 2577 } 2578 2579 static const struct file_operations toshiba_acpi_fops = { 2580 .owner = THIS_MODULE, 2581 .unlocked_ioctl = toshiba_acpi_ioctl, 2582 .llseek = noop_llseek, 2583 }; 2584 2585 /* 2586 * WWAN RFKill handlers 2587 */ 2588 static int toshiba_acpi_wwan_set_block(void *data, bool blocked) 2589 { 2590 struct toshiba_acpi_dev *dev = data; 2591 int ret; 2592 2593 ret = toshiba_wireless_status(dev); 2594 if (ret) 2595 return ret; 2596 2597 if (!dev->killswitch) 2598 return 0; 2599 2600 return toshiba_wwan_set(dev, !blocked); 2601 } 2602 2603 static void toshiba_acpi_wwan_poll(struct rfkill *rfkill, void *data) 2604 { 2605 struct toshiba_acpi_dev *dev = data; 2606 2607 if (toshiba_wireless_status(dev)) 2608 return; 2609 2610 rfkill_set_hw_state(dev->wwan_rfk, !dev->killswitch); 2611 } 2612 2613 static const struct rfkill_ops wwan_rfk_ops = { 2614 .set_block = toshiba_acpi_wwan_set_block, 2615 .poll = toshiba_acpi_wwan_poll, 2616 }; 2617 2618 static int toshiba_acpi_setup_wwan_rfkill(struct toshiba_acpi_dev *dev) 2619 { 2620 int ret = toshiba_wireless_status(dev); 2621 2622 if (ret) 2623 return ret; 2624 2625 dev->wwan_rfk = rfkill_alloc("Toshiba WWAN", 2626 &dev->acpi_dev->dev, 2627 RFKILL_TYPE_WWAN, 2628 &wwan_rfk_ops, 2629 dev); 2630 if (!dev->wwan_rfk) { 2631 pr_err("Unable to allocate WWAN rfkill device\n"); 2632 return -ENOMEM; 2633 } 2634 2635 rfkill_set_hw_state(dev->wwan_rfk, !dev->killswitch); 2636 2637 ret = rfkill_register(dev->wwan_rfk); 2638 if (ret) { 2639 pr_err("Unable to register WWAN rfkill device\n"); 2640 rfkill_destroy(dev->wwan_rfk); 2641 } 2642 2643 return ret; 2644 } 2645 2646 /* 2647 * Hotkeys 2648 */ 2649 static int toshiba_acpi_enable_hotkeys(struct toshiba_acpi_dev *dev) 2650 { 2651 acpi_status status; 2652 u32 result; 2653 2654 status = acpi_evaluate_object(dev->acpi_dev->handle, 2655 "ENAB", NULL, NULL); 2656 if (ACPI_FAILURE(status)) 2657 return -ENODEV; 2658 2659 /* 2660 * Enable the "Special Functions" mode only if they are 2661 * supported and if they are activated. 2662 */ 2663 if (dev->kbd_function_keys_supported && dev->special_functions) 2664 result = hci_write(dev, HCI_HOTKEY_EVENT, 2665 HCI_HOTKEY_SPECIAL_FUNCTIONS); 2666 else 2667 result = hci_write(dev, HCI_HOTKEY_EVENT, HCI_HOTKEY_ENABLE); 2668 2669 if (result == TOS_FAILURE) 2670 return -EIO; 2671 else if (result == TOS_NOT_SUPPORTED) 2672 return -ENODEV; 2673 2674 return 0; 2675 } 2676 2677 static bool toshiba_acpi_i8042_filter(unsigned char data, unsigned char str, 2678 struct serio *port) 2679 { 2680 if (str & I8042_STR_AUXDATA) 2681 return false; 2682 2683 if (unlikely(data == 0xe0)) 2684 return false; 2685 2686 if ((data & 0x7f) == TOS1900_FN_SCAN) { 2687 schedule_work(&toshiba_acpi->hotkey_work); 2688 return true; 2689 } 2690 2691 return false; 2692 } 2693 2694 static void toshiba_acpi_hotkey_work(struct work_struct *work) 2695 { 2696 acpi_handle ec_handle = ec_get_handle(); 2697 acpi_status status; 2698 2699 if (!ec_handle) 2700 return; 2701 2702 status = acpi_evaluate_object(ec_handle, "NTFY", NULL, NULL); 2703 if (ACPI_FAILURE(status)) 2704 pr_err("ACPI NTFY method execution failed\n"); 2705 } 2706 2707 /* 2708 * Returns hotkey scancode, or < 0 on failure. 2709 */ 2710 static int toshiba_acpi_query_hotkey(struct toshiba_acpi_dev *dev) 2711 { 2712 unsigned long long value; 2713 acpi_status status; 2714 2715 status = acpi_evaluate_integer(dev->acpi_dev->handle, "INFO", 2716 NULL, &value); 2717 if (ACPI_FAILURE(status)) { 2718 pr_err("ACPI INFO method execution failed\n"); 2719 return -EIO; 2720 } 2721 2722 return value; 2723 } 2724 2725 static void toshiba_acpi_report_hotkey(struct toshiba_acpi_dev *dev, 2726 int scancode) 2727 { 2728 if (scancode == 0x100) 2729 return; 2730 2731 /* Act on key press; ignore key release */ 2732 if (scancode & 0x80) 2733 return; 2734 2735 if (!sparse_keymap_report_event(dev->hotkey_dev, scancode, 1, true)) 2736 pr_info("Unknown key %x\n", scancode); 2737 } 2738 2739 static void toshiba_acpi_process_hotkeys(struct toshiba_acpi_dev *dev) 2740 { 2741 if (dev->info_supported) { 2742 int scancode = toshiba_acpi_query_hotkey(dev); 2743 2744 if (scancode < 0) { 2745 pr_err("Failed to query hotkey event\n"); 2746 } else if (scancode != 0) { 2747 toshiba_acpi_report_hotkey(dev, scancode); 2748 dev->key_event_valid = 1; 2749 dev->last_key_event = scancode; 2750 } 2751 } else if (dev->system_event_supported) { 2752 u32 result; 2753 u32 value; 2754 int retries = 3; 2755 2756 do { 2757 result = hci_read(dev, HCI_SYSTEM_EVENT, &value); 2758 switch (result) { 2759 case TOS_SUCCESS: 2760 toshiba_acpi_report_hotkey(dev, (int)value); 2761 dev->key_event_valid = 1; 2762 dev->last_key_event = value; 2763 break; 2764 case TOS_NOT_SUPPORTED: 2765 /* 2766 * This is a workaround for an unresolved 2767 * issue on some machines where system events 2768 * sporadically become disabled. 2769 */ 2770 result = hci_write(dev, HCI_SYSTEM_EVENT, 1); 2771 if (result == TOS_SUCCESS) 2772 pr_notice("Re-enabled hotkeys\n"); 2773 /* Fall through */ 2774 default: 2775 retries--; 2776 break; 2777 } 2778 } while (retries && result != TOS_FIFO_EMPTY); 2779 } 2780 } 2781 2782 static int toshiba_acpi_setup_keyboard(struct toshiba_acpi_dev *dev) 2783 { 2784 const struct key_entry *keymap = toshiba_acpi_keymap; 2785 acpi_handle ec_handle; 2786 int error; 2787 2788 if (disable_hotkeys) { 2789 pr_info("Hotkeys disabled by module parameter\n"); 2790 return 0; 2791 } 2792 2793 if (wmi_has_guid(TOSHIBA_WMI_EVENT_GUID)) { 2794 pr_info("WMI event detected, hotkeys will not be monitored\n"); 2795 return 0; 2796 } 2797 2798 error = toshiba_acpi_enable_hotkeys(dev); 2799 if (error) 2800 return error; 2801 2802 if (toshiba_hotkey_event_type_get(dev, &dev->hotkey_event_type)) 2803 pr_notice("Unable to query Hotkey Event Type\n"); 2804 2805 dev->hotkey_dev = input_allocate_device(); 2806 if (!dev->hotkey_dev) 2807 return -ENOMEM; 2808 2809 dev->hotkey_dev->name = "Toshiba input device"; 2810 dev->hotkey_dev->phys = "toshiba_acpi/input0"; 2811 dev->hotkey_dev->id.bustype = BUS_HOST; 2812 2813 if (dev->hotkey_event_type == HCI_SYSTEM_TYPE1 || 2814 !dev->kbd_function_keys_supported) 2815 keymap = toshiba_acpi_keymap; 2816 else if (dev->hotkey_event_type == HCI_SYSTEM_TYPE2 || 2817 dev->kbd_function_keys_supported) 2818 keymap = toshiba_acpi_alt_keymap; 2819 else 2820 pr_info("Unknown event type received %x\n", 2821 dev->hotkey_event_type); 2822 error = sparse_keymap_setup(dev->hotkey_dev, keymap, NULL); 2823 if (error) 2824 goto err_free_dev; 2825 2826 /* 2827 * For some machines the SCI responsible for providing hotkey 2828 * notification doesn't fire. We can trigger the notification 2829 * whenever the Fn key is pressed using the NTFY method, if 2830 * supported, so if it's present set up an i8042 key filter 2831 * for this purpose. 2832 */ 2833 ec_handle = ec_get_handle(); 2834 if (ec_handle && acpi_has_method(ec_handle, "NTFY")) { 2835 INIT_WORK(&dev->hotkey_work, toshiba_acpi_hotkey_work); 2836 2837 error = i8042_install_filter(toshiba_acpi_i8042_filter); 2838 if (error) { 2839 pr_err("Error installing key filter\n"); 2840 goto err_free_dev; 2841 } 2842 2843 dev->ntfy_supported = 1; 2844 } 2845 2846 /* 2847 * Determine hotkey query interface. Prefer using the INFO 2848 * method when it is available. 2849 */ 2850 if (acpi_has_method(dev->acpi_dev->handle, "INFO")) 2851 dev->info_supported = 1; 2852 else if (hci_write(dev, HCI_SYSTEM_EVENT, 1) == TOS_SUCCESS) 2853 dev->system_event_supported = 1; 2854 2855 if (!dev->info_supported && !dev->system_event_supported) { 2856 pr_warn("No hotkey query interface found\n"); 2857 goto err_remove_filter; 2858 } 2859 2860 error = input_register_device(dev->hotkey_dev); 2861 if (error) { 2862 pr_info("Unable to register input device\n"); 2863 goto err_remove_filter; 2864 } 2865 2866 return 0; 2867 2868 err_remove_filter: 2869 if (dev->ntfy_supported) 2870 i8042_remove_filter(toshiba_acpi_i8042_filter); 2871 err_free_dev: 2872 input_free_device(dev->hotkey_dev); 2873 dev->hotkey_dev = NULL; 2874 return error; 2875 } 2876 2877 static int toshiba_acpi_setup_backlight(struct toshiba_acpi_dev *dev) 2878 { 2879 struct backlight_properties props; 2880 int brightness; 2881 int ret; 2882 2883 /* 2884 * Some machines don't support the backlight methods at all, and 2885 * others support it read-only. Either of these is pretty useless, 2886 * so only register the backlight device if the backlight method 2887 * supports both reads and writes. 2888 */ 2889 brightness = __get_lcd_brightness(dev); 2890 if (brightness < 0) 2891 return 0; 2892 /* 2893 * If transflective backlight is supported and the brightness is zero 2894 * (lowest brightness level), the set_lcd_brightness function will 2895 * activate the transflective backlight, making the LCD appear to be 2896 * turned off, simply increment the brightness level to avoid that. 2897 */ 2898 if (dev->tr_backlight_supported && brightness == 0) 2899 brightness++; 2900 ret = set_lcd_brightness(dev, brightness); 2901 if (ret) { 2902 pr_debug("Backlight method is read-only, disabling backlight support\n"); 2903 return 0; 2904 } 2905 2906 /* 2907 * Tell acpi-video-detect code to prefer vendor backlight on all 2908 * systems with transflective backlight and on dmi matched systems. 2909 */ 2910 if (dev->tr_backlight_supported || 2911 dmi_check_system(toshiba_vendor_backlight_dmi)) 2912 acpi_video_set_dmi_backlight_type(acpi_backlight_vendor); 2913 2914 if (acpi_video_get_backlight_type() != acpi_backlight_vendor) 2915 return 0; 2916 2917 memset(&props, 0, sizeof(props)); 2918 props.type = BACKLIGHT_PLATFORM; 2919 props.max_brightness = HCI_LCD_BRIGHTNESS_LEVELS - 1; 2920 2921 /* Adding an extra level and having 0 change to transflective mode */ 2922 if (dev->tr_backlight_supported) 2923 props.max_brightness++; 2924 2925 dev->backlight_dev = backlight_device_register("toshiba", 2926 &dev->acpi_dev->dev, 2927 dev, 2928 &toshiba_backlight_data, 2929 &props); 2930 if (IS_ERR(dev->backlight_dev)) { 2931 ret = PTR_ERR(dev->backlight_dev); 2932 pr_err("Could not register toshiba backlight device\n"); 2933 dev->backlight_dev = NULL; 2934 return ret; 2935 } 2936 2937 dev->backlight_dev->props.brightness = brightness; 2938 return 0; 2939 } 2940 2941 static void print_supported_features(struct toshiba_acpi_dev *dev) 2942 { 2943 pr_info("Supported laptop features:"); 2944 2945 if (dev->hotkey_dev) 2946 pr_cont(" hotkeys"); 2947 if (dev->backlight_dev) 2948 pr_cont(" backlight"); 2949 if (dev->video_supported) 2950 pr_cont(" video-out"); 2951 if (dev->fan_supported) 2952 pr_cont(" fan"); 2953 if (dev->tr_backlight_supported) 2954 pr_cont(" transflective-backlight"); 2955 if (dev->illumination_supported) 2956 pr_cont(" illumination"); 2957 if (dev->kbd_illum_supported) 2958 pr_cont(" keyboard-backlight"); 2959 if (dev->touchpad_supported) 2960 pr_cont(" touchpad"); 2961 if (dev->eco_supported) 2962 pr_cont(" eco-led"); 2963 if (dev->accelerometer_supported) 2964 pr_cont(" accelerometer-axes"); 2965 if (dev->usb_sleep_charge_supported) 2966 pr_cont(" usb-sleep-charge"); 2967 if (dev->usb_rapid_charge_supported) 2968 pr_cont(" usb-rapid-charge"); 2969 if (dev->usb_sleep_music_supported) 2970 pr_cont(" usb-sleep-music"); 2971 if (dev->kbd_function_keys_supported) 2972 pr_cont(" special-function-keys"); 2973 if (dev->panel_power_on_supported) 2974 pr_cont(" panel-power-on"); 2975 if (dev->usb_three_supported) 2976 pr_cont(" usb3"); 2977 if (dev->wwan_supported) 2978 pr_cont(" wwan"); 2979 if (dev->cooling_method_supported) 2980 pr_cont(" cooling-method"); 2981 2982 pr_cont("\n"); 2983 } 2984 2985 static int toshiba_acpi_remove(struct acpi_device *acpi_dev) 2986 { 2987 struct toshiba_acpi_dev *dev = acpi_driver_data(acpi_dev); 2988 2989 misc_deregister(&dev->miscdev); 2990 2991 remove_toshiba_proc_entries(dev); 2992 2993 if (dev->accelerometer_supported && dev->indio_dev) { 2994 iio_device_unregister(dev->indio_dev); 2995 iio_device_free(dev->indio_dev); 2996 } 2997 2998 if (dev->sysfs_created) 2999 sysfs_remove_group(&dev->acpi_dev->dev.kobj, 3000 &toshiba_attr_group); 3001 3002 if (dev->ntfy_supported) { 3003 i8042_remove_filter(toshiba_acpi_i8042_filter); 3004 cancel_work_sync(&dev->hotkey_work); 3005 } 3006 3007 if (dev->hotkey_dev) 3008 input_unregister_device(dev->hotkey_dev); 3009 3010 backlight_device_unregister(dev->backlight_dev); 3011 3012 if (dev->illumination_led_registered) 3013 led_classdev_unregister(&dev->led_dev); 3014 3015 if (dev->kbd_led_registered) 3016 led_classdev_unregister(&dev->kbd_led); 3017 3018 if (dev->eco_led_registered) 3019 led_classdev_unregister(&dev->eco_led); 3020 3021 if (dev->wwan_rfk) { 3022 rfkill_unregister(dev->wwan_rfk); 3023 rfkill_destroy(dev->wwan_rfk); 3024 } 3025 3026 if (toshiba_acpi) 3027 toshiba_acpi = NULL; 3028 3029 kfree(dev); 3030 3031 return 0; 3032 } 3033 3034 static const char *find_hci_method(acpi_handle handle) 3035 { 3036 if (acpi_has_method(handle, "GHCI")) 3037 return "GHCI"; 3038 3039 if (acpi_has_method(handle, "SPFC")) 3040 return "SPFC"; 3041 3042 return NULL; 3043 } 3044 3045 static int toshiba_acpi_add(struct acpi_device *acpi_dev) 3046 { 3047 struct toshiba_acpi_dev *dev; 3048 const char *hci_method; 3049 u32 dummy; 3050 int ret = 0; 3051 3052 if (toshiba_acpi) 3053 return -EBUSY; 3054 3055 pr_info("Toshiba Laptop ACPI Extras version %s\n", 3056 TOSHIBA_ACPI_VERSION); 3057 3058 hci_method = find_hci_method(acpi_dev->handle); 3059 if (!hci_method) { 3060 pr_err("HCI interface not found\n"); 3061 return -ENODEV; 3062 } 3063 3064 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 3065 if (!dev) 3066 return -ENOMEM; 3067 dev->acpi_dev = acpi_dev; 3068 dev->method_hci = hci_method; 3069 dev->miscdev.minor = MISC_DYNAMIC_MINOR; 3070 dev->miscdev.name = "toshiba_acpi"; 3071 dev->miscdev.fops = &toshiba_acpi_fops; 3072 3073 ret = misc_register(&dev->miscdev); 3074 if (ret) { 3075 pr_err("Failed to register miscdevice\n"); 3076 kfree(dev); 3077 return ret; 3078 } 3079 3080 acpi_dev->driver_data = dev; 3081 dev_set_drvdata(&acpi_dev->dev, dev); 3082 3083 /* Query the BIOS for supported features */ 3084 3085 /* 3086 * The "Special Functions" are always supported by the laptops 3087 * with the new keyboard layout, query for its presence to help 3088 * determine the keymap layout to use. 3089 */ 3090 ret = toshiba_function_keys_get(dev, &dev->special_functions); 3091 dev->kbd_function_keys_supported = !ret; 3092 3093 dev->hotkey_event_type = 0; 3094 if (toshiba_acpi_setup_keyboard(dev)) 3095 pr_info("Unable to activate hotkeys\n"); 3096 3097 /* Determine whether or not BIOS supports transflective backlight */ 3098 ret = get_tr_backlight_status(dev, &dummy); 3099 dev->tr_backlight_supported = !ret; 3100 3101 ret = toshiba_acpi_setup_backlight(dev); 3102 if (ret) 3103 goto error; 3104 3105 toshiba_illumination_available(dev); 3106 if (dev->illumination_supported) { 3107 dev->led_dev.name = "toshiba::illumination"; 3108 dev->led_dev.max_brightness = 1; 3109 dev->led_dev.brightness_set = toshiba_illumination_set; 3110 dev->led_dev.brightness_get = toshiba_illumination_get; 3111 if (!led_classdev_register(&acpi_dev->dev, &dev->led_dev)) 3112 dev->illumination_led_registered = true; 3113 } 3114 3115 toshiba_eco_mode_available(dev); 3116 if (dev->eco_supported) { 3117 dev->eco_led.name = "toshiba::eco_mode"; 3118 dev->eco_led.max_brightness = 1; 3119 dev->eco_led.brightness_set = toshiba_eco_mode_set_status; 3120 dev->eco_led.brightness_get = toshiba_eco_mode_get_status; 3121 if (!led_classdev_register(&dev->acpi_dev->dev, &dev->eco_led)) 3122 dev->eco_led_registered = true; 3123 } 3124 3125 toshiba_kbd_illum_available(dev); 3126 /* 3127 * Only register the LED if KBD illumination is supported 3128 * and the keyboard backlight operation mode is set to FN-Z 3129 * or we detect a second gen keyboard backlight 3130 */ 3131 if (dev->kbd_illum_supported && 3132 (dev->kbd_mode == SCI_KBD_MODE_FNZ || dev->kbd_type == 2)) { 3133 dev->kbd_led.name = "toshiba::kbd_backlight"; 3134 dev->kbd_led.flags = LED_BRIGHT_HW_CHANGED; 3135 dev->kbd_led.max_brightness = 1; 3136 dev->kbd_led.brightness_set = toshiba_kbd_backlight_set; 3137 dev->kbd_led.brightness_get = toshiba_kbd_backlight_get; 3138 if (!led_classdev_register(&dev->acpi_dev->dev, &dev->kbd_led)) 3139 dev->kbd_led_registered = true; 3140 } 3141 3142 ret = toshiba_touchpad_get(dev, &dummy); 3143 dev->touchpad_supported = !ret; 3144 3145 toshiba_accelerometer_available(dev); 3146 if (dev->accelerometer_supported) { 3147 dev->indio_dev = iio_device_alloc(sizeof(*dev)); 3148 if (!dev->indio_dev) { 3149 pr_err("Unable to allocate iio device\n"); 3150 goto iio_error; 3151 } 3152 3153 pr_info("Registering Toshiba accelerometer iio device\n"); 3154 3155 dev->indio_dev->info = &toshiba_iio_accel_info; 3156 dev->indio_dev->name = "Toshiba accelerometer"; 3157 dev->indio_dev->dev.parent = &acpi_dev->dev; 3158 dev->indio_dev->modes = INDIO_DIRECT_MODE; 3159 dev->indio_dev->channels = toshiba_iio_accel_channels; 3160 dev->indio_dev->num_channels = 3161 ARRAY_SIZE(toshiba_iio_accel_channels); 3162 3163 ret = iio_device_register(dev->indio_dev); 3164 if (ret < 0) { 3165 pr_err("Unable to register iio device\n"); 3166 iio_device_free(dev->indio_dev); 3167 } 3168 } 3169 iio_error: 3170 3171 toshiba_usb_sleep_charge_available(dev); 3172 3173 ret = toshiba_usb_rapid_charge_get(dev, &dummy); 3174 dev->usb_rapid_charge_supported = !ret; 3175 3176 ret = toshiba_usb_sleep_music_get(dev, &dummy); 3177 dev->usb_sleep_music_supported = !ret; 3178 3179 ret = toshiba_panel_power_on_get(dev, &dummy); 3180 dev->panel_power_on_supported = !ret; 3181 3182 ret = toshiba_usb_three_get(dev, &dummy); 3183 dev->usb_three_supported = !ret; 3184 3185 ret = get_video_status(dev, &dummy); 3186 dev->video_supported = !ret; 3187 3188 ret = get_fan_status(dev, &dummy); 3189 dev->fan_supported = !ret; 3190 3191 toshiba_wwan_available(dev); 3192 if (dev->wwan_supported) 3193 toshiba_acpi_setup_wwan_rfkill(dev); 3194 3195 toshiba_cooling_method_available(dev); 3196 3197 print_supported_features(dev); 3198 3199 ret = sysfs_create_group(&dev->acpi_dev->dev.kobj, 3200 &toshiba_attr_group); 3201 if (ret) { 3202 dev->sysfs_created = 0; 3203 goto error; 3204 } 3205 dev->sysfs_created = !ret; 3206 3207 create_toshiba_proc_entries(dev); 3208 3209 toshiba_acpi = dev; 3210 3211 return 0; 3212 3213 error: 3214 toshiba_acpi_remove(acpi_dev); 3215 return ret; 3216 } 3217 3218 static void toshiba_acpi_notify(struct acpi_device *acpi_dev, u32 event) 3219 { 3220 struct toshiba_acpi_dev *dev = acpi_driver_data(acpi_dev); 3221 3222 switch (event) { 3223 case 0x80: /* Hotkeys and some system events */ 3224 /* 3225 * Machines with this WMI GUID aren't supported due to bugs in 3226 * their AML. 3227 * 3228 * Return silently to avoid triggering a netlink event. 3229 */ 3230 if (wmi_has_guid(TOSHIBA_WMI_EVENT_GUID)) 3231 return; 3232 toshiba_acpi_process_hotkeys(dev); 3233 break; 3234 case 0x81: /* Dock events */ 3235 case 0x82: 3236 case 0x83: 3237 pr_info("Dock event received %x\n", event); 3238 break; 3239 case 0x88: /* Thermal events */ 3240 pr_info("Thermal event received\n"); 3241 break; 3242 case 0x8f: /* LID closed */ 3243 case 0x90: /* LID is closed and Dock has been ejected */ 3244 break; 3245 case 0x8c: /* SATA power events */ 3246 case 0x8b: 3247 pr_info("SATA power event received %x\n", event); 3248 break; 3249 case 0x92: /* Keyboard backlight mode changed */ 3250 dev->kbd_event_generated = true; 3251 /* Update sysfs entries */ 3252 if (sysfs_update_group(&acpi_dev->dev.kobj, 3253 &toshiba_attr_group)) 3254 pr_err("Unable to update sysfs entries\n"); 3255 /* Notify LED subsystem about keyboard backlight change */ 3256 if (dev->kbd_type == 2 && dev->kbd_mode != SCI_KBD_MODE_AUTO) 3257 led_classdev_notify_brightness_hw_changed(&dev->kbd_led, 3258 (dev->kbd_mode == SCI_KBD_MODE_ON) ? 3259 LED_FULL : LED_OFF); 3260 break; 3261 case 0x85: /* Unknown */ 3262 case 0x8d: /* Unknown */ 3263 case 0x8e: /* Unknown */ 3264 case 0x94: /* Unknown */ 3265 case 0x95: /* Unknown */ 3266 default: 3267 pr_info("Unknown event received %x\n", event); 3268 break; 3269 } 3270 3271 acpi_bus_generate_netlink_event(acpi_dev->pnp.device_class, 3272 dev_name(&acpi_dev->dev), 3273 event, (event == 0x80) ? 3274 dev->last_key_event : 0); 3275 } 3276 3277 #ifdef CONFIG_PM_SLEEP 3278 static int toshiba_acpi_suspend(struct device *device) 3279 { 3280 struct toshiba_acpi_dev *dev = acpi_driver_data(to_acpi_device(device)); 3281 3282 if (dev->hotkey_dev) { 3283 u32 result; 3284 3285 result = hci_write(dev, HCI_HOTKEY_EVENT, HCI_HOTKEY_DISABLE); 3286 if (result != TOS_SUCCESS) 3287 pr_info("Unable to disable hotkeys\n"); 3288 } 3289 3290 return 0; 3291 } 3292 3293 static int toshiba_acpi_resume(struct device *device) 3294 { 3295 struct toshiba_acpi_dev *dev = acpi_driver_data(to_acpi_device(device)); 3296 3297 if (dev->hotkey_dev) { 3298 if (toshiba_acpi_enable_hotkeys(dev)) 3299 pr_info("Unable to re-enable hotkeys\n"); 3300 } 3301 3302 if (dev->wwan_rfk) { 3303 if (!toshiba_wireless_status(dev)) 3304 rfkill_set_hw_state(dev->wwan_rfk, !dev->killswitch); 3305 } 3306 3307 return 0; 3308 } 3309 #endif 3310 3311 static SIMPLE_DEV_PM_OPS(toshiba_acpi_pm, 3312 toshiba_acpi_suspend, toshiba_acpi_resume); 3313 3314 static struct acpi_driver toshiba_acpi_driver = { 3315 .name = "Toshiba ACPI driver", 3316 .owner = THIS_MODULE, 3317 .ids = toshiba_device_ids, 3318 .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS, 3319 .ops = { 3320 .add = toshiba_acpi_add, 3321 .remove = toshiba_acpi_remove, 3322 .notify = toshiba_acpi_notify, 3323 }, 3324 .drv.pm = &toshiba_acpi_pm, 3325 }; 3326 3327 static int __init toshiba_acpi_init(void) 3328 { 3329 int ret; 3330 3331 toshiba_proc_dir = proc_mkdir(PROC_TOSHIBA, acpi_root_dir); 3332 if (!toshiba_proc_dir) { 3333 pr_err("Unable to create proc dir " PROC_TOSHIBA "\n"); 3334 return -ENODEV; 3335 } 3336 3337 ret = acpi_bus_register_driver(&toshiba_acpi_driver); 3338 if (ret) { 3339 pr_err("Failed to register ACPI driver: %d\n", ret); 3340 remove_proc_entry(PROC_TOSHIBA, acpi_root_dir); 3341 } 3342 3343 return ret; 3344 } 3345 3346 static void __exit toshiba_acpi_exit(void) 3347 { 3348 acpi_bus_unregister_driver(&toshiba_acpi_driver); 3349 if (toshiba_proc_dir) 3350 remove_proc_entry(PROC_TOSHIBA, acpi_root_dir); 3351 } 3352 3353 module_init(toshiba_acpi_init); 3354 module_exit(toshiba_acpi_exit); 3355