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