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>
31 #include <linux/power/bq24190_charger.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;
893 static int __init lenovo_yoga_tab2_830_1050_init_codec(void)
895 struct device *codec_dev;
896 struct pinctrl *pinctrl;
899 codec_dev = bus_find_device_by_name(&spi_bus_type, NULL,
900 LENOVO_YOGA_TAB2_830_1050_CODEC_NAME);
902 pr_err("error cannot find %s device\n", LENOVO_YOGA_TAB2_830_1050_CODEC_NAME);
906 ret = pinctrl_register_mappings(&lenovo_yoga_tab2_830_1050_codec_pinctrl_map, 1);
910 pinctrl = pinctrl_get_select(codec_dev, "codec_32khz_clk");
911 if (IS_ERR(pinctrl)) {
912 ret = dev_err_probe(codec_dev, PTR_ERR(pinctrl), "selecting codec_32khz_clk\n");
913 goto err_unregister_mappings;
916 /* We're done with the codec_dev now */
917 put_device(codec_dev);
919 lenovo_yoga_tab2_830_1050_codec_pinctrl = pinctrl;
922 err_unregister_mappings:
923 pinctrl_unregister_mappings(&lenovo_yoga_tab2_830_1050_codec_pinctrl_map);
925 put_device(codec_dev);
930 * These tablet's DSDT does not set acpi_gbl_reduced_hardware, so acpi_power_off
931 * gets used as pm_power_off handler. This causes "poweroff" on these tablets
932 * to hang hard. Requiring pressing the powerbutton for 30 seconds *twice*
933 * followed by a normal 3 second press to recover. Avoid this by doing an EFI
936 static void lenovo_yoga_tab2_830_1050_power_off(void)
938 efi.reset_system(EFI_RESET_SHUTDOWN, EFI_SUCCESS, 0, NULL);
941 static int __init lenovo_yoga_tab2_830_1050_init(void)
945 ret = lenovo_yoga_tab2_830_1050_init_display();
949 ret = lenovo_yoga_tab2_830_1050_init_codec();
953 pm_power_off = lenovo_yoga_tab2_830_1050_power_off;
957 static void lenovo_yoga_tab2_830_1050_exit(void)
959 pm_power_off = NULL; /* Just turn poweroff into halt on module unload */
961 if (lenovo_yoga_tab2_830_1050_codec_pinctrl) {
962 pinctrl_put(lenovo_yoga_tab2_830_1050_codec_pinctrl);
963 pinctrl_unregister_mappings(&lenovo_yoga_tab2_830_1050_codec_pinctrl_map);
967 /* Nextbook Ares 8 tablets have an Android factory img with everything hardcoded */
968 static const char * const nextbook_ares8_accel_mount_matrix[] = {
974 static const struct property_entry nextbook_ares8_accel_props[] = {
975 PROPERTY_ENTRY_STRING_ARRAY("mount-matrix", nextbook_ares8_accel_mount_matrix),
979 static const struct software_node nextbook_ares8_accel_node = {
980 .properties = nextbook_ares8_accel_props,
983 static const struct property_entry nextbook_ares8_touchscreen_props[] = {
984 PROPERTY_ENTRY_U32("touchscreen-size-x", 800),
985 PROPERTY_ENTRY_U32("touchscreen-size-y", 1280),
989 static const struct software_node nextbook_ares8_touchscreen_node = {
990 .properties = nextbook_ares8_touchscreen_props,
993 static const struct x86_i2c_client_info nextbook_ares8_i2c_clients[] __initconst = {
995 /* Freescale MMA8653FC accel */
999 .dev_name = "mma8653",
1000 .swnode = &nextbook_ares8_accel_node,
1002 .adapter_path = "\\_SB_.I2C3",
1004 /* FT5416DQ9 touchscreen controller */
1006 .type = "edt-ft5x06",
1008 .dev_name = "ft5416",
1009 .swnode = &nextbook_ares8_touchscreen_node,
1011 .adapter_path = "\\_SB_.I2C4",
1013 .type = X86_ACPI_IRQ_TYPE_GPIOINT,
1014 .chip = "INT33FC:02",
1016 .trigger = ACPI_EDGE_SENSITIVE,
1017 .polarity = ACPI_ACTIVE_LOW,
1022 static struct gpiod_lookup_table nextbook_ares8_int3496_gpios = {
1023 .dev_id = "intel-int3496",
1025 GPIO_LOOKUP("INT33FC:02", 1, "mux", GPIO_ACTIVE_HIGH),
1026 GPIO_LOOKUP("INT33FC:02", 18, "id", GPIO_ACTIVE_HIGH),
1031 static struct gpiod_lookup_table * const nextbook_ares8_gpios[] = {
1032 &nextbook_ares8_int3496_gpios,
1036 static const struct x86_dev_info nextbook_ares8_info __initconst = {
1037 .i2c_client_info = nextbook_ares8_i2c_clients,
1038 .i2c_client_count = ARRAY_SIZE(nextbook_ares8_i2c_clients),
1039 .pdev_info = int3496_pdevs,
1040 .pdev_count = ARRAY_SIZE(int3496_pdevs),
1041 .gpiod_lookup_tables = nextbook_ares8_gpios,
1042 .invalid_aei_gpiochip = "INT33FC:02",
1046 * Whitelabel (sold as various brands) TM800A550L tablets.
1047 * These tablet's DSDT contains a whole bunch of bogus ACPI I2C devices
1048 * (removed through acpi_quirk_skip_i2c_client_enumeration()) and
1049 * the touchscreen fwnode has the wrong GPIOs.
1051 static const char * const whitelabel_tm800a550l_accel_mount_matrix[] = {
1057 static const struct property_entry whitelabel_tm800a550l_accel_props[] = {
1058 PROPERTY_ENTRY_STRING_ARRAY("mount-matrix", whitelabel_tm800a550l_accel_mount_matrix),
1062 static const struct software_node whitelabel_tm800a550l_accel_node = {
1063 .properties = whitelabel_tm800a550l_accel_props,
1066 static const struct property_entry whitelabel_tm800a550l_goodix_props[] = {
1067 PROPERTY_ENTRY_STRING("firmware-name", "gt912-tm800a550l.fw"),
1068 PROPERTY_ENTRY_STRING("goodix,config-name", "gt912-tm800a550l.cfg"),
1069 PROPERTY_ENTRY_U32("goodix,main-clk", 54),
1073 static const struct software_node whitelabel_tm800a550l_goodix_node = {
1074 .properties = whitelabel_tm800a550l_goodix_props,
1077 static const struct x86_i2c_client_info whitelabel_tm800a550l_i2c_clients[] __initconst = {
1079 /* goodix touchscreen */
1081 .type = "GDIX1001:00",
1083 .dev_name = "goodix_ts",
1084 .swnode = &whitelabel_tm800a550l_goodix_node,
1086 .adapter_path = "\\_SB_.I2C2",
1088 .type = X86_ACPI_IRQ_TYPE_APIC,
1090 .trigger = ACPI_EDGE_SENSITIVE,
1091 .polarity = ACPI_ACTIVE_HIGH,
1094 /* kxcj91008 accel */
1096 .type = "kxcj91008",
1098 .dev_name = "kxcj91008",
1099 .swnode = &whitelabel_tm800a550l_accel_node,
1101 .adapter_path = "\\_SB_.I2C3",
1105 static struct gpiod_lookup_table whitelabel_tm800a550l_goodix_gpios = {
1106 .dev_id = "i2c-goodix_ts",
1108 GPIO_LOOKUP("INT33FC:01", 26, "reset", GPIO_ACTIVE_HIGH),
1109 GPIO_LOOKUP("INT33FC:02", 3, "irq", GPIO_ACTIVE_HIGH),
1114 static struct gpiod_lookup_table * const whitelabel_tm800a550l_gpios[] = {
1115 &whitelabel_tm800a550l_goodix_gpios,
1119 static const struct x86_dev_info whitelabel_tm800a550l_info __initconst = {
1120 .i2c_client_info = whitelabel_tm800a550l_i2c_clients,
1121 .i2c_client_count = ARRAY_SIZE(whitelabel_tm800a550l_i2c_clients),
1122 .gpiod_lookup_tables = whitelabel_tm800a550l_gpios,
1126 * If the EFI bootloader is not Xiaomi's own signed Android loader, then the
1127 * Xiaomi Mi Pad 2 X86 tablet sets OSID in the DSDT to 1 (Windows), causing
1128 * a bunch of devices to be hidden.
1130 * This takes care of instantiating the hidden devices manually.
1132 static const struct x86_i2c_client_info xiaomi_mipad2_i2c_clients[] __initconst = {
1134 /* BQ27520 fuel-gauge */
1138 .dev_name = "bq27520",
1139 .swnode = &fg_bq25890_supply_node,
1141 .adapter_path = "\\_SB_.PCI0.I2C1",
1143 /* KTD2026 RGB notification LED controller */
1147 .dev_name = "ktd2026",
1149 .adapter_path = "\\_SB_.PCI0.I2C3",
1153 static const struct x86_dev_info xiaomi_mipad2_info __initconst = {
1154 .i2c_client_info = xiaomi_mipad2_i2c_clients,
1155 .i2c_client_count = ARRAY_SIZE(xiaomi_mipad2_i2c_clients),
1158 static const struct dmi_system_id x86_android_tablet_ids[] __initconst = {
1160 /* Asus MeMO Pad 7 ME176C */
1162 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
1163 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "ME176C"),
1165 .driver_data = (void *)&asus_me176c_info,
1170 DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
1171 DMI_MATCH(DMI_PRODUCT_NAME, "TF103C"),
1173 .driver_data = (void *)&asus_tf103c_info,
1176 /* Chuwi Hi8 (CWI509) */
1178 DMI_MATCH(DMI_BOARD_VENDOR, "Hampoo"),
1179 DMI_MATCH(DMI_BOARD_NAME, "BYT-PA03C"),
1180 DMI_MATCH(DMI_SYS_VENDOR, "ilife"),
1181 DMI_MATCH(DMI_PRODUCT_NAME, "S806"),
1183 .driver_data = (void *)&chuwi_hi8_info,
1187 .ident = "CZC ODEON TPC-10 (\"P10T\")",
1189 DMI_MATCH(DMI_SYS_VENDOR, "CZC"),
1190 DMI_MATCH(DMI_PRODUCT_NAME, "ODEON*TPC-10"),
1192 .driver_data = (void *)&czc_p10t,
1195 /* CZC P10T variant */
1196 .ident = "ViewSonic ViewPad 10",
1198 DMI_MATCH(DMI_SYS_VENDOR, "ViewSonic"),
1199 DMI_MATCH(DMI_PRODUCT_NAME, "VPAD10"),
1201 .driver_data = (void *)&czc_p10t,
1204 /* Lenovo Yoga Book X90F / X91F / X91L */
1206 /* Non exact match to match all versions */
1207 DMI_MATCH(DMI_PRODUCT_NAME, "Lenovo YB1-X9"),
1209 .driver_data = (void *)&lenovo_yogabook_x9x_info,
1213 * Lenovo Yoga Tablet 2 830F/L or 1050F/L (The 8" and 10"
1214 * Lenovo Yoga Tablet 2 use the same mainboard)
1217 DMI_MATCH(DMI_SYS_VENDOR, "Intel Corp."),
1218 DMI_MATCH(DMI_PRODUCT_NAME, "VALLEYVIEW C0 PLATFORM"),
1219 DMI_MATCH(DMI_BOARD_NAME, "BYT-T FFD8"),
1220 /* Partial match on beginning of BIOS version */
1221 DMI_MATCH(DMI_BIOS_VERSION, "BLADE_21"),
1223 .driver_data = (void *)&lenovo_yoga_tab2_830_1050_info,
1226 /* Nextbook Ares 8 */
1228 DMI_MATCH(DMI_SYS_VENDOR, "Insyde"),
1229 DMI_MATCH(DMI_PRODUCT_NAME, "M890BAP"),
1231 .driver_data = (void *)&nextbook_ares8_info,
1234 /* Whitelabel (sold as various brands) TM800A550L */
1236 DMI_MATCH(DMI_BOARD_VENDOR, "AMI Corporation"),
1237 DMI_MATCH(DMI_BOARD_NAME, "Aptio CRB"),
1238 /* Above strings are too generic, also match on BIOS version */
1239 DMI_MATCH(DMI_BIOS_VERSION, "ZY-8-BI-PX4S70VTR400-X423B-005-D"),
1241 .driver_data = (void *)&whitelabel_tm800a550l_info,
1244 /* Xiaomi Mi Pad 2 */
1246 DMI_MATCH(DMI_SYS_VENDOR, "Xiaomi Inc"),
1247 DMI_MATCH(DMI_PRODUCT_NAME, "Mipad2"),
1249 .driver_data = (void *)&xiaomi_mipad2_info,
1253 MODULE_DEVICE_TABLE(dmi, x86_android_tablet_ids);
1255 static int i2c_client_count;
1256 static int pdev_count;
1257 static int serdev_count;
1258 static struct i2c_client **i2c_clients;
1259 static struct platform_device **pdevs;
1260 static struct serdev_device **serdevs;
1261 static struct gpiod_lookup_table * const *gpiod_lookup_tables;
1262 static const struct software_node *bat_swnode;
1263 static void (*exit_handler)(void);
1265 static __init int x86_instantiate_i2c_client(const struct x86_dev_info *dev_info,
1268 const struct x86_i2c_client_info *client_info = &dev_info->i2c_client_info[idx];
1269 struct i2c_board_info board_info = client_info->board_info;
1270 struct i2c_adapter *adap;
1274 board_info.irq = x86_acpi_irq_helper_get(&client_info->irq_data);
1275 if (board_info.irq < 0)
1276 return board_info.irq;
1278 status = acpi_get_handle(NULL, client_info->adapter_path, &handle);
1279 if (ACPI_FAILURE(status)) {
1280 pr_err("Error could not get %s handle\n", client_info->adapter_path);
1284 adap = i2c_acpi_find_adapter_by_handle(handle);
1286 pr_err("error could not get %s adapter\n", client_info->adapter_path);
1290 i2c_clients[idx] = i2c_new_client_device(adap, &board_info);
1291 put_device(&adap->dev);
1292 if (IS_ERR(i2c_clients[idx]))
1293 return dev_err_probe(&adap->dev, PTR_ERR(i2c_clients[idx]),
1294 "creating I2C-client %d\n", idx);
1299 static __init int x86_instantiate_serdev(const struct x86_serdev_info *info, int idx)
1301 struct acpi_device *ctrl_adev, *serdev_adev;
1302 struct serdev_device *serdev;
1303 struct device *ctrl_dev;
1306 ctrl_adev = acpi_dev_get_first_match_dev(info->ctrl_hid, info->ctrl_uid, -1);
1308 pr_err("error could not get %s/%s ctrl adev\n",
1309 info->ctrl_hid, info->ctrl_uid);
1313 serdev_adev = acpi_dev_get_first_match_dev(info->serdev_hid, NULL, -1);
1315 pr_err("error could not get %s serdev adev\n", info->serdev_hid);
1319 /* get_first_physical_node() returns a weak ref, no need to put() it */
1320 ctrl_dev = acpi_get_first_physical_node(ctrl_adev);
1322 pr_err("error could not get %s/%s ctrl physical dev\n",
1323 info->ctrl_hid, info->ctrl_uid);
1324 goto put_serdev_adev;
1327 /* ctrl_dev now points to the controller's parent, get the controller */
1328 ctrl_dev = device_find_child_by_name(ctrl_dev, info->ctrl_devname);
1330 pr_err("error could not get %s/%s %s ctrl dev\n",
1331 info->ctrl_hid, info->ctrl_uid, info->ctrl_devname);
1332 goto put_serdev_adev;
1335 serdev = serdev_device_alloc(to_serdev_controller(ctrl_dev));
1338 goto put_serdev_adev;
1341 ACPI_COMPANION_SET(&serdev->dev, serdev_adev);
1342 acpi_device_set_enumerated(serdev_adev);
1344 ret = serdev_device_add(serdev);
1346 dev_err(&serdev->dev, "error %d adding serdev\n", ret);
1347 serdev_device_put(serdev);
1348 goto put_serdev_adev;
1351 serdevs[idx] = serdev;
1354 acpi_dev_put(serdev_adev);
1356 acpi_dev_put(ctrl_adev);
1360 static void x86_android_tablet_cleanup(void)
1364 for (i = 0; i < serdev_count; i++) {
1366 serdev_device_remove(serdevs[i]);
1371 for (i = 0; i < pdev_count; i++)
1372 platform_device_unregister(pdevs[i]);
1376 for (i = 0; i < i2c_client_count; i++)
1377 i2c_unregister_device(i2c_clients[i]);
1384 for (i = 0; gpiod_lookup_tables && gpiod_lookup_tables[i]; i++)
1385 gpiod_remove_lookup_table(gpiod_lookup_tables[i]);
1387 software_node_unregister(bat_swnode);
1390 static __init int x86_android_tablet_init(void)
1392 const struct x86_dev_info *dev_info;
1393 const struct dmi_system_id *id;
1394 struct gpio_chip *chip;
1397 id = dmi_first_match(x86_android_tablet_ids);
1401 dev_info = id->driver_data;
1404 * The broken DSDTs on these devices often also include broken
1405 * _AEI (ACPI Event Interrupt) handlers, disable these.
1407 if (dev_info->invalid_aei_gpiochip) {
1408 chip = gpiochip_find(dev_info->invalid_aei_gpiochip,
1409 gpiochip_find_match_label);
1411 pr_err("error cannot find GPIO chip %s\n", dev_info->invalid_aei_gpiochip);
1414 acpi_gpiochip_free_interrupts(chip);
1418 * Since this runs from module_init() it cannot use -EPROBE_DEFER,
1419 * instead pre-load any modules which are listed as requirements.
1421 for (i = 0; dev_info->modules && dev_info->modules[i]; i++)
1422 request_module(dev_info->modules[i]);
1424 bat_swnode = dev_info->bat_swnode;
1426 ret = software_node_register(bat_swnode);
1431 gpiod_lookup_tables = dev_info->gpiod_lookup_tables;
1432 for (i = 0; gpiod_lookup_tables && gpiod_lookup_tables[i]; i++)
1433 gpiod_add_lookup_table(gpiod_lookup_tables[i]);
1435 if (dev_info->init) {
1436 ret = dev_info->init();
1438 x86_android_tablet_cleanup();
1441 exit_handler = dev_info->exit;
1444 i2c_clients = kcalloc(dev_info->i2c_client_count, sizeof(*i2c_clients), GFP_KERNEL);
1446 x86_android_tablet_cleanup();
1450 i2c_client_count = dev_info->i2c_client_count;
1451 for (i = 0; i < i2c_client_count; i++) {
1452 ret = x86_instantiate_i2c_client(dev_info, i);
1454 x86_android_tablet_cleanup();
1459 pdevs = kcalloc(dev_info->pdev_count, sizeof(*pdevs), GFP_KERNEL);
1461 x86_android_tablet_cleanup();
1465 pdev_count = dev_info->pdev_count;
1466 for (i = 0; i < pdev_count; i++) {
1467 pdevs[i] = platform_device_register_full(&dev_info->pdev_info[i]);
1468 if (IS_ERR(pdevs[i])) {
1469 x86_android_tablet_cleanup();
1470 return PTR_ERR(pdevs[i]);
1474 serdevs = kcalloc(dev_info->serdev_count, sizeof(*serdevs), GFP_KERNEL);
1476 x86_android_tablet_cleanup();
1480 serdev_count = dev_info->serdev_count;
1481 for (i = 0; i < serdev_count; i++) {
1482 ret = x86_instantiate_serdev(&dev_info->serdev_info[i], i);
1484 x86_android_tablet_cleanup();
1492 module_init(x86_android_tablet_init);
1493 module_exit(x86_android_tablet_cleanup);
1495 MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>");
1496 MODULE_DESCRIPTION("X86 Android tablets DSDT fixups driver");
1497 MODULE_LICENSE("GPL");