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