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