1 // SPDX-License-Identifier: GPL-2.0+
3 * DMI based code to deal with broken DSDTs on X86 tablets which ship with
4 * Android as (part of) the factory image. The factory kernels shipped on these
5 * devices typically have a bunch of things hardcoded, rather than specified
8 * Copyright (C) 2021 Hans de Goede <hdegoede@redhat.com>
11 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
13 #include <linux/acpi.h>
14 #include <linux/dmi.h>
15 #include <linux/efi.h>
16 #include <linux/gpio_keys.h>
17 #include <linux/gpio/consumer.h>
18 #include <linux/gpio/driver.h>
19 #include <linux/gpio/machine.h>
20 #include <linux/i2c.h>
21 #include <linux/input.h>
22 #include <linux/irq.h>
23 #include <linux/irqdomain.h>
24 #include <linux/module.h>
25 #include <linux/mod_devicetable.h>
26 #include <linux/pinctrl/consumer.h>
27 #include <linux/pinctrl/machine.h>
28 #include <linux/platform_data/lp855x.h>
29 #include <linux/platform_device.h>
30 #include <linux/power/bq24190_charger.h>
31 #include <linux/reboot.h>
32 #include <linux/rmi.h>
33 #include <linux/serdev.h>
34 #include <linux/spi/spi.h>
35 #include <linux/string.h>
36 /* For gpio_get_desc() which is EXPORT_SYMBOL_GPL() */
37 #include "../../gpio/gpiolib.h"
38 #include "../../gpio/gpiolib-acpi.h"
41 * Helper code to get Linux IRQ numbers given a description of the IRQ source
42 * (either IOAPIC index, or GPIO chip name + pin-number).
44 enum x86_acpi_irq_type {
45 X86_ACPI_IRQ_TYPE_NONE,
46 X86_ACPI_IRQ_TYPE_APIC,
47 X86_ACPI_IRQ_TYPE_GPIOINT,
48 X86_ACPI_IRQ_TYPE_PMIC,
51 struct x86_acpi_irq_data {
52 char *chip; /* GPIO chip label (GPIOINT) or PMIC ACPI path (PMIC) */
53 enum x86_acpi_irq_type type;
54 enum irq_domain_bus_token domain;
56 int trigger; /* ACPI_EDGE_SENSITIVE / ACPI_LEVEL_SENSITIVE */
57 int polarity; /* ACPI_ACTIVE_HIGH / ACPI_ACTIVE_LOW / ACPI_ACTIVE_BOTH */
60 static int gpiochip_find_match_label(struct gpio_chip *gc, void *data)
62 return gc->label && !strcmp(gc->label, data);
65 static int x86_android_tablet_get_gpiod(char *label, int pin, struct gpio_desc **desc)
67 struct gpio_desc *gpiod;
68 struct gpio_chip *chip;
70 chip = gpiochip_find(label, gpiochip_find_match_label);
72 pr_err("error cannot find GPIO chip %s\n", label);
76 gpiod = gpiochip_get_desc(chip, pin);
78 pr_err("error %ld getting GPIO %s %d\n", PTR_ERR(gpiod), label, pin);
79 return PTR_ERR(gpiod);
86 static int x86_acpi_irq_helper_get(const struct x86_acpi_irq_data *data)
88 struct irq_fwspec fwspec = { };
89 struct irq_domain *domain;
90 struct acpi_device *adev;
91 struct gpio_desc *gpiod;
92 unsigned int irq_type;
98 case X86_ACPI_IRQ_TYPE_APIC:
100 * The DSDT may already reference the GSI in a device skipped by
101 * acpi_quirk_skip_i2c_client_enumeration(). Unregister the GSI
102 * to avoid EBUSY errors in this case.
104 acpi_unregister_gsi(data->index);
105 irq = acpi_register_gsi(NULL, data->index, data->trigger, data->polarity);
107 pr_err("error %d getting APIC IRQ %d\n", irq, data->index);
110 case X86_ACPI_IRQ_TYPE_GPIOINT:
111 /* Like acpi_dev_gpio_irq_get(), but without parsing ACPI resources */
112 ret = x86_android_tablet_get_gpiod(data->chip, data->index, &gpiod);
116 irq = gpiod_to_irq(gpiod);
118 pr_err("error %d getting IRQ %s %d\n", irq, data->chip, data->index);
122 irq_type = acpi_dev_get_irq_type(data->trigger, data->polarity);
123 if (irq_type != IRQ_TYPE_NONE && irq_type != irq_get_trigger_type(irq))
124 irq_set_irq_type(irq, irq_type);
127 case X86_ACPI_IRQ_TYPE_PMIC:
128 status = acpi_get_handle(NULL, data->chip, &handle);
129 if (ACPI_FAILURE(status)) {
130 pr_err("error could not get %s handle\n", data->chip);
134 adev = acpi_fetch_acpi_dev(handle);
136 pr_err("error could not get %s adev\n", data->chip);
140 fwspec.fwnode = acpi_fwnode_handle(adev);
141 domain = irq_find_matching_fwspec(&fwspec, data->domain);
143 pr_err("error could not find IRQ domain for %s\n", data->chip);
147 return irq_create_mapping(domain, data->index);
153 struct x86_i2c_client_info {
154 struct i2c_board_info board_info;
156 struct x86_acpi_irq_data irq_data;
159 struct x86_serdev_info {
160 const char *ctrl_hid;
161 const char *ctrl_uid;
162 const char *ctrl_devname;
164 * ATM the serdev core only supports of or ACPI matching; and sofar all
165 * Android x86 tablets DSDTs have usable serdev nodes, but sometimes
166 * under the wrong controller. So we just tie the existing serdev ACPI
167 * node to the right controller.
169 const char *serdev_hid;
172 struct x86_dev_info {
173 char *invalid_aei_gpiochip;
174 const char * const *modules;
175 const struct software_node *bat_swnode;
176 struct gpiod_lookup_table * const *gpiod_lookup_tables;
177 const struct x86_i2c_client_info *i2c_client_info;
178 const struct platform_device_info *pdev_info;
179 const struct x86_serdev_info *serdev_info;
180 int i2c_client_count;
187 /* Generic / shared charger / battery settings */
188 static const char * const tusb1211_chg_det_psy[] = { "tusb1211-charger-detect" };
189 static const char * const bq24190_psy[] = { "bq24190-charger" };
190 static const char * const bq25890_psy[] = { "bq25890-charger" };
192 static const struct property_entry fg_bq24190_supply_props[] = {
193 PROPERTY_ENTRY_STRING_ARRAY("supplied-from", bq24190_psy),
197 static const struct software_node fg_bq24190_supply_node = {
198 .properties = fg_bq24190_supply_props,
201 static const struct property_entry fg_bq25890_supply_props[] = {
202 PROPERTY_ENTRY_STRING_ARRAY("supplied-from", bq25890_psy),
206 static const struct software_node fg_bq25890_supply_node = {
207 .properties = fg_bq25890_supply_props,
210 /* LiPo HighVoltage (max 4.35V) settings used by most devs with a HV bat. */
211 static const struct property_entry generic_lipo_hv_4v35_battery_props[] = {
212 PROPERTY_ENTRY_STRING("compatible", "simple-battery"),
213 PROPERTY_ENTRY_STRING("device-chemistry", "lithium-ion"),
214 PROPERTY_ENTRY_U32("precharge-current-microamp", 256000),
215 PROPERTY_ENTRY_U32("charge-term-current-microamp", 128000),
216 PROPERTY_ENTRY_U32("constant-charge-current-max-microamp", 1856000),
217 PROPERTY_ENTRY_U32("constant-charge-voltage-max-microvolt", 4352000),
218 PROPERTY_ENTRY_U32("factory-internal-resistance-micro-ohms", 150000),
222 static const struct software_node generic_lipo_hv_4v35_battery_node = {
223 .properties = generic_lipo_hv_4v35_battery_props,
226 /* For enabling the bq24190 5V boost based on id-pin */
227 static struct regulator_consumer_supply intel_int3496_consumer = {
229 .dev_name = "intel-int3496",
232 static const struct regulator_init_data bq24190_vbus_init_data = {
234 .name = "bq24190_vbus",
235 .valid_ops_mask = REGULATOR_CHANGE_STATUS,
237 .consumer_supplies = &intel_int3496_consumer,
238 .num_consumer_supplies = 1,
241 static struct bq24190_platform_data bq24190_pdata = {
242 .regulator_init_data = &bq24190_vbus_init_data,
245 static const char * const bq24190_modules[] __initconst = {
246 "intel_crystal_cove_charger", /* For the bq24190 IRQ */
247 "bq24190_charger", /* For the Vbus regulator for intel-int3496 */
251 /* Generic pdevs array and gpio-lookups for micro USB ID pin handling */
252 static const struct platform_device_info int3496_pdevs[] __initconst = {
254 /* For micro USB ID pin handling */
255 .name = "intel-int3496",
256 .id = PLATFORM_DEVID_NONE,
260 static struct gpiod_lookup_table int3496_gpo2_pin22_gpios = {
261 .dev_id = "intel-int3496",
263 GPIO_LOOKUP("INT33FC:02", 22, "id", GPIO_ACTIVE_HIGH),
268 /* Asus ME176C and TF103C tablets shared data */
269 static struct gpio_keys_button asus_me176c_tf103c_lid = {
271 /* .gpio gets filled in by asus_me176c_tf103c_init() */
276 .debounce_interval = 50,
279 static const struct gpio_keys_platform_data asus_me176c_tf103c_lid_pdata __initconst = {
280 .buttons = &asus_me176c_tf103c_lid,
285 static const struct platform_device_info asus_me176c_tf103c_pdevs[] __initconst = {
288 .id = PLATFORM_DEVID_AUTO,
289 .data = &asus_me176c_tf103c_lid_pdata,
290 .size_data = sizeof(asus_me176c_tf103c_lid_pdata),
293 /* For micro USB ID pin handling */
294 .name = "intel-int3496",
295 .id = PLATFORM_DEVID_NONE,
299 static int __init asus_me176c_tf103c_init(void)
301 struct gpio_desc *gpiod;
304 ret = x86_android_tablet_get_gpiod("INT33FC:02", 12, &gpiod);
307 asus_me176c_tf103c_lid.gpio = desc_to_gpio(gpiod);
313 /* Asus ME176C tablets have an Android factory img with everything hardcoded */
314 static const char * const asus_me176c_accel_mount_matrix[] = {
320 static const struct property_entry asus_me176c_accel_props[] = {
321 PROPERTY_ENTRY_STRING_ARRAY("mount-matrix", asus_me176c_accel_mount_matrix),
325 static const struct software_node asus_me176c_accel_node = {
326 .properties = asus_me176c_accel_props,
329 static const struct property_entry asus_me176c_bq24190_props[] = {
330 PROPERTY_ENTRY_STRING_ARRAY("supplied-from", tusb1211_chg_det_psy),
331 PROPERTY_ENTRY_REF("monitored-battery", &generic_lipo_hv_4v35_battery_node),
332 PROPERTY_ENTRY_U32("ti,system-minimum-microvolt", 3600000),
333 PROPERTY_ENTRY_BOOL("omit-battery-class"),
334 PROPERTY_ENTRY_BOOL("disable-reset"),
338 static const struct software_node asus_me176c_bq24190_node = {
339 .properties = asus_me176c_bq24190_props,
342 static const struct property_entry asus_me176c_ug3105_props[] = {
343 PROPERTY_ENTRY_STRING_ARRAY("supplied-from", bq24190_psy),
344 PROPERTY_ENTRY_REF("monitored-battery", &generic_lipo_hv_4v35_battery_node),
345 PROPERTY_ENTRY_U32("upisemi,rsns-microohm", 10000),
349 static const struct software_node asus_me176c_ug3105_node = {
350 .properties = asus_me176c_ug3105_props,
353 static const struct x86_i2c_client_info asus_me176c_i2c_clients[] __initconst = {
355 /* bq24297 battery charger */
359 .dev_name = "bq24297",
360 .swnode = &asus_me176c_bq24190_node,
361 .platform_data = &bq24190_pdata,
363 .adapter_path = "\\_SB_.I2C1",
365 .type = X86_ACPI_IRQ_TYPE_PMIC,
366 .chip = "\\_SB_.I2C7.PMIC",
367 .domain = DOMAIN_BUS_WAKEUP,
371 /* ug3105 battery monitor */
375 .dev_name = "ug3105",
376 .swnode = &asus_me176c_ug3105_node,
378 .adapter_path = "\\_SB_.I2C1",
380 /* ak09911 compass */
384 .dev_name = "ak09911",
386 .adapter_path = "\\_SB_.I2C5",
388 /* kxtj21009 accel */
392 .dev_name = "kxtj21009",
393 .swnode = &asus_me176c_accel_node,
395 .adapter_path = "\\_SB_.I2C5",
397 .type = X86_ACPI_IRQ_TYPE_APIC,
399 .trigger = ACPI_EDGE_SENSITIVE,
400 .polarity = ACPI_ACTIVE_LOW,
403 /* goodix touchscreen */
405 .type = "GDIX1001:00",
407 .dev_name = "goodix_ts",
409 .adapter_path = "\\_SB_.I2C6",
411 .type = X86_ACPI_IRQ_TYPE_APIC,
413 .trigger = ACPI_EDGE_SENSITIVE,
414 .polarity = ACPI_ACTIVE_LOW,
419 static const struct x86_serdev_info asus_me176c_serdevs[] __initconst = {
421 .ctrl_hid = "80860F0A",
423 .ctrl_devname = "serial0",
424 .serdev_hid = "BCM2E3A",
428 static struct gpiod_lookup_table asus_me176c_goodix_gpios = {
429 .dev_id = "i2c-goodix_ts",
431 GPIO_LOOKUP("INT33FC:00", 60, "reset", GPIO_ACTIVE_HIGH),
432 GPIO_LOOKUP("INT33FC:02", 28, "irq", GPIO_ACTIVE_HIGH),
437 static struct gpiod_lookup_table * const asus_me176c_gpios[] = {
438 &int3496_gpo2_pin22_gpios,
439 &asus_me176c_goodix_gpios,
443 static const struct x86_dev_info asus_me176c_info __initconst = {
444 .i2c_client_info = asus_me176c_i2c_clients,
445 .i2c_client_count = ARRAY_SIZE(asus_me176c_i2c_clients),
446 .pdev_info = asus_me176c_tf103c_pdevs,
447 .pdev_count = ARRAY_SIZE(asus_me176c_tf103c_pdevs),
448 .serdev_info = asus_me176c_serdevs,
449 .serdev_count = ARRAY_SIZE(asus_me176c_serdevs),
450 .gpiod_lookup_tables = asus_me176c_gpios,
451 .bat_swnode = &generic_lipo_hv_4v35_battery_node,
452 .modules = bq24190_modules,
453 .invalid_aei_gpiochip = "INT33FC:02",
454 .init = asus_me176c_tf103c_init,
457 /* Asus TF103C tablets have an Android factory img with everything hardcoded */
458 static const char * const asus_tf103c_accel_mount_matrix[] = {
464 static const struct property_entry asus_tf103c_accel_props[] = {
465 PROPERTY_ENTRY_STRING_ARRAY("mount-matrix", asus_tf103c_accel_mount_matrix),
469 static const struct software_node asus_tf103c_accel_node = {
470 .properties = asus_tf103c_accel_props,
473 static const struct property_entry asus_tf103c_touchscreen_props[] = {
474 PROPERTY_ENTRY_STRING("compatible", "atmel,atmel_mxt_ts"),
478 static const struct software_node asus_tf103c_touchscreen_node = {
479 .properties = asus_tf103c_touchscreen_props,
482 static const struct property_entry asus_tf103c_battery_props[] = {
483 PROPERTY_ENTRY_STRING("compatible", "simple-battery"),
484 PROPERTY_ENTRY_STRING("device-chemistry", "lithium-ion-polymer"),
485 PROPERTY_ENTRY_U32("precharge-current-microamp", 256000),
486 PROPERTY_ENTRY_U32("charge-term-current-microamp", 128000),
487 PROPERTY_ENTRY_U32("constant-charge-current-max-microamp", 2048000),
488 PROPERTY_ENTRY_U32("constant-charge-voltage-max-microvolt", 4208000),
489 PROPERTY_ENTRY_U32("factory-internal-resistance-micro-ohms", 150000),
493 static const struct software_node asus_tf103c_battery_node = {
494 .properties = asus_tf103c_battery_props,
497 static const struct property_entry asus_tf103c_bq24190_props[] = {
498 PROPERTY_ENTRY_STRING_ARRAY("supplied-from", tusb1211_chg_det_psy),
499 PROPERTY_ENTRY_REF("monitored-battery", &asus_tf103c_battery_node),
500 PROPERTY_ENTRY_U32("ti,system-minimum-microvolt", 3600000),
501 PROPERTY_ENTRY_BOOL("omit-battery-class"),
502 PROPERTY_ENTRY_BOOL("disable-reset"),
506 static const struct software_node asus_tf103c_bq24190_node = {
507 .properties = asus_tf103c_bq24190_props,
510 static const struct property_entry asus_tf103c_ug3105_props[] = {
511 PROPERTY_ENTRY_STRING_ARRAY("supplied-from", bq24190_psy),
512 PROPERTY_ENTRY_REF("monitored-battery", &asus_tf103c_battery_node),
513 PROPERTY_ENTRY_U32("upisemi,rsns-microohm", 5000),
517 static const struct software_node asus_tf103c_ug3105_node = {
518 .properties = asus_tf103c_ug3105_props,
521 static const struct x86_i2c_client_info asus_tf103c_i2c_clients[] __initconst = {
523 /* bq24297 battery charger */
527 .dev_name = "bq24297",
528 .swnode = &asus_tf103c_bq24190_node,
529 .platform_data = &bq24190_pdata,
531 .adapter_path = "\\_SB_.I2C1",
533 .type = X86_ACPI_IRQ_TYPE_PMIC,
534 .chip = "\\_SB_.I2C7.PMIC",
535 .domain = DOMAIN_BUS_WAKEUP,
539 /* ug3105 battery monitor */
543 .dev_name = "ug3105",
544 .swnode = &asus_tf103c_ug3105_node,
546 .adapter_path = "\\_SB_.I2C1",
548 /* ak09911 compass */
552 .dev_name = "ak09911",
554 .adapter_path = "\\_SB_.I2C5",
556 /* kxtj21009 accel */
560 .dev_name = "kxtj21009",
561 .swnode = &asus_tf103c_accel_node,
563 .adapter_path = "\\_SB_.I2C5",
565 /* atmel touchscreen */
567 .type = "atmel_mxt_ts",
569 .dev_name = "atmel_mxt_ts",
570 .swnode = &asus_tf103c_touchscreen_node,
572 .adapter_path = "\\_SB_.I2C6",
574 .type = X86_ACPI_IRQ_TYPE_GPIOINT,
575 .chip = "INT33FC:02",
577 .trigger = ACPI_EDGE_SENSITIVE,
578 .polarity = ACPI_ACTIVE_LOW,
583 static struct gpiod_lookup_table * const asus_tf103c_gpios[] = {
584 &int3496_gpo2_pin22_gpios,
588 static const struct x86_dev_info asus_tf103c_info __initconst = {
589 .i2c_client_info = asus_tf103c_i2c_clients,
590 .i2c_client_count = ARRAY_SIZE(asus_tf103c_i2c_clients),
591 .pdev_info = asus_me176c_tf103c_pdevs,
592 .pdev_count = ARRAY_SIZE(asus_me176c_tf103c_pdevs),
593 .gpiod_lookup_tables = asus_tf103c_gpios,
594 .bat_swnode = &asus_tf103c_battery_node,
595 .modules = bq24190_modules,
596 .invalid_aei_gpiochip = "INT33FC:02",
597 .init = asus_me176c_tf103c_init,
601 * When booted with the BIOS set to Android mode the Chuwi Hi8 (CWI509) DSDT
602 * contains a whole bunch of bogus ACPI I2C devices and is missing entries
603 * for the touchscreen and the accelerometer.
605 static const struct property_entry chuwi_hi8_gsl1680_props[] = {
606 PROPERTY_ENTRY_U32("touchscreen-size-x", 1665),
607 PROPERTY_ENTRY_U32("touchscreen-size-y", 1140),
608 PROPERTY_ENTRY_BOOL("touchscreen-swapped-x-y"),
609 PROPERTY_ENTRY_BOOL("silead,home-button"),
610 PROPERTY_ENTRY_STRING("firmware-name", "gsl1680-chuwi-hi8.fw"),
614 static const struct software_node chuwi_hi8_gsl1680_node = {
615 .properties = chuwi_hi8_gsl1680_props,
618 static const char * const chuwi_hi8_mount_matrix[] = {
624 static const struct property_entry chuwi_hi8_bma250e_props[] = {
625 PROPERTY_ENTRY_STRING_ARRAY("mount-matrix", chuwi_hi8_mount_matrix),
629 static const struct software_node chuwi_hi8_bma250e_node = {
630 .properties = chuwi_hi8_bma250e_props,
633 static const struct x86_i2c_client_info chuwi_hi8_i2c_clients[] __initconst = {
635 /* Silead touchscreen */
639 .swnode = &chuwi_hi8_gsl1680_node,
641 .adapter_path = "\\_SB_.I2C4",
643 .type = X86_ACPI_IRQ_TYPE_APIC,
645 .trigger = ACPI_EDGE_SENSITIVE,
646 .polarity = ACPI_ACTIVE_HIGH,
649 /* BMA250E accelerometer */
653 .swnode = &chuwi_hi8_bma250e_node,
655 .adapter_path = "\\_SB_.I2C3",
657 .type = X86_ACPI_IRQ_TYPE_GPIOINT,
658 .chip = "INT33FC:02",
660 .trigger = ACPI_LEVEL_SENSITIVE,
661 .polarity = ACPI_ACTIVE_HIGH,
666 static const struct x86_dev_info chuwi_hi8_info __initconst = {
667 .i2c_client_info = chuwi_hi8_i2c_clients,
668 .i2c_client_count = ARRAY_SIZE(chuwi_hi8_i2c_clients),
671 #define CZC_EC_EXTRA_PORT 0x68
672 #define CZC_EC_ANDROID_KEYS 0x63
674 static int __init czc_p10t_init(void)
677 * The device boots up in "Windows 7" mode, when the home button sends a
678 * Windows specific key sequence (Left Meta + D) and the second button
679 * sends an unknown one while also toggling the Radio Kill Switch.
680 * This is a surprising behavior when the second button is labeled "Back".
682 * The vendor-supplied Android-x86 build switches the device to a "Android"
683 * mode by writing value 0x63 to the I/O port 0x68. This just seems to just
684 * set bit 6 on address 0x96 in the EC region; switching the bit directly
685 * seems to achieve the same result. It uses a "p10t_switcher" to do the
686 * job. It doesn't seem to be able to do anything else, and no other use
687 * of the port 0x68 is known.
689 * In the Android mode, the home button sends just a single scancode,
690 * which can be handled in Linux userspace more reasonably and the back
691 * button only sends a scancode without toggling the kill switch.
692 * The scancode can then be mapped either to Back or RF Kill functionality
693 * in userspace, depending on how the button is labeled on that particular
696 outb(CZC_EC_ANDROID_KEYS, CZC_EC_EXTRA_PORT);
700 static const struct x86_dev_info czc_p10t __initconst = {
701 .init = czc_p10t_init,
704 /* Lenovo Yoga Book X90F / X91F / X91L need manual instantiation of the fg client */
705 static const struct x86_i2c_client_info lenovo_yogabook_x9x_i2c_clients[] __initconst = {
707 /* BQ27542 fuel-gauge */
711 .dev_name = "bq27542",
712 .swnode = &fg_bq25890_supply_node,
714 .adapter_path = "\\_SB_.PCI0.I2C1",
718 static const struct x86_dev_info lenovo_yogabook_x9x_info __initconst = {
719 .i2c_client_info = lenovo_yogabook_x9x_i2c_clients,
720 .i2c_client_count = ARRAY_SIZE(lenovo_yogabook_x9x_i2c_clients),
723 /* Lenovo Yoga Tablet 2 1050F/L's Android factory img has everything hardcoded */
724 static const struct property_entry lenovo_yoga_tab2_830_1050_bq24190_props[] = {
725 PROPERTY_ENTRY_STRING_ARRAY("supplied-from", tusb1211_chg_det_psy),
726 PROPERTY_ENTRY_REF("monitored-battery", &generic_lipo_hv_4v35_battery_node),
727 PROPERTY_ENTRY_BOOL("omit-battery-class"),
728 PROPERTY_ENTRY_BOOL("disable-reset"),
732 static const struct software_node lenovo_yoga_tab2_830_1050_bq24190_node = {
733 .properties = lenovo_yoga_tab2_830_1050_bq24190_props,
736 /* This gets filled by lenovo_yoga_tab2_830_1050_init() */
737 static struct rmi_device_platform_data lenovo_yoga_tab2_830_1050_rmi_pdata = { };
739 static struct lp855x_platform_data lenovo_yoga_tab2_830_1050_lp8557_pdata = {
740 .device_control = 0x86,
741 .initial_brightness = 128,
744 static const struct x86_i2c_client_info lenovo_yoga_tab2_830_1050_i2c_clients[] __initconst = {
746 /* bq24292i battery charger */
750 .dev_name = "bq24292i",
751 .swnode = &lenovo_yoga_tab2_830_1050_bq24190_node,
752 .platform_data = &bq24190_pdata,
754 .adapter_path = "\\_SB_.I2C1",
756 .type = X86_ACPI_IRQ_TYPE_GPIOINT,
757 .chip = "INT33FC:02",
759 .trigger = ACPI_EDGE_SENSITIVE,
760 .polarity = ACPI_ACTIVE_HIGH,
763 /* BQ27541 fuel-gauge */
767 .dev_name = "bq27541",
768 .swnode = &fg_bq24190_supply_node,
770 .adapter_path = "\\_SB_.I2C1",
772 /* Synaptics RMI touchscreen */
776 .dev_name = "rmi4_i2c",
777 .platform_data = &lenovo_yoga_tab2_830_1050_rmi_pdata,
779 .adapter_path = "\\_SB_.I2C6",
781 .type = X86_ACPI_IRQ_TYPE_APIC,
783 .trigger = ACPI_EDGE_SENSITIVE,
784 .polarity = ACPI_ACTIVE_HIGH,
787 /* LP8557 Backlight controller */
791 .dev_name = "lp8557",
792 .platform_data = &lenovo_yoga_tab2_830_1050_lp8557_pdata,
794 .adapter_path = "\\_SB_.I2C3",
798 static struct gpiod_lookup_table lenovo_yoga_tab2_830_1050_int3496_gpios = {
799 .dev_id = "intel-int3496",
801 GPIO_LOOKUP("INT33FC:02", 1, "mux", GPIO_ACTIVE_LOW),
802 GPIO_LOOKUP("INT33FC:02", 24, "id", GPIO_ACTIVE_HIGH),
807 #define LENOVO_YOGA_TAB2_830_1050_CODEC_NAME "spi-10WM5102:00"
809 static struct gpiod_lookup_table lenovo_yoga_tab2_830_1050_codec_gpios = {
810 .dev_id = LENOVO_YOGA_TAB2_830_1050_CODEC_NAME,
812 GPIO_LOOKUP("gpio_crystalcove", 3, "reset", GPIO_ACTIVE_HIGH),
813 GPIO_LOOKUP("INT33FC:01", 23, "wlf,ldoena", GPIO_ACTIVE_HIGH),
814 GPIO_LOOKUP("arizona", 2, "wlf,spkvdd-ena", GPIO_ACTIVE_HIGH),
815 GPIO_LOOKUP("arizona", 4, "wlf,micd-pol", GPIO_ACTIVE_LOW),
820 static struct gpiod_lookup_table * const lenovo_yoga_tab2_830_1050_gpios[] = {
821 &lenovo_yoga_tab2_830_1050_int3496_gpios,
822 &lenovo_yoga_tab2_830_1050_codec_gpios,
826 static int __init lenovo_yoga_tab2_830_1050_init(void);
827 static void lenovo_yoga_tab2_830_1050_exit(void);
829 static struct x86_dev_info lenovo_yoga_tab2_830_1050_info __initdata = {
830 .i2c_client_info = lenovo_yoga_tab2_830_1050_i2c_clients,
831 /* i2c_client_count gets set by lenovo_yoga_tab2_830_1050_init() */
832 .pdev_info = int3496_pdevs,
833 .pdev_count = ARRAY_SIZE(int3496_pdevs),
834 .gpiod_lookup_tables = lenovo_yoga_tab2_830_1050_gpios,
835 .bat_swnode = &generic_lipo_hv_4v35_battery_node,
836 .modules = bq24190_modules,
837 .invalid_aei_gpiochip = "INT33FC:02",
838 .init = lenovo_yoga_tab2_830_1050_init,
839 .exit = lenovo_yoga_tab2_830_1050_exit,
843 * The Lenovo Yoga Tablet 2 830 and 1050 (8" vs 10") versions use the same
844 * mainboard, but they need some different treatment related to the display:
845 * 1. The 830 uses a portrait LCD panel with a landscape touchscreen, requiring
846 * the touchscreen driver to adjust the touch-coords to match the LCD.
847 * 2. Both use an TI LP8557 LED backlight controller. On the 1050 the LP8557's
848 * PWM input is connected to the PMIC's PWM output and everything works fine
849 * with the defaults programmed into the LP8557 by the BIOS.
850 * But on the 830 the LP8557's PWM input is connected to a PWM output coming
851 * from the LCD panel's controller. The Android code has a hack in the i915
852 * driver to write the non-standard DSI reg 0x9f with the desired backlight
853 * level to set the duty-cycle of the LCD's PWM output.
855 * To avoid having to have a similar hack in the mainline kernel the LP8557
856 * entry in lenovo_yoga_tab2_830_1050_i2c_clients instead just programs the
857 * LP8557 to directly set the level, ignoring the PWM input. This means that
858 * the LP8557 i2c_client should only be instantiated on the 830.
860 static int __init lenovo_yoga_tab2_830_1050_init_display(void)
862 struct gpio_desc *gpiod;
865 /* Use PMIC GPIO 10 bootstrap pin to differentiate 830 vs 1050 */
866 ret = x86_android_tablet_get_gpiod("gpio_crystalcove", 10, &gpiod);
870 ret = gpiod_get_value_cansleep(gpiod);
872 pr_info("detected Lenovo Yoga Tablet 2 1050F/L\n");
873 lenovo_yoga_tab2_830_1050_info.i2c_client_count =
874 ARRAY_SIZE(lenovo_yoga_tab2_830_1050_i2c_clients) - 1;
876 pr_info("detected Lenovo Yoga Tablet 2 830F/L\n");
877 lenovo_yoga_tab2_830_1050_rmi_pdata.sensor_pdata.axis_align.swap_axes = true;
878 lenovo_yoga_tab2_830_1050_rmi_pdata.sensor_pdata.axis_align.flip_y = true;
879 lenovo_yoga_tab2_830_1050_info.i2c_client_count =
880 ARRAY_SIZE(lenovo_yoga_tab2_830_1050_i2c_clients);
886 /* SUS (INT33FC:02) pin 6 needs to be configured as pmu_clk for the audio codec */
887 static const struct pinctrl_map lenovo_yoga_tab2_830_1050_codec_pinctrl_map =
888 PIN_MAP_MUX_GROUP(LENOVO_YOGA_TAB2_830_1050_CODEC_NAME, "codec_32khz_clk",
889 "INT33FC:02", "pmu_clk2_grp", "pmu_clk");
891 static struct pinctrl *lenovo_yoga_tab2_830_1050_codec_pinctrl;
892 static struct sys_off_handler *lenovo_yoga_tab2_830_1050_sys_off_handler;
894 static int __init lenovo_yoga_tab2_830_1050_init_codec(void)
896 struct device *codec_dev;
897 struct pinctrl *pinctrl;
900 codec_dev = bus_find_device_by_name(&spi_bus_type, NULL,
901 LENOVO_YOGA_TAB2_830_1050_CODEC_NAME);
903 pr_err("error cannot find %s device\n", LENOVO_YOGA_TAB2_830_1050_CODEC_NAME);
907 ret = pinctrl_register_mappings(&lenovo_yoga_tab2_830_1050_codec_pinctrl_map, 1);
911 pinctrl = pinctrl_get_select(codec_dev, "codec_32khz_clk");
912 if (IS_ERR(pinctrl)) {
913 ret = dev_err_probe(codec_dev, PTR_ERR(pinctrl), "selecting codec_32khz_clk\n");
914 goto err_unregister_mappings;
917 /* We're done with the codec_dev now */
918 put_device(codec_dev);
920 lenovo_yoga_tab2_830_1050_codec_pinctrl = pinctrl;
923 err_unregister_mappings:
924 pinctrl_unregister_mappings(&lenovo_yoga_tab2_830_1050_codec_pinctrl_map);
926 put_device(codec_dev);
931 * These tablet's DSDT does not set acpi_gbl_reduced_hardware, so acpi_power_off
932 * gets used as pm_power_off handler. This causes "poweroff" on these tablets
933 * to hang hard. Requiring pressing the powerbutton for 30 seconds *twice*
934 * followed by a normal 3 second press to recover. Avoid this by doing an EFI
937 static int lenovo_yoga_tab2_830_1050_power_off(struct sys_off_data *data)
939 efi.reset_system(EFI_RESET_SHUTDOWN, EFI_SUCCESS, 0, NULL);
944 static int __init lenovo_yoga_tab2_830_1050_init(void)
948 ret = lenovo_yoga_tab2_830_1050_init_display();
952 ret = lenovo_yoga_tab2_830_1050_init_codec();
956 /* SYS_OFF_PRIO_FIRMWARE + 1 so that it runs before acpi_power_off */
957 lenovo_yoga_tab2_830_1050_sys_off_handler =
958 register_sys_off_handler(SYS_OFF_MODE_POWER_OFF, SYS_OFF_PRIO_FIRMWARE + 1,
959 lenovo_yoga_tab2_830_1050_power_off, NULL);
960 if (IS_ERR(lenovo_yoga_tab2_830_1050_sys_off_handler))
961 return PTR_ERR(lenovo_yoga_tab2_830_1050_sys_off_handler);
966 static void lenovo_yoga_tab2_830_1050_exit(void)
968 unregister_sys_off_handler(lenovo_yoga_tab2_830_1050_sys_off_handler);
970 if (lenovo_yoga_tab2_830_1050_codec_pinctrl) {
971 pinctrl_put(lenovo_yoga_tab2_830_1050_codec_pinctrl);
972 pinctrl_unregister_mappings(&lenovo_yoga_tab2_830_1050_codec_pinctrl_map);
976 /* Nextbook Ares 8 tablets have an Android factory img with everything hardcoded */
977 static const char * const nextbook_ares8_accel_mount_matrix[] = {
983 static const struct property_entry nextbook_ares8_accel_props[] = {
984 PROPERTY_ENTRY_STRING_ARRAY("mount-matrix", nextbook_ares8_accel_mount_matrix),
988 static const struct software_node nextbook_ares8_accel_node = {
989 .properties = nextbook_ares8_accel_props,
992 static const struct property_entry nextbook_ares8_touchscreen_props[] = {
993 PROPERTY_ENTRY_U32("touchscreen-size-x", 800),
994 PROPERTY_ENTRY_U32("touchscreen-size-y", 1280),
998 static const struct software_node nextbook_ares8_touchscreen_node = {
999 .properties = nextbook_ares8_touchscreen_props,
1002 static const struct x86_i2c_client_info nextbook_ares8_i2c_clients[] __initconst = {
1004 /* Freescale MMA8653FC accel */
1008 .dev_name = "mma8653",
1009 .swnode = &nextbook_ares8_accel_node,
1011 .adapter_path = "\\_SB_.I2C3",
1013 /* FT5416DQ9 touchscreen controller */
1015 .type = "edt-ft5x06",
1017 .dev_name = "ft5416",
1018 .swnode = &nextbook_ares8_touchscreen_node,
1020 .adapter_path = "\\_SB_.I2C4",
1022 .type = X86_ACPI_IRQ_TYPE_GPIOINT,
1023 .chip = "INT33FC:02",
1025 .trigger = ACPI_EDGE_SENSITIVE,
1026 .polarity = ACPI_ACTIVE_LOW,
1031 static struct gpiod_lookup_table nextbook_ares8_int3496_gpios = {
1032 .dev_id = "intel-int3496",
1034 GPIO_LOOKUP("INT33FC:02", 1, "mux", GPIO_ACTIVE_HIGH),
1035 GPIO_LOOKUP("INT33FC:02", 18, "id", GPIO_ACTIVE_HIGH),
1040 static struct gpiod_lookup_table * const nextbook_ares8_gpios[] = {
1041 &nextbook_ares8_int3496_gpios,
1045 static const struct x86_dev_info nextbook_ares8_info __initconst = {
1046 .i2c_client_info = nextbook_ares8_i2c_clients,
1047 .i2c_client_count = ARRAY_SIZE(nextbook_ares8_i2c_clients),
1048 .pdev_info = int3496_pdevs,
1049 .pdev_count = ARRAY_SIZE(int3496_pdevs),
1050 .gpiod_lookup_tables = nextbook_ares8_gpios,
1051 .invalid_aei_gpiochip = "INT33FC:02",
1055 * Whitelabel (sold as various brands) TM800A550L tablets.
1056 * These tablet's DSDT contains a whole bunch of bogus ACPI I2C devices
1057 * (removed through acpi_quirk_skip_i2c_client_enumeration()) and
1058 * the touchscreen fwnode has the wrong GPIOs.
1060 static const char * const whitelabel_tm800a550l_accel_mount_matrix[] = {
1066 static const struct property_entry whitelabel_tm800a550l_accel_props[] = {
1067 PROPERTY_ENTRY_STRING_ARRAY("mount-matrix", whitelabel_tm800a550l_accel_mount_matrix),
1071 static const struct software_node whitelabel_tm800a550l_accel_node = {
1072 .properties = whitelabel_tm800a550l_accel_props,
1075 static const struct property_entry whitelabel_tm800a550l_goodix_props[] = {
1076 PROPERTY_ENTRY_STRING("firmware-name", "gt912-tm800a550l.fw"),
1077 PROPERTY_ENTRY_STRING("goodix,config-name", "gt912-tm800a550l.cfg"),
1078 PROPERTY_ENTRY_U32("goodix,main-clk", 54),
1082 static const struct software_node whitelabel_tm800a550l_goodix_node = {
1083 .properties = whitelabel_tm800a550l_goodix_props,
1086 static const struct x86_i2c_client_info whitelabel_tm800a550l_i2c_clients[] __initconst = {
1088 /* goodix touchscreen */
1090 .type = "GDIX1001:00",
1092 .dev_name = "goodix_ts",
1093 .swnode = &whitelabel_tm800a550l_goodix_node,
1095 .adapter_path = "\\_SB_.I2C2",
1097 .type = X86_ACPI_IRQ_TYPE_APIC,
1099 .trigger = ACPI_EDGE_SENSITIVE,
1100 .polarity = ACPI_ACTIVE_HIGH,
1103 /* kxcj91008 accel */
1105 .type = "kxcj91008",
1107 .dev_name = "kxcj91008",
1108 .swnode = &whitelabel_tm800a550l_accel_node,
1110 .adapter_path = "\\_SB_.I2C3",
1114 static struct gpiod_lookup_table whitelabel_tm800a550l_goodix_gpios = {
1115 .dev_id = "i2c-goodix_ts",
1117 GPIO_LOOKUP("INT33FC:01", 26, "reset", GPIO_ACTIVE_HIGH),
1118 GPIO_LOOKUP("INT33FC:02", 3, "irq", GPIO_ACTIVE_HIGH),
1123 static struct gpiod_lookup_table * const whitelabel_tm800a550l_gpios[] = {
1124 &whitelabel_tm800a550l_goodix_gpios,
1128 static const struct x86_dev_info whitelabel_tm800a550l_info __initconst = {
1129 .i2c_client_info = whitelabel_tm800a550l_i2c_clients,
1130 .i2c_client_count = ARRAY_SIZE(whitelabel_tm800a550l_i2c_clients),
1131 .gpiod_lookup_tables = whitelabel_tm800a550l_gpios,
1135 * If the EFI bootloader is not Xiaomi's own signed Android loader, then the
1136 * Xiaomi Mi Pad 2 X86 tablet sets OSID in the DSDT to 1 (Windows), causing
1137 * a bunch of devices to be hidden.
1139 * This takes care of instantiating the hidden devices manually.
1141 static const struct x86_i2c_client_info xiaomi_mipad2_i2c_clients[] __initconst = {
1143 /* BQ27520 fuel-gauge */
1147 .dev_name = "bq27520",
1148 .swnode = &fg_bq25890_supply_node,
1150 .adapter_path = "\\_SB_.PCI0.I2C1",
1152 /* KTD2026 RGB notification LED controller */
1156 .dev_name = "ktd2026",
1158 .adapter_path = "\\_SB_.PCI0.I2C3",
1162 static const struct x86_dev_info xiaomi_mipad2_info __initconst = {
1163 .i2c_client_info = xiaomi_mipad2_i2c_clients,
1164 .i2c_client_count = ARRAY_SIZE(xiaomi_mipad2_i2c_clients),
1167 static const struct dmi_system_id x86_android_tablet_ids[] __initconst = {
1169 /* Asus MeMO Pad 7 ME176C */
1171 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
1172 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "ME176C"),
1174 .driver_data = (void *)&asus_me176c_info,
1179 DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
1180 DMI_MATCH(DMI_PRODUCT_NAME, "TF103C"),
1182 .driver_data = (void *)&asus_tf103c_info,
1185 /* Chuwi Hi8 (CWI509) */
1187 DMI_MATCH(DMI_BOARD_VENDOR, "Hampoo"),
1188 DMI_MATCH(DMI_BOARD_NAME, "BYT-PA03C"),
1189 DMI_MATCH(DMI_SYS_VENDOR, "ilife"),
1190 DMI_MATCH(DMI_PRODUCT_NAME, "S806"),
1192 .driver_data = (void *)&chuwi_hi8_info,
1196 .ident = "CZC ODEON TPC-10 (\"P10T\")",
1198 DMI_MATCH(DMI_SYS_VENDOR, "CZC"),
1199 DMI_MATCH(DMI_PRODUCT_NAME, "ODEON*TPC-10"),
1201 .driver_data = (void *)&czc_p10t,
1204 /* CZC P10T variant */
1205 .ident = "ViewSonic ViewPad 10",
1207 DMI_MATCH(DMI_SYS_VENDOR, "ViewSonic"),
1208 DMI_MATCH(DMI_PRODUCT_NAME, "VPAD10"),
1210 .driver_data = (void *)&czc_p10t,
1213 /* Lenovo Yoga Book X90F / X91F / X91L */
1215 /* Non exact match to match all versions */
1216 DMI_MATCH(DMI_PRODUCT_NAME, "Lenovo YB1-X9"),
1218 .driver_data = (void *)&lenovo_yogabook_x9x_info,
1222 * Lenovo Yoga Tablet 2 830F/L or 1050F/L (The 8" and 10"
1223 * Lenovo Yoga Tablet 2 use the same mainboard)
1226 DMI_MATCH(DMI_SYS_VENDOR, "Intel Corp."),
1227 DMI_MATCH(DMI_PRODUCT_NAME, "VALLEYVIEW C0 PLATFORM"),
1228 DMI_MATCH(DMI_BOARD_NAME, "BYT-T FFD8"),
1229 /* Partial match on beginning of BIOS version */
1230 DMI_MATCH(DMI_BIOS_VERSION, "BLADE_21"),
1232 .driver_data = (void *)&lenovo_yoga_tab2_830_1050_info,
1235 /* Nextbook Ares 8 */
1237 DMI_MATCH(DMI_SYS_VENDOR, "Insyde"),
1238 DMI_MATCH(DMI_PRODUCT_NAME, "M890BAP"),
1240 .driver_data = (void *)&nextbook_ares8_info,
1243 /* Whitelabel (sold as various brands) TM800A550L */
1245 DMI_MATCH(DMI_BOARD_VENDOR, "AMI Corporation"),
1246 DMI_MATCH(DMI_BOARD_NAME, "Aptio CRB"),
1247 /* Above strings are too generic, also match on BIOS version */
1248 DMI_MATCH(DMI_BIOS_VERSION, "ZY-8-BI-PX4S70VTR400-X423B-005-D"),
1250 .driver_data = (void *)&whitelabel_tm800a550l_info,
1253 /* Xiaomi Mi Pad 2 */
1255 DMI_MATCH(DMI_SYS_VENDOR, "Xiaomi Inc"),
1256 DMI_MATCH(DMI_PRODUCT_NAME, "Mipad2"),
1258 .driver_data = (void *)&xiaomi_mipad2_info,
1262 MODULE_DEVICE_TABLE(dmi, x86_android_tablet_ids);
1264 static int i2c_client_count;
1265 static int pdev_count;
1266 static int serdev_count;
1267 static struct i2c_client **i2c_clients;
1268 static struct platform_device **pdevs;
1269 static struct serdev_device **serdevs;
1270 static struct gpiod_lookup_table * const *gpiod_lookup_tables;
1271 static const struct software_node *bat_swnode;
1272 static void (*exit_handler)(void);
1274 static __init int x86_instantiate_i2c_client(const struct x86_dev_info *dev_info,
1277 const struct x86_i2c_client_info *client_info = &dev_info->i2c_client_info[idx];
1278 struct i2c_board_info board_info = client_info->board_info;
1279 struct i2c_adapter *adap;
1283 board_info.irq = x86_acpi_irq_helper_get(&client_info->irq_data);
1284 if (board_info.irq < 0)
1285 return board_info.irq;
1287 status = acpi_get_handle(NULL, client_info->adapter_path, &handle);
1288 if (ACPI_FAILURE(status)) {
1289 pr_err("Error could not get %s handle\n", client_info->adapter_path);
1293 adap = i2c_acpi_find_adapter_by_handle(handle);
1295 pr_err("error could not get %s adapter\n", client_info->adapter_path);
1299 i2c_clients[idx] = i2c_new_client_device(adap, &board_info);
1300 put_device(&adap->dev);
1301 if (IS_ERR(i2c_clients[idx]))
1302 return dev_err_probe(&adap->dev, PTR_ERR(i2c_clients[idx]),
1303 "creating I2C-client %d\n", idx);
1308 static __init int x86_instantiate_serdev(const struct x86_serdev_info *info, int idx)
1310 struct acpi_device *ctrl_adev, *serdev_adev;
1311 struct serdev_device *serdev;
1312 struct device *ctrl_dev;
1315 ctrl_adev = acpi_dev_get_first_match_dev(info->ctrl_hid, info->ctrl_uid, -1);
1317 pr_err("error could not get %s/%s ctrl adev\n",
1318 info->ctrl_hid, info->ctrl_uid);
1322 serdev_adev = acpi_dev_get_first_match_dev(info->serdev_hid, NULL, -1);
1324 pr_err("error could not get %s serdev adev\n", info->serdev_hid);
1328 /* get_first_physical_node() returns a weak ref, no need to put() it */
1329 ctrl_dev = acpi_get_first_physical_node(ctrl_adev);
1331 pr_err("error could not get %s/%s ctrl physical dev\n",
1332 info->ctrl_hid, info->ctrl_uid);
1333 goto put_serdev_adev;
1336 /* ctrl_dev now points to the controller's parent, get the controller */
1337 ctrl_dev = device_find_child_by_name(ctrl_dev, info->ctrl_devname);
1339 pr_err("error could not get %s/%s %s ctrl dev\n",
1340 info->ctrl_hid, info->ctrl_uid, info->ctrl_devname);
1341 goto put_serdev_adev;
1344 serdev = serdev_device_alloc(to_serdev_controller(ctrl_dev));
1347 goto put_serdev_adev;
1350 ACPI_COMPANION_SET(&serdev->dev, serdev_adev);
1351 acpi_device_set_enumerated(serdev_adev);
1353 ret = serdev_device_add(serdev);
1355 dev_err(&serdev->dev, "error %d adding serdev\n", ret);
1356 serdev_device_put(serdev);
1357 goto put_serdev_adev;
1360 serdevs[idx] = serdev;
1363 acpi_dev_put(serdev_adev);
1365 acpi_dev_put(ctrl_adev);
1369 static void x86_android_tablet_cleanup(void)
1373 for (i = 0; i < serdev_count; i++) {
1375 serdev_device_remove(serdevs[i]);
1380 for (i = 0; i < pdev_count; i++)
1381 platform_device_unregister(pdevs[i]);
1385 for (i = 0; i < i2c_client_count; i++)
1386 i2c_unregister_device(i2c_clients[i]);
1393 for (i = 0; gpiod_lookup_tables && gpiod_lookup_tables[i]; i++)
1394 gpiod_remove_lookup_table(gpiod_lookup_tables[i]);
1396 software_node_unregister(bat_swnode);
1399 static __init int x86_android_tablet_init(void)
1401 const struct x86_dev_info *dev_info;
1402 const struct dmi_system_id *id;
1403 struct gpio_chip *chip;
1406 id = dmi_first_match(x86_android_tablet_ids);
1410 dev_info = id->driver_data;
1413 * The broken DSDTs on these devices often also include broken
1414 * _AEI (ACPI Event Interrupt) handlers, disable these.
1416 if (dev_info->invalid_aei_gpiochip) {
1417 chip = gpiochip_find(dev_info->invalid_aei_gpiochip,
1418 gpiochip_find_match_label);
1420 pr_err("error cannot find GPIO chip %s\n", dev_info->invalid_aei_gpiochip);
1423 acpi_gpiochip_free_interrupts(chip);
1427 * Since this runs from module_init() it cannot use -EPROBE_DEFER,
1428 * instead pre-load any modules which are listed as requirements.
1430 for (i = 0; dev_info->modules && dev_info->modules[i]; i++)
1431 request_module(dev_info->modules[i]);
1433 bat_swnode = dev_info->bat_swnode;
1435 ret = software_node_register(bat_swnode);
1440 gpiod_lookup_tables = dev_info->gpiod_lookup_tables;
1441 for (i = 0; gpiod_lookup_tables && gpiod_lookup_tables[i]; i++)
1442 gpiod_add_lookup_table(gpiod_lookup_tables[i]);
1444 if (dev_info->init) {
1445 ret = dev_info->init();
1447 x86_android_tablet_cleanup();
1450 exit_handler = dev_info->exit;
1453 i2c_clients = kcalloc(dev_info->i2c_client_count, sizeof(*i2c_clients), GFP_KERNEL);
1455 x86_android_tablet_cleanup();
1459 i2c_client_count = dev_info->i2c_client_count;
1460 for (i = 0; i < i2c_client_count; i++) {
1461 ret = x86_instantiate_i2c_client(dev_info, i);
1463 x86_android_tablet_cleanup();
1468 pdevs = kcalloc(dev_info->pdev_count, sizeof(*pdevs), GFP_KERNEL);
1470 x86_android_tablet_cleanup();
1474 pdev_count = dev_info->pdev_count;
1475 for (i = 0; i < pdev_count; i++) {
1476 pdevs[i] = platform_device_register_full(&dev_info->pdev_info[i]);
1477 if (IS_ERR(pdevs[i])) {
1478 x86_android_tablet_cleanup();
1479 return PTR_ERR(pdevs[i]);
1483 serdevs = kcalloc(dev_info->serdev_count, sizeof(*serdevs), GFP_KERNEL);
1485 x86_android_tablet_cleanup();
1489 serdev_count = dev_info->serdev_count;
1490 for (i = 0; i < serdev_count; i++) {
1491 ret = x86_instantiate_serdev(&dev_info->serdev_info[i], i);
1493 x86_android_tablet_cleanup();
1501 module_init(x86_android_tablet_init);
1502 module_exit(x86_android_tablet_cleanup);
1504 MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>");
1505 MODULE_DESCRIPTION("X86 Android tablets DSDT fixups driver");
1506 MODULE_LICENSE("GPL");