| // SPDX-License-Identifier: GPL-2.0+ | |
| /* | |
| * Intel XHCI (Cherry Trail, Broxton and others) USB OTG role switch driver | |
| * | |
| * Copyright (c) 2016-2017 Hans de Goede <hdegoede@redhat.com> | |
| * | |
| * Loosely based on android x86 kernel code which is: | |
| * | |
| * Copyright (C) 2014 Intel Corp. | |
| * | |
| * Author: Wu, Hao | |
| */ | |
| #include <linux/acpi.h> | |
| #include <linux/delay.h> | |
| #include <linux/err.h> | |
| #include <linux/io.h> | |
| #include <linux/kernel.h> | |
| #include <linux/module.h> | |
| #include <linux/platform_device.h> | |
| #include <linux/pm_runtime.h> | |
| #include <linux/property.h> | |
| #include <linux/usb/role.h> | |
| /* register definition */ | |
| #define DUAL_ROLE_CFG0 0x68 | |
| #define SW_VBUS_VALID BIT(24) | |
| #define SW_IDPIN_EN BIT(21) | |
| #define SW_IDPIN BIT(20) | |
| #define SW_SWITCH_EN BIT(16) | |
| #define DRD_CONFIG_DYNAMIC 0 | |
| #define DRD_CONFIG_STATIC_HOST 1 | |
| #define DRD_CONFIG_STATIC_DEVICE 2 | |
| #define DRD_CONFIG_MASK 3 | |
| #define DUAL_ROLE_CFG1 0x6c | |
| #define HOST_MODE BIT(29) | |
| #define DUAL_ROLE_CFG1_POLL_TIMEOUT 1000 | |
| #define DRV_NAME "intel_xhci_usb_sw" | |
| struct intel_xhci_usb_data { | |
| struct usb_role_switch *role_sw; | |
| void __iomem *base; | |
| bool enable_sw_switch; | |
| }; | |
| static const struct software_node intel_xhci_usb_node = { | |
| "intel-xhci-usb-sw", | |
| }; | |
| static int intel_xhci_usb_set_role(struct device *dev, enum usb_role role) | |
| { | |
| struct intel_xhci_usb_data *data = dev_get_drvdata(dev); | |
| unsigned long timeout; | |
| acpi_status status; | |
| u32 glk, val; | |
| u32 drd_config = DRD_CONFIG_DYNAMIC; | |
| /* | |
| * On many CHT devices ACPI event (_AEI) handlers read / modify / | |
| * write the cfg0 register, just like we do. Take the ACPI lock | |
| * to avoid us racing with the AML code. | |
| */ | |
| status = acpi_acquire_global_lock(ACPI_WAIT_FOREVER, &glk); | |
| if (ACPI_FAILURE(status) && status != AE_NOT_CONFIGURED) { | |
| dev_err(dev, "Error could not acquire lock\n"); | |
| return -EIO; | |
| } | |
| pm_runtime_get_sync(dev); | |
| /* | |
| * Set idpin value as requested. | |
| * Since some devices rely on firmware setting DRD_CONFIG and | |
| * SW_SWITCH_EN bits to be zero for role switch, | |
| * do not set these bits for those devices. | |
| */ | |
| val = readl(data->base + DUAL_ROLE_CFG0); | |
| switch (role) { | |
| case USB_ROLE_NONE: | |
| val |= SW_IDPIN; | |
| val &= ~SW_VBUS_VALID; | |
| drd_config = DRD_CONFIG_DYNAMIC; | |
| break; | |
| case USB_ROLE_HOST: | |
| val &= ~SW_IDPIN; | |
| val &= ~SW_VBUS_VALID; | |
| drd_config = DRD_CONFIG_STATIC_HOST; | |
| break; | |
| case USB_ROLE_DEVICE: | |
| val |= SW_IDPIN; | |
| val |= SW_VBUS_VALID; | |
| drd_config = DRD_CONFIG_STATIC_DEVICE; | |
| break; | |
| } | |
| val |= SW_IDPIN_EN; | |
| if (data->enable_sw_switch) { | |
| val &= ~DRD_CONFIG_MASK; | |
| val |= SW_SWITCH_EN | drd_config; | |
| } | |
| writel(val, data->base + DUAL_ROLE_CFG0); | |
| acpi_release_global_lock(glk); | |
| /* In most case it takes about 600ms to finish mode switching */ | |
| timeout = jiffies + msecs_to_jiffies(DUAL_ROLE_CFG1_POLL_TIMEOUT); | |
| /* Polling on CFG1 register to confirm mode switch.*/ | |
| do { | |
| val = readl(data->base + DUAL_ROLE_CFG1); | |
| if (!!(val & HOST_MODE) == (role == USB_ROLE_HOST)) { | |
| pm_runtime_put(dev); | |
| return 0; | |
| } | |
| /* Interval for polling is set to about 5 - 10 ms */ | |
| usleep_range(5000, 10000); | |
| } while (time_before(jiffies, timeout)); | |
| pm_runtime_put(dev); | |
| dev_warn(dev, "Timeout waiting for role-switch\n"); | |
| return -ETIMEDOUT; | |
| } | |
| static enum usb_role intel_xhci_usb_get_role(struct device *dev) | |
| { | |
| struct intel_xhci_usb_data *data = dev_get_drvdata(dev); | |
| enum usb_role role; | |
| u32 val; | |
| pm_runtime_get_sync(dev); | |
| val = readl(data->base + DUAL_ROLE_CFG0); | |
| pm_runtime_put(dev); | |
| if (!(val & SW_IDPIN)) | |
| role = USB_ROLE_HOST; | |
| else if (val & SW_VBUS_VALID) | |
| role = USB_ROLE_DEVICE; | |
| else | |
| role = USB_ROLE_NONE; | |
| return role; | |
| } | |
| static int intel_xhci_usb_probe(struct platform_device *pdev) | |
| { | |
| struct usb_role_switch_desc sw_desc = { }; | |
| struct device *dev = &pdev->dev; | |
| struct intel_xhci_usb_data *data; | |
| struct resource *res; | |
| int ret; | |
| data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL); | |
| if (!data) | |
| return -ENOMEM; | |
| res = platform_get_resource(pdev, IORESOURCE_MEM, 0); | |
| if (!res) | |
| return -EINVAL; | |
| data->base = devm_ioremap_nocache(dev, res->start, resource_size(res)); | |
| if (!data->base) | |
| return -ENOMEM; | |
| platform_set_drvdata(pdev, data); | |
| ret = software_node_register(&intel_xhci_usb_node); | |
| if (ret) | |
| return ret; | |
| sw_desc.set = intel_xhci_usb_set_role, | |
| sw_desc.get = intel_xhci_usb_get_role, | |
| sw_desc.allow_userspace_control = true, | |
| sw_desc.fwnode = software_node_fwnode(&intel_xhci_usb_node); | |
| data->enable_sw_switch = !device_property_read_bool(dev, | |
| "sw_switch_disable"); | |
| data->role_sw = usb_role_switch_register(dev, &sw_desc); | |
| if (IS_ERR(data->role_sw)) { | |
| fwnode_handle_put(sw_desc.fwnode); | |
| return PTR_ERR(data->role_sw); | |
| } | |
| pm_runtime_set_active(dev); | |
| pm_runtime_enable(dev); | |
| return 0; | |
| } | |
| static int intel_xhci_usb_remove(struct platform_device *pdev) | |
| { | |
| struct intel_xhci_usb_data *data = platform_get_drvdata(pdev); | |
| pm_runtime_disable(&pdev->dev); | |
| usb_role_switch_unregister(data->role_sw); | |
| fwnode_handle_put(software_node_fwnode(&intel_xhci_usb_node)); | |
| return 0; | |
| } | |
| static const struct platform_device_id intel_xhci_usb_table[] = { | |
| { .name = DRV_NAME }, | |
| {} | |
| }; | |
| MODULE_DEVICE_TABLE(platform, intel_xhci_usb_table); | |
| static struct platform_driver intel_xhci_usb_driver = { | |
| .driver = { | |
| .name = DRV_NAME, | |
| }, | |
| .id_table = intel_xhci_usb_table, | |
| .probe = intel_xhci_usb_probe, | |
| .remove = intel_xhci_usb_remove, | |
| }; | |
| module_platform_driver(intel_xhci_usb_driver); | |
| MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>"); | |
| MODULE_DESCRIPTION("Intel XHCI USB role switch driver"); | |
| MODULE_LICENSE("GPL"); |