drivers/platform/x86/x86-android-tablets/lenovo.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Board info for Lenovo X86 tablets which ship with Android as the factory image
   4  * and which have broken DSDT tables. The factory kernels shipped on these
   5  * devices typically have a bunch of things hardcoded, rather than specified
   6  * in their DSDT.
   7  *
   8  * Copyright (C) 2021-2023 Hans de Goede <[email protected]>
   9  */
  10
  11 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  12
  13 #include <linux/efi.h>
  14 #include <linux/gpio/machine.h>
  15 #include <linux/mfd/arizona/pdata.h>
  16 #include <linux/mfd/arizona/registers.h>
  17 #include <linux/mfd/intel_soc_pmic.h>
  18 #include <linux/pinctrl/consumer.h>
  19 #include <linux/pinctrl/machine.h>
  20 #include <linux/platform_data/lp855x.h>
  21 #include <linux/platform_device.h>
  22 #include <linux/power/bq24190_charger.h>
  23 #include <linux/reboot.h>
  24 #include <linux/rmi.h>
  25 #include <linux/spi/spi.h>
  26
  27 #include "shared-psy-info.h"
  28 #include "x86-android-tablets.h"
  29
  30 /*
  31  * Various Lenovo models use a TI LP8557 LED backlight controller with its PWM
  32  * input connected to a PWM output coming from the LCD panel's controller.
  33  * The Android kernels have a hack in the i915 driver to write a non-standard
  34  * panel specific DSI register to set the duty-cycle of the LCD's PWM output.
  35  *
  36  * To avoid having to have a similar hack in the mainline kernel program the
  37  * LP8557 to directly set the level and use the lp855x_bl driver for control.
  38  *
  39  * The LP8557 can either be configured to multiply its PWM input and
  40  * the I2C register set level (requiring both to be at 100% for 100% output);
  41  * or to only take the I2C register set level into account.
  42  *
  43  * Multiplying the 2 levels is useful because this will turn off the backlight
  44  * when the panel goes off and turns off its PWM output.
  45  *
  46  * But on some models the panel's PWM output defaults to a duty-cycle of
  47  * much less then 100%, severely limiting max brightness. In this case
  48  * the LP8557 should be configured to only take the I2C register into
  49  * account and the i915 driver must turn off the panel and the backlight
  50  * separately using e.g. VBT MIPI sequences to turn off the backlight.
  51  */
  52 static struct lp855x_platform_data lenovo_lp8557_pwm_and_reg_pdata = {
  53         .device_control = 0x86,
  54         .initial_brightness = 128,
  55 };
  56
  57 static struct lp855x_platform_data lenovo_lp8557_reg_only_pdata = {
  58         .device_control = 0x85,
  59         .initial_brightness = 128,
  60 };
  61
  62 /* Lenovo Yoga Book X90F / X90L's Android factory img has everything hardcoded */
  63
  64 static const struct property_entry lenovo_yb1_x90_wacom_props[] = {
  65         PROPERTY_ENTRY_U32("hid-descr-addr", 0x0001),
  66         PROPERTY_ENTRY_U32("post-reset-deassert-delay-ms", 150),
  67         { }
  68 };
  69
  70 static const struct software_node lenovo_yb1_x90_wacom_node = {
  71         .properties = lenovo_yb1_x90_wacom_props,
  72 };
  73
  74 /*
  75  * The HiDeep IST940E touchscreen comes up in I2C-HID mode. The native protocol
  76  * reports ABS_MT_PRESSURE and ABS_MT_TOUCH_MAJOR which are not reported in HID
  77  * mode, so using native mode is preferred.
  78  * It could alternatively be used in HID mode by changing the properties to:
  79  *      PROPERTY_ENTRY_U32("hid-descr-addr", 0x0020),
  80  *      PROPERTY_ENTRY_U32("post-reset-deassert-delay-ms", 120),
  81  * and changing board_info.type to "hid-over-i2c".
  82  */
  83 static const struct property_entry lenovo_yb1_x90_hideep_ts_props[] = {
  84         PROPERTY_ENTRY_U32("touchscreen-size-x", 1200),
  85         PROPERTY_ENTRY_U32("touchscreen-size-y", 1920),
  86         PROPERTY_ENTRY_U32("touchscreen-max-pressure", 16384),
  87         PROPERTY_ENTRY_BOOL("hideep,force-native-protocol"),
  88         { }
  89 };
  90
  91 static const struct software_node lenovo_yb1_x90_hideep_ts_node = {
  92         .properties = lenovo_yb1_x90_hideep_ts_props,
  93 };
  94
  95 static const struct x86_i2c_client_info lenovo_yb1_x90_i2c_clients[] __initconst = {
  96         {
  97                 /* BQ27542 fuel-gauge */
  98                 .board_info = {
  99                         .type = "bq27542",
 100                         .addr = 0x55,
 101                         .dev_name = "bq27542",
 102                         .swnode = &fg_bq25890_supply_node,
 103                 },
 104                 .adapter_path = "\\_SB_.PCI0.I2C1",
 105         }, {
 106                 /* Goodix Touchscreen in keyboard half */
 107                 .board_info = {
 108                         .type = "GDIX1001:00",
 109                         .addr = 0x14,
 110                         .dev_name = "goodix_ts",
 111                 },
 112                 .adapter_path = "\\_SB_.PCI0.I2C2",
 113                 .irq_data = {
 114                         .type = X86_ACPI_IRQ_TYPE_GPIOINT,
 115                         .chip = "INT33FF:01",
 116                         .index = 56,
 117                         .trigger = ACPI_EDGE_SENSITIVE,
 118                         .polarity = ACPI_ACTIVE_LOW,
 119                         .con_id = "goodix_ts_irq",
 120                         .free_gpio = true,
 121                 },
 122         }, {
 123                 /* Wacom Digitizer in keyboard half */
 124                 .board_info = {
 125                         .type = "hid-over-i2c",
 126                         .addr = 0x09,
 127                         .dev_name = "wacom",
 128                         .swnode = &lenovo_yb1_x90_wacom_node,
 129                 },
 130                 .adapter_path = "\\_SB_.PCI0.I2C4",
 131                 .irq_data = {
 132                         .type = X86_ACPI_IRQ_TYPE_GPIOINT,
 133                         .chip = "INT33FF:01",
 134                         .index = 49,
 135                         .trigger = ACPI_LEVEL_SENSITIVE,
 136                         .polarity = ACPI_ACTIVE_LOW,
 137                         .con_id = "wacom_irq",
 138                 },
 139         }, {
 140                 /* LP8557 Backlight controller */
 141                 .board_info = {
 142                         .type = "lp8557",
 143                         .addr = 0x2c,
 144                         .dev_name = "lp8557",
 145                         .platform_data = &lenovo_lp8557_pwm_and_reg_pdata,
 146                 },
 147                 .adapter_path = "\\_SB_.PCI0.I2C4",
 148         }, {
 149                 /* HiDeep IST940E Touchscreen in display half */
 150                 .board_info = {
 151                         .type = "hideep_ts",
 152                         .addr = 0x6c,
 153                         .dev_name = "hideep_ts",
 154                         .swnode = &lenovo_yb1_x90_hideep_ts_node,
 155                 },
 156                 .adapter_path = "\\_SB_.PCI0.I2C6",
 157                 .irq_data = {
 158                         .type = X86_ACPI_IRQ_TYPE_GPIOINT,
 159                         .chip = "INT33FF:03",
 160                         .index = 77,
 161                         .trigger = ACPI_LEVEL_SENSITIVE,
 162                         .polarity = ACPI_ACTIVE_LOW,
 163                         .con_id = "hideep_ts_irq",
 164                 },
 165         },
 166 };
 167
 168 static const struct platform_device_info lenovo_yb1_x90_pdevs[] __initconst = {
 169         {
 170                 .name = "yogabook-touch-kbd-digitizer-switch",
 171                 .id = PLATFORM_DEVID_NONE,
 172         },
 173 };
 174
 175 /*
 176  * DSDT says UART path is "\\_SB.PCIO.URT1" with a letter 'O' instead of
 177  * the number '0' add the link manually.
 178  */
 179 static const struct x86_serdev_info lenovo_yb1_x90_serdevs[] __initconst = {
 180         {
 181                 .ctrl_hid = "8086228A",
 182                 .ctrl_uid = "1",
 183                 .ctrl_devname = "serial0",
 184                 .serdev_hid = "BCM2E1A",
 185         },
 186 };
 187
 188 static const struct x86_gpio_button lenovo_yb1_x90_lid __initconst = {
 189         .button = {
 190                 .code = SW_LID,
 191                 .active_low = true,
 192                 .desc = "lid_sw",
 193                 .type = EV_SW,
 194                 .wakeup = true,
 195                 .debounce_interval = 50,
 196         },
 197         .chip = "INT33FF:02",
 198         .pin = 19,
 199 };
 200
 201 static struct gpiod_lookup_table lenovo_yb1_x90_goodix_gpios = {
 202         .dev_id = "i2c-goodix_ts",
 203         .table = {
 204                 GPIO_LOOKUP("INT33FF:01", 53, "reset", GPIO_ACTIVE_HIGH),
 205                 GPIO_LOOKUP("INT33FF:01", 56, "irq", GPIO_ACTIVE_HIGH),
 206                 { }
 207         },
 208 };
 209
 210 static struct gpiod_lookup_table lenovo_yb1_x90_hideep_gpios = {
 211         .dev_id = "i2c-hideep_ts",
 212         .table = {
 213                 GPIO_LOOKUP("INT33FF:00", 7, "reset", GPIO_ACTIVE_LOW),
 214                 { }
 215         },
 216 };
 217
 218 static struct gpiod_lookup_table lenovo_yb1_x90_wacom_gpios = {
 219         .dev_id = "i2c-wacom",
 220         .table = {
 221                 GPIO_LOOKUP("INT33FF:00", 82, "reset", GPIO_ACTIVE_LOW),
 222                 { }
 223         },
 224 };
 225
 226 static struct gpiod_lookup_table * const lenovo_yb1_x90_gpios[] = {
 227         &lenovo_yb1_x90_hideep_gpios,
 228         &lenovo_yb1_x90_goodix_gpios,
 229         &lenovo_yb1_x90_wacom_gpios,
 230         NULL
 231 };
 232
 233 static int __init lenovo_yb1_x90_init(struct device *dev)
 234 {
 235         /* Enable the regulators used by the touchscreens */
 236
 237         /* Vprog3B 3.0V used by the goodix touchscreen in the keyboard half */
 238         intel_soc_pmic_exec_mipi_pmic_seq_element(0x6e, 0x9b, 0x02, 0xff);
 239
 240         /* Vprog4D 3.0V used by the HiDeep touchscreen in the display half */
 241         intel_soc_pmic_exec_mipi_pmic_seq_element(0x6e, 0x9f, 0x02, 0xff);
 242
 243         /* Vprog5A 1.8V used by the HiDeep touchscreen in the display half */
 244         intel_soc_pmic_exec_mipi_pmic_seq_element(0x6e, 0xa0, 0x02, 0xff);
 245
 246         /* Vprog5B 1.8V used by the goodix touchscreen in the keyboard half */
 247         intel_soc_pmic_exec_mipi_pmic_seq_element(0x6e, 0xa1, 0x02, 0xff);
 248
 249         return 0;
 250 }
 251
 252 const struct x86_dev_info lenovo_yogabook_x90_info __initconst = {
 253         .i2c_client_info = lenovo_yb1_x90_i2c_clients,
 254         .i2c_client_count = ARRAY_SIZE(lenovo_yb1_x90_i2c_clients),
 255         .pdev_info = lenovo_yb1_x90_pdevs,
 256         .pdev_count = ARRAY_SIZE(lenovo_yb1_x90_pdevs),
 257         .serdev_info = lenovo_yb1_x90_serdevs,
 258         .serdev_count = ARRAY_SIZE(lenovo_yb1_x90_serdevs),
 259         .gpio_button = &lenovo_yb1_x90_lid,
 260         .gpio_button_count = 1,
 261         .gpiod_lookup_tables = lenovo_yb1_x90_gpios,
 262         .init = lenovo_yb1_x90_init,
 263 };
 264
 265 /* Lenovo Yoga Book X91F/L Windows tablet needs manual instantiation of the fg client */
 266 static const struct x86_i2c_client_info lenovo_yogabook_x91_i2c_clients[] __initconst = {
 267         {
 268                 /* BQ27542 fuel-gauge */
 269                 .board_info = {
 270                         .type = "bq27542",
 271                         .addr = 0x55,
 272                         .dev_name = "bq27542",
 273                         .swnode = &fg_bq25890_supply_node,
 274                 },
 275                 .adapter_path = "\\_SB_.PCI0.I2C1",
 276         },
 277 };
 278
 279 const struct x86_dev_info lenovo_yogabook_x91_info __initconst = {
 280         .i2c_client_info = lenovo_yogabook_x91_i2c_clients,
 281         .i2c_client_count = ARRAY_SIZE(lenovo_yogabook_x91_i2c_clients),
 282 };
 283
 284 /* Lenovo Yoga Tablet 2 1050F/L's Android factory img has everything hardcoded */
 285 static const struct property_entry lenovo_yoga_tab2_830_1050_bq24190_props[] = {
 286         PROPERTY_ENTRY_STRING_ARRAY_LEN("supplied-from", tusb1211_chg_det_psy, 1),
 287         PROPERTY_ENTRY_REF("monitored-battery", &generic_lipo_hv_4v35_battery_node),
 288         PROPERTY_ENTRY_BOOL("omit-battery-class"),
 289         PROPERTY_ENTRY_BOOL("disable-reset"),
 290         { }
 291 };
 292
 293 static const struct software_node lenovo_yoga_tab2_830_1050_bq24190_node = {
 294         .properties = lenovo_yoga_tab2_830_1050_bq24190_props,
 295 };
 296
 297 static const struct x86_gpio_button lenovo_yoga_tab2_830_1050_lid __initconst = {
 298         .button = {
 299                 .code = SW_LID,
 300                 .active_low = true,
 301                 .desc = "lid_sw",
 302                 .type = EV_SW,
 303                 .wakeup = true,
 304                 .debounce_interval = 50,
 305         },
 306         .chip = "INT33FC:02",
 307         .pin = 26,
 308 };
 309
 310 /* This gets filled by lenovo_yoga_tab2_830_1050_init() */
 311 static struct rmi_device_platform_data lenovo_yoga_tab2_830_1050_rmi_pdata = { };
 312
 313 static struct x86_i2c_client_info lenovo_yoga_tab2_830_1050_i2c_clients[] __initdata = {
 314         {
 315                 /*
 316                  * This must be the first entry because lenovo_yoga_tab2_830_1050_init()
 317                  * may update its swnode. LSM303DA accelerometer + magnetometer.
 318                  */
 319                 .board_info = {
 320                         .type = "lsm303d",
 321                         .addr = 0x1d,
 322                         .dev_name = "lsm303d",
 323                 },
 324                 .adapter_path = "\\_SB_.I2C5",
 325         }, {
 326                 /* AL3320A ambient light sensor */
 327                 .board_info = {
 328                         .type = "al3320a",
 329                         .addr = 0x1c,
 330                         .dev_name = "al3320a",
 331                 },
 332                 .adapter_path = "\\_SB_.I2C5",
 333         }, {
 334                 /* bq24292i battery charger */
 335                 .board_info = {
 336                         .type = "bq24190",
 337                         .addr = 0x6b,
 338                         .dev_name = "bq24292i",
 339                         .swnode = &lenovo_yoga_tab2_830_1050_bq24190_node,
 340                         .platform_data = &bq24190_pdata,
 341                 },
 342                 .adapter_path = "\\_SB_.I2C1",
 343                 .irq_data = {
 344                         .type = X86_ACPI_IRQ_TYPE_GPIOINT,
 345                         .chip = "INT33FC:02",
 346                         .index = 2,
 347                         .trigger = ACPI_EDGE_SENSITIVE,
 348                         .polarity = ACPI_ACTIVE_HIGH,
 349                         .con_id = "bq24292i_irq",
 350                 },
 351         }, {
 352                 /* BQ27541 fuel-gauge */
 353                 .board_info = {
 354                         .type = "bq27541",
 355                         .addr = 0x55,
 356                         .dev_name = "bq27541",
 357                         .swnode = &fg_bq24190_supply_node,
 358                 },
 359                 .adapter_path = "\\_SB_.I2C1",
 360         }, {
 361                 /* Synaptics RMI touchscreen */
 362                 .board_info = {
 363                         .type = "rmi4_i2c",
 364                         .addr = 0x38,
 365                         .dev_name = "rmi4_i2c",
 366                         .platform_data = &lenovo_yoga_tab2_830_1050_rmi_pdata,
 367                 },
 368                 .adapter_path = "\\_SB_.I2C6",
 369                 .irq_data = {
 370                         .type = X86_ACPI_IRQ_TYPE_APIC,
 371                         .index = 0x45,
 372                         .trigger = ACPI_EDGE_SENSITIVE,
 373                         .polarity = ACPI_ACTIVE_HIGH,
 374                 },
 375         }, {
 376                 /* LP8557 Backlight controller */
 377                 .board_info = {
 378                         .type = "lp8557",
 379                         .addr = 0x2c,
 380                         .dev_name = "lp8557",
 381                         .platform_data = &lenovo_lp8557_pwm_and_reg_pdata,
 382                 },
 383                 .adapter_path = "\\_SB_.I2C3",
 384         },
 385 };
 386
 387 static struct gpiod_lookup_table lenovo_yoga_tab2_830_1050_int3496_gpios = {
 388         .dev_id = "intel-int3496",
 389         .table = {
 390                 GPIO_LOOKUP("INT33FC:02", 1, "mux", GPIO_ACTIVE_LOW),
 391                 GPIO_LOOKUP("INT33FC:02", 24, "id", GPIO_ACTIVE_HIGH),
 392                 { }
 393         },
 394 };
 395
 396 #define LENOVO_YOGA_TAB2_830_1050_CODEC_NAME "spi-10WM5102:00"
 397
 398 static struct gpiod_lookup_table lenovo_yoga_tab2_830_1050_codec_gpios = {
 399         .dev_id = LENOVO_YOGA_TAB2_830_1050_CODEC_NAME,
 400         .table = {
 401                 GPIO_LOOKUP("gpio_crystalcove", 3, "reset", GPIO_ACTIVE_HIGH),
 402                 GPIO_LOOKUP("INT33FC:01", 23, "wlf,ldoena", GPIO_ACTIVE_HIGH),
 403                 GPIO_LOOKUP("arizona", 2, "wlf,spkvdd-ena", GPIO_ACTIVE_HIGH),
 404                 GPIO_LOOKUP("arizona", 4, "wlf,micd-pol", GPIO_ACTIVE_LOW),
 405                 { }
 406         },
 407 };
 408
 409 static struct gpiod_lookup_table * const lenovo_yoga_tab2_830_1050_gpios[] = {
 410         &lenovo_yoga_tab2_830_1050_int3496_gpios,
 411         &lenovo_yoga_tab2_830_1050_codec_gpios,
 412         NULL
 413 };
 414
 415 static int __init lenovo_yoga_tab2_830_1050_init(struct device *dev);
 416 static void lenovo_yoga_tab2_830_1050_exit(void);
 417
 418 const struct x86_dev_info lenovo_yoga_tab2_830_1050_info __initconst = {
 419         .i2c_client_info = lenovo_yoga_tab2_830_1050_i2c_clients,
 420         .i2c_client_count = ARRAY_SIZE(lenovo_yoga_tab2_830_1050_i2c_clients),
 421         .pdev_info = int3496_pdevs,
 422         .pdev_count = 1,
 423         .gpio_button = &lenovo_yoga_tab2_830_1050_lid,
 424         .gpio_button_count = 1,
 425         .gpiod_lookup_tables = lenovo_yoga_tab2_830_1050_gpios,
 426         .bat_swnode = &generic_lipo_hv_4v35_battery_node,
 427         .modules = bq24190_modules,
 428         .init = lenovo_yoga_tab2_830_1050_init,
 429         .exit = lenovo_yoga_tab2_830_1050_exit,
 430 };
 431
 432 /*
 433  * The Lenovo Yoga Tablet 2 830 and 1050 (8" vs 10") versions use the same
 434  * mainboard, but the 830 uses a portrait LCD panel with a landscape touchscreen,
 435  * requiring the touchscreen driver to adjust the touch-coords to match the LCD.
 436  * And requiring the accelerometer to have a mount-matrix set to correct for
 437  * the 90° rotation of the LCD vs the frame.
 438  */
 439 static const char * const lenovo_yoga_tab2_830_lms303d_mount_matrix[] = {
 440         "0", "1", "0",
 441         "-1", "0", "0",
 442         "0", "0", "1"
 443 };
 444
 445 static const struct property_entry lenovo_yoga_tab2_830_lms303d_props[] = {
 446         PROPERTY_ENTRY_STRING_ARRAY("mount-matrix", lenovo_yoga_tab2_830_lms303d_mount_matrix),
 447         { }
 448 };
 449
 450 static const struct software_node lenovo_yoga_tab2_830_lms303d_node = {
 451         .properties = lenovo_yoga_tab2_830_lms303d_props,
 452 };
 453
 454 static int __init lenovo_yoga_tab2_830_1050_init_touchscreen(void)
 455 {
 456         struct gpio_desc *gpiod;
 457         int ret;
 458
 459         /* Use PMIC GPIO 10 bootstrap pin to differentiate 830 vs 1050 */
 460         ret = x86_android_tablet_get_gpiod("gpio_crystalcove", 10, "yoga_bootstrap",
 461                                            false, GPIOD_ASIS, &gpiod);
 462         if (ret)
 463                 return ret;
 464
 465         ret = gpiod_get_value_cansleep(gpiod);
 466         if (ret) {
 467                 pr_info("detected Lenovo Yoga Tablet 2 1050F/L\n");
 468         } else {
 469                 pr_info("detected Lenovo Yoga Tablet 2 830F/L\n");
 470                 lenovo_yoga_tab2_830_1050_rmi_pdata.sensor_pdata.axis_align.swap_axes = true;
 471                 lenovo_yoga_tab2_830_1050_rmi_pdata.sensor_pdata.axis_align.flip_y = true;
 472                 lenovo_yoga_tab2_830_1050_i2c_clients[0].board_info.swnode =
 473                         &lenovo_yoga_tab2_830_lms303d_node;
 474         }
 475
 476         return 0;
 477 }
 478
 479 /* SUS (INT33FC:02) pin 6 needs to be configured as pmu_clk for the audio codec */
 480 static const struct pinctrl_map lenovo_yoga_tab2_830_1050_codec_pinctrl_map =
 481         PIN_MAP_MUX_GROUP(LENOVO_YOGA_TAB2_830_1050_CODEC_NAME, "codec_32khz_clk",
 482                           "INT33FC:02", "pmu_clk2_grp", "pmu_clk");
 483
 484 static struct pinctrl *lenovo_yoga_tab2_830_1050_codec_pinctrl;
 485 static struct sys_off_handler *lenovo_yoga_tab2_830_1050_sys_off_handler;
 486
 487 static int __init lenovo_yoga_tab2_830_1050_init_codec(void)
 488 {
 489         struct device *codec_dev;
 490         struct pinctrl *pinctrl;
 491         int ret;
 492
 493         codec_dev = bus_find_device_by_name(&spi_bus_type, NULL,
 494                                             LENOVO_YOGA_TAB2_830_1050_CODEC_NAME);
 495         if (!codec_dev) {
 496                 pr_err("error cannot find %s device\n", LENOVO_YOGA_TAB2_830_1050_CODEC_NAME);
 497                 return -ENODEV;
 498         }
 499
 500         ret = pinctrl_register_mappings(&lenovo_yoga_tab2_830_1050_codec_pinctrl_map, 1);
 501         if (ret)
 502                 goto err_put_device;
 503
 504         pinctrl = pinctrl_get_select(codec_dev, "codec_32khz_clk");
 505         if (IS_ERR(pinctrl)) {
 506                 ret = dev_err_probe(codec_dev, PTR_ERR(pinctrl), "selecting codec_32khz_clk\n");
 507                 goto err_unregister_mappings;
 508         }
 509
 510         /* We're done with the codec_dev now */
 511         put_device(codec_dev);
 512
 513         lenovo_yoga_tab2_830_1050_codec_pinctrl = pinctrl;
 514         return 0;
 515
 516 err_unregister_mappings:
 517         pinctrl_unregister_mappings(&lenovo_yoga_tab2_830_1050_codec_pinctrl_map);
 518 err_put_device:
 519         put_device(codec_dev);
 520         return ret;
 521 }
 522
 523 /*
 524  * These tablet's DSDT does not set acpi_gbl_reduced_hardware, so acpi_power_off
 525  * gets used as pm_power_off handler. This causes "poweroff" on these tablets
 526  * to hang hard. Requiring pressing the powerbutton for 30 seconds *twice*
 527  * followed by a normal 3 second press to recover. Avoid this by doing an EFI
 528  * poweroff instead.
 529  */
 530 static int lenovo_yoga_tab2_830_1050_power_off(struct sys_off_data *data)
 531 {
 532         efi.reset_system(EFI_RESET_SHUTDOWN, EFI_SUCCESS, 0, NULL);
 533
 534         return NOTIFY_DONE;
 535 }
 536
 537 static int __init lenovo_yoga_tab2_830_1050_init(struct device *dev)
 538 {
 539         int ret;
 540
 541         ret = lenovo_yoga_tab2_830_1050_init_touchscreen();
 542         if (ret)
 543                 return ret;
 544
 545         ret = lenovo_yoga_tab2_830_1050_init_codec();
 546         if (ret)
 547                 return ret;
 548
 549         /* SYS_OFF_PRIO_FIRMWARE + 1 so that it runs before acpi_power_off */
 550         lenovo_yoga_tab2_830_1050_sys_off_handler =
 551                 register_sys_off_handler(SYS_OFF_MODE_POWER_OFF, SYS_OFF_PRIO_FIRMWARE + 1,
 552                                          lenovo_yoga_tab2_830_1050_power_off, NULL);
 553         if (IS_ERR(lenovo_yoga_tab2_830_1050_sys_off_handler))
 554                 return PTR_ERR(lenovo_yoga_tab2_830_1050_sys_off_handler);
 555
 556         return 0;
 557 }
 558
 559 static void lenovo_yoga_tab2_830_1050_exit(void)
 560 {
 561         unregister_sys_off_handler(lenovo_yoga_tab2_830_1050_sys_off_handler);
 562
 563         if (lenovo_yoga_tab2_830_1050_codec_pinctrl) {
 564                 pinctrl_put(lenovo_yoga_tab2_830_1050_codec_pinctrl);
 565                 pinctrl_unregister_mappings(&lenovo_yoga_tab2_830_1050_codec_pinctrl_map);
 566         }
 567 }
 568
 569 /*
 570  * Lenovo Yoga Tablet 2 Pro 1380F/L
 571  *
 572  * The Lenovo Yoga Tablet 2 Pro 1380F/L mostly has the same design as the 830F/L
 573  * and the 1050F/L so this re-uses some of the handling for that from above.
 574  */
 575 static const char * const lc824206xa_chg_det_psy[] = { "lc824206xa-charger-detect" };
 576
 577 static const struct property_entry lenovo_yoga_tab2_1380_bq24190_props[] = {
 578         PROPERTY_ENTRY_STRING_ARRAY("supplied-from", lc824206xa_chg_det_psy),
 579         PROPERTY_ENTRY_REF("monitored-battery", &generic_lipo_hv_4v35_battery_node),
 580         PROPERTY_ENTRY_BOOL("omit-battery-class"),
 581         PROPERTY_ENTRY_BOOL("disable-reset"),
 582         { }
 583 };
 584
 585 static const struct software_node lenovo_yoga_tab2_1380_bq24190_node = {
 586         .properties = lenovo_yoga_tab2_1380_bq24190_props,
 587 };
 588
 589 /* For enabling the bq24190 5V boost based on id-pin */
 590 static struct regulator_consumer_supply lc824206xa_consumer = {
 591         .supply = "vbus",
 592         .dev_name = "i2c-lc824206xa",
 593 };
 594
 595 static const struct regulator_init_data lenovo_yoga_tab2_1380_bq24190_vbus_init_data = {
 596         .constraints = {
 597                 .name = "bq24190_vbus",
 598                 .valid_ops_mask = REGULATOR_CHANGE_STATUS,
 599         },
 600         .consumer_supplies = &lc824206xa_consumer,
 601         .num_consumer_supplies = 1,
 602 };
 603
 604 struct bq24190_platform_data lenovo_yoga_tab2_1380_bq24190_pdata = {
 605         .regulator_init_data = &lenovo_yoga_tab2_1380_bq24190_vbus_init_data,
 606 };
 607
 608 static const struct property_entry lenovo_yoga_tab2_1380_lc824206xa_props[] = {
 609         PROPERTY_ENTRY_BOOL("onnn,enable-miclr-for-dcp"),
 610         { }
 611 };
 612
 613 static const struct software_node lenovo_yoga_tab2_1380_lc824206xa_node = {
 614         .properties = lenovo_yoga_tab2_1380_lc824206xa_props,
 615 };
 616
 617 static const char * const lenovo_yoga_tab2_1380_lms303d_mount_matrix[] = {
 618         "0", "-1", "0",
 619         "-1", "0", "0",
 620         "0", "0", "1"
 621 };
 622
 623 static const struct property_entry lenovo_yoga_tab2_1380_lms303d_props[] = {
 624         PROPERTY_ENTRY_STRING_ARRAY("mount-matrix", lenovo_yoga_tab2_1380_lms303d_mount_matrix),
 625         { }
 626 };
 627
 628 static const struct software_node lenovo_yoga_tab2_1380_lms303d_node = {
 629         .properties = lenovo_yoga_tab2_1380_lms303d_props,
 630 };
 631
 632 static const struct x86_i2c_client_info lenovo_yoga_tab2_1380_i2c_clients[] __initconst = {
 633         {
 634                 /* BQ27541 fuel-gauge */
 635                 .board_info = {
 636                         .type = "bq27541",
 637                         .addr = 0x55,
 638                         .dev_name = "bq27541",
 639                         .swnode = &fg_bq24190_supply_node,
 640                 },
 641                 .adapter_path = "\\_SB_.I2C1",
 642         }, {
 643                 /* bq24292i battery charger */
 644                 .board_info = {
 645                         .type = "bq24190",
 646                         .addr = 0x6b,
 647                         .dev_name = "bq24292i",
 648                         .swnode = &lenovo_yoga_tab2_1380_bq24190_node,
 649                         .platform_data = &lenovo_yoga_tab2_1380_bq24190_pdata,
 650                 },
 651                 .adapter_path = "\\_SB_.I2C1",
 652                 .irq_data = {
 653                         .type = X86_ACPI_IRQ_TYPE_GPIOINT,
 654                         .chip = "INT33FC:02",
 655                         .index = 2,
 656                         .trigger = ACPI_EDGE_SENSITIVE,
 657                         .polarity = ACPI_ACTIVE_HIGH,
 658                         .con_id = "bq24292i_irq",
 659                 },
 660         }, {
 661                 /* LP8557 Backlight controller */
 662                 .board_info = {
 663                         .type = "lp8557",
 664                         .addr = 0x2c,
 665                         .dev_name = "lp8557",
 666                         .platform_data = &lenovo_lp8557_pwm_and_reg_pdata,
 667                 },
 668                 .adapter_path = "\\_SB_.I2C3",
 669         }, {
 670                 /* LC824206XA Micro USB Switch */
 671                 .board_info = {
 672                         .type = "lc824206xa",
 673                         .addr = 0x48,
 674                         .dev_name = "lc824206xa",
 675                         .swnode = &lenovo_yoga_tab2_1380_lc824206xa_node,
 676                 },
 677                 .adapter_path = "\\_SB_.I2C3",
 678                 .irq_data = {
 679                         .type = X86_ACPI_IRQ_TYPE_GPIOINT,
 680                         .chip = "INT33FC:02",
 681                         .index = 1,
 682                         .trigger = ACPI_LEVEL_SENSITIVE,
 683                         .polarity = ACPI_ACTIVE_LOW,
 684                         .con_id = "lc824206xa_irq",
 685                 },
 686         }, {
 687                 /* AL3320A ambient light sensor */
 688                 .board_info = {
 689                         .type = "al3320a",
 690                         .addr = 0x1c,
 691                         .dev_name = "al3320a",
 692                 },
 693                 .adapter_path = "\\_SB_.I2C5",
 694         }, {
 695                 /* LSM303DA accelerometer + magnetometer */
 696                 .board_info = {
 697                         .type = "lsm303d",
 698                         .addr = 0x1d,
 699                         .dev_name = "lsm303d",
 700                         .swnode = &lenovo_yoga_tab2_1380_lms303d_node,
 701                 },
 702                 .adapter_path = "\\_SB_.I2C5",
 703         }, {
 704                 /* Synaptics RMI touchscreen */
 705                 .board_info = {
 706                         .type = "rmi4_i2c",
 707                         .addr = 0x38,
 708                         .dev_name = "rmi4_i2c",
 709                         .platform_data = &lenovo_yoga_tab2_830_1050_rmi_pdata,
 710                 },
 711                 .adapter_path = "\\_SB_.I2C6",
 712                 .irq_data = {
 713                         .type = X86_ACPI_IRQ_TYPE_APIC,
 714                         .index = 0x45,
 715                         .trigger = ACPI_EDGE_SENSITIVE,
 716                         .polarity = ACPI_ACTIVE_HIGH,
 717                 },
 718         }
 719 };
 720
 721 static const struct platform_device_info lenovo_yoga_tab2_1380_pdevs[] __initconst = {
 722         {
 723                 /* For the Tablet 2 Pro 1380's custom fast charging driver */
 724                 .name = "lenovo-yoga-tab2-pro-1380-fastcharger",
 725                 .id = PLATFORM_DEVID_NONE,
 726         },
 727 };
 728
 729 const char * const lenovo_yoga_tab2_1380_modules[] __initconst = {
 730         "bq24190_charger",            /* For the Vbus regulator for lc824206xa */
 731         NULL
 732 };
 733
 734 static int __init lenovo_yoga_tab2_1380_init(struct device *dev)
 735 {
 736         int ret;
 737
 738         /* To verify that the DMI matching works vs the 830 / 1050 models */
 739         pr_info("detected Lenovo Yoga Tablet 2 Pro 1380F/L\n");
 740
 741         ret = lenovo_yoga_tab2_830_1050_init_codec();
 742         if (ret)
 743                 return ret;
 744
 745         /* SYS_OFF_PRIO_FIRMWARE + 1 so that it runs before acpi_power_off */
 746         lenovo_yoga_tab2_830_1050_sys_off_handler =
 747                 register_sys_off_handler(SYS_OFF_MODE_POWER_OFF, SYS_OFF_PRIO_FIRMWARE + 1,
 748                                          lenovo_yoga_tab2_830_1050_power_off, NULL);
 749         if (IS_ERR(lenovo_yoga_tab2_830_1050_sys_off_handler))
 750                 return PTR_ERR(lenovo_yoga_tab2_830_1050_sys_off_handler);
 751
 752         return 0;
 753 }
 754
 755 static struct gpiod_lookup_table lenovo_yoga_tab2_1380_fc_gpios = {
 756         .dev_id = "serial0-0",
 757         .table = {
 758                 GPIO_LOOKUP("INT33FC:00", 57, "uart3_txd", GPIO_ACTIVE_HIGH),
 759                 GPIO_LOOKUP("INT33FC:00", 61, "uart3_rxd", GPIO_ACTIVE_HIGH),
 760                 { }
 761         },
 762 };
 763
 764 static struct gpiod_lookup_table * const lenovo_yoga_tab2_1380_gpios[] = {
 765         &lenovo_yoga_tab2_830_1050_codec_gpios,
 766         &lenovo_yoga_tab2_1380_fc_gpios,
 767         NULL
 768 };
 769
 770 const struct x86_dev_info lenovo_yoga_tab2_1380_info __initconst = {
 771         .i2c_client_info = lenovo_yoga_tab2_1380_i2c_clients,
 772         .i2c_client_count = ARRAY_SIZE(lenovo_yoga_tab2_1380_i2c_clients),
 773         .pdev_info = lenovo_yoga_tab2_1380_pdevs,
 774         .pdev_count = ARRAY_SIZE(lenovo_yoga_tab2_1380_pdevs),
 775         .gpio_button = &lenovo_yoga_tab2_830_1050_lid,
 776         .gpio_button_count = 1,
 777         .gpiod_lookup_tables = lenovo_yoga_tab2_1380_gpios,
 778         .bat_swnode = &generic_lipo_hv_4v35_battery_node,
 779         .modules = lenovo_yoga_tab2_1380_modules,
 780         .init = lenovo_yoga_tab2_1380_init,
 781         .exit = lenovo_yoga_tab2_830_1050_exit,
 782 };
 783
 784 /* Lenovo Yoga Tab 3 Pro YT3-X90F */
 785
 786 /*
 787  * There are 2 batteries, with 2 bq27500 fuel-gauges and 2 bq25892 chargers,
 788  * "bq25890-charger-1" is instantiated from: drivers/i2c/busses/i2c-cht-wc.c.
 789  */
 790 static const char * const lenovo_yt3_bq25892_0_suppliers[] = { "cht_wcove_pwrsrc" };
 791 static const char * const bq25890_1_psy[] = { "bq25890-charger-1" };
 792
 793 static const struct property_entry fg_bq25890_1_supply_props[] = {
 794         PROPERTY_ENTRY_STRING_ARRAY("supplied-from", bq25890_1_psy),
 795         { }
 796 };
 797
 798 static const struct software_node fg_bq25890_1_supply_node = {
 799         .properties = fg_bq25890_1_supply_props,
 800 };
 801
 802 /* bq25892 charger settings for the flat lipo battery behind the screen */
 803 static const struct property_entry lenovo_yt3_bq25892_0_props[] = {
 804         PROPERTY_ENTRY_STRING_ARRAY("supplied-from", lenovo_yt3_bq25892_0_suppliers),
 805         PROPERTY_ENTRY_U32("linux,iinlim-percentage", 40),
 806         PROPERTY_ENTRY_BOOL("linux,skip-reset"),
 807         /* Values taken from Android Factory Image */
 808         PROPERTY_ENTRY_U32("ti,charge-current", 2048000),
 809         PROPERTY_ENTRY_U32("ti,battery-regulation-voltage", 4352000),
 810         PROPERTY_ENTRY_U32("ti,termination-current", 128000),
 811         PROPERTY_ENTRY_U32("ti,precharge-current", 128000),
 812         PROPERTY_ENTRY_U32("ti,minimum-sys-voltage", 3700000),
 813         PROPERTY_ENTRY_U32("ti,boost-voltage", 4998000),
 814         PROPERTY_ENTRY_U32("ti,boost-max-current", 500000),
 815         PROPERTY_ENTRY_BOOL("ti,use-ilim-pin"),
 816         { }
 817 };
 818
 819 static const struct software_node lenovo_yt3_bq25892_0_node = {
 820         .properties = lenovo_yt3_bq25892_0_props,
 821 };
 822
 823 static const struct property_entry lenovo_yt3_hideep_ts_props[] = {
 824         PROPERTY_ENTRY_U32("touchscreen-size-x", 1600),
 825         PROPERTY_ENTRY_U32("touchscreen-size-y", 2560),
 826         PROPERTY_ENTRY_U32("touchscreen-max-pressure", 255),
 827         { }
 828 };
 829
 830 static const struct software_node lenovo_yt3_hideep_ts_node = {
 831         .properties = lenovo_yt3_hideep_ts_props,
 832 };
 833
 834 static const struct x86_i2c_client_info lenovo_yt3_i2c_clients[] __initconst = {
 835         {
 836                 /* bq27500 fuel-gauge for the flat lipo battery behind the screen */
 837                 .board_info = {
 838                         .type = "bq27500",
 839                         .addr = 0x55,
 840                         .dev_name = "bq27500_0",
 841                         .swnode = &fg_bq25890_supply_node,
 842                 },
 843                 .adapter_path = "\\_SB_.PCI0.I2C1",
 844         }, {
 845                 /* bq25892 charger for the flat lipo battery behind the screen */
 846                 .board_info = {
 847                         .type = "bq25892",
 848                         .addr = 0x6b,
 849                         .dev_name = "bq25892_0",
 850                         .swnode = &lenovo_yt3_bq25892_0_node,
 851                 },
 852                 .adapter_path = "\\_SB_.PCI0.I2C1",
 853                 .irq_data = {
 854                         .type = X86_ACPI_IRQ_TYPE_GPIOINT,
 855                         .chip = "INT33FF:01",
 856                         .index = 5,
 857                         .trigger = ACPI_EDGE_SENSITIVE,
 858                         .polarity = ACPI_ACTIVE_LOW,
 859                         .con_id = "bq25892_0_irq",
 860                 },
 861         }, {
 862                 /* bq27500 fuel-gauge for the round li-ion cells in the hinge */
 863                 .board_info = {
 864                         .type = "bq27500",
 865                         .addr = 0x55,
 866                         .dev_name = "bq27500_1",
 867                         .swnode = &fg_bq25890_1_supply_node,
 868                 },
 869                 .adapter_path = "\\_SB_.PCI0.I2C2",
 870         }, {
 871                 /* HiDeep IST520E Touchscreen */
 872                 .board_info = {
 873                         .type = "hideep_ts",
 874                         .addr = 0x6c,
 875                         .dev_name = "hideep_ts",
 876                         .swnode = &lenovo_yt3_hideep_ts_node,
 877                 },
 878                 .adapter_path = "\\_SB_.PCI0.I2C6",
 879                 .irq_data = {
 880                         .type = X86_ACPI_IRQ_TYPE_GPIOINT,
 881                         .chip = "INT33FF:03",
 882                         .index = 77,
 883                         .trigger = ACPI_LEVEL_SENSITIVE,
 884                         .polarity = ACPI_ACTIVE_LOW,
 885                         .con_id = "hideep_ts_irq",
 886                 },
 887         }, {
 888                 /* LP8557 Backlight controller */
 889                 .board_info = {
 890                         .type = "lp8557",
 891                         .addr = 0x2c,
 892                         .dev_name = "lp8557",
 893                         .platform_data = &lenovo_lp8557_reg_only_pdata,
 894                 },
 895                 .adapter_path = "\\_SB_.PCI0.I2C1",
 896         }
 897 };
 898
 899 /*
 900  * The AOSP 3.5 mm Headset: Accessory Specification gives the following values:
 901  * Function A Play/Pause:           0 ohm
 902  * Function D Voice assistant:    135 ohm
 903  * Function B Volume Up           240 ohm
 904  * Function C Volume Down         470 ohm
 905  * Minimum Mic DC resistance     1000 ohm
 906  * Minimum Ear speaker impedance   16 ohm
 907  * Note the first max value below must be less then the min. speaker impedance,
 908  * to allow CTIA/OMTP detection to work. The other max values are the closest
 909  * value from extcon-arizona.c:arizona_micd_levels halfway 2 button resistances.
 910  */
 911 static const struct arizona_micd_range arizona_micd_aosp_ranges[] = {
 912         { .max =  11, .key = KEY_PLAYPAUSE },
 913         { .max = 186, .key = KEY_VOICECOMMAND },
 914         { .max = 348, .key = KEY_VOLUMEUP },
 915         { .max = 752, .key = KEY_VOLUMEDOWN },
 916 };
 917
 918 /* YT3 WM5102 arizona_micd_config comes from Android kernel sources */
 919 static struct arizona_micd_config lenovo_yt3_wm5102_micd_config[] = {
 920         { 0, 1, 0 },
 921         { ARIZONA_ACCDET_SRC, 2, 1 },
 922 };
 923
 924 static struct arizona_pdata lenovo_yt3_wm5102_pdata = {
 925         .irq_flags = IRQF_TRIGGER_LOW,
 926         .micd_detect_debounce = 200,
 927         .micd_ranges = arizona_micd_aosp_ranges,
 928         .num_micd_ranges = ARRAY_SIZE(arizona_micd_aosp_ranges),
 929         .hpdet_channel = ARIZONA_ACCDET_MODE_HPL,
 930
 931         /* Below settings come from Android kernel sources */
 932         .micd_bias_start_time = 1,
 933         .micd_rate = 6,
 934         .micd_configs = lenovo_yt3_wm5102_micd_config,
 935         .num_micd_configs = ARRAY_SIZE(lenovo_yt3_wm5102_micd_config),
 936         .micbias = {
 937                 [0] = { /* MICBIAS1 */
 938                         .mV = 2800,
 939                         .ext_cap = 1,
 940                         .discharge = 1,
 941                         .soft_start = 0,
 942                         .bypass = 0,
 943                 },
 944                 [1] = { /* MICBIAS2 */
 945                         .mV = 2800,
 946                         .ext_cap = 1,
 947                         .discharge = 1,
 948                         .soft_start = 0,
 949                         .bypass = 0,
 950                 },
 951                 [2] = { /* MICBIAS2 */
 952                         .mV = 2800,
 953                         .ext_cap = 1,
 954                         .discharge = 1,
 955                         .soft_start = 0,
 956                         .bypass = 0,
 957                 },
 958         },
 959 };
 960
 961 static const struct x86_spi_dev_info lenovo_yt3_spi_devs[] __initconst = {
 962         {
 963                 /* WM5102 codec */
 964                 .board_info = {
 965                         .modalias = "wm5102",
 966                         .platform_data = &lenovo_yt3_wm5102_pdata,
 967                         .max_speed_hz = 5000000,
 968                 },
 969                 .ctrl_path = "\\_SB_.PCI0.SPI1",
 970                 .irq_data = {
 971                         .type = X86_ACPI_IRQ_TYPE_GPIOINT,
 972                         .chip = "INT33FF:00",
 973                         .index = 91,
 974                         .trigger = ACPI_LEVEL_SENSITIVE,
 975                         .polarity = ACPI_ACTIVE_LOW,
 976                         .con_id = "wm5102_irq",
 977                 },
 978         }
 979 };
 980
 981 static int __init lenovo_yt3_init(struct device *dev)
 982 {
 983         int ret;
 984
 985         /*
 986          * The "bq25892_0" charger IC has its /CE (Charge-Enable) and OTG pins
 987          * connected to GPIOs, rather then having them hardwired to the correct
 988          * values as is normally done.
 989          *
 990          * The bq25890_charger driver controls these through I2C, but this only
 991          * works if not overridden by the pins. Set these pins here:
 992          * 1. Set /CE to 1 to allow charging.
 993          * 2. Set OTG to 0 disable V5 boost output since the 5V boost output of
 994          *    the main "bq25892_1" charger is used when necessary.
 995          */
 996
 997         /* /CE pin */
 998         ret = x86_android_tablet_get_gpiod("INT33FF:02", 22, "bq25892_0_ce",
 999                                            true, GPIOD_OUT_HIGH, NULL);
1000         if (ret < 0)
1001                 return ret;
1002
1003         /* OTG pin */
1004         ret = x86_android_tablet_get_gpiod("INT33FF:03", 19, "bq25892_0_otg",
1005                                            false, GPIOD_OUT_LOW, NULL);
1006         if (ret < 0)
1007                 return ret;
1008
1009         /* Enable the regulators used by the touchscreen */
1010         intel_soc_pmic_exec_mipi_pmic_seq_element(0x6e, 0x9b, 0x02, 0xff);
1011         intel_soc_pmic_exec_mipi_pmic_seq_element(0x6e, 0xa0, 0x02, 0xff);
1012
1013         return 0;
1014 }
1015
1016 static struct gpiod_lookup_table lenovo_yt3_hideep_gpios = {
1017         .dev_id = "i2c-hideep_ts",
1018         .table = {
1019                 GPIO_LOOKUP("INT33FF:00", 7, "reset", GPIO_ACTIVE_LOW),
1020                 { }
1021         },
1022 };
1023
1024 static struct gpiod_lookup_table lenovo_yt3_wm5102_gpios = {
1025         .dev_id = "spi1.0",
1026         .table = {
1027                 GPIO_LOOKUP("INT33FF:00", 75, "wlf,spkvdd-ena", GPIO_ACTIVE_HIGH),
1028                 GPIO_LOOKUP("INT33FF:00", 81, "wlf,ldoena", GPIO_ACTIVE_HIGH),
1029                 GPIO_LOOKUP("INT33FF:00", 82, "reset", GPIO_ACTIVE_HIGH),
1030                 GPIO_LOOKUP("arizona", 2, "wlf,micd-pol", GPIO_ACTIVE_HIGH),
1031                 { }
1032         },
1033 };
1034
1035 static struct gpiod_lookup_table * const lenovo_yt3_gpios[] = {
1036         &lenovo_yt3_hideep_gpios,
1037         &lenovo_yt3_wm5102_gpios,
1038         NULL
1039 };
1040
1041 const struct x86_dev_info lenovo_yt3_info __initconst = {
1042         .i2c_client_info = lenovo_yt3_i2c_clients,
1043         .i2c_client_count = ARRAY_SIZE(lenovo_yt3_i2c_clients),
1044         .spi_dev_info = lenovo_yt3_spi_devs,
1045         .spi_dev_count = ARRAY_SIZE(lenovo_yt3_spi_devs),
1046         .gpiod_lookup_tables = lenovo_yt3_gpios,
1047         .init = lenovo_yt3_init,
1048 };