| // SPDX-License-Identifier: GPL-2.0-or-later | |
| /* | |
| * DMI based code to deal with broken DSDTs on X86 tablets which ship with | |
| * Android as (part of) the factory image. The factory kernels shipped on these | |
| * devices typically have a bunch of things hardcoded, rather than specified | |
| * in their DSDT. | |
| * | |
| * Copyright (C) 2021-2023 Hans de Goede <hansg@kernel.org> | |
| */ | |
| #include <linux/acpi.h> | |
| #include <linux/gpio/machine.h> | |
| #include <linux/gpio/property.h> | |
| #include <linux/input-event-codes.h> | |
| #include <linux/leds.h> | |
| #include <linux/pci.h> | |
| #include <linux/platform_device.h> | |
| #include <linux/pwm.h> | |
| #include <dt-bindings/leds/common.h> | |
| #include "shared-psy-info.h" | |
| #include "x86-android-tablets.h" | |
| /* | |
| * Advantech MICA-071 | |
| * This is a standard Windows tablet, but it has an extra "quick launch" button | |
| * which is not described in the ACPI tables in anyway. | |
| * Use the x86-android-tablets infra to create a gpio-keys device for this. | |
| */ | |
| static const struct software_node advantech_mica_071_gpio_keys_node = { | |
| .name = "prog1_key", | |
| }; | |
| static const struct property_entry advantech_mica_071_prog1_key_props[] = { | |
| PROPERTY_ENTRY_U32("linux,code", KEY_PROG1), | |
| PROPERTY_ENTRY_STRING("label", "prog1_key"), | |
| PROPERTY_ENTRY_GPIO("gpios", &baytrail_gpiochip_nodes[0], 2, GPIO_ACTIVE_LOW), | |
| PROPERTY_ENTRY_U32("debounce-interval", 50), | |
| { } | |
| }; | |
| static const struct software_node advantech_mica_071_prog1_key_node = { | |
| .parent = &advantech_mica_071_gpio_keys_node, | |
| .properties = advantech_mica_071_prog1_key_props, | |
| }; | |
| static const struct software_node *advantech_mica_071_button_swnodes[] = { | |
| &advantech_mica_071_gpio_keys_node, | |
| &advantech_mica_071_prog1_key_node, | |
| NULL | |
| }; | |
| const struct x86_dev_info advantech_mica_071_info __initconst = { | |
| .gpio_button_swnodes = advantech_mica_071_button_swnodes, | |
| .gpiochip_type = X86_GPIOCHIP_BAYTRAIL, | |
| }; | |
| /* | |
| * When booted with the BIOS set to Android mode the Chuwi Hi8 (CWI509) DSDT | |
| * contains a whole bunch of bogus ACPI I2C devices and is missing entries | |
| * for the touchscreen and the accelerometer. | |
| */ | |
| static const struct property_entry chuwi_hi8_gsl1680_props[] = { | |
| PROPERTY_ENTRY_U32("touchscreen-size-x", 1665), | |
| PROPERTY_ENTRY_U32("touchscreen-size-y", 1140), | |
| PROPERTY_ENTRY_BOOL("touchscreen-swapped-x-y"), | |
| PROPERTY_ENTRY_BOOL("silead,home-button"), | |
| PROPERTY_ENTRY_STRING("firmware-name", "gsl1680-chuwi-hi8.fw"), | |
| { } | |
| }; | |
| static const struct software_node chuwi_hi8_gsl1680_node = { | |
| .properties = chuwi_hi8_gsl1680_props, | |
| }; | |
| static const char * const chuwi_hi8_mount_matrix[] = { | |
| "1", "0", "0", | |
| "0", "-1", "0", | |
| "0", "0", "1" | |
| }; | |
| static const struct property_entry chuwi_hi8_bma250e_props[] = { | |
| PROPERTY_ENTRY_STRING_ARRAY("mount-matrix", chuwi_hi8_mount_matrix), | |
| { } | |
| }; | |
| static const struct software_node chuwi_hi8_bma250e_node = { | |
| .properties = chuwi_hi8_bma250e_props, | |
| }; | |
| static const struct x86_i2c_client_info chuwi_hi8_i2c_clients[] __initconst = { | |
| { | |
| /* Silead touchscreen */ | |
| .board_info = { | |
| .type = "gsl1680", | |
| .addr = 0x40, | |
| .swnode = &chuwi_hi8_gsl1680_node, | |
| }, | |
| .adapter_path = "\\_SB_.I2C4", | |
| .irq_data = { | |
| .type = X86_ACPI_IRQ_TYPE_APIC, | |
| .index = 0x44, | |
| .trigger = ACPI_EDGE_SENSITIVE, | |
| .polarity = ACPI_ACTIVE_HIGH, | |
| }, | |
| }, { | |
| /* BMA250E accelerometer */ | |
| .board_info = { | |
| .type = "bma250e", | |
| .addr = 0x18, | |
| .swnode = &chuwi_hi8_bma250e_node, | |
| }, | |
| .adapter_path = "\\_SB_.I2C3", | |
| .irq_data = { | |
| .type = X86_ACPI_IRQ_TYPE_GPIOINT, | |
| .chip = "INT33FC:02", | |
| .index = 23, | |
| .trigger = ACPI_LEVEL_SENSITIVE, | |
| .polarity = ACPI_ACTIVE_HIGH, | |
| .con_id = "bma250e_irq", | |
| }, | |
| }, | |
| }; | |
| static int __init chuwi_hi8_init(struct device *dev) | |
| { | |
| /* | |
| * Avoid the acpi_unregister_gsi() call in x86_acpi_irq_helper_get() | |
| * breaking the touchscreen + logging various errors when the Windows | |
| * BIOS is used. | |
| */ | |
| if (acpi_dev_present("MSSL0001", NULL, 1)) | |
| return -ENODEV; | |
| return 0; | |
| } | |
| const struct x86_dev_info chuwi_hi8_info __initconst = { | |
| .i2c_client_info = chuwi_hi8_i2c_clients, | |
| .i2c_client_count = ARRAY_SIZE(chuwi_hi8_i2c_clients), | |
| .init = chuwi_hi8_init, | |
| }; | |
| /* | |
| * Cyberbook T116 Android version | |
| * This comes in both Windows and Android versions and even on Android | |
| * the DSDT is mostly sane. This tablet has 2 extra general purpose buttons | |
| * in the button row with the power + volume-buttons labeled P and F. | |
| * Use the x86-android-tablets infra to create a gpio-keys device for these. | |
| */ | |
| static const struct software_node cyberbook_t116_gpio_keys_node = { | |
| .name = "prog_keys", | |
| }; | |
| static const struct property_entry cyberbook_t116_prog1_key_props[] = { | |
| PROPERTY_ENTRY_U32("linux,code", KEY_PROG1), | |
| PROPERTY_ENTRY_STRING("label", "prog1_key"), | |
| PROPERTY_ENTRY_GPIO("gpios", &cherryview_gpiochip_nodes[0], 30, GPIO_ACTIVE_LOW), | |
| PROPERTY_ENTRY_U32("debounce-interval", 50), | |
| { } | |
| }; | |
| static const struct software_node cyberbook_t116_prog1_key_node = { | |
| .parent = &cyberbook_t116_gpio_keys_node, | |
| .properties = cyberbook_t116_prog1_key_props, | |
| }; | |
| static const struct property_entry cyberbook_t116_prog2_key_props[] = { | |
| PROPERTY_ENTRY_U32("linux,code", KEY_PROG2), | |
| PROPERTY_ENTRY_STRING("label", "prog2_key"), | |
| PROPERTY_ENTRY_GPIO("gpios", &cherryview_gpiochip_nodes[3], 48, GPIO_ACTIVE_LOW), | |
| PROPERTY_ENTRY_U32("debounce-interval", 50), | |
| { } | |
| }; | |
| static const struct software_node cyberbook_t116_prog2_key_node = { | |
| .parent = &cyberbook_t116_gpio_keys_node, | |
| .properties = cyberbook_t116_prog2_key_props, | |
| }; | |
| static const struct software_node *cyberbook_t116_buttons_swnodes[] = { | |
| &cyberbook_t116_gpio_keys_node, | |
| &cyberbook_t116_prog1_key_node, | |
| &cyberbook_t116_prog2_key_node, | |
| NULL | |
| }; | |
| const struct x86_dev_info cyberbook_t116_info __initconst = { | |
| .gpio_button_swnodes = cyberbook_t116_buttons_swnodes, | |
| .gpiochip_type = X86_GPIOCHIP_CHERRYVIEW, | |
| }; | |
| #define CZC_EC_EXTRA_PORT 0x68 | |
| #define CZC_EC_ANDROID_KEYS 0x63 | |
| static int __init czc_p10t_init(struct device *dev) | |
| { | |
| /* | |
| * The device boots up in "Windows 7" mode, when the home button sends a | |
| * Windows specific key sequence (Left Meta + D) and the second button | |
| * sends an unknown one while also toggling the Radio Kill Switch. | |
| * This is a surprising behavior when the second button is labeled "Back". | |
| * | |
| * The vendor-supplied Android-x86 build switches the device to a "Android" | |
| * mode by writing value 0x63 to the I/O port 0x68. This just seems to just | |
| * set bit 6 on address 0x96 in the EC region; switching the bit directly | |
| * seems to achieve the same result. It uses a "p10t_switcher" to do the | |
| * job. It doesn't seem to be able to do anything else, and no other use | |
| * of the port 0x68 is known. | |
| * | |
| * In the Android mode, the home button sends just a single scancode, | |
| * which can be handled in Linux userspace more reasonably and the back | |
| * button only sends a scancode without toggling the kill switch. | |
| * The scancode can then be mapped either to Back or RF Kill functionality | |
| * in userspace, depending on how the button is labeled on that particular | |
| * model. | |
| */ | |
| outb(CZC_EC_ANDROID_KEYS, CZC_EC_EXTRA_PORT); | |
| return 0; | |
| } | |
| const struct x86_dev_info czc_p10t __initconst = { | |
| .init = czc_p10t_init, | |
| }; | |
| /* Medion Lifetab S10346 tablets have an Android factory image with everything hardcoded */ | |
| static const char * const medion_lifetab_s10346_accel_mount_matrix[] = { | |
| "0", "1", "0", | |
| "1", "0", "0", | |
| "0", "0", "1" | |
| }; | |
| static const struct property_entry medion_lifetab_s10346_accel_props[] = { | |
| PROPERTY_ENTRY_STRING_ARRAY("mount-matrix", medion_lifetab_s10346_accel_mount_matrix), | |
| { } | |
| }; | |
| static const struct software_node medion_lifetab_s10346_accel_node = { | |
| .properties = medion_lifetab_s10346_accel_props, | |
| }; | |
| /* Note the LCD panel is mounted upside down, this is correctly indicated in the VBT */ | |
| static const struct property_entry medion_lifetab_s10346_touchscreen_props[] = { | |
| PROPERTY_ENTRY_BOOL("touchscreen-inverted-x"), | |
| PROPERTY_ENTRY_BOOL("touchscreen-swapped-x-y"), | |
| PROPERTY_ENTRY_GPIO("reset-gpios", &baytrail_gpiochip_nodes[1], 26, GPIO_ACTIVE_HIGH), | |
| PROPERTY_ENTRY_GPIO("irq-gpios", &baytrail_gpiochip_nodes[2], 3, GPIO_ACTIVE_HIGH), | |
| { } | |
| }; | |
| static const struct software_node medion_lifetab_s10346_touchscreen_node = { | |
| .properties = medion_lifetab_s10346_touchscreen_props, | |
| }; | |
| static const struct x86_i2c_client_info medion_lifetab_s10346_i2c_clients[] __initconst = { | |
| { | |
| /* kxtj21009 accelerometer */ | |
| .board_info = { | |
| .type = "kxtj21009", | |
| .addr = 0x0f, | |
| .dev_name = "kxtj21009", | |
| .swnode = &medion_lifetab_s10346_accel_node, | |
| }, | |
| .adapter_path = "\\_SB_.I2C3", | |
| .irq_data = { | |
| .type = X86_ACPI_IRQ_TYPE_GPIOINT, | |
| .chip = "INT33FC:02", | |
| .index = 23, | |
| .trigger = ACPI_EDGE_SENSITIVE, | |
| .polarity = ACPI_ACTIVE_HIGH, | |
| .con_id = "kxtj21009_irq", | |
| }, | |
| }, { | |
| /* goodix touchscreen */ | |
| .board_info = { | |
| .type = "GDIX1001:00", | |
| .addr = 0x14, | |
| .dev_name = "goodix_ts", | |
| .swnode = &medion_lifetab_s10346_touchscreen_node, | |
| }, | |
| .adapter_path = "\\_SB_.I2C4", | |
| .irq_data = { | |
| .type = X86_ACPI_IRQ_TYPE_APIC, | |
| .index = 0x44, | |
| .trigger = ACPI_EDGE_SENSITIVE, | |
| .polarity = ACPI_ACTIVE_LOW, | |
| }, | |
| }, | |
| }; | |
| const struct x86_dev_info medion_lifetab_s10346_info __initconst = { | |
| .i2c_client_info = medion_lifetab_s10346_i2c_clients, | |
| .i2c_client_count = ARRAY_SIZE(medion_lifetab_s10346_i2c_clients), | |
| .gpiochip_type = X86_GPIOCHIP_BAYTRAIL, | |
| }; | |
| /* Nextbook Ares 8 (BYT) tablets have an Android factory image with everything hardcoded */ | |
| static const char * const nextbook_ares8_accel_mount_matrix[] = { | |
| "0", "-1", "0", | |
| "-1", "0", "0", | |
| "0", "0", "1" | |
| }; | |
| static const struct property_entry nextbook_ares8_accel_props[] = { | |
| PROPERTY_ENTRY_STRING_ARRAY("mount-matrix", nextbook_ares8_accel_mount_matrix), | |
| { } | |
| }; | |
| static const struct software_node nextbook_ares8_accel_node = { | |
| .properties = nextbook_ares8_accel_props, | |
| }; | |
| static const struct property_entry nextbook_ares8_touchscreen_props[] = { | |
| PROPERTY_ENTRY_U32("touchscreen-size-x", 800), | |
| PROPERTY_ENTRY_U32("touchscreen-size-y", 1280), | |
| { } | |
| }; | |
| static const struct software_node nextbook_ares8_touchscreen_node = { | |
| .properties = nextbook_ares8_touchscreen_props, | |
| }; | |
| static const struct x86_i2c_client_info nextbook_ares8_i2c_clients[] __initconst = { | |
| { | |
| /* Freescale MMA8653FC accelerometer */ | |
| .board_info = { | |
| .type = "mma8653", | |
| .addr = 0x1d, | |
| .dev_name = "mma8653", | |
| .swnode = &nextbook_ares8_accel_node, | |
| }, | |
| .adapter_path = "\\_SB_.I2C3", | |
| }, { | |
| /* FT5416DQ9 touchscreen controller */ | |
| .board_info = { | |
| .type = "edt-ft5x06", | |
| .addr = 0x38, | |
| .dev_name = "ft5416", | |
| .swnode = &nextbook_ares8_touchscreen_node, | |
| }, | |
| .adapter_path = "\\_SB_.I2C4", | |
| .irq_data = { | |
| .type = X86_ACPI_IRQ_TYPE_GPIOINT, | |
| .chip = "INT33FC:02", | |
| .index = 3, | |
| .trigger = ACPI_EDGE_SENSITIVE, | |
| .polarity = ACPI_ACTIVE_LOW, | |
| .con_id = "ft5416_irq", | |
| }, | |
| }, | |
| }; | |
| const struct x86_dev_info nextbook_ares8_info __initconst = { | |
| .i2c_client_info = nextbook_ares8_i2c_clients, | |
| .i2c_client_count = ARRAY_SIZE(nextbook_ares8_i2c_clients), | |
| .pdev_info = int3496_pdevs, | |
| .pdev_count = 1, | |
| .gpiochip_type = X86_GPIOCHIP_BAYTRAIL, | |
| }; | |
| /* Nextbook Ares 8A (CHT) tablets have an Android factory image with everything hardcoded */ | |
| static const char * const nextbook_ares8a_accel_mount_matrix[] = { | |
| "1", "0", "0", | |
| "0", "-1", "0", | |
| "0", "0", "1" | |
| }; | |
| static const struct property_entry nextbook_ares8a_accel_props[] = { | |
| PROPERTY_ENTRY_STRING_ARRAY("mount-matrix", nextbook_ares8a_accel_mount_matrix), | |
| { } | |
| }; | |
| static const struct software_node nextbook_ares8a_accel_node = { | |
| .properties = nextbook_ares8a_accel_props, | |
| }; | |
| static const struct property_entry nextbook_ares8a_ft5416_props[] = { | |
| PROPERTY_ENTRY_U32("touchscreen-size-x", 800), | |
| PROPERTY_ENTRY_U32("touchscreen-size-y", 1280), | |
| PROPERTY_ENTRY_GPIO("reset-gpios", &cherryview_gpiochip_nodes[1], 25, GPIO_ACTIVE_LOW), | |
| { } | |
| }; | |
| static const struct software_node nextbook_ares8a_ft5416_node = { | |
| .properties = nextbook_ares8a_ft5416_props, | |
| }; | |
| static const struct x86_i2c_client_info nextbook_ares8a_i2c_clients[] __initconst = { | |
| { | |
| /* Freescale MMA8653FC accelerometer */ | |
| .board_info = { | |
| .type = "mma8653", | |
| .addr = 0x1d, | |
| .dev_name = "mma8653", | |
| .swnode = &nextbook_ares8a_accel_node, | |
| }, | |
| .adapter_path = "\\_SB_.PCI0.I2C3", | |
| }, { | |
| /* FT5416DQ9 touchscreen controller */ | |
| .board_info = { | |
| .type = "edt-ft5x06", | |
| .addr = 0x38, | |
| .dev_name = "ft5416", | |
| .swnode = &nextbook_ares8a_ft5416_node, | |
| }, | |
| .adapter_path = "\\_SB_.PCI0.I2C6", | |
| .irq_data = { | |
| .type = X86_ACPI_IRQ_TYPE_GPIOINT, | |
| .chip = "INT33FF:01", | |
| .index = 17, | |
| .trigger = ACPI_EDGE_SENSITIVE, | |
| .polarity = ACPI_ACTIVE_LOW, | |
| .con_id = "ft5416_irq", | |
| }, | |
| }, | |
| }; | |
| const struct x86_dev_info nextbook_ares8a_info __initconst = { | |
| .i2c_client_info = nextbook_ares8a_i2c_clients, | |
| .i2c_client_count = ARRAY_SIZE(nextbook_ares8a_i2c_clients), | |
| .gpiochip_type = X86_GPIOCHIP_CHERRYVIEW, | |
| }; | |
| /* | |
| * Peaq C1010 | |
| * This is a standard Windows tablet, but it has a special Dolby button. | |
| * This button has a WMI interface, but that is broken. Instead of trying to | |
| * use the broken WMI interface, instantiate a gpio-keys device for this. | |
| */ | |
| static const struct software_node peaq_c1010_gpio_keys_node = { | |
| .name = "gpio_keys", | |
| }; | |
| static const struct property_entry peaq_c1010_dolby_key_props[] = { | |
| PROPERTY_ENTRY_U32("linux,code", KEY_SOUND), | |
| PROPERTY_ENTRY_STRING("label", "dolby_key"), | |
| PROPERTY_ENTRY_GPIO("gpios", &baytrail_gpiochip_nodes[0], 3, GPIO_ACTIVE_LOW), | |
| PROPERTY_ENTRY_U32("debounce-interval", 50), | |
| { } | |
| }; | |
| static const struct software_node peaq_c1010_dolby_key_node = { | |
| .parent = &peaq_c1010_gpio_keys_node, | |
| .properties = peaq_c1010_dolby_key_props, | |
| }; | |
| static const struct software_node *peaq_c1010_button_swnodes[] = { | |
| &peaq_c1010_gpio_keys_node, | |
| &peaq_c1010_dolby_key_node, | |
| NULL | |
| }; | |
| const struct x86_dev_info peaq_c1010_info __initconst = { | |
| .gpio_button_swnodes = peaq_c1010_button_swnodes, | |
| .gpiochip_type = X86_GPIOCHIP_BAYTRAIL, | |
| }; | |
| /* | |
| * Whitelabel (sold as various brands) TM800A550L tablets. | |
| * These tablet's DSDT contains a whole bunch of bogus ACPI I2C devices | |
| * (removed through acpi_quirk_skip_i2c_client_enumeration()) and | |
| * the touchscreen firmware node has the wrong GPIOs. | |
| */ | |
| static const char * const whitelabel_tm800a550l_accel_mount_matrix[] = { | |
| "-1", "0", "0", | |
| "0", "1", "0", | |
| "0", "0", "1" | |
| }; | |
| static const struct property_entry whitelabel_tm800a550l_accel_props[] = { | |
| PROPERTY_ENTRY_STRING_ARRAY("mount-matrix", whitelabel_tm800a550l_accel_mount_matrix), | |
| { } | |
| }; | |
| static const struct software_node whitelabel_tm800a550l_accel_node = { | |
| .properties = whitelabel_tm800a550l_accel_props, | |
| }; | |
| static const struct property_entry whitelabel_tm800a550l_goodix_props[] = { | |
| PROPERTY_ENTRY_STRING("firmware-name", "gt912-tm800a550l.fw"), | |
| PROPERTY_ENTRY_STRING("goodix,config-name", "gt912-tm800a550l.cfg"), | |
| PROPERTY_ENTRY_U32("goodix,main-clk", 54), | |
| PROPERTY_ENTRY_GPIO("reset-gpios", &baytrail_gpiochip_nodes[1], 26, GPIO_ACTIVE_HIGH), | |
| PROPERTY_ENTRY_GPIO("irq-gpios", &baytrail_gpiochip_nodes[2], 3, GPIO_ACTIVE_HIGH), | |
| { } | |
| }; | |
| static const struct software_node whitelabel_tm800a550l_goodix_node = { | |
| .properties = whitelabel_tm800a550l_goodix_props, | |
| }; | |
| static const struct x86_i2c_client_info whitelabel_tm800a550l_i2c_clients[] __initconst = { | |
| { | |
| /* goodix touchscreen */ | |
| .board_info = { | |
| .type = "GDIX1001:00", | |
| .addr = 0x14, | |
| .dev_name = "goodix_ts", | |
| .swnode = &whitelabel_tm800a550l_goodix_node, | |
| }, | |
| .adapter_path = "\\_SB_.I2C2", | |
| .irq_data = { | |
| .type = X86_ACPI_IRQ_TYPE_APIC, | |
| .index = 0x44, | |
| .trigger = ACPI_EDGE_SENSITIVE, | |
| .polarity = ACPI_ACTIVE_HIGH, | |
| }, | |
| }, { | |
| /* kxcj91008 accelerometer */ | |
| .board_info = { | |
| .type = "kxcj91008", | |
| .addr = 0x0f, | |
| .dev_name = "kxcj91008", | |
| .swnode = &whitelabel_tm800a550l_accel_node, | |
| }, | |
| .adapter_path = "\\_SB_.I2C3", | |
| }, | |
| }; | |
| const struct x86_dev_info whitelabel_tm800a550l_info __initconst = { | |
| .i2c_client_info = whitelabel_tm800a550l_i2c_clients, | |
| .i2c_client_count = ARRAY_SIZE(whitelabel_tm800a550l_i2c_clients), | |
| .gpiochip_type = X86_GPIOCHIP_BAYTRAIL, | |
| }; | |
| /* | |
| * Vexia EDU ATLA 10 tablet 5V, Android 4.4 + Guadalinex Ubuntu tablet | |
| * distributed to schools in the Spanish AndalucÃa region. | |
| */ | |
| static const struct property_entry vexia_edu_atla10_5v_touchscreen_props[] = { | |
| PROPERTY_ENTRY_U32("hid-descr-addr", 0x0000), | |
| PROPERTY_ENTRY_U32("post-reset-deassert-delay-ms", 120), | |
| PROPERTY_ENTRY_GPIO("reset-gpios", &baytrail_gpiochip_nodes[1], 26, GPIO_ACTIVE_LOW), | |
| { } | |
| }; | |
| static const struct software_node vexia_edu_atla10_5v_touchscreen_node = { | |
| .properties = vexia_edu_atla10_5v_touchscreen_props, | |
| }; | |
| static const struct x86_i2c_client_info vexia_edu_atla10_5v_i2c_clients[] __initconst = { | |
| { | |
| /* kxcjk1013 accelerometer */ | |
| .board_info = { | |
| .type = "kxcjk1013", | |
| .addr = 0x0f, | |
| .dev_name = "kxcjk1013", | |
| }, | |
| .adapter_path = "\\_SB_.I2C3", | |
| }, { | |
| /* touchscreen controller */ | |
| .board_info = { | |
| .type = "hid-over-i2c", | |
| .addr = 0x38, | |
| .dev_name = "FTSC1000", | |
| .swnode = &vexia_edu_atla10_5v_touchscreen_node, | |
| }, | |
| .adapter_path = "\\_SB_.I2C4", | |
| .irq_data = { | |
| .type = X86_ACPI_IRQ_TYPE_APIC, | |
| .index = 0x44, | |
| .trigger = ACPI_LEVEL_SENSITIVE, | |
| .polarity = ACPI_ACTIVE_HIGH, | |
| }, | |
| } | |
| }; | |
| const struct x86_dev_info vexia_edu_atla10_5v_info __initconst = { | |
| .i2c_client_info = vexia_edu_atla10_5v_i2c_clients, | |
| .i2c_client_count = ARRAY_SIZE(vexia_edu_atla10_5v_i2c_clients), | |
| .gpiochip_type = X86_GPIOCHIP_BAYTRAIL, | |
| }; | |
| /* | |
| * Vexia EDU ATLA 10 tablet 9V, Android 4.2 + Guadalinex Ubuntu tablet | |
| * distributed to schools in the Spanish AndalucÃa region. | |
| */ | |
| static const char * const crystal_cove_pwrsrc_psy[] = { "crystal_cove_pwrsrc" }; | |
| static const struct property_entry vexia_edu_atla10_9v_ulpmc_props[] = { | |
| PROPERTY_ENTRY_STRING_ARRAY("supplied-from", crystal_cove_pwrsrc_psy), | |
| { } | |
| }; | |
| static const struct software_node vexia_edu_atla10_9v_ulpmc_node = { | |
| .properties = vexia_edu_atla10_9v_ulpmc_props, | |
| }; | |
| static const char * const vexia_edu_atla10_9v_accel_mount_matrix[] = { | |
| "0", "-1", "0", | |
| "1", "0", "0", | |
| "0", "0", "1" | |
| }; | |
| static const struct property_entry vexia_edu_atla10_9v_accel_props[] = { | |
| PROPERTY_ENTRY_STRING_ARRAY("mount-matrix", vexia_edu_atla10_9v_accel_mount_matrix), | |
| { } | |
| }; | |
| static const struct software_node vexia_edu_atla10_9v_accel_node = { | |
| .properties = vexia_edu_atla10_9v_accel_props, | |
| }; | |
| static const struct property_entry vexia_edu_atla10_9v_touchscreen_props[] = { | |
| PROPERTY_ENTRY_U32("hid-descr-addr", 0x0000), | |
| PROPERTY_ENTRY_U32("post-reset-deassert-delay-ms", 120), | |
| PROPERTY_ENTRY_GPIO("reset-gpios", &baytrail_gpiochip_nodes[0], 60, GPIO_ACTIVE_LOW), | |
| { } | |
| }; | |
| static const struct software_node vexia_edu_atla10_9v_touchscreen_node = { | |
| .properties = vexia_edu_atla10_9v_touchscreen_props, | |
| }; | |
| static const struct property_entry vexia_edu_atla10_9v_pmic_props[] = { | |
| PROPERTY_ENTRY_BOOL("linux,register-pwrsrc-power_supply"), | |
| { } | |
| }; | |
| static const struct software_node vexia_edu_atla10_9v_pmic_node = { | |
| .properties = vexia_edu_atla10_9v_pmic_props, | |
| }; | |
| static const struct x86_i2c_client_info vexia_edu_atla10_9v_i2c_clients[] __initconst = { | |
| { | |
| /* I2C attached embedded controller, used to access fuel-gauge */ | |
| .board_info = { | |
| .type = "vexia_atla10_ec", | |
| .addr = 0x76, | |
| .dev_name = "ulpmc", | |
| .swnode = &vexia_edu_atla10_9v_ulpmc_node, | |
| }, | |
| .adapter_path = "0000:00:18.1", | |
| }, { | |
| /* RT5642 audio codec */ | |
| .board_info = { | |
| .type = "rt5640", | |
| .addr = 0x1c, | |
| .dev_name = "rt5640", | |
| }, | |
| .adapter_path = "0000:00:18.2", | |
| .irq_data = { | |
| .type = X86_ACPI_IRQ_TYPE_GPIOINT, | |
| .chip = "INT33FC:02", | |
| .index = 4, | |
| .trigger = ACPI_EDGE_SENSITIVE, | |
| .polarity = ACPI_ACTIVE_HIGH, | |
| .con_id = "rt5640_irq", | |
| }, | |
| }, { | |
| /* kxtj21009 accelerometer */ | |
| .board_info = { | |
| .type = "kxtj21009", | |
| .addr = 0x0f, | |
| .dev_name = "kxtj21009", | |
| .swnode = &vexia_edu_atla10_9v_accel_node, | |
| }, | |
| .adapter_path = "0000:00:18.5", | |
| }, { | |
| /* FT5416DQ9 touchscreen controller */ | |
| .board_info = { | |
| .type = "hid-over-i2c", | |
| .addr = 0x38, | |
| .dev_name = "FTSC1000", | |
| .swnode = &vexia_edu_atla10_9v_touchscreen_node, | |
| }, | |
| .adapter_path = "0000:00:18.6", | |
| .irq_data = { | |
| .type = X86_ACPI_IRQ_TYPE_APIC, | |
| .index = 0x45, | |
| .trigger = ACPI_LEVEL_SENSITIVE, | |
| .polarity = ACPI_ACTIVE_HIGH, | |
| }, | |
| }, { | |
| /* Crystal Cove PMIC */ | |
| .board_info = { | |
| .type = "intel_soc_pmic_crc", | |
| .addr = 0x6e, | |
| .dev_name = "intel_soc_pmic_crc", | |
| .swnode = &vexia_edu_atla10_9v_pmic_node, | |
| }, | |
| .adapter_path = "0000:00:18.7", | |
| .irq_data = { | |
| .type = X86_ACPI_IRQ_TYPE_APIC, | |
| .index = 0x43, | |
| .trigger = ACPI_LEVEL_SENSITIVE, | |
| .polarity = ACPI_ACTIVE_HIGH, | |
| }, | |
| } | |
| }; | |
| static const struct x86_serdev_info vexia_edu_atla10_9v_serdevs[] __initconst = { | |
| { | |
| .ctrl.pci.devfn = PCI_DEVFN(0x1e, 3), | |
| .ctrl_devname = "serial0", | |
| .serdev_hid = "OBDA8723", | |
| }, | |
| }; | |
| static int __init vexia_edu_atla10_9v_init(struct device *dev) | |
| { | |
| struct pci_dev *pdev; | |
| int ret; | |
| /* Enable the Wifi module by setting the wifi_enable pin to 1 */ | |
| ret = x86_android_tablet_get_gpiod("INT33FC:02", 20, "wifi_enable", | |
| false, GPIOD_OUT_HIGH, NULL); | |
| if (ret) | |
| return ret; | |
| /* Reprobe the SDIO controller to enumerate the now enabled Wifi module */ | |
| pdev = pci_get_domain_bus_and_slot(0, 0, PCI_DEVFN(0x11, 0)); | |
| if (!pdev) { | |
| pr_warn("Could not get PCI SDIO at devfn 0x%02x\n", PCI_DEVFN(0x11, 0)); | |
| return 0; | |
| } | |
| ret = device_reprobe(&pdev->dev); | |
| if (ret) | |
| pci_warn(pdev, "Reprobing error: %d\n", ret); | |
| pci_dev_put(pdev); | |
| return 0; | |
| } | |
| const struct x86_dev_info vexia_edu_atla10_9v_info __initconst = { | |
| .i2c_client_info = vexia_edu_atla10_9v_i2c_clients, | |
| .i2c_client_count = ARRAY_SIZE(vexia_edu_atla10_9v_i2c_clients), | |
| .serdev_info = vexia_edu_atla10_9v_serdevs, | |
| .serdev_count = ARRAY_SIZE(vexia_edu_atla10_9v_serdevs), | |
| .init = vexia_edu_atla10_9v_init, | |
| .use_pci = true, | |
| .gpiochip_type = X86_GPIOCHIP_BAYTRAIL, | |
| }; | |
| /* | |
| * The firmware node for ktd2026 on Xaomi pad2. It composed of a RGB LED node | |
| * with three subnodes for each color (B/G/R). The RGB LED node is named | |
| * "multi-led" to align with the name in the device tree. | |
| */ | |
| /* Main firmware node for ktd2026 */ | |
| static const struct software_node ktd2026_node = { | |
| .name = "ktd2026", | |
| }; | |
| static const struct property_entry ktd2026_rgb_led_props[] = { | |
| PROPERTY_ENTRY_U32("reg", 0), | |
| PROPERTY_ENTRY_U32("color", LED_COLOR_ID_RGB), | |
| PROPERTY_ENTRY_STRING("label", "mipad2:rgb:indicator"), | |
| PROPERTY_ENTRY_STRING("linux,default-trigger", "bq27520-0-charging-orange-full-green"), | |
| { } | |
| }; | |
| static const struct software_node ktd2026_rgb_led_node = { | |
| .name = "multi-led", | |
| .properties = ktd2026_rgb_led_props, | |
| .parent = &ktd2026_node, | |
| }; | |
| static const struct property_entry ktd2026_blue_led_props[] = { | |
| PROPERTY_ENTRY_U32("reg", 0), | |
| PROPERTY_ENTRY_U32("color", LED_COLOR_ID_BLUE), | |
| { } | |
| }; | |
| static const struct software_node ktd2026_blue_led_node = { | |
| .properties = ktd2026_blue_led_props, | |
| .parent = &ktd2026_rgb_led_node, | |
| }; | |
| static const struct property_entry ktd2026_green_led_props[] = { | |
| PROPERTY_ENTRY_U32("reg", 1), | |
| PROPERTY_ENTRY_U32("color", LED_COLOR_ID_GREEN), | |
| { } | |
| }; | |
| static const struct software_node ktd2026_green_led_node = { | |
| .properties = ktd2026_green_led_props, | |
| .parent = &ktd2026_rgb_led_node, | |
| }; | |
| static const struct property_entry ktd2026_red_led_props[] = { | |
| PROPERTY_ENTRY_U32("reg", 2), | |
| PROPERTY_ENTRY_U32("color", LED_COLOR_ID_RED), | |
| { } | |
| }; | |
| static const struct software_node ktd2026_red_led_node = { | |
| .properties = ktd2026_red_led_props, | |
| .parent = &ktd2026_rgb_led_node, | |
| }; | |
| static const struct software_node *ktd2026_node_group[] = { | |
| &ktd2026_node, | |
| &ktd2026_rgb_led_node, | |
| &ktd2026_red_led_node, | |
| &ktd2026_green_led_node, | |
| &ktd2026_blue_led_node, | |
| NULL | |
| }; | |
| /* | |
| * For the LEDs which backlight the Menu / Home / Back capacitive buttons on | |
| * the bottom bezel. These are attached to a TPS61158 LED controller which | |
| * is controlled by the "pwm_soc_lpss_2" PWM output. | |
| */ | |
| #define XIAOMI_MIPAD2_LED_PERIOD_NS 19200 | |
| #define XIAOMI_MIPAD2_LED_MAX_DUTY_NS 6000 /* From Android kernel */ | |
| static struct pwm_device *xiaomi_mipad2_led_pwm; | |
| static int xiaomi_mipad2_brightness_set(struct led_classdev *led_cdev, | |
| enum led_brightness val) | |
| { | |
| struct pwm_state state = { | |
| .period = XIAOMI_MIPAD2_LED_PERIOD_NS, | |
| .duty_cycle = XIAOMI_MIPAD2_LED_MAX_DUTY_NS * val / LED_FULL, | |
| /* Always set PWM enabled to avoid the pin floating */ | |
| .enabled = true, | |
| }; | |
| return pwm_apply_might_sleep(xiaomi_mipad2_led_pwm, &state); | |
| } | |
| static int __init xiaomi_mipad2_init(struct device *dev) | |
| { | |
| struct led_classdev *led_cdev; | |
| xiaomi_mipad2_led_pwm = devm_pwm_get(dev, "pwm_soc_lpss_2"); | |
| if (IS_ERR(xiaomi_mipad2_led_pwm)) | |
| return dev_err_probe(dev, PTR_ERR(xiaomi_mipad2_led_pwm), "getting pwm\n"); | |
| led_cdev = devm_kzalloc(dev, sizeof(*led_cdev), GFP_KERNEL); | |
| if (!led_cdev) | |
| return -ENOMEM; | |
| led_cdev->name = "mipad2:white:touch-buttons-backlight"; | |
| led_cdev->max_brightness = LED_FULL; | |
| led_cdev->default_trigger = "input-events"; | |
| led_cdev->brightness_set_blocking = xiaomi_mipad2_brightness_set; | |
| /* Turn LED off during suspend */ | |
| led_cdev->flags = LED_CORE_SUSPENDRESUME; | |
| return devm_led_classdev_register(dev, led_cdev); | |
| } | |
| /* | |
| * If the EFI bootloader is not Xiaomi's own signed Android loader, then the | |
| * Xiaomi Mi Pad 2 X86 tablet sets OSID in the DSDT to 1 (Windows), causing | |
| * a bunch of devices to be hidden. | |
| * | |
| * This takes care of instantiating the hidden devices manually. | |
| */ | |
| static const struct x86_i2c_client_info xiaomi_mipad2_i2c_clients[] __initconst = { | |
| { | |
| /* BQ27520 fuel-gauge */ | |
| .board_info = { | |
| .type = "bq27520", | |
| .addr = 0x55, | |
| .dev_name = "bq27520", | |
| .swnode = &fg_bq25890_supply_node, | |
| }, | |
| .adapter_path = "\\_SB_.PCI0.I2C1", | |
| }, { | |
| /* KTD2026 RGB notification LED controller */ | |
| .board_info = { | |
| .type = "ktd2026", | |
| .addr = 0x30, | |
| .dev_name = "ktd2026", | |
| .swnode = &ktd2026_node, | |
| }, | |
| .adapter_path = "\\_SB_.PCI0.I2C3", | |
| }, | |
| }; | |
| const struct x86_dev_info xiaomi_mipad2_info __initconst = { | |
| .i2c_client_info = xiaomi_mipad2_i2c_clients, | |
| .i2c_client_count = ARRAY_SIZE(xiaomi_mipad2_i2c_clients), | |
| .swnode_group = ktd2026_node_group, | |
| .init = xiaomi_mipad2_init, | |
| }; |