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