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