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