| // 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> | |
| */ | |
| #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt | |
| #include <linux/acpi.h> | |
| #include <linux/bug.h> | |
| #include <linux/device.h> | |
| #include <linux/dmi.h> | |
| #include <linux/fwnode.h> | |
| #include <linux/gpio/consumer.h> | |
| #include <linux/gpio/machine.h> | |
| #include <linux/irq.h> | |
| #include <linux/module.h> | |
| #include <linux/pci.h> | |
| #include <linux/platform_device.h> | |
| #include <linux/serdev.h> | |
| #include <linux/string.h> | |
| #include "x86-android-tablets.h" | |
| #include "../serdev_helpers.h" | |
| static struct platform_device *x86_android_tablet_device; | |
| /* | |
| * This helper allows getting a GPIO descriptor *before* the actual device | |
| * consuming it has been instantiated. This function MUST only be used to | |
| * handle this special case such as, e.g.: | |
| * | |
| * 1. Getting an IRQ from a GPIO for i2c_board_info.irq which is passed to | |
| * i2c_client_new() to instantiate i2c_client-s; or | |
| * 2. Calling desc_to_gpio() to get an old style GPIO number for gpio-keys | |
| * platform_data which still uses old style GPIO numbers. | |
| * | |
| * Since the consuming device has not been instantiated yet a dynamic lookup | |
| * is generated using the special x86_android_tablet device for dev_id. | |
| * | |
| * For normal GPIO lookups a standard static struct gpiod_lookup_table MUST be used. | |
| */ | |
| int x86_android_tablet_get_gpiod(const char *chip, int pin, const char *con_id, | |
| bool active_low, enum gpiod_flags dflags, | |
| struct gpio_desc **desc) | |
| { | |
| struct gpiod_lookup_table *lookup; | |
| struct gpio_desc *gpiod; | |
| lookup = kzalloc_flex(*lookup, table, 2); | |
| if (!lookup) | |
| return -ENOMEM; | |
| lookup->dev_id = KBUILD_MODNAME; | |
| lookup->table[0] = | |
| GPIO_LOOKUP(chip, pin, con_id, active_low ? GPIO_ACTIVE_LOW : GPIO_ACTIVE_HIGH); | |
| gpiod_add_lookup_table(lookup); | |
| gpiod = devm_gpiod_get(&x86_android_tablet_device->dev, con_id, dflags); | |
| gpiod_remove_lookup_table(lookup); | |
| kfree(lookup); | |
| if (IS_ERR(gpiod)) { | |
| pr_err("error %ld getting GPIO %s %d\n", PTR_ERR(gpiod), chip, pin); | |
| return PTR_ERR(gpiod); | |
| } | |
| if (desc) | |
| *desc = gpiod; | |
| return 0; | |
| } | |
| int x86_acpi_irq_helper_get(const struct x86_acpi_irq_data *data) | |
| { | |
| struct irq_fwspec fwspec = { }; | |
| struct irq_domain *domain; | |
| struct acpi_device *adev; | |
| struct gpio_desc *gpiod; | |
| unsigned int irq_type; | |
| acpi_handle handle; | |
| acpi_status status; | |
| int irq, ret; | |
| switch (data->type) { | |
| case X86_ACPI_IRQ_TYPE_APIC: | |
| /* | |
| * The DSDT may already reference the GSI in a device skipped by | |
| * acpi_quirk_skip_i2c_client_enumeration(). Unregister the GSI | |
| * to avoid -EBUSY errors in this case. | |
| */ | |
| acpi_unregister_gsi(data->index); | |
| irq = acpi_register_gsi(NULL, data->index, data->trigger, data->polarity); | |
| if (irq < 0) | |
| pr_err("error %d getting APIC IRQ %d\n", irq, data->index); | |
| return irq; | |
| case X86_ACPI_IRQ_TYPE_GPIOINT: | |
| /* Like acpi_dev_gpio_irq_get(), but without parsing ACPI resources */ | |
| ret = x86_android_tablet_get_gpiod(data->chip, data->index, data->con_id, | |
| false, GPIOD_ASIS, &gpiod); | |
| if (ret) | |
| return ret; | |
| irq = gpiod_to_irq(gpiod); | |
| if (irq < 0) { | |
| pr_err("error %d getting IRQ %s %d\n", irq, data->chip, data->index); | |
| return irq; | |
| } | |
| irq_type = acpi_dev_get_irq_type(data->trigger, data->polarity); | |
| if (irq_type != IRQ_TYPE_NONE && irq_type != irq_get_trigger_type(irq)) | |
| irq_set_irq_type(irq, irq_type); | |
| if (data->free_gpio) | |
| devm_gpiod_put(&x86_android_tablet_device->dev, gpiod); | |
| return irq; | |
| case X86_ACPI_IRQ_TYPE_PMIC: | |
| status = acpi_get_handle(NULL, data->chip, &handle); | |
| if (ACPI_FAILURE(status)) { | |
| pr_err("error could not get %s handle\n", data->chip); | |
| return -ENODEV; | |
| } | |
| adev = acpi_fetch_acpi_dev(handle); | |
| if (!adev) { | |
| pr_err("error could not get %s adev\n", data->chip); | |
| return -ENODEV; | |
| } | |
| fwspec.fwnode = acpi_fwnode_handle(adev); | |
| domain = irq_find_matching_fwspec(&fwspec, data->domain); | |
| if (!domain) { | |
| pr_err("error could not find IRQ domain for %s\n", data->chip); | |
| return -ENODEV; | |
| } | |
| return irq_create_mapping(domain, data->index); | |
| default: | |
| return 0; | |
| } | |
| } | |
| static int i2c_client_count; | |
| static int spi_dev_count; | |
| static int pdev_count; | |
| static int serdev_count; | |
| static struct i2c_client **i2c_clients; | |
| static struct spi_device **spi_devs; | |
| static struct platform_device **pdevs; | |
| static struct serdev_device **serdevs; | |
| static const struct software_node **gpio_button_swnodes; | |
| static const struct software_node **swnode_group; | |
| static void (*exit_handler)(void); | |
| static __init struct i2c_adapter * | |
| get_i2c_adap_by_handle(const struct x86_i2c_client_info *client_info) | |
| { | |
| acpi_handle handle; | |
| acpi_status status; | |
| status = acpi_get_handle(NULL, client_info->adapter_path, &handle); | |
| if (ACPI_FAILURE(status)) { | |
| pr_err("Error could not get %s handle\n", client_info->adapter_path); | |
| return NULL; | |
| } | |
| return i2c_acpi_find_adapter_by_handle(handle); | |
| } | |
| static __init int match_parent(struct device *dev, const void *data) | |
| { | |
| return dev->parent == data; | |
| } | |
| static __init struct i2c_adapter * | |
| get_i2c_adap_by_pci_parent(const struct x86_i2c_client_info *client_info) | |
| { | |
| struct i2c_adapter *adap = NULL; | |
| struct device *pdev, *adap_dev; | |
| pdev = bus_find_device_by_name(&pci_bus_type, NULL, client_info->adapter_path); | |
| if (!pdev) { | |
| pr_err("Error could not find %s PCI device\n", client_info->adapter_path); | |
| return NULL; | |
| } | |
| adap_dev = bus_find_device(&i2c_bus_type, NULL, pdev, match_parent); | |
| if (adap_dev) { | |
| adap = i2c_verify_adapter(adap_dev); | |
| if (!adap) | |
| put_device(adap_dev); | |
| } | |
| put_device(pdev); | |
| return adap; | |
| } | |
| static __init int x86_instantiate_i2c_client(const struct x86_dev_info *dev_info, | |
| int idx) | |
| { | |
| const struct x86_i2c_client_info *client_info = &dev_info->i2c_client_info[idx]; | |
| struct i2c_board_info board_info = client_info->board_info; | |
| struct i2c_adapter *adap; | |
| board_info.irq = x86_acpi_irq_helper_get(&client_info->irq_data); | |
| if (board_info.irq < 0) | |
| return board_info.irq; | |
| if (dev_info->use_pci) | |
| adap = get_i2c_adap_by_pci_parent(client_info); | |
| else | |
| adap = get_i2c_adap_by_handle(client_info); | |
| if (!adap) { | |
| pr_err("error could not get %s adapter\n", client_info->adapter_path); | |
| return -ENODEV; | |
| } | |
| i2c_clients[idx] = i2c_new_client_device(adap, &board_info); | |
| put_device(&adap->dev); | |
| if (IS_ERR(i2c_clients[idx])) | |
| return dev_err_probe(&adap->dev, PTR_ERR(i2c_clients[idx]), | |
| "creating I2C-client %d\n", idx); | |
| return 0; | |
| } | |
| static __init int x86_instantiate_spi_dev(const struct x86_dev_info *dev_info, int idx) | |
| { | |
| const struct x86_spi_dev_info *spi_dev_info = &dev_info->spi_dev_info[idx]; | |
| struct spi_board_info board_info = spi_dev_info->board_info; | |
| struct spi_controller *controller; | |
| struct acpi_device *adev; | |
| acpi_handle handle; | |
| acpi_status status; | |
| board_info.irq = x86_acpi_irq_helper_get(&spi_dev_info->irq_data); | |
| if (board_info.irq < 0) | |
| return board_info.irq; | |
| status = acpi_get_handle(NULL, spi_dev_info->ctrl_path, &handle); | |
| if (ACPI_FAILURE(status)) { | |
| pr_err("Error could not get %s handle\n", spi_dev_info->ctrl_path); | |
| return -ENODEV; | |
| } | |
| adev = acpi_fetch_acpi_dev(handle); | |
| if (!adev) { | |
| pr_err("Error could not get adev for %s\n", spi_dev_info->ctrl_path); | |
| return -ENODEV; | |
| } | |
| controller = acpi_spi_find_controller_by_adev(adev); | |
| if (!controller) { | |
| pr_err("Error could not get SPI controller for %s\n", spi_dev_info->ctrl_path); | |
| return -ENODEV; | |
| } | |
| spi_devs[idx] = spi_new_device(controller, &board_info); | |
| put_device(&controller->dev); | |
| if (!spi_devs[idx]) | |
| return -ENOMEM; | |
| return 0; | |
| } | |
| static __init struct device * | |
| get_serdev_controller_by_pci_parent(const struct x86_serdev_info *info) | |
| { | |
| struct pci_dev *pdev; | |
| pdev = pci_get_domain_bus_and_slot(0, 0, info->ctrl.pci.devfn); | |
| if (!pdev) { | |
| pr_err("error could not get PCI serdev at devfn 0x%02x\n", info->ctrl.pci.devfn); | |
| return ERR_PTR(-ENODEV); | |
| } | |
| /* This puts our reference on pdev and returns a ref on the ctrl */ | |
| return get_serdev_controller_from_parent(&pdev->dev, 0, info->ctrl_devname); | |
| } | |
| static __init int x86_instantiate_serdev(const struct x86_dev_info *dev_info, int idx) | |
| { | |
| const struct x86_serdev_info *info = &dev_info->serdev_info[idx]; | |
| struct acpi_device *serdev_adev; | |
| struct serdev_device *serdev; | |
| struct device *ctrl_dev; | |
| int ret = -ENODEV; | |
| if (dev_info->use_pci) | |
| ctrl_dev = get_serdev_controller_by_pci_parent(info); | |
| else | |
| ctrl_dev = get_serdev_controller(info->ctrl.acpi.hid, info->ctrl.acpi.uid, | |
| 0, info->ctrl_devname); | |
| if (IS_ERR(ctrl_dev)) | |
| return PTR_ERR(ctrl_dev); | |
| serdev_adev = acpi_dev_get_first_match_dev(info->serdev_hid, NULL, -1); | |
| if (!serdev_adev) { | |
| pr_err("error could not get %s serdev adev\n", info->serdev_hid); | |
| goto put_ctrl_dev; | |
| } | |
| serdev = serdev_device_alloc(to_serdev_controller(ctrl_dev)); | |
| if (!serdev) { | |
| ret = -ENOMEM; | |
| goto put_serdev_adev; | |
| } | |
| ACPI_COMPANION_SET(&serdev->dev, serdev_adev); | |
| acpi_device_set_enumerated(serdev_adev); | |
| ret = serdev_device_add(serdev); | |
| if (ret) { | |
| dev_err(&serdev->dev, "error %d adding serdev\n", ret); | |
| serdev_device_put(serdev); | |
| goto put_serdev_adev; | |
| } | |
| serdevs[idx] = serdev; | |
| put_serdev_adev: | |
| acpi_dev_put(serdev_adev); | |
| put_ctrl_dev: | |
| put_device(ctrl_dev); | |
| return ret; | |
| } | |
| const struct software_node baytrail_gpiochip_nodes[] = { | |
| { .name = "INT33FC:00" }, | |
| { .name = "INT33FC:01" }, | |
| { .name = "INT33FC:02" }, | |
| }; | |
| static const struct software_node *baytrail_gpiochip_node_group[] = { | |
| &baytrail_gpiochip_nodes[0], | |
| &baytrail_gpiochip_nodes[1], | |
| &baytrail_gpiochip_nodes[2], | |
| NULL | |
| }; | |
| const struct software_node cherryview_gpiochip_nodes[] = { | |
| { .name = "INT33FF:00" }, | |
| { .name = "INT33FF:01" }, | |
| { .name = "INT33FF:02" }, | |
| { .name = "INT33FF:03" }, | |
| }; | |
| static const struct software_node *cherryview_gpiochip_node_group[] = { | |
| &cherryview_gpiochip_nodes[0], | |
| &cherryview_gpiochip_nodes[1], | |
| &cherryview_gpiochip_nodes[2], | |
| &cherryview_gpiochip_nodes[3], | |
| NULL | |
| }; | |
| const struct software_node crystalcove_gpiochip_node = { | |
| .name = "INT33FD:00", | |
| }; | |
| static const struct software_node *crystalcove_gpiochip_node_group[] = { | |
| &crystalcove_gpiochip_node, | |
| NULL | |
| }; | |
| static void gpio_secondary_unset(void *data) | |
| { | |
| struct device *dev = data; | |
| set_secondary_fwnode(dev, NULL); | |
| put_device(dev); | |
| } | |
| static void gpio_secondary_unregister_node_group(void *data) | |
| { | |
| const struct software_node **nodes = data; | |
| software_node_unregister_node_group(nodes); | |
| } | |
| static int gpio_secondary_fwnode_init(struct device *parent, | |
| const struct software_node * const *node_group) | |
| { | |
| const struct software_node *const *swnode; | |
| struct fwnode_handle *fwnode; | |
| int ret; | |
| if (!node_group) | |
| return 0; | |
| ret = software_node_register_node_group(node_group); | |
| if (ret) | |
| return ret; | |
| ret = devm_add_action_or_reset(parent, | |
| gpio_secondary_unregister_node_group, | |
| (void *)node_group); | |
| if (ret) | |
| return ret; | |
| for (swnode = node_group; *swnode; swnode++) { | |
| struct device *dev __free(put_device) = | |
| acpi_bus_find_device_by_name((*swnode)->name); | |
| if (!dev) | |
| return dev_err_probe(parent, | |
| -ENODEV, "Failed to find the required GPIO controller: %s\n", | |
| (*swnode)->name); | |
| fwnode = software_node_fwnode(*swnode); | |
| if (WARN_ON(!fwnode)) | |
| return -ENOENT; | |
| struct device *phys_dev __free(put_device) = | |
| acpi_bus_get_primary_device(to_acpi_device(dev)); | |
| if (!phys_dev) | |
| return dev_err_probe(parent, -ENODEV, | |
| "No physical device for ACPI GPIO dev: %pfwP\n", | |
| fwnode); | |
| set_secondary_fwnode(phys_dev, fwnode); | |
| ret = devm_add_action_or_reset(parent, gpio_secondary_unset, get_device(phys_dev)); | |
| if (ret) | |
| return ret; | |
| } | |
| return 0; | |
| } | |
| static void x86_android_tablet_remove(struct platform_device *pdev) | |
| { | |
| int i; | |
| for (i = serdev_count - 1; i >= 0; i--) { | |
| if (serdevs[i]) | |
| serdev_device_remove(serdevs[i]); | |
| } | |
| kfree(serdevs); | |
| for (i = pdev_count - 1; i >= 0; i--) | |
| platform_device_unregister(pdevs[i]); | |
| kfree(pdevs); | |
| for (i = spi_dev_count - 1; i >= 0; i--) | |
| spi_unregister_device(spi_devs[i]); | |
| kfree(spi_devs); | |
| for (i = i2c_client_count - 1; i >= 0; i--) | |
| i2c_unregister_device(i2c_clients[i]); | |
| kfree(i2c_clients); | |
| if (exit_handler) | |
| exit_handler(); | |
| software_node_unregister_node_group(gpio_button_swnodes); | |
| software_node_unregister_node_group(swnode_group); | |
| } | |
| static __init int x86_android_tablet_probe(struct platform_device *pdev) | |
| { | |
| const struct software_node * const *gpiochip_node_group; | |
| const struct x86_dev_info *dev_info; | |
| const struct dmi_system_id *id; | |
| int i, ret = 0; | |
| id = dmi_first_match(x86_android_tablet_ids); | |
| if (!id) | |
| return -ENODEV; | |
| dev_info = id->driver_data; | |
| /* Allow x86_android_tablet_device use before probe() exits */ | |
| x86_android_tablet_device = pdev; | |
| /* | |
| * Since this runs from module_init() it cannot use -EPROBE_DEFER, | |
| * instead pre-load any modules which are listed as requirements. | |
| */ | |
| for (i = 0; dev_info->modules && dev_info->modules[i]; i++) | |
| request_module(dev_info->modules[i]); | |
| switch (dev_info->gpiochip_type) { | |
| case X86_GPIOCHIP_BAYTRAIL: | |
| gpiochip_node_group = baytrail_gpiochip_node_group; | |
| break; | |
| case X86_GPIOCHIP_CHERRYVIEW: | |
| gpiochip_node_group = cherryview_gpiochip_node_group; | |
| break; | |
| case X86_GPIOCHIP_UNSPECIFIED: | |
| gpiochip_node_group = NULL; | |
| break; | |
| } | |
| ret = gpio_secondary_fwnode_init(&pdev->dev, gpiochip_node_group); | |
| if (ret) { | |
| x86_android_tablet_remove(pdev); | |
| return ret; | |
| } | |
| if (dev_info->has_crystalcove) { | |
| ret = gpio_secondary_fwnode_init(&pdev->dev, crystalcove_gpiochip_node_group); | |
| if (ret) { | |
| x86_android_tablet_remove(pdev); | |
| return ret; | |
| } | |
| } | |
| ret = software_node_register_node_group(dev_info->swnode_group); | |
| if (ret) { | |
| x86_android_tablet_remove(pdev); | |
| return ret; | |
| } | |
| swnode_group = dev_info->swnode_group; | |
| if (dev_info->init) { | |
| ret = dev_info->init(&pdev->dev); | |
| if (ret < 0) { | |
| x86_android_tablet_remove(pdev); | |
| return ret; | |
| } | |
| exit_handler = dev_info->exit; | |
| } | |
| i2c_clients = kzalloc_objs(*i2c_clients, dev_info->i2c_client_count); | |
| if (!i2c_clients) { | |
| x86_android_tablet_remove(pdev); | |
| return -ENOMEM; | |
| } | |
| i2c_client_count = dev_info->i2c_client_count; | |
| for (i = 0; i < i2c_client_count; i++) { | |
| ret = x86_instantiate_i2c_client(dev_info, i); | |
| if (ret < 0) { | |
| x86_android_tablet_remove(pdev); | |
| return ret; | |
| } | |
| } | |
| spi_devs = kzalloc_objs(*spi_devs, dev_info->spi_dev_count); | |
| if (!spi_devs) { | |
| x86_android_tablet_remove(pdev); | |
| return -ENOMEM; | |
| } | |
| spi_dev_count = dev_info->spi_dev_count; | |
| for (i = 0; i < spi_dev_count; i++) { | |
| ret = x86_instantiate_spi_dev(dev_info, i); | |
| if (ret < 0) { | |
| x86_android_tablet_remove(pdev); | |
| return ret; | |
| } | |
| } | |
| /* + 1 to make space for the (optional) gpio_keys_button platform device */ | |
| pdevs = kzalloc_objs(*pdevs, dev_info->pdev_count + 1); | |
| if (!pdevs) { | |
| x86_android_tablet_remove(pdev); | |
| return -ENOMEM; | |
| } | |
| pdev_count = dev_info->pdev_count; | |
| for (i = 0; i < pdev_count; i++) { | |
| pdevs[i] = platform_device_register_full(&dev_info->pdev_info[i]); | |
| if (IS_ERR(pdevs[i])) { | |
| ret = PTR_ERR(pdevs[i]); | |
| x86_android_tablet_remove(pdev); | |
| return ret; | |
| } | |
| } | |
| serdevs = kzalloc_objs(*serdevs, dev_info->serdev_count); | |
| if (!serdevs) { | |
| x86_android_tablet_remove(pdev); | |
| return -ENOMEM; | |
| } | |
| serdev_count = dev_info->serdev_count; | |
| for (i = 0; i < serdev_count; i++) { | |
| ret = x86_instantiate_serdev(dev_info, i); | |
| if (ret < 0) { | |
| x86_android_tablet_remove(pdev); | |
| return ret; | |
| } | |
| } | |
| if (dev_info->gpio_button_swnodes) { | |
| struct platform_device_info button_info = { | |
| .name = "gpio-keys", | |
| .id = PLATFORM_DEVID_AUTO, | |
| }; | |
| ret = software_node_register_node_group(dev_info->gpio_button_swnodes); | |
| if (ret < 0) { | |
| x86_android_tablet_remove(pdev); | |
| return ret; | |
| } | |
| gpio_button_swnodes = dev_info->gpio_button_swnodes; | |
| button_info.fwnode = software_node_fwnode(dev_info->gpio_button_swnodes[0]); | |
| pdevs[pdev_count] = platform_device_register_full(&button_info); | |
| if (IS_ERR(pdevs[pdev_count])) { | |
| ret = PTR_ERR(pdevs[pdev_count]); | |
| x86_android_tablet_remove(pdev); | |
| return ret; | |
| } | |
| pdev_count++; | |
| } | |
| return 0; | |
| } | |
| static struct platform_driver x86_android_tablet_driver = { | |
| .driver = { | |
| .name = KBUILD_MODNAME, | |
| }, | |
| .remove = x86_android_tablet_remove, | |
| }; | |
| static int __init x86_android_tablet_init(void) | |
| { | |
| x86_android_tablet_device = platform_create_bundle(&x86_android_tablet_driver, | |
| x86_android_tablet_probe, | |
| NULL, 0, NULL, 0); | |
| return PTR_ERR_OR_ZERO(x86_android_tablet_device); | |
| } | |
| module_init(x86_android_tablet_init); | |
| static void __exit x86_android_tablet_exit(void) | |
| { | |
| platform_device_unregister(x86_android_tablet_device); | |
| platform_driver_unregister(&x86_android_tablet_driver); | |
| } | |
| module_exit(x86_android_tablet_exit); | |
| MODULE_AUTHOR("Hans de Goede <hansg@kernel.org>"); | |
| MODULE_DESCRIPTION("X86 Android tablets DSDT fixups driver"); | |
| MODULE_LICENSE("GPL"); |