1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * ideapad-laptop.c - Lenovo IdeaPad ACPI Extras 4 * 5 * Copyright © 2010 Intel Corporation 6 * Copyright © 2010 David Woodhouse <dwmw2@infradead.org> 7 */ 8 9 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 10 11 #include <linux/acpi.h> 12 #include <linux/backlight.h> 13 #include <linux/bitfield.h> 14 #include <linux/bitops.h> 15 #include <linux/bug.h> 16 #include <linux/cleanup.h> 17 #include <linux/debugfs.h> 18 #include <linux/device.h> 19 #include <linux/dmi.h> 20 #include <linux/i8042.h> 21 #include <linux/init.h> 22 #include <linux/input.h> 23 #include <linux/input/sparse-keymap.h> 24 #include <linux/jiffies.h> 25 #include <linux/kernel.h> 26 #include <linux/leds.h> 27 #include <linux/module.h> 28 #include <linux/platform_device.h> 29 #include <linux/platform_profile.h> 30 #include <linux/rfkill.h> 31 #include <linux/seq_file.h> 32 #include <linux/sysfs.h> 33 #include <linux/types.h> 34 #include <linux/wmi.h> 35 #include "ideapad-laptop.h" 36 37 #include <acpi/video.h> 38 39 #include <dt-bindings/leds/common.h> 40 41 #define IDEAPAD_RFKILL_DEV_NUM 3 42 43 enum { 44 CFG_CAP_BT_BIT = 16, 45 CFG_CAP_3G_BIT = 17, 46 CFG_CAP_WIFI_BIT = 18, 47 CFG_CAP_CAM_BIT = 19, 48 49 /* 50 * These are OnScreenDisplay support bits that can be useful to determine 51 * whether a hotkey exists/should show OSD. But they aren't particularly 52 * meaningful since they were introduced later, i.e. 2010 IdeaPads 53 * don't have these, but they still have had OSD for hotkeys. 54 */ 55 CFG_OSD_NUMLK_BIT = 27, 56 CFG_OSD_CAPSLK_BIT = 28, 57 CFG_OSD_MICMUTE_BIT = 29, 58 CFG_OSD_TOUCHPAD_BIT = 30, 59 CFG_OSD_CAM_BIT = 31, 60 }; 61 62 enum { 63 GBMD_CONSERVATION_STATE_BIT = 5, 64 }; 65 66 enum { 67 SBMC_CONSERVATION_ON = 3, 68 SBMC_CONSERVATION_OFF = 5, 69 }; 70 71 enum { 72 HALS_KBD_BL_SUPPORT_BIT = 4, 73 HALS_KBD_BL_STATE_BIT = 5, 74 HALS_USB_CHARGING_SUPPORT_BIT = 6, 75 HALS_USB_CHARGING_STATE_BIT = 7, 76 HALS_FNLOCK_SUPPORT_BIT = 9, 77 HALS_FNLOCK_STATE_BIT = 10, 78 HALS_HOTKEYS_PRIMARY_BIT = 11, 79 }; 80 81 enum { 82 SALS_KBD_BL_ON = 0x8, 83 SALS_KBD_BL_OFF = 0x9, 84 SALS_USB_CHARGING_ON = 0xa, 85 SALS_USB_CHARGING_OFF = 0xb, 86 SALS_FNLOCK_ON = 0xe, 87 SALS_FNLOCK_OFF = 0xf, 88 }; 89 90 enum { 91 VPCCMD_R_VPC1 = 0x10, 92 VPCCMD_R_BL_MAX, 93 VPCCMD_R_BL, 94 VPCCMD_W_BL, 95 VPCCMD_R_WIFI, 96 VPCCMD_W_WIFI, 97 VPCCMD_R_BT, 98 VPCCMD_W_BT, 99 VPCCMD_R_BL_POWER, 100 VPCCMD_R_NOVO, 101 VPCCMD_R_VPC2, 102 VPCCMD_R_TOUCHPAD, 103 VPCCMD_W_TOUCHPAD, 104 VPCCMD_R_CAMERA, 105 VPCCMD_W_CAMERA, 106 VPCCMD_R_3G, 107 VPCCMD_W_3G, 108 VPCCMD_R_ODD, /* 0x21 */ 109 VPCCMD_W_FAN, 110 VPCCMD_R_RF, 111 VPCCMD_W_RF, 112 VPCCMD_W_YMC = 0x2A, 113 VPCCMD_R_FAN = 0x2B, 114 VPCCMD_R_SPECIAL_BUTTONS = 0x31, 115 VPCCMD_W_BL_POWER = 0x33, 116 }; 117 118 /* 119 * These correspond to the number of supported states - 1 120 * Future keyboard types may need a new system, if there's a collision 121 * KBD_BL_TRISTATE_AUTO has no way to report or set the auto state 122 * so it effectively has 3 states, but needs to handle 4 123 */ 124 enum { 125 KBD_BL_STANDARD = 1, 126 KBD_BL_TRISTATE = 2, 127 KBD_BL_TRISTATE_AUTO = 3, 128 }; 129 130 #define KBD_BL_QUERY_TYPE 0x1 131 #define KBD_BL_TRISTATE_TYPE 0x5 132 #define KBD_BL_TRISTATE_AUTO_TYPE 0x7 133 134 #define KBD_BL_COMMAND_GET 0x2 135 #define KBD_BL_COMMAND_SET 0x3 136 #define KBD_BL_COMMAND_TYPE GENMASK(7, 4) 137 138 #define KBD_BL_GET_BRIGHTNESS GENMASK(15, 1) 139 #define KBD_BL_SET_BRIGHTNESS GENMASK(19, 16) 140 141 #define KBD_BL_KBLC_CHANGED_EVENT 12 142 143 struct ideapad_dytc_priv { 144 enum platform_profile_option current_profile; 145 struct platform_profile_handler pprof; 146 struct mutex mutex; /* protects the DYTC interface */ 147 struct ideapad_private *priv; 148 }; 149 150 struct ideapad_rfk_priv { 151 int dev; 152 struct ideapad_private *priv; 153 }; 154 155 struct ideapad_private { 156 struct acpi_device *adev; 157 struct mutex vpc_mutex; /* protects the VPC calls */ 158 struct rfkill *rfk[IDEAPAD_RFKILL_DEV_NUM]; 159 struct ideapad_rfk_priv rfk_priv[IDEAPAD_RFKILL_DEV_NUM]; 160 struct platform_device *platform_device; 161 struct input_dev *inputdev; 162 struct backlight_device *blightdev; 163 struct ideapad_dytc_priv *dytc; 164 struct dentry *debug; 165 unsigned long cfg; 166 unsigned long r_touchpad_val; 167 struct { 168 bool conservation_mode : 1; 169 bool dytc : 1; 170 bool fan_mode : 1; 171 bool fn_lock : 1; 172 bool set_fn_lock_led : 1; 173 bool hw_rfkill_switch : 1; 174 bool kbd_bl : 1; 175 bool touchpad_ctrl_via_ec : 1; 176 bool ctrl_ps2_aux_port : 1; 177 bool usb_charging : 1; 178 bool ymc_ec_trigger : 1; 179 } features; 180 struct { 181 bool initialized; 182 int type; 183 struct led_classdev led; 184 unsigned int last_brightness; 185 } kbd_bl; 186 struct { 187 bool initialized; 188 struct led_classdev led; 189 unsigned int last_brightness; 190 } fn_lock; 191 }; 192 193 static bool no_bt_rfkill; 194 module_param(no_bt_rfkill, bool, 0444); 195 MODULE_PARM_DESC(no_bt_rfkill, "No rfkill for bluetooth."); 196 197 static bool allow_v4_dytc; 198 module_param(allow_v4_dytc, bool, 0444); 199 MODULE_PARM_DESC(allow_v4_dytc, 200 "Enable DYTC version 4 platform-profile support. " 201 "If you need this please report this to: platform-driver-x86@vger.kernel.org"); 202 203 static bool hw_rfkill_switch; 204 module_param(hw_rfkill_switch, bool, 0444); 205 MODULE_PARM_DESC(hw_rfkill_switch, 206 "Enable rfkill support for laptops with a hw on/off wifi switch/slider. " 207 "If you need this please report this to: platform-driver-x86@vger.kernel.org"); 208 209 static bool set_fn_lock_led; 210 module_param(set_fn_lock_led, bool, 0444); 211 MODULE_PARM_DESC(set_fn_lock_led, 212 "Enable driver based updates of the fn-lock LED on fn-lock changes. " 213 "If you need this please report this to: platform-driver-x86@vger.kernel.org"); 214 215 static bool ctrl_ps2_aux_port; 216 module_param(ctrl_ps2_aux_port, bool, 0444); 217 MODULE_PARM_DESC(ctrl_ps2_aux_port, 218 "Enable driver based PS/2 aux port en-/dis-abling on touchpad on/off toggle. " 219 "If you need this please report this to: platform-driver-x86@vger.kernel.org"); 220 221 static bool touchpad_ctrl_via_ec; 222 module_param(touchpad_ctrl_via_ec, bool, 0444); 223 MODULE_PARM_DESC(touchpad_ctrl_via_ec, 224 "Enable registering a 'touchpad' sysfs-attribute which can be used to manually " 225 "tell the EC to enable/disable the touchpad. This may not work on all models."); 226 227 static bool ymc_ec_trigger __read_mostly; 228 module_param(ymc_ec_trigger, bool, 0444); 229 MODULE_PARM_DESC(ymc_ec_trigger, 230 "Enable EC triggering work-around to force emitting tablet mode events. " 231 "If you need this please report this to: platform-driver-x86@vger.kernel.org"); 232 233 /* 234 * shared data 235 */ 236 237 static struct ideapad_private *ideapad_shared; 238 static DEFINE_MUTEX(ideapad_shared_mutex); 239 240 static int ideapad_shared_init(struct ideapad_private *priv) 241 { 242 int ret; 243 244 guard(mutex)(&ideapad_shared_mutex); 245 246 if (!ideapad_shared) { 247 ideapad_shared = priv; 248 ret = 0; 249 } else { 250 dev_warn(&priv->adev->dev, "found multiple platform devices\n"); 251 ret = -EINVAL; 252 } 253 254 return ret; 255 } 256 257 static void ideapad_shared_exit(struct ideapad_private *priv) 258 { 259 guard(mutex)(&ideapad_shared_mutex); 260 261 if (ideapad_shared == priv) 262 ideapad_shared = NULL; 263 } 264 265 /* 266 * ACPI Helpers 267 */ 268 #define IDEAPAD_EC_TIMEOUT 200 /* in ms */ 269 270 static int eval_int(acpi_handle handle, const char *name, unsigned long *res) 271 { 272 unsigned long long result; 273 acpi_status status; 274 275 status = acpi_evaluate_integer(handle, (char *)name, NULL, &result); 276 if (ACPI_FAILURE(status)) 277 return -EIO; 278 279 *res = result; 280 281 return 0; 282 } 283 284 static int eval_int_with_arg(acpi_handle handle, const char *name, unsigned long arg, 285 unsigned long *res) 286 { 287 struct acpi_object_list params; 288 unsigned long long result; 289 union acpi_object in_obj; 290 acpi_status status; 291 292 params.count = 1; 293 params.pointer = &in_obj; 294 in_obj.type = ACPI_TYPE_INTEGER; 295 in_obj.integer.value = arg; 296 297 status = acpi_evaluate_integer(handle, (char *)name, ¶ms, &result); 298 if (ACPI_FAILURE(status)) 299 return -EIO; 300 301 if (res) 302 *res = result; 303 304 return 0; 305 } 306 307 static int exec_simple_method(acpi_handle handle, const char *name, unsigned long arg) 308 { 309 acpi_status status = acpi_execute_simple_method(handle, (char *)name, arg); 310 311 return ACPI_FAILURE(status) ? -EIO : 0; 312 } 313 314 static int eval_gbmd(acpi_handle handle, unsigned long *res) 315 { 316 return eval_int(handle, "GBMD", res); 317 } 318 319 static int exec_sbmc(acpi_handle handle, unsigned long arg) 320 { 321 return exec_simple_method(handle, "SBMC", arg); 322 } 323 324 static int eval_hals(acpi_handle handle, unsigned long *res) 325 { 326 return eval_int(handle, "HALS", res); 327 } 328 329 static int exec_sals(acpi_handle handle, unsigned long arg) 330 { 331 return exec_simple_method(handle, "SALS", arg); 332 } 333 334 static int exec_kblc(acpi_handle handle, unsigned long arg) 335 { 336 return exec_simple_method(handle, "KBLC", arg); 337 } 338 339 static int eval_kblc(acpi_handle handle, unsigned long cmd, unsigned long *res) 340 { 341 return eval_int_with_arg(handle, "KBLC", cmd, res); 342 } 343 344 static int eval_dytc(acpi_handle handle, unsigned long cmd, unsigned long *res) 345 { 346 return eval_int_with_arg(handle, "DYTC", cmd, res); 347 } 348 349 static int eval_vpcr(acpi_handle handle, unsigned long cmd, unsigned long *res) 350 { 351 return eval_int_with_arg(handle, "VPCR", cmd, res); 352 } 353 354 static int eval_vpcw(acpi_handle handle, unsigned long cmd, unsigned long data) 355 { 356 struct acpi_object_list params; 357 union acpi_object in_obj[2]; 358 acpi_status status; 359 360 params.count = 2; 361 params.pointer = in_obj; 362 in_obj[0].type = ACPI_TYPE_INTEGER; 363 in_obj[0].integer.value = cmd; 364 in_obj[1].type = ACPI_TYPE_INTEGER; 365 in_obj[1].integer.value = data; 366 367 status = acpi_evaluate_object(handle, "VPCW", ¶ms, NULL); 368 if (ACPI_FAILURE(status)) 369 return -EIO; 370 371 return 0; 372 } 373 374 static int read_ec_data(acpi_handle handle, unsigned long cmd, unsigned long *data) 375 { 376 unsigned long end_jiffies, val; 377 int err; 378 379 err = eval_vpcw(handle, 1, cmd); 380 if (err) 381 return err; 382 383 end_jiffies = jiffies + msecs_to_jiffies(IDEAPAD_EC_TIMEOUT) + 1; 384 385 while (time_before(jiffies, end_jiffies)) { 386 schedule(); 387 388 err = eval_vpcr(handle, 1, &val); 389 if (err) 390 return err; 391 392 if (val == 0) 393 return eval_vpcr(handle, 0, data); 394 } 395 396 acpi_handle_err(handle, "timeout in %s\n", __func__); 397 398 return -ETIMEDOUT; 399 } 400 401 static int write_ec_cmd(acpi_handle handle, unsigned long cmd, unsigned long data) 402 { 403 unsigned long end_jiffies, val; 404 int err; 405 406 err = eval_vpcw(handle, 0, data); 407 if (err) 408 return err; 409 410 err = eval_vpcw(handle, 1, cmd); 411 if (err) 412 return err; 413 414 end_jiffies = jiffies + msecs_to_jiffies(IDEAPAD_EC_TIMEOUT) + 1; 415 416 while (time_before(jiffies, end_jiffies)) { 417 schedule(); 418 419 err = eval_vpcr(handle, 1, &val); 420 if (err) 421 return err; 422 423 if (val == 0) 424 return 0; 425 } 426 427 acpi_handle_err(handle, "timeout in %s\n", __func__); 428 429 return -ETIMEDOUT; 430 } 431 432 /* 433 * debugfs 434 */ 435 static int debugfs_status_show(struct seq_file *s, void *data) 436 { 437 struct ideapad_private *priv = s->private; 438 unsigned long value; 439 440 guard(mutex)(&priv->vpc_mutex); 441 442 if (!read_ec_data(priv->adev->handle, VPCCMD_R_BL_MAX, &value)) 443 seq_printf(s, "Backlight max: %lu\n", value); 444 if (!read_ec_data(priv->adev->handle, VPCCMD_R_BL, &value)) 445 seq_printf(s, "Backlight now: %lu\n", value); 446 if (!read_ec_data(priv->adev->handle, VPCCMD_R_BL_POWER, &value)) 447 seq_printf(s, "BL power value: %s (%lu)\n", value ? "on" : "off", value); 448 449 seq_puts(s, "=====================\n"); 450 451 if (!read_ec_data(priv->adev->handle, VPCCMD_R_RF, &value)) 452 seq_printf(s, "Radio status: %s (%lu)\n", value ? "on" : "off", value); 453 if (!read_ec_data(priv->adev->handle, VPCCMD_R_WIFI, &value)) 454 seq_printf(s, "Wifi status: %s (%lu)\n", value ? "on" : "off", value); 455 if (!read_ec_data(priv->adev->handle, VPCCMD_R_BT, &value)) 456 seq_printf(s, "BT status: %s (%lu)\n", value ? "on" : "off", value); 457 if (!read_ec_data(priv->adev->handle, VPCCMD_R_3G, &value)) 458 seq_printf(s, "3G status: %s (%lu)\n", value ? "on" : "off", value); 459 460 seq_puts(s, "=====================\n"); 461 462 if (!read_ec_data(priv->adev->handle, VPCCMD_R_TOUCHPAD, &value)) 463 seq_printf(s, "Touchpad status: %s (%lu)\n", value ? "on" : "off", value); 464 if (!read_ec_data(priv->adev->handle, VPCCMD_R_CAMERA, &value)) 465 seq_printf(s, "Camera status: %s (%lu)\n", value ? "on" : "off", value); 466 467 seq_puts(s, "=====================\n"); 468 469 if (!eval_gbmd(priv->adev->handle, &value)) 470 seq_printf(s, "GBMD: %#010lx\n", value); 471 if (!eval_hals(priv->adev->handle, &value)) 472 seq_printf(s, "HALS: %#010lx\n", value); 473 474 return 0; 475 } 476 DEFINE_SHOW_ATTRIBUTE(debugfs_status); 477 478 static int debugfs_cfg_show(struct seq_file *s, void *data) 479 { 480 struct ideapad_private *priv = s->private; 481 482 seq_printf(s, "_CFG: %#010lx\n\n", priv->cfg); 483 484 seq_puts(s, "Capabilities:"); 485 if (test_bit(CFG_CAP_BT_BIT, &priv->cfg)) 486 seq_puts(s, " bluetooth"); 487 if (test_bit(CFG_CAP_3G_BIT, &priv->cfg)) 488 seq_puts(s, " 3G"); 489 if (test_bit(CFG_CAP_WIFI_BIT, &priv->cfg)) 490 seq_puts(s, " wifi"); 491 if (test_bit(CFG_CAP_CAM_BIT, &priv->cfg)) 492 seq_puts(s, " camera"); 493 seq_puts(s, "\n"); 494 495 seq_puts(s, "OSD support:"); 496 if (test_bit(CFG_OSD_NUMLK_BIT, &priv->cfg)) 497 seq_puts(s, " num-lock"); 498 if (test_bit(CFG_OSD_CAPSLK_BIT, &priv->cfg)) 499 seq_puts(s, " caps-lock"); 500 if (test_bit(CFG_OSD_MICMUTE_BIT, &priv->cfg)) 501 seq_puts(s, " mic-mute"); 502 if (test_bit(CFG_OSD_TOUCHPAD_BIT, &priv->cfg)) 503 seq_puts(s, " touchpad"); 504 if (test_bit(CFG_OSD_CAM_BIT, &priv->cfg)) 505 seq_puts(s, " camera"); 506 seq_puts(s, "\n"); 507 508 seq_puts(s, "Graphics: "); 509 switch (priv->cfg & 0x700) { 510 case 0x100: 511 seq_puts(s, "Intel"); 512 break; 513 case 0x200: 514 seq_puts(s, "ATI"); 515 break; 516 case 0x300: 517 seq_puts(s, "Nvidia"); 518 break; 519 case 0x400: 520 seq_puts(s, "Intel and ATI"); 521 break; 522 case 0x500: 523 seq_puts(s, "Intel and Nvidia"); 524 break; 525 } 526 seq_puts(s, "\n"); 527 528 return 0; 529 } 530 DEFINE_SHOW_ATTRIBUTE(debugfs_cfg); 531 532 static void ideapad_debugfs_init(struct ideapad_private *priv) 533 { 534 struct dentry *dir; 535 536 dir = debugfs_create_dir("ideapad", NULL); 537 priv->debug = dir; 538 539 debugfs_create_file("cfg", 0444, dir, priv, &debugfs_cfg_fops); 540 debugfs_create_file("status", 0444, dir, priv, &debugfs_status_fops); 541 } 542 543 static void ideapad_debugfs_exit(struct ideapad_private *priv) 544 { 545 debugfs_remove_recursive(priv->debug); 546 priv->debug = NULL; 547 } 548 549 /* 550 * sysfs 551 */ 552 static ssize_t camera_power_show(struct device *dev, 553 struct device_attribute *attr, 554 char *buf) 555 { 556 struct ideapad_private *priv = dev_get_drvdata(dev); 557 unsigned long result = 0; 558 int err; 559 560 scoped_guard(mutex, &priv->vpc_mutex) { 561 err = read_ec_data(priv->adev->handle, VPCCMD_R_CAMERA, &result); 562 if (err) 563 return err; 564 } 565 566 return sysfs_emit(buf, "%d\n", !!result); 567 } 568 569 static ssize_t camera_power_store(struct device *dev, 570 struct device_attribute *attr, 571 const char *buf, size_t count) 572 { 573 struct ideapad_private *priv = dev_get_drvdata(dev); 574 bool state; 575 int err; 576 577 err = kstrtobool(buf, &state); 578 if (err) 579 return err; 580 581 scoped_guard(mutex, &priv->vpc_mutex) { 582 err = write_ec_cmd(priv->adev->handle, VPCCMD_W_CAMERA, state); 583 if (err) 584 return err; 585 } 586 587 return count; 588 } 589 590 static DEVICE_ATTR_RW(camera_power); 591 592 static ssize_t conservation_mode_show(struct device *dev, 593 struct device_attribute *attr, 594 char *buf) 595 { 596 struct ideapad_private *priv = dev_get_drvdata(dev); 597 unsigned long result; 598 int err; 599 600 err = eval_gbmd(priv->adev->handle, &result); 601 if (err) 602 return err; 603 604 return sysfs_emit(buf, "%d\n", !!test_bit(GBMD_CONSERVATION_STATE_BIT, &result)); 605 } 606 607 static ssize_t conservation_mode_store(struct device *dev, 608 struct device_attribute *attr, 609 const char *buf, size_t count) 610 { 611 struct ideapad_private *priv = dev_get_drvdata(dev); 612 bool state; 613 int err; 614 615 err = kstrtobool(buf, &state); 616 if (err) 617 return err; 618 619 err = exec_sbmc(priv->adev->handle, state ? SBMC_CONSERVATION_ON : SBMC_CONSERVATION_OFF); 620 if (err) 621 return err; 622 623 return count; 624 } 625 626 static DEVICE_ATTR_RW(conservation_mode); 627 628 static ssize_t fan_mode_show(struct device *dev, 629 struct device_attribute *attr, 630 char *buf) 631 { 632 struct ideapad_private *priv = dev_get_drvdata(dev); 633 unsigned long result = 0; 634 int err; 635 636 scoped_guard(mutex, &priv->vpc_mutex) { 637 err = read_ec_data(priv->adev->handle, VPCCMD_R_FAN, &result); 638 if (err) 639 return err; 640 } 641 642 return sysfs_emit(buf, "%lu\n", result); 643 } 644 645 static ssize_t fan_mode_store(struct device *dev, 646 struct device_attribute *attr, 647 const char *buf, size_t count) 648 { 649 struct ideapad_private *priv = dev_get_drvdata(dev); 650 unsigned int state; 651 int err; 652 653 err = kstrtouint(buf, 0, &state); 654 if (err) 655 return err; 656 657 if (state > 4 || state == 3) 658 return -EINVAL; 659 660 scoped_guard(mutex, &priv->vpc_mutex) { 661 err = write_ec_cmd(priv->adev->handle, VPCCMD_W_FAN, state); 662 if (err) 663 return err; 664 } 665 666 return count; 667 } 668 669 static DEVICE_ATTR_RW(fan_mode); 670 671 static int ideapad_fn_lock_get(struct ideapad_private *priv) 672 { 673 unsigned long hals; 674 int err; 675 676 err = eval_hals(priv->adev->handle, &hals); 677 if (err) 678 return err; 679 680 return !!test_bit(HALS_FNLOCK_STATE_BIT, &hals); 681 } 682 683 static int ideapad_fn_lock_set(struct ideapad_private *priv, bool state) 684 { 685 return exec_sals(priv->adev->handle, 686 state ? SALS_FNLOCK_ON : SALS_FNLOCK_OFF); 687 } 688 689 static void ideapad_fn_lock_led_notify(struct ideapad_private *priv, int brightness) 690 { 691 if (!priv->fn_lock.initialized) 692 return; 693 694 if (brightness == priv->fn_lock.last_brightness) 695 return; 696 697 priv->fn_lock.last_brightness = brightness; 698 699 led_classdev_notify_brightness_hw_changed(&priv->fn_lock.led, brightness); 700 } 701 702 static ssize_t fn_lock_show(struct device *dev, 703 struct device_attribute *attr, 704 char *buf) 705 { 706 struct ideapad_private *priv = dev_get_drvdata(dev); 707 int brightness; 708 709 brightness = ideapad_fn_lock_get(priv); 710 if (brightness < 0) 711 return brightness; 712 713 return sysfs_emit(buf, "%d\n", brightness); 714 } 715 716 static ssize_t fn_lock_store(struct device *dev, 717 struct device_attribute *attr, 718 const char *buf, size_t count) 719 { 720 struct ideapad_private *priv = dev_get_drvdata(dev); 721 bool state; 722 int err; 723 724 err = kstrtobool(buf, &state); 725 if (err) 726 return err; 727 728 err = ideapad_fn_lock_set(priv, state); 729 if (err) 730 return err; 731 732 ideapad_fn_lock_led_notify(priv, state); 733 734 return count; 735 } 736 737 static DEVICE_ATTR_RW(fn_lock); 738 739 static ssize_t touchpad_show(struct device *dev, 740 struct device_attribute *attr, 741 char *buf) 742 { 743 struct ideapad_private *priv = dev_get_drvdata(dev); 744 unsigned long result = 0; 745 int err; 746 747 scoped_guard(mutex, &priv->vpc_mutex) { 748 err = read_ec_data(priv->adev->handle, VPCCMD_R_TOUCHPAD, &result); 749 if (err) 750 return err; 751 } 752 753 priv->r_touchpad_val = result; 754 755 return sysfs_emit(buf, "%d\n", !!result); 756 } 757 758 static ssize_t touchpad_store(struct device *dev, 759 struct device_attribute *attr, 760 const char *buf, size_t count) 761 { 762 struct ideapad_private *priv = dev_get_drvdata(dev); 763 bool state; 764 int err; 765 766 err = kstrtobool(buf, &state); 767 if (err) 768 return err; 769 770 scoped_guard(mutex, &priv->vpc_mutex) { 771 err = write_ec_cmd(priv->adev->handle, VPCCMD_W_TOUCHPAD, state); 772 if (err) 773 return err; 774 } 775 776 priv->r_touchpad_val = state; 777 778 return count; 779 } 780 781 static DEVICE_ATTR_RW(touchpad); 782 783 static ssize_t usb_charging_show(struct device *dev, 784 struct device_attribute *attr, 785 char *buf) 786 { 787 struct ideapad_private *priv = dev_get_drvdata(dev); 788 unsigned long hals; 789 int err; 790 791 err = eval_hals(priv->adev->handle, &hals); 792 if (err) 793 return err; 794 795 return sysfs_emit(buf, "%d\n", !!test_bit(HALS_USB_CHARGING_STATE_BIT, &hals)); 796 } 797 798 static ssize_t usb_charging_store(struct device *dev, 799 struct device_attribute *attr, 800 const char *buf, size_t count) 801 { 802 struct ideapad_private *priv = dev_get_drvdata(dev); 803 bool state; 804 int err; 805 806 err = kstrtobool(buf, &state); 807 if (err) 808 return err; 809 810 err = exec_sals(priv->adev->handle, state ? SALS_USB_CHARGING_ON : SALS_USB_CHARGING_OFF); 811 if (err) 812 return err; 813 814 return count; 815 } 816 817 static DEVICE_ATTR_RW(usb_charging); 818 819 static struct attribute *ideapad_attributes[] = { 820 &dev_attr_camera_power.attr, 821 &dev_attr_conservation_mode.attr, 822 &dev_attr_fan_mode.attr, 823 &dev_attr_fn_lock.attr, 824 &dev_attr_touchpad.attr, 825 &dev_attr_usb_charging.attr, 826 NULL 827 }; 828 829 static umode_t ideapad_is_visible(struct kobject *kobj, 830 struct attribute *attr, 831 int idx) 832 { 833 struct device *dev = kobj_to_dev(kobj); 834 struct ideapad_private *priv = dev_get_drvdata(dev); 835 bool supported = true; 836 837 if (attr == &dev_attr_camera_power.attr) 838 supported = test_bit(CFG_CAP_CAM_BIT, &priv->cfg); 839 else if (attr == &dev_attr_conservation_mode.attr) 840 supported = priv->features.conservation_mode; 841 else if (attr == &dev_attr_fan_mode.attr) 842 supported = priv->features.fan_mode; 843 else if (attr == &dev_attr_fn_lock.attr) 844 supported = priv->features.fn_lock; 845 else if (attr == &dev_attr_touchpad.attr) 846 supported = priv->features.touchpad_ctrl_via_ec; 847 else if (attr == &dev_attr_usb_charging.attr) 848 supported = priv->features.usb_charging; 849 850 return supported ? attr->mode : 0; 851 } 852 853 static const struct attribute_group ideapad_attribute_group = { 854 .is_visible = ideapad_is_visible, 855 .attrs = ideapad_attributes 856 }; 857 858 /* 859 * DYTC Platform profile 860 */ 861 #define DYTC_CMD_QUERY 0 /* To get DYTC status - enable/revision */ 862 #define DYTC_CMD_SET 1 /* To enable/disable IC function mode */ 863 #define DYTC_CMD_GET 2 /* To get current IC function and mode */ 864 #define DYTC_CMD_RESET 0x1ff /* To reset back to default */ 865 866 #define DYTC_QUERY_ENABLE_BIT 8 /* Bit 8 - 0 = disabled, 1 = enabled */ 867 #define DYTC_QUERY_SUBREV_BIT 16 /* Bits 16 - 27 - sub revision */ 868 #define DYTC_QUERY_REV_BIT 28 /* Bits 28 - 31 - revision */ 869 870 #define DYTC_GET_FUNCTION_BIT 8 /* Bits 8-11 - function setting */ 871 #define DYTC_GET_MODE_BIT 12 /* Bits 12-15 - mode setting */ 872 873 #define DYTC_SET_FUNCTION_BIT 12 /* Bits 12-15 - function setting */ 874 #define DYTC_SET_MODE_BIT 16 /* Bits 16-19 - mode setting */ 875 #define DYTC_SET_VALID_BIT 20 /* Bit 20 - 1 = on, 0 = off */ 876 877 #define DYTC_FUNCTION_STD 0 /* Function = 0, standard mode */ 878 #define DYTC_FUNCTION_CQL 1 /* Function = 1, lap mode */ 879 #define DYTC_FUNCTION_MMC 11 /* Function = 11, desk mode */ 880 881 #define DYTC_MODE_PERFORM 2 /* High power mode aka performance */ 882 #define DYTC_MODE_LOW_POWER 3 /* Low power mode aka quiet */ 883 #define DYTC_MODE_BALANCE 0xF /* Default mode aka balanced */ 884 885 #define DYTC_SET_COMMAND(function, mode, on) \ 886 (DYTC_CMD_SET | (function) << DYTC_SET_FUNCTION_BIT | \ 887 (mode) << DYTC_SET_MODE_BIT | \ 888 (on) << DYTC_SET_VALID_BIT) 889 890 #define DYTC_DISABLE_CQL DYTC_SET_COMMAND(DYTC_FUNCTION_CQL, DYTC_MODE_BALANCE, 0) 891 892 #define DYTC_ENABLE_CQL DYTC_SET_COMMAND(DYTC_FUNCTION_CQL, DYTC_MODE_BALANCE, 1) 893 894 static int convert_dytc_to_profile(int dytcmode, enum platform_profile_option *profile) 895 { 896 switch (dytcmode) { 897 case DYTC_MODE_LOW_POWER: 898 *profile = PLATFORM_PROFILE_LOW_POWER; 899 break; 900 case DYTC_MODE_BALANCE: 901 *profile = PLATFORM_PROFILE_BALANCED; 902 break; 903 case DYTC_MODE_PERFORM: 904 *profile = PLATFORM_PROFILE_PERFORMANCE; 905 break; 906 default: /* Unknown mode */ 907 return -EINVAL; 908 } 909 910 return 0; 911 } 912 913 static int convert_profile_to_dytc(enum platform_profile_option profile, int *perfmode) 914 { 915 switch (profile) { 916 case PLATFORM_PROFILE_LOW_POWER: 917 *perfmode = DYTC_MODE_LOW_POWER; 918 break; 919 case PLATFORM_PROFILE_BALANCED: 920 *perfmode = DYTC_MODE_BALANCE; 921 break; 922 case PLATFORM_PROFILE_PERFORMANCE: 923 *perfmode = DYTC_MODE_PERFORM; 924 break; 925 default: /* Unknown profile */ 926 return -EOPNOTSUPP; 927 } 928 929 return 0; 930 } 931 932 /* 933 * dytc_profile_get: Function to register with platform_profile 934 * handler. Returns current platform profile. 935 */ 936 static int dytc_profile_get(struct platform_profile_handler *pprof, 937 enum platform_profile_option *profile) 938 { 939 struct ideapad_dytc_priv *dytc = container_of(pprof, struct ideapad_dytc_priv, pprof); 940 941 *profile = dytc->current_profile; 942 return 0; 943 } 944 945 /* 946 * Helper function - check if we are in CQL mode and if we are 947 * - disable CQL, 948 * - run the command 949 * - enable CQL 950 * If not in CQL mode, just run the command 951 */ 952 static int dytc_cql_command(struct ideapad_private *priv, unsigned long cmd, 953 unsigned long *output) 954 { 955 int err, cmd_err, cur_funcmode; 956 957 /* Determine if we are in CQL mode. This alters the commands we do */ 958 err = eval_dytc(priv->adev->handle, DYTC_CMD_GET, output); 959 if (err) 960 return err; 961 962 cur_funcmode = (*output >> DYTC_GET_FUNCTION_BIT) & 0xF; 963 /* Check if we're OK to return immediately */ 964 if (cmd == DYTC_CMD_GET && cur_funcmode != DYTC_FUNCTION_CQL) 965 return 0; 966 967 if (cur_funcmode == DYTC_FUNCTION_CQL) { 968 err = eval_dytc(priv->adev->handle, DYTC_DISABLE_CQL, NULL); 969 if (err) 970 return err; 971 } 972 973 cmd_err = eval_dytc(priv->adev->handle, cmd, output); 974 /* Check return condition after we've restored CQL state */ 975 976 if (cur_funcmode == DYTC_FUNCTION_CQL) { 977 err = eval_dytc(priv->adev->handle, DYTC_ENABLE_CQL, NULL); 978 if (err) 979 return err; 980 } 981 982 return cmd_err; 983 } 984 985 /* 986 * dytc_profile_set: Function to register with platform_profile 987 * handler. Sets current platform profile. 988 */ 989 static int dytc_profile_set(struct platform_profile_handler *pprof, 990 enum platform_profile_option profile) 991 { 992 struct ideapad_dytc_priv *dytc = container_of(pprof, struct ideapad_dytc_priv, pprof); 993 struct ideapad_private *priv = dytc->priv; 994 unsigned long output; 995 int err; 996 997 scoped_guard(mutex_intr, &dytc->mutex) { 998 if (profile == PLATFORM_PROFILE_BALANCED) { 999 /* To get back to balanced mode we just issue a reset command */ 1000 err = eval_dytc(priv->adev->handle, DYTC_CMD_RESET, NULL); 1001 if (err) 1002 return err; 1003 } else { 1004 int perfmode; 1005 1006 err = convert_profile_to_dytc(profile, &perfmode); 1007 if (err) 1008 return err; 1009 1010 /* Determine if we are in CQL mode. This alters the commands we do */ 1011 err = dytc_cql_command(priv, 1012 DYTC_SET_COMMAND(DYTC_FUNCTION_MMC, perfmode, 1), 1013 &output); 1014 if (err) 1015 return err; 1016 } 1017 1018 /* Success - update current profile */ 1019 dytc->current_profile = profile; 1020 return 0; 1021 } 1022 1023 return -EINTR; 1024 } 1025 1026 static void dytc_profile_refresh(struct ideapad_private *priv) 1027 { 1028 enum platform_profile_option profile; 1029 unsigned long output; 1030 int err, perfmode; 1031 1032 scoped_guard(mutex, &priv->dytc->mutex) 1033 err = dytc_cql_command(priv, DYTC_CMD_GET, &output); 1034 if (err) 1035 return; 1036 1037 perfmode = (output >> DYTC_GET_MODE_BIT) & 0xF; 1038 1039 if (convert_dytc_to_profile(perfmode, &profile)) 1040 return; 1041 1042 if (profile != priv->dytc->current_profile) { 1043 priv->dytc->current_profile = profile; 1044 platform_profile_notify(); 1045 } 1046 } 1047 1048 static const struct dmi_system_id ideapad_dytc_v4_allow_table[] = { 1049 { 1050 /* Ideapad 5 Pro 16ACH6 */ 1051 .matches = { 1052 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"), 1053 DMI_MATCH(DMI_PRODUCT_NAME, "82L5") 1054 } 1055 }, 1056 { 1057 /* Ideapad 5 15ITL05 */ 1058 .matches = { 1059 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"), 1060 DMI_MATCH(DMI_PRODUCT_VERSION, "IdeaPad 5 15ITL05") 1061 } 1062 }, 1063 {} 1064 }; 1065 1066 static int ideapad_dytc_profile_init(struct ideapad_private *priv) 1067 { 1068 int err, dytc_version; 1069 unsigned long output; 1070 1071 if (!priv->features.dytc) 1072 return -ENODEV; 1073 1074 err = eval_dytc(priv->adev->handle, DYTC_CMD_QUERY, &output); 1075 /* For all other errors we can flag the failure */ 1076 if (err) 1077 return err; 1078 1079 /* Check DYTC is enabled and supports mode setting */ 1080 if (!test_bit(DYTC_QUERY_ENABLE_BIT, &output)) { 1081 dev_info(&priv->platform_device->dev, "DYTC_QUERY_ENABLE_BIT returned false\n"); 1082 return -ENODEV; 1083 } 1084 1085 dytc_version = (output >> DYTC_QUERY_REV_BIT) & 0xF; 1086 1087 if (dytc_version < 4) { 1088 dev_info(&priv->platform_device->dev, "DYTC_VERSION < 4 is not supported\n"); 1089 return -ENODEV; 1090 } 1091 1092 if (dytc_version < 5 && 1093 !(allow_v4_dytc || dmi_check_system(ideapad_dytc_v4_allow_table))) { 1094 dev_info(&priv->platform_device->dev, 1095 "DYTC_VERSION 4 support may not work. Pass ideapad_laptop.allow_v4_dytc=Y on the kernel commandline to enable\n"); 1096 return -ENODEV; 1097 } 1098 1099 priv->dytc = kzalloc(sizeof(*priv->dytc), GFP_KERNEL); 1100 if (!priv->dytc) 1101 return -ENOMEM; 1102 1103 mutex_init(&priv->dytc->mutex); 1104 1105 priv->dytc->priv = priv; 1106 priv->dytc->pprof.profile_get = dytc_profile_get; 1107 priv->dytc->pprof.profile_set = dytc_profile_set; 1108 1109 /* Setup supported modes */ 1110 set_bit(PLATFORM_PROFILE_LOW_POWER, priv->dytc->pprof.choices); 1111 set_bit(PLATFORM_PROFILE_BALANCED, priv->dytc->pprof.choices); 1112 set_bit(PLATFORM_PROFILE_PERFORMANCE, priv->dytc->pprof.choices); 1113 1114 /* Create platform_profile structure and register */ 1115 err = platform_profile_register(&priv->dytc->pprof); 1116 if (err) 1117 goto pp_reg_failed; 1118 1119 /* Ensure initial values are correct */ 1120 dytc_profile_refresh(priv); 1121 1122 return 0; 1123 1124 pp_reg_failed: 1125 mutex_destroy(&priv->dytc->mutex); 1126 kfree(priv->dytc); 1127 priv->dytc = NULL; 1128 1129 return err; 1130 } 1131 1132 static void ideapad_dytc_profile_exit(struct ideapad_private *priv) 1133 { 1134 if (!priv->dytc) 1135 return; 1136 1137 platform_profile_remove(); 1138 mutex_destroy(&priv->dytc->mutex); 1139 kfree(priv->dytc); 1140 1141 priv->dytc = NULL; 1142 } 1143 1144 /* 1145 * Rfkill 1146 */ 1147 struct ideapad_rfk_data { 1148 char *name; 1149 int cfgbit; 1150 int opcode; 1151 int type; 1152 }; 1153 1154 static const struct ideapad_rfk_data ideapad_rfk_data[] = { 1155 { "ideapad_wlan", CFG_CAP_WIFI_BIT, VPCCMD_W_WIFI, RFKILL_TYPE_WLAN }, 1156 { "ideapad_bluetooth", CFG_CAP_BT_BIT, VPCCMD_W_BT, RFKILL_TYPE_BLUETOOTH }, 1157 { "ideapad_3g", CFG_CAP_3G_BIT, VPCCMD_W_3G, RFKILL_TYPE_WWAN }, 1158 }; 1159 1160 static int ideapad_rfk_set(void *data, bool blocked) 1161 { 1162 struct ideapad_rfk_priv *priv = data; 1163 int opcode = ideapad_rfk_data[priv->dev].opcode; 1164 1165 guard(mutex)(&priv->priv->vpc_mutex); 1166 1167 return write_ec_cmd(priv->priv->adev->handle, opcode, !blocked); 1168 } 1169 1170 static const struct rfkill_ops ideapad_rfk_ops = { 1171 .set_block = ideapad_rfk_set, 1172 }; 1173 1174 static void ideapad_sync_rfk_state(struct ideapad_private *priv) 1175 { 1176 unsigned long hw_blocked = 0; 1177 int i; 1178 1179 if (priv->features.hw_rfkill_switch) { 1180 guard(mutex)(&priv->vpc_mutex); 1181 1182 if (read_ec_data(priv->adev->handle, VPCCMD_R_RF, &hw_blocked)) 1183 return; 1184 hw_blocked = !hw_blocked; 1185 } 1186 1187 for (i = 0; i < IDEAPAD_RFKILL_DEV_NUM; i++) 1188 if (priv->rfk[i]) 1189 rfkill_set_hw_state(priv->rfk[i], hw_blocked); 1190 } 1191 1192 static int ideapad_register_rfkill(struct ideapad_private *priv, int dev) 1193 { 1194 unsigned long rf_enabled; 1195 int err; 1196 1197 if (no_bt_rfkill && ideapad_rfk_data[dev].type == RFKILL_TYPE_BLUETOOTH) { 1198 /* Force to enable bluetooth when no_bt_rfkill=1 */ 1199 write_ec_cmd(priv->adev->handle, ideapad_rfk_data[dev].opcode, 1); 1200 return 0; 1201 } 1202 1203 priv->rfk_priv[dev].dev = dev; 1204 priv->rfk_priv[dev].priv = priv; 1205 1206 priv->rfk[dev] = rfkill_alloc(ideapad_rfk_data[dev].name, 1207 &priv->platform_device->dev, 1208 ideapad_rfk_data[dev].type, 1209 &ideapad_rfk_ops, 1210 &priv->rfk_priv[dev]); 1211 if (!priv->rfk[dev]) 1212 return -ENOMEM; 1213 1214 err = read_ec_data(priv->adev->handle, ideapad_rfk_data[dev].opcode - 1, &rf_enabled); 1215 if (err) 1216 rf_enabled = 1; 1217 1218 rfkill_init_sw_state(priv->rfk[dev], !rf_enabled); 1219 1220 err = rfkill_register(priv->rfk[dev]); 1221 if (err) 1222 rfkill_destroy(priv->rfk[dev]); 1223 1224 return err; 1225 } 1226 1227 static void ideapad_unregister_rfkill(struct ideapad_private *priv, int dev) 1228 { 1229 if (!priv->rfk[dev]) 1230 return; 1231 1232 rfkill_unregister(priv->rfk[dev]); 1233 rfkill_destroy(priv->rfk[dev]); 1234 } 1235 1236 /* 1237 * Platform device 1238 */ 1239 static int ideapad_sysfs_init(struct ideapad_private *priv) 1240 { 1241 return device_add_group(&priv->platform_device->dev, 1242 &ideapad_attribute_group); 1243 } 1244 1245 static void ideapad_sysfs_exit(struct ideapad_private *priv) 1246 { 1247 device_remove_group(&priv->platform_device->dev, 1248 &ideapad_attribute_group); 1249 } 1250 1251 /* 1252 * input device 1253 */ 1254 #define IDEAPAD_WMI_KEY 0x100 1255 1256 static const struct key_entry ideapad_keymap[] = { 1257 { KE_KEY, 6, { KEY_SWITCHVIDEOMODE } }, 1258 { KE_KEY, 7, { KEY_CAMERA } }, 1259 { KE_KEY, 8, { KEY_MICMUTE } }, 1260 { KE_KEY, 11, { KEY_F16 } }, 1261 { KE_KEY, 13, { KEY_WLAN } }, 1262 { KE_KEY, 16, { KEY_PROG1 } }, 1263 { KE_KEY, 17, { KEY_PROG2 } }, 1264 { KE_KEY, 64, { KEY_PROG3 } }, 1265 { KE_KEY, 65, { KEY_PROG4 } }, 1266 { KE_KEY, 66, { KEY_TOUCHPAD_OFF } }, 1267 { KE_KEY, 67, { KEY_TOUCHPAD_ON } }, 1268 { KE_KEY, 128, { KEY_ESC } }, 1269 1270 /* 1271 * WMI keys 1272 */ 1273 1274 /* FnLock (handled by the firmware) */ 1275 { KE_IGNORE, 0x02 | IDEAPAD_WMI_KEY }, 1276 /* Esc (handled by the firmware) */ 1277 { KE_IGNORE, 0x03 | IDEAPAD_WMI_KEY }, 1278 /* Customizable Lenovo Hotkey ("star" with 'S' inside) */ 1279 { KE_KEY, 0x01 | IDEAPAD_WMI_KEY, { KEY_FAVORITES } }, 1280 { KE_KEY, 0x04 | IDEAPAD_WMI_KEY, { KEY_SELECTIVE_SCREENSHOT } }, 1281 /* Lenovo Support */ 1282 { KE_KEY, 0x07 | IDEAPAD_WMI_KEY, { KEY_HELP } }, 1283 { KE_KEY, 0x0e | IDEAPAD_WMI_KEY, { KEY_PICKUP_PHONE } }, 1284 { KE_KEY, 0x0f | IDEAPAD_WMI_KEY, { KEY_HANGUP_PHONE } }, 1285 /* Refresh Rate Toggle (Fn+R) */ 1286 { KE_KEY, 0x10 | IDEAPAD_WMI_KEY, { KEY_REFRESH_RATE_TOGGLE } }, 1287 /* Dark mode toggle */ 1288 { KE_KEY, 0x13 | IDEAPAD_WMI_KEY, { KEY_PROG1 } }, 1289 /* Sound profile switch */ 1290 { KE_KEY, 0x12 | IDEAPAD_WMI_KEY, { KEY_PROG2 } }, 1291 /* Lenovo Virtual Background application */ 1292 { KE_KEY, 0x28 | IDEAPAD_WMI_KEY, { KEY_PROG3 } }, 1293 /* Lenovo Support */ 1294 { KE_KEY, 0x27 | IDEAPAD_WMI_KEY, { KEY_HELP } }, 1295 /* Refresh Rate Toggle */ 1296 { KE_KEY, 0x0a | IDEAPAD_WMI_KEY, { KEY_REFRESH_RATE_TOGGLE } }, 1297 /* Specific to some newer models */ 1298 { KE_KEY, 0x3e | IDEAPAD_WMI_KEY, { KEY_MICMUTE } }, 1299 { KE_KEY, 0x3f | IDEAPAD_WMI_KEY, { KEY_RFKILL } }, 1300 1301 { KE_END }, 1302 }; 1303 1304 static int ideapad_input_init(struct ideapad_private *priv) 1305 { 1306 struct input_dev *inputdev; 1307 int err; 1308 1309 inputdev = input_allocate_device(); 1310 if (!inputdev) 1311 return -ENOMEM; 1312 1313 inputdev->name = "Ideapad extra buttons"; 1314 inputdev->phys = "ideapad/input0"; 1315 inputdev->id.bustype = BUS_HOST; 1316 inputdev->dev.parent = &priv->platform_device->dev; 1317 1318 err = sparse_keymap_setup(inputdev, ideapad_keymap, NULL); 1319 if (err) { 1320 dev_err(&priv->platform_device->dev, 1321 "Could not set up input device keymap: %d\n", err); 1322 goto err_free_dev; 1323 } 1324 1325 err = input_register_device(inputdev); 1326 if (err) { 1327 dev_err(&priv->platform_device->dev, 1328 "Could not register input device: %d\n", err); 1329 goto err_free_dev; 1330 } 1331 1332 priv->inputdev = inputdev; 1333 1334 return 0; 1335 1336 err_free_dev: 1337 input_free_device(inputdev); 1338 1339 return err; 1340 } 1341 1342 static void ideapad_input_exit(struct ideapad_private *priv) 1343 { 1344 input_unregister_device(priv->inputdev); 1345 priv->inputdev = NULL; 1346 } 1347 1348 static void ideapad_input_report(struct ideapad_private *priv, 1349 unsigned long scancode) 1350 { 1351 sparse_keymap_report_event(priv->inputdev, scancode, 1, true); 1352 } 1353 1354 static void ideapad_input_novokey(struct ideapad_private *priv) 1355 { 1356 unsigned long long_pressed; 1357 1358 scoped_guard(mutex, &priv->vpc_mutex) 1359 if (read_ec_data(priv->adev->handle, VPCCMD_R_NOVO, &long_pressed)) 1360 return; 1361 1362 if (long_pressed) 1363 ideapad_input_report(priv, 17); 1364 else 1365 ideapad_input_report(priv, 16); 1366 } 1367 1368 static void ideapad_check_special_buttons(struct ideapad_private *priv) 1369 { 1370 unsigned long bit, value; 1371 1372 scoped_guard(mutex, &priv->vpc_mutex) 1373 if (read_ec_data(priv->adev->handle, VPCCMD_R_SPECIAL_BUTTONS, &value)) 1374 return; 1375 1376 for_each_set_bit (bit, &value, 16) { 1377 switch (bit) { 1378 case 6: /* Z570 */ 1379 case 0: /* Z580 */ 1380 /* Thermal Management / Performance Mode button */ 1381 if (priv->dytc) 1382 platform_profile_cycle(); 1383 else 1384 ideapad_input_report(priv, 65); 1385 break; 1386 case 1: 1387 /* OneKey Theater button */ 1388 ideapad_input_report(priv, 64); 1389 break; 1390 default: 1391 dev_info(&priv->platform_device->dev, 1392 "Unknown special button: %lu\n", bit); 1393 break; 1394 } 1395 } 1396 } 1397 1398 /* 1399 * backlight 1400 */ 1401 static int ideapad_backlight_get_brightness(struct backlight_device *blightdev) 1402 { 1403 struct ideapad_private *priv = bl_get_data(blightdev); 1404 unsigned long now; 1405 int err; 1406 1407 guard(mutex)(&priv->vpc_mutex); 1408 1409 err = read_ec_data(priv->adev->handle, VPCCMD_R_BL, &now); 1410 if (err) 1411 return err; 1412 1413 return now; 1414 } 1415 1416 static int ideapad_backlight_update_status(struct backlight_device *blightdev) 1417 { 1418 struct ideapad_private *priv = bl_get_data(blightdev); 1419 int err; 1420 1421 guard(mutex)(&priv->vpc_mutex); 1422 1423 err = write_ec_cmd(priv->adev->handle, VPCCMD_W_BL, 1424 blightdev->props.brightness); 1425 if (err) 1426 return err; 1427 1428 err = write_ec_cmd(priv->adev->handle, VPCCMD_W_BL_POWER, 1429 blightdev->props.power != BACKLIGHT_POWER_OFF); 1430 if (err) 1431 return err; 1432 1433 return 0; 1434 } 1435 1436 static const struct backlight_ops ideapad_backlight_ops = { 1437 .get_brightness = ideapad_backlight_get_brightness, 1438 .update_status = ideapad_backlight_update_status, 1439 }; 1440 1441 static int ideapad_backlight_init(struct ideapad_private *priv) 1442 { 1443 struct backlight_device *blightdev; 1444 struct backlight_properties props; 1445 unsigned long max, now, power; 1446 int err; 1447 1448 err = read_ec_data(priv->adev->handle, VPCCMD_R_BL_MAX, &max); 1449 if (err) 1450 return err; 1451 1452 err = read_ec_data(priv->adev->handle, VPCCMD_R_BL, &now); 1453 if (err) 1454 return err; 1455 1456 err = read_ec_data(priv->adev->handle, VPCCMD_R_BL_POWER, &power); 1457 if (err) 1458 return err; 1459 1460 memset(&props, 0, sizeof(props)); 1461 1462 props.max_brightness = max; 1463 props.type = BACKLIGHT_PLATFORM; 1464 1465 blightdev = backlight_device_register("ideapad", 1466 &priv->platform_device->dev, 1467 priv, 1468 &ideapad_backlight_ops, 1469 &props); 1470 if (IS_ERR(blightdev)) { 1471 err = PTR_ERR(blightdev); 1472 dev_err(&priv->platform_device->dev, 1473 "Could not register backlight device: %d\n", err); 1474 return err; 1475 } 1476 1477 priv->blightdev = blightdev; 1478 blightdev->props.brightness = now; 1479 blightdev->props.power = power ? BACKLIGHT_POWER_ON : BACKLIGHT_POWER_OFF; 1480 1481 backlight_update_status(blightdev); 1482 1483 return 0; 1484 } 1485 1486 static void ideapad_backlight_exit(struct ideapad_private *priv) 1487 { 1488 backlight_device_unregister(priv->blightdev); 1489 priv->blightdev = NULL; 1490 } 1491 1492 static void ideapad_backlight_notify_power(struct ideapad_private *priv) 1493 { 1494 struct backlight_device *blightdev = priv->blightdev; 1495 unsigned long power; 1496 1497 if (!blightdev) 1498 return; 1499 1500 guard(mutex)(&priv->vpc_mutex); 1501 1502 if (read_ec_data(priv->adev->handle, VPCCMD_R_BL_POWER, &power)) 1503 return; 1504 1505 blightdev->props.power = power ? BACKLIGHT_POWER_ON : BACKLIGHT_POWER_OFF; 1506 } 1507 1508 static void ideapad_backlight_notify_brightness(struct ideapad_private *priv) 1509 { 1510 unsigned long now; 1511 1512 /* if we control brightness via acpi video driver */ 1513 if (!priv->blightdev) 1514 scoped_guard(mutex, &priv->vpc_mutex) 1515 read_ec_data(priv->adev->handle, VPCCMD_R_BL, &now); 1516 else 1517 backlight_force_update(priv->blightdev, BACKLIGHT_UPDATE_HOTKEY); 1518 } 1519 1520 /* 1521 * keyboard backlight 1522 */ 1523 static int ideapad_kbd_bl_check_tristate(int type) 1524 { 1525 return (type == KBD_BL_TRISTATE) || (type == KBD_BL_TRISTATE_AUTO); 1526 } 1527 1528 static int ideapad_kbd_bl_brightness_get(struct ideapad_private *priv) 1529 { 1530 unsigned long value; 1531 int err; 1532 1533 if (ideapad_kbd_bl_check_tristate(priv->kbd_bl.type)) { 1534 err = eval_kblc(priv->adev->handle, 1535 FIELD_PREP(KBD_BL_COMMAND_TYPE, priv->kbd_bl.type) | 1536 KBD_BL_COMMAND_GET, 1537 &value); 1538 1539 if (err) 1540 return err; 1541 1542 /* Convert returned value to brightness level */ 1543 value = FIELD_GET(KBD_BL_GET_BRIGHTNESS, value); 1544 1545 /* Off, low or high */ 1546 if (value <= priv->kbd_bl.led.max_brightness) 1547 return value; 1548 1549 /* Auto, report as off */ 1550 if (value == priv->kbd_bl.led.max_brightness + 1) 1551 return 0; 1552 1553 /* Unknown value */ 1554 dev_warn(&priv->platform_device->dev, 1555 "Unknown keyboard backlight value: %lu", value); 1556 return -EINVAL; 1557 } 1558 1559 err = eval_hals(priv->adev->handle, &value); 1560 if (err) 1561 return err; 1562 1563 return !!test_bit(HALS_KBD_BL_STATE_BIT, &value); 1564 } 1565 1566 static enum led_brightness ideapad_kbd_bl_led_cdev_brightness_get(struct led_classdev *led_cdev) 1567 { 1568 struct ideapad_private *priv = container_of(led_cdev, struct ideapad_private, kbd_bl.led); 1569 1570 return ideapad_kbd_bl_brightness_get(priv); 1571 } 1572 1573 static int ideapad_kbd_bl_brightness_set(struct ideapad_private *priv, unsigned int brightness) 1574 { 1575 int err; 1576 unsigned long value; 1577 int type = priv->kbd_bl.type; 1578 1579 if (ideapad_kbd_bl_check_tristate(type)) { 1580 if (brightness > priv->kbd_bl.led.max_brightness) 1581 return -EINVAL; 1582 1583 value = FIELD_PREP(KBD_BL_SET_BRIGHTNESS, brightness) | 1584 FIELD_PREP(KBD_BL_COMMAND_TYPE, type) | 1585 KBD_BL_COMMAND_SET; 1586 err = exec_kblc(priv->adev->handle, value); 1587 } else { 1588 err = exec_sals(priv->adev->handle, brightness ? SALS_KBD_BL_ON : SALS_KBD_BL_OFF); 1589 } 1590 1591 if (err) 1592 return err; 1593 1594 priv->kbd_bl.last_brightness = brightness; 1595 1596 return 0; 1597 } 1598 1599 static int ideapad_kbd_bl_led_cdev_brightness_set(struct led_classdev *led_cdev, 1600 enum led_brightness brightness) 1601 { 1602 struct ideapad_private *priv = container_of(led_cdev, struct ideapad_private, kbd_bl.led); 1603 1604 return ideapad_kbd_bl_brightness_set(priv, brightness); 1605 } 1606 1607 static void ideapad_kbd_bl_notify(struct ideapad_private *priv) 1608 { 1609 int brightness; 1610 1611 if (!priv->kbd_bl.initialized) 1612 return; 1613 1614 brightness = ideapad_kbd_bl_brightness_get(priv); 1615 if (brightness < 0) 1616 return; 1617 1618 if (brightness == priv->kbd_bl.last_brightness) 1619 return; 1620 1621 priv->kbd_bl.last_brightness = brightness; 1622 1623 led_classdev_notify_brightness_hw_changed(&priv->kbd_bl.led, brightness); 1624 } 1625 1626 static int ideapad_kbd_bl_init(struct ideapad_private *priv) 1627 { 1628 int brightness, err; 1629 1630 if (!priv->features.kbd_bl) 1631 return -ENODEV; 1632 1633 if (WARN_ON(priv->kbd_bl.initialized)) 1634 return -EEXIST; 1635 1636 if (ideapad_kbd_bl_check_tristate(priv->kbd_bl.type)) { 1637 priv->kbd_bl.led.max_brightness = 2; 1638 } else { 1639 priv->kbd_bl.led.max_brightness = 1; 1640 } 1641 1642 brightness = ideapad_kbd_bl_brightness_get(priv); 1643 if (brightness < 0) 1644 return brightness; 1645 1646 priv->kbd_bl.last_brightness = brightness; 1647 priv->kbd_bl.led.name = "platform::" LED_FUNCTION_KBD_BACKLIGHT; 1648 priv->kbd_bl.led.brightness_get = ideapad_kbd_bl_led_cdev_brightness_get; 1649 priv->kbd_bl.led.brightness_set_blocking = ideapad_kbd_bl_led_cdev_brightness_set; 1650 priv->kbd_bl.led.flags = LED_BRIGHT_HW_CHANGED; 1651 1652 err = led_classdev_register(&priv->platform_device->dev, &priv->kbd_bl.led); 1653 if (err) 1654 return err; 1655 1656 priv->kbd_bl.initialized = true; 1657 1658 return 0; 1659 } 1660 1661 static void ideapad_kbd_bl_exit(struct ideapad_private *priv) 1662 { 1663 if (!priv->kbd_bl.initialized) 1664 return; 1665 1666 priv->kbd_bl.initialized = false; 1667 1668 led_classdev_unregister(&priv->kbd_bl.led); 1669 } 1670 1671 /* 1672 * FnLock LED 1673 */ 1674 static enum led_brightness ideapad_fn_lock_led_cdev_get(struct led_classdev *led_cdev) 1675 { 1676 struct ideapad_private *priv = container_of(led_cdev, struct ideapad_private, fn_lock.led); 1677 1678 return ideapad_fn_lock_get(priv); 1679 } 1680 1681 static int ideapad_fn_lock_led_cdev_set(struct led_classdev *led_cdev, 1682 enum led_brightness brightness) 1683 { 1684 struct ideapad_private *priv = container_of(led_cdev, struct ideapad_private, fn_lock.led); 1685 1686 return ideapad_fn_lock_set(priv, brightness); 1687 } 1688 1689 static int ideapad_fn_lock_led_init(struct ideapad_private *priv) 1690 { 1691 int brightness, err; 1692 1693 if (!priv->features.fn_lock) 1694 return -ENODEV; 1695 1696 if (WARN_ON(priv->fn_lock.initialized)) 1697 return -EEXIST; 1698 1699 priv->fn_lock.led.max_brightness = 1; 1700 1701 brightness = ideapad_fn_lock_get(priv); 1702 if (brightness < 0) 1703 return brightness; 1704 1705 priv->fn_lock.last_brightness = brightness; 1706 priv->fn_lock.led.name = "platform::" LED_FUNCTION_FNLOCK; 1707 priv->fn_lock.led.brightness_get = ideapad_fn_lock_led_cdev_get; 1708 priv->fn_lock.led.brightness_set_blocking = ideapad_fn_lock_led_cdev_set; 1709 priv->fn_lock.led.flags = LED_BRIGHT_HW_CHANGED; 1710 1711 err = led_classdev_register(&priv->platform_device->dev, &priv->fn_lock.led); 1712 if (err) 1713 return err; 1714 1715 priv->fn_lock.initialized = true; 1716 1717 return 0; 1718 } 1719 1720 static void ideapad_fn_lock_led_exit(struct ideapad_private *priv) 1721 { 1722 if (!priv->fn_lock.initialized) 1723 return; 1724 1725 priv->fn_lock.initialized = false; 1726 1727 led_classdev_unregister(&priv->fn_lock.led); 1728 } 1729 1730 /* 1731 * module init/exit 1732 */ 1733 static void ideapad_sync_touchpad_state(struct ideapad_private *priv, bool send_events) 1734 { 1735 unsigned long value; 1736 unsigned char param; 1737 int ret; 1738 1739 /* Without reading from EC touchpad LED doesn't switch state */ 1740 scoped_guard(mutex, &priv->vpc_mutex) 1741 ret = read_ec_data(priv->adev->handle, VPCCMD_R_TOUCHPAD, &value); 1742 if (ret) 1743 return; 1744 1745 /* 1746 * Some IdeaPads don't really turn off touchpad - they only 1747 * switch the LED state. We (de)activate KBC AUX port to turn 1748 * touchpad off and on. We send KEY_TOUCHPAD_OFF and 1749 * KEY_TOUCHPAD_ON to not to get out of sync with LED 1750 */ 1751 if (priv->features.ctrl_ps2_aux_port) 1752 i8042_command(¶m, value ? I8042_CMD_AUX_ENABLE : I8042_CMD_AUX_DISABLE); 1753 1754 /* 1755 * On older models the EC controls the touchpad and toggles it on/off 1756 * itself, in this case we report KEY_TOUCHPAD_ON/_OFF. Some models do 1757 * an acpi-notify with VPC bit 5 set on resume, so this function get 1758 * called with send_events=true on every resume. Therefor if the EC did 1759 * not toggle, do nothing to avoid sending spurious KEY_TOUCHPAD_TOGGLE. 1760 */ 1761 if (send_events && value != priv->r_touchpad_val) { 1762 ideapad_input_report(priv, value ? 67 : 66); 1763 sysfs_notify(&priv->platform_device->dev.kobj, NULL, "touchpad"); 1764 } 1765 1766 priv->r_touchpad_val = value; 1767 } 1768 1769 static const struct dmi_system_id ymc_ec_trigger_quirk_dmi_table[] = { 1770 { 1771 /* Lenovo Yoga 7 14ARB7 */ 1772 .matches = { 1773 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"), 1774 DMI_MATCH(DMI_PRODUCT_NAME, "82QF"), 1775 }, 1776 }, 1777 { 1778 /* Lenovo Yoga 7 14ACN6 */ 1779 .matches = { 1780 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"), 1781 DMI_MATCH(DMI_PRODUCT_NAME, "82N7"), 1782 }, 1783 }, 1784 { } 1785 }; 1786 1787 static void ideapad_laptop_trigger_ec(void) 1788 { 1789 struct ideapad_private *priv; 1790 int ret; 1791 1792 guard(mutex)(&ideapad_shared_mutex); 1793 1794 priv = ideapad_shared; 1795 if (!priv) 1796 return; 1797 1798 if (!priv->features.ymc_ec_trigger) 1799 return; 1800 1801 scoped_guard(mutex, &priv->vpc_mutex) 1802 ret = write_ec_cmd(priv->adev->handle, VPCCMD_W_YMC, 1); 1803 if (ret) 1804 dev_warn(&priv->platform_device->dev, "Could not write YMC: %d\n", ret); 1805 } 1806 1807 static int ideapad_laptop_nb_notify(struct notifier_block *nb, 1808 unsigned long action, void *data) 1809 { 1810 switch (action) { 1811 case IDEAPAD_LAPTOP_YMC_EVENT: 1812 ideapad_laptop_trigger_ec(); 1813 break; 1814 } 1815 1816 return 0; 1817 } 1818 1819 static struct notifier_block ideapad_laptop_notifier = { 1820 .notifier_call = ideapad_laptop_nb_notify, 1821 }; 1822 1823 static BLOCKING_NOTIFIER_HEAD(ideapad_laptop_chain_head); 1824 1825 int ideapad_laptop_register_notifier(struct notifier_block *nb) 1826 { 1827 return blocking_notifier_chain_register(&ideapad_laptop_chain_head, nb); 1828 } 1829 EXPORT_SYMBOL_NS_GPL(ideapad_laptop_register_notifier, IDEAPAD_LAPTOP); 1830 1831 int ideapad_laptop_unregister_notifier(struct notifier_block *nb) 1832 { 1833 return blocking_notifier_chain_unregister(&ideapad_laptop_chain_head, nb); 1834 } 1835 EXPORT_SYMBOL_NS_GPL(ideapad_laptop_unregister_notifier, IDEAPAD_LAPTOP); 1836 1837 void ideapad_laptop_call_notifier(unsigned long action, void *data) 1838 { 1839 blocking_notifier_call_chain(&ideapad_laptop_chain_head, action, data); 1840 } 1841 EXPORT_SYMBOL_NS_GPL(ideapad_laptop_call_notifier, IDEAPAD_LAPTOP); 1842 1843 static void ideapad_acpi_notify(acpi_handle handle, u32 event, void *data) 1844 { 1845 struct ideapad_private *priv = data; 1846 unsigned long vpc1, vpc2, bit; 1847 1848 scoped_guard(mutex, &priv->vpc_mutex) { 1849 if (read_ec_data(handle, VPCCMD_R_VPC1, &vpc1)) 1850 return; 1851 1852 if (read_ec_data(handle, VPCCMD_R_VPC2, &vpc2)) 1853 return; 1854 } 1855 1856 vpc1 = (vpc2 << 8) | vpc1; 1857 1858 for_each_set_bit (bit, &vpc1, 16) { 1859 switch (bit) { 1860 case 13: 1861 case 11: 1862 case 8: 1863 case 7: 1864 case 6: 1865 ideapad_input_report(priv, bit); 1866 break; 1867 case 10: 1868 /* 1869 * This event gets send on a Yoga 300-11IBR when the EC 1870 * believes that the device has changed between laptop/ 1871 * tent/stand/tablet mode. The EC relies on getting 1872 * angle info from 2 accelerometers through a special 1873 * windows service calling a DSM on the DUAL250E ACPI- 1874 * device. Linux does not do this, making the laptop/ 1875 * tent/stand/tablet mode info unreliable, so we simply 1876 * ignore these events. 1877 */ 1878 break; 1879 case 9: 1880 ideapad_sync_rfk_state(priv); 1881 break; 1882 case 5: 1883 ideapad_sync_touchpad_state(priv, true); 1884 break; 1885 case 4: 1886 ideapad_backlight_notify_brightness(priv); 1887 break; 1888 case 3: 1889 ideapad_input_novokey(priv); 1890 break; 1891 case 2: 1892 ideapad_backlight_notify_power(priv); 1893 break; 1894 case KBD_BL_KBLC_CHANGED_EVENT: 1895 case 1: 1896 /* 1897 * Some IdeaPads report event 1 every ~20 1898 * seconds while on battery power; some 1899 * report this when changing to/from tablet 1900 * mode; some report this when the keyboard 1901 * backlight has changed. 1902 */ 1903 ideapad_kbd_bl_notify(priv); 1904 break; 1905 case 0: 1906 ideapad_check_special_buttons(priv); 1907 break; 1908 default: 1909 dev_info(&priv->platform_device->dev, 1910 "Unknown event: %lu\n", bit); 1911 } 1912 } 1913 } 1914 1915 /* On some models we need to call exec_sals(SALS_FNLOCK_ON/OFF) to set the LED */ 1916 static const struct dmi_system_id set_fn_lock_led_list[] = { 1917 { 1918 /* https://bugzilla.kernel.org/show_bug.cgi?id=212671 */ 1919 .matches = { 1920 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"), 1921 DMI_MATCH(DMI_PRODUCT_VERSION, "Lenovo Legion R7000P2020H"), 1922 } 1923 }, 1924 { 1925 .matches = { 1926 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"), 1927 DMI_MATCH(DMI_PRODUCT_VERSION, "Lenovo Legion 5 15ARH05"), 1928 } 1929 }, 1930 {} 1931 }; 1932 1933 /* 1934 * Some ideapads have a hardware rfkill switch, but most do not have one. 1935 * Reading VPCCMD_R_RF always results in 0 on models without a hardware rfkill, 1936 * switch causing ideapad_laptop to wrongly report all radios as hw-blocked. 1937 * There used to be a long list of DMI ids for models without a hw rfkill 1938 * switch here, but that resulted in playing whack a mole. 1939 * More importantly wrongly reporting the wifi radio as hw-blocked, results in 1940 * non working wifi. Whereas not reporting it hw-blocked, when it actually is 1941 * hw-blocked results in an empty SSID list, which is a much more benign 1942 * failure mode. 1943 * So the default now is the much safer option of assuming there is no 1944 * hardware rfkill switch. This default also actually matches most hardware, 1945 * since having a hw rfkill switch is quite rare on modern hardware, so this 1946 * also leads to a much shorter list. 1947 */ 1948 static const struct dmi_system_id hw_rfkill_list[] = { 1949 {} 1950 }; 1951 1952 /* 1953 * On some models the EC toggles the touchpad muted LED on touchpad toggle 1954 * hotkey presses, but the EC does not actually disable the touchpad itself. 1955 * On these models the driver needs to explicitly enable/disable the i8042 1956 * (PS/2) aux port. 1957 */ 1958 static const struct dmi_system_id ctrl_ps2_aux_port_list[] = { 1959 { 1960 /* Lenovo Ideapad Z570 */ 1961 .matches = { 1962 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"), 1963 DMI_MATCH(DMI_PRODUCT_VERSION, "Ideapad Z570"), 1964 }, 1965 }, 1966 {} 1967 }; 1968 1969 static void ideapad_check_features(struct ideapad_private *priv) 1970 { 1971 acpi_handle handle = priv->adev->handle; 1972 unsigned long val; 1973 1974 priv->features.set_fn_lock_led = 1975 set_fn_lock_led || dmi_check_system(set_fn_lock_led_list); 1976 priv->features.hw_rfkill_switch = 1977 hw_rfkill_switch || dmi_check_system(hw_rfkill_list); 1978 priv->features.ctrl_ps2_aux_port = 1979 ctrl_ps2_aux_port || dmi_check_system(ctrl_ps2_aux_port_list); 1980 priv->features.touchpad_ctrl_via_ec = touchpad_ctrl_via_ec; 1981 priv->features.ymc_ec_trigger = 1982 ymc_ec_trigger || dmi_check_system(ymc_ec_trigger_quirk_dmi_table); 1983 1984 if (!read_ec_data(handle, VPCCMD_R_FAN, &val)) 1985 priv->features.fan_mode = true; 1986 1987 if (acpi_has_method(handle, "GBMD") && acpi_has_method(handle, "SBMC")) 1988 priv->features.conservation_mode = true; 1989 1990 if (acpi_has_method(handle, "DYTC")) 1991 priv->features.dytc = true; 1992 1993 if (acpi_has_method(handle, "HALS") && acpi_has_method(handle, "SALS")) { 1994 if (!eval_hals(handle, &val)) { 1995 if (test_bit(HALS_FNLOCK_SUPPORT_BIT, &val)) 1996 priv->features.fn_lock = true; 1997 1998 if (test_bit(HALS_KBD_BL_SUPPORT_BIT, &val)) { 1999 priv->features.kbd_bl = true; 2000 priv->kbd_bl.type = KBD_BL_STANDARD; 2001 } 2002 2003 if (test_bit(HALS_USB_CHARGING_SUPPORT_BIT, &val)) 2004 priv->features.usb_charging = true; 2005 } 2006 } 2007 2008 if (acpi_has_method(handle, "KBLC")) { 2009 if (!eval_kblc(priv->adev->handle, KBD_BL_QUERY_TYPE, &val)) { 2010 if (val == KBD_BL_TRISTATE_TYPE) { 2011 priv->features.kbd_bl = true; 2012 priv->kbd_bl.type = KBD_BL_TRISTATE; 2013 } else if (val == KBD_BL_TRISTATE_AUTO_TYPE) { 2014 priv->features.kbd_bl = true; 2015 priv->kbd_bl.type = KBD_BL_TRISTATE_AUTO; 2016 } else { 2017 dev_warn(&priv->platform_device->dev, 2018 "Unknown keyboard type: %lu", 2019 val); 2020 } 2021 } 2022 } 2023 } 2024 2025 #if IS_ENABLED(CONFIG_ACPI_WMI) 2026 /* 2027 * WMI driver 2028 */ 2029 enum ideapad_wmi_event_type { 2030 IDEAPAD_WMI_EVENT_ESC, 2031 IDEAPAD_WMI_EVENT_FN_KEYS, 2032 }; 2033 2034 struct ideapad_wmi_private { 2035 enum ideapad_wmi_event_type event; 2036 }; 2037 2038 static int ideapad_wmi_probe(struct wmi_device *wdev, const void *context) 2039 { 2040 struct ideapad_wmi_private *wpriv; 2041 2042 wpriv = devm_kzalloc(&wdev->dev, sizeof(*wpriv), GFP_KERNEL); 2043 if (!wpriv) 2044 return -ENOMEM; 2045 2046 *wpriv = *(const struct ideapad_wmi_private *)context; 2047 2048 dev_set_drvdata(&wdev->dev, wpriv); 2049 return 0; 2050 } 2051 2052 static void ideapad_wmi_notify(struct wmi_device *wdev, union acpi_object *data) 2053 { 2054 struct ideapad_wmi_private *wpriv = dev_get_drvdata(&wdev->dev); 2055 struct ideapad_private *priv; 2056 2057 guard(mutex)(&ideapad_shared_mutex); 2058 2059 priv = ideapad_shared; 2060 if (!priv) 2061 return; 2062 2063 switch (wpriv->event) { 2064 case IDEAPAD_WMI_EVENT_ESC: 2065 ideapad_input_report(priv, 128); 2066 break; 2067 case IDEAPAD_WMI_EVENT_FN_KEYS: 2068 if (priv->features.set_fn_lock_led) { 2069 int brightness = ideapad_fn_lock_get(priv); 2070 2071 if (brightness >= 0) { 2072 ideapad_fn_lock_set(priv, brightness); 2073 ideapad_fn_lock_led_notify(priv, brightness); 2074 } 2075 } 2076 2077 if (data->type != ACPI_TYPE_INTEGER) { 2078 dev_warn(&wdev->dev, 2079 "WMI event data is not an integer\n"); 2080 break; 2081 } 2082 2083 dev_dbg(&wdev->dev, "WMI fn-key event: 0x%llx\n", 2084 data->integer.value); 2085 2086 /* 0x02 FnLock, 0x03 Esc */ 2087 if (data->integer.value == 0x02 || data->integer.value == 0x03) 2088 ideapad_fn_lock_led_notify(priv, data->integer.value == 0x02); 2089 2090 ideapad_input_report(priv, 2091 data->integer.value | IDEAPAD_WMI_KEY); 2092 2093 break; 2094 } 2095 } 2096 2097 static const struct ideapad_wmi_private ideapad_wmi_context_esc = { 2098 .event = IDEAPAD_WMI_EVENT_ESC 2099 }; 2100 2101 static const struct ideapad_wmi_private ideapad_wmi_context_fn_keys = { 2102 .event = IDEAPAD_WMI_EVENT_FN_KEYS 2103 }; 2104 2105 static const struct wmi_device_id ideapad_wmi_ids[] = { 2106 { "26CAB2E5-5CF1-46AE-AAC3-4A12B6BA50E6", &ideapad_wmi_context_esc }, /* Yoga 3 */ 2107 { "56322276-8493-4CE8-A783-98C991274F5E", &ideapad_wmi_context_esc }, /* Yoga 700 */ 2108 { "8FC0DE0C-B4E4-43FD-B0F3-8871711C1294", &ideapad_wmi_context_fn_keys }, /* Legion 5 */ 2109 {}, 2110 }; 2111 MODULE_DEVICE_TABLE(wmi, ideapad_wmi_ids); 2112 2113 static struct wmi_driver ideapad_wmi_driver = { 2114 .driver = { 2115 .name = "ideapad_wmi", 2116 }, 2117 .id_table = ideapad_wmi_ids, 2118 .probe = ideapad_wmi_probe, 2119 .notify = ideapad_wmi_notify, 2120 }; 2121 2122 static int ideapad_wmi_driver_register(void) 2123 { 2124 return wmi_driver_register(&ideapad_wmi_driver); 2125 } 2126 2127 static void ideapad_wmi_driver_unregister(void) 2128 { 2129 return wmi_driver_unregister(&ideapad_wmi_driver); 2130 } 2131 2132 #else 2133 static inline int ideapad_wmi_driver_register(void) { return 0; } 2134 static inline void ideapad_wmi_driver_unregister(void) { } 2135 #endif 2136 2137 /* 2138 * ACPI driver 2139 */ 2140 static int ideapad_acpi_add(struct platform_device *pdev) 2141 { 2142 struct acpi_device *adev = ACPI_COMPANION(&pdev->dev); 2143 struct ideapad_private *priv; 2144 acpi_status status; 2145 unsigned long cfg; 2146 int err, i; 2147 2148 if (!adev || eval_int(adev->handle, "_CFG", &cfg)) 2149 return -ENODEV; 2150 2151 priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL); 2152 if (!priv) 2153 return -ENOMEM; 2154 2155 dev_set_drvdata(&pdev->dev, priv); 2156 2157 priv->cfg = cfg; 2158 priv->adev = adev; 2159 priv->platform_device = pdev; 2160 2161 err = devm_mutex_init(&pdev->dev, &priv->vpc_mutex); 2162 if (err) 2163 return err; 2164 2165 ideapad_check_features(priv); 2166 2167 err = ideapad_sysfs_init(priv); 2168 if (err) 2169 return err; 2170 2171 ideapad_debugfs_init(priv); 2172 2173 err = ideapad_input_init(priv); 2174 if (err) 2175 goto input_failed; 2176 2177 err = ideapad_kbd_bl_init(priv); 2178 if (err) { 2179 if (err != -ENODEV) 2180 dev_warn(&pdev->dev, "Could not set up keyboard backlight LED: %d\n", err); 2181 else 2182 dev_info(&pdev->dev, "Keyboard backlight control not available\n"); 2183 } 2184 2185 err = ideapad_fn_lock_led_init(priv); 2186 if (err) { 2187 if (err != -ENODEV) 2188 dev_warn(&pdev->dev, "Could not set up FnLock LED: %d\n", err); 2189 else 2190 dev_info(&pdev->dev, "FnLock control not available\n"); 2191 } 2192 2193 /* 2194 * On some models without a hw-switch (the yoga 2 13 at least) 2195 * VPCCMD_W_RF must be explicitly set to 1 for the wifi to work. 2196 */ 2197 if (!priv->features.hw_rfkill_switch) 2198 write_ec_cmd(priv->adev->handle, VPCCMD_W_RF, 1); 2199 2200 for (i = 0; i < IDEAPAD_RFKILL_DEV_NUM; i++) 2201 if (test_bit(ideapad_rfk_data[i].cfgbit, &priv->cfg)) 2202 ideapad_register_rfkill(priv, i); 2203 2204 ideapad_sync_rfk_state(priv); 2205 ideapad_sync_touchpad_state(priv, false); 2206 2207 err = ideapad_dytc_profile_init(priv); 2208 if (err) { 2209 if (err != -ENODEV) 2210 dev_warn(&pdev->dev, "Could not set up DYTC interface: %d\n", err); 2211 else 2212 dev_info(&pdev->dev, "DYTC interface is not available\n"); 2213 } 2214 2215 if (acpi_video_get_backlight_type() == acpi_backlight_vendor) { 2216 err = ideapad_backlight_init(priv); 2217 if (err && err != -ENODEV) 2218 goto backlight_failed; 2219 } 2220 2221 status = acpi_install_notify_handler(adev->handle, 2222 ACPI_DEVICE_NOTIFY, 2223 ideapad_acpi_notify, priv); 2224 if (ACPI_FAILURE(status)) { 2225 err = -EIO; 2226 goto notification_failed; 2227 } 2228 2229 err = ideapad_shared_init(priv); 2230 if (err) 2231 goto shared_init_failed; 2232 2233 ideapad_laptop_register_notifier(&ideapad_laptop_notifier); 2234 2235 return 0; 2236 2237 shared_init_failed: 2238 acpi_remove_notify_handler(priv->adev->handle, 2239 ACPI_DEVICE_NOTIFY, 2240 ideapad_acpi_notify); 2241 2242 notification_failed: 2243 ideapad_backlight_exit(priv); 2244 2245 backlight_failed: 2246 ideapad_dytc_profile_exit(priv); 2247 2248 for (i = 0; i < IDEAPAD_RFKILL_DEV_NUM; i++) 2249 ideapad_unregister_rfkill(priv, i); 2250 2251 ideapad_fn_lock_led_exit(priv); 2252 ideapad_kbd_bl_exit(priv); 2253 ideapad_input_exit(priv); 2254 2255 input_failed: 2256 ideapad_debugfs_exit(priv); 2257 ideapad_sysfs_exit(priv); 2258 2259 return err; 2260 } 2261 2262 static void ideapad_acpi_remove(struct platform_device *pdev) 2263 { 2264 struct ideapad_private *priv = dev_get_drvdata(&pdev->dev); 2265 int i; 2266 2267 ideapad_laptop_unregister_notifier(&ideapad_laptop_notifier); 2268 2269 ideapad_shared_exit(priv); 2270 2271 acpi_remove_notify_handler(priv->adev->handle, 2272 ACPI_DEVICE_NOTIFY, 2273 ideapad_acpi_notify); 2274 2275 ideapad_backlight_exit(priv); 2276 ideapad_dytc_profile_exit(priv); 2277 2278 for (i = 0; i < IDEAPAD_RFKILL_DEV_NUM; i++) 2279 ideapad_unregister_rfkill(priv, i); 2280 2281 ideapad_fn_lock_led_exit(priv); 2282 ideapad_kbd_bl_exit(priv); 2283 ideapad_input_exit(priv); 2284 ideapad_debugfs_exit(priv); 2285 ideapad_sysfs_exit(priv); 2286 } 2287 2288 #ifdef CONFIG_PM_SLEEP 2289 static int ideapad_acpi_resume(struct device *dev) 2290 { 2291 struct ideapad_private *priv = dev_get_drvdata(dev); 2292 2293 ideapad_sync_rfk_state(priv); 2294 ideapad_sync_touchpad_state(priv, false); 2295 2296 if (priv->dytc) 2297 dytc_profile_refresh(priv); 2298 2299 return 0; 2300 } 2301 #endif 2302 static SIMPLE_DEV_PM_OPS(ideapad_pm, NULL, ideapad_acpi_resume); 2303 2304 static const struct acpi_device_id ideapad_device_ids[] = { 2305 {"VPC2004", 0}, 2306 {"", 0}, 2307 }; 2308 MODULE_DEVICE_TABLE(acpi, ideapad_device_ids); 2309 2310 static struct platform_driver ideapad_acpi_driver = { 2311 .probe = ideapad_acpi_add, 2312 .remove_new = ideapad_acpi_remove, 2313 .driver = { 2314 .name = "ideapad_acpi", 2315 .pm = &ideapad_pm, 2316 .acpi_match_table = ACPI_PTR(ideapad_device_ids), 2317 }, 2318 }; 2319 2320 static int __init ideapad_laptop_init(void) 2321 { 2322 int err; 2323 2324 err = ideapad_wmi_driver_register(); 2325 if (err) 2326 return err; 2327 2328 err = platform_driver_register(&ideapad_acpi_driver); 2329 if (err) { 2330 ideapad_wmi_driver_unregister(); 2331 return err; 2332 } 2333 2334 return 0; 2335 } 2336 module_init(ideapad_laptop_init) 2337 2338 static void __exit ideapad_laptop_exit(void) 2339 { 2340 ideapad_wmi_driver_unregister(); 2341 platform_driver_unregister(&ideapad_acpi_driver); 2342 } 2343 module_exit(ideapad_laptop_exit) 2344 2345 MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>"); 2346 MODULE_DESCRIPTION("IdeaPad ACPI Extras"); 2347 MODULE_LICENSE("GPL"); 2348