| // SPDX-License-Identifier: GPL-2.0 | |
| /* | |
| * Apple Silicon DWC3 Glue driver | |
| * Copyright (C) The Asahi Linux Contributors | |
| * | |
| * Based on: | |
| * - dwc3-qcom.c Copyright (c) 2018, The Linux Foundation. All rights reserved. | |
| * - dwc3-of-simple.c Copyright (c) 2015 Texas Instruments Incorporated - https://www.ti.com | |
| */ | |
| #include <linux/of.h> | |
| #include <linux/module.h> | |
| #include <linux/mutex.h> | |
| #include <linux/platform_device.h> | |
| #include <linux/reset.h> | |
| #include "glue.h" | |
| /* | |
| * This platform requires a very specific sequence of operations to bring up dwc3 and its USB3 PHY: | |
| * | |
| * 1) The PHY itself has to be brought up; for this we need to know the mode (USB3, | |
| * USB3+DisplayPort, USB4, etc) and the lane orientation. This happens through typec_mux_set. | |
| * 2) DWC3 has to be brought up but we must not touch the gadget area or start xhci yet. | |
| * 3) The PHY bring-up has to be finalized and dwc3's PIPE interface has to be switched to the | |
| * USB3 PHY, this is done inside phy_set_mode. | |
| * 4) We can now initialize xhci or gadget mode. | |
| * | |
| * We can switch 1 and 2 but 3 has to happen after (1 and 2) and 4 has to happen after 3. | |
| * | |
| * And then to bring this all down again: | |
| * | |
| * 1) DWC3 has to exit host or gadget mode and must no longer touch those registers | |
| * 2) The PHY has to switch dwc3's PIPE interface back to the dummy backend | |
| * 3) The PHY itself can be shut down, this happens from typec_mux_set | |
| * | |
| * We also can't transition the PHY from one mode to another while dwc3 is up and running (this is | |
| * slightly wrong, some transitions are possible, others aren't but because we have no documentation | |
| * for this I'd rather play it safe). | |
| * | |
| * After both the PHY and dwc3 are initialized we will only ever see a single "new device connected" | |
| * event. If we just keep them running only the first device plugged in will ever work. XHCI's port | |
| * status register actually does show the correct state but no interrupt ever comes in. In gadget | |
| * mode we don't even get a USBDisconnected event and everything looks like there's still something | |
| * connected on the other end. | |
| * This can be partially explained because the USB2 D+/D- lines are connected through a stateful | |
| * eUSB2 repeater which in turn is controlled by a variant of the TI TPS6598x USB PD chip which | |
| * resets the repeater out-of-band everytime the CC lines are (dis)connected. This then requires a | |
| * PHY reset to make sure the PHY and the eUSB2 repeater state are synchronized again. | |
| * | |
| * And to make this all extra fun: If we get the order of some of this wrong either the port is just | |
| * broken until a phy+dwc3 reset, or it's broken until a full SoC reset (likely because we can't | |
| * reset some parts of the PHY), or some watchdog kicks in after a few seconds and forces a full SoC | |
| * reset (mostly seen this with USB4/Thunderbolt but there's clearly some watchdog that hates | |
| * invalid states). | |
| * | |
| * Hence there's really no good way to keep dwc3 fully up and running after we disconnect a cable | |
| * because then we can't shut down the PHY anymore. And if we kept the PHY running in whatever mode | |
| * it was until the next cable is connected we'd need to tear it all down and bring it back up again | |
| * anyway to detect and use the next device. | |
| * | |
| * Instead, we just shut down everything when a cable is disconnected and transition to | |
| * DWC3_APPLE_NO_CABLE. | |
| * During initial probe we don't have any information about the connected cable and can't bring up | |
| * the PHY properly and thus also can't fully bring up dwc3. Instead, we just keep everything off | |
| * and defer the first dwc3 probe until we get the first cable connected event. Until then we stay | |
| * in DWC3_APPLE_PROBE_PENDING. | |
| * Once a cable is connected we then keep track of the controller mode here by transitioning to | |
| * DWC3_APPLE_HOST or DWC3_APPLE_DEVICE. | |
| */ | |
| enum dwc3_apple_state { | |
| DWC3_APPLE_PROBE_PENDING, /* Before first cable connection, dwc3_core_probe not called */ | |
| DWC3_APPLE_NO_CABLE, /* No cable connected, dwc3 suspended after dwc3_core_exit */ | |
| DWC3_APPLE_HOST, /* Cable connected, dwc3 in host mode */ | |
| DWC3_APPLE_DEVICE, /* Cable connected, dwc3 in device mode */ | |
| }; | |
| /** | |
| * struct dwc3_apple - Apple-specific DWC3 USB controller | |
| * @dwc: Core DWC3 structure | |
| * @dev: Pointer to the device structure | |
| * @mmio_resource: Resource to be passed to dwc3_core_probe | |
| * @apple_regs: Apple-specific DWC3 registers | |
| * @reset: Reset control | |
| * @role_sw: USB role switch | |
| * @lock: Mutex for synchronizing access | |
| * @state: Current state of the controller, see documentation for the enum for details | |
| */ | |
| struct dwc3_apple { | |
| struct dwc3 dwc; | |
| struct device *dev; | |
| struct resource *mmio_resource; | |
| void __iomem *apple_regs; | |
| struct reset_control *reset; | |
| struct usb_role_switch *role_sw; | |
| struct mutex lock; | |
| enum dwc3_apple_state state; | |
| }; | |
| #define to_dwc3_apple(d) container_of((d), struct dwc3_apple, dwc) | |
| /* | |
| * Apple Silicon dwc3 vendor-specific registers | |
| * | |
| * These registers were identified by tracing XNU's memory access patterns and correlating them with | |
| * debug output over serial to determine their names. We don't exactly know what these do but | |
| * without these USB3 devices sometimes don't work. | |
| */ | |
| #define APPLE_DWC3_REGS_START 0xcd00 | |
| #define APPLE_DWC3_REGS_END 0xcdff | |
| #define APPLE_DWC3_CIO_LFPS_OFFSET 0xcd38 | |
| #define APPLE_DWC3_CIO_LFPS_OFFSET_VALUE 0xf800f80 | |
| #define APPLE_DWC3_CIO_BW_NGT_OFFSET 0xcd3c | |
| #define APPLE_DWC3_CIO_BW_NGT_OFFSET_VALUE 0xfc00fc0 | |
| #define APPLE_DWC3_CIO_LINK_TIMER 0xcd40 | |
| #define APPLE_DWC3_CIO_PENDING_HP_TIMER GENMASK(23, 16) | |
| #define APPLE_DWC3_CIO_PENDING_HP_TIMER_VALUE 0x14 | |
| #define APPLE_DWC3_CIO_PM_LC_TIMER GENMASK(15, 8) | |
| #define APPLE_DWC3_CIO_PM_LC_TIMER_VALUE 0xa | |
| #define APPLE_DWC3_CIO_PM_ENTRY_TIMER GENMASK(7, 0) | |
| #define APPLE_DWC3_CIO_PM_ENTRY_TIMER_VALUE 0x10 | |
| static inline void dwc3_apple_writel(struct dwc3_apple *appledwc, u32 offset, u32 value) | |
| { | |
| writel(value, appledwc->apple_regs + offset - APPLE_DWC3_REGS_START); | |
| } | |
| static inline u32 dwc3_apple_readl(struct dwc3_apple *appledwc, u32 offset) | |
| { | |
| return readl(appledwc->apple_regs + offset - APPLE_DWC3_REGS_START); | |
| } | |
| static inline void dwc3_apple_mask(struct dwc3_apple *appledwc, u32 offset, u32 mask, u32 value) | |
| { | |
| u32 reg; | |
| reg = dwc3_apple_readl(appledwc, offset); | |
| reg &= ~mask; | |
| reg |= value; | |
| dwc3_apple_writel(appledwc, offset, reg); | |
| } | |
| static void dwc3_apple_setup_cio(struct dwc3_apple *appledwc) | |
| { | |
| dwc3_apple_writel(appledwc, APPLE_DWC3_CIO_LFPS_OFFSET, APPLE_DWC3_CIO_LFPS_OFFSET_VALUE); | |
| dwc3_apple_writel(appledwc, APPLE_DWC3_CIO_BW_NGT_OFFSET, | |
| APPLE_DWC3_CIO_BW_NGT_OFFSET_VALUE); | |
| dwc3_apple_mask(appledwc, APPLE_DWC3_CIO_LINK_TIMER, APPLE_DWC3_CIO_PENDING_HP_TIMER, | |
| FIELD_PREP(APPLE_DWC3_CIO_PENDING_HP_TIMER, | |
| APPLE_DWC3_CIO_PENDING_HP_TIMER_VALUE)); | |
| dwc3_apple_mask(appledwc, APPLE_DWC3_CIO_LINK_TIMER, APPLE_DWC3_CIO_PM_LC_TIMER, | |
| FIELD_PREP(APPLE_DWC3_CIO_PM_LC_TIMER, APPLE_DWC3_CIO_PM_LC_TIMER_VALUE)); | |
| dwc3_apple_mask(appledwc, APPLE_DWC3_CIO_LINK_TIMER, APPLE_DWC3_CIO_PM_ENTRY_TIMER, | |
| FIELD_PREP(APPLE_DWC3_CIO_PM_ENTRY_TIMER, | |
| APPLE_DWC3_CIO_PM_ENTRY_TIMER_VALUE)); | |
| } | |
| static void dwc3_apple_set_ptrcap(struct dwc3_apple *appledwc, u32 mode) | |
| { | |
| guard(spinlock_irqsave)(&appledwc->dwc.lock); | |
| dwc3_set_prtcap(&appledwc->dwc, mode, false); | |
| } | |
| static int dwc3_apple_core_probe(struct dwc3_apple *appledwc) | |
| { | |
| struct dwc3_probe_data probe_data = {}; | |
| int ret; | |
| lockdep_assert_held(&appledwc->lock); | |
| WARN_ON_ONCE(appledwc->state != DWC3_APPLE_PROBE_PENDING); | |
| appledwc->dwc.dev = appledwc->dev; | |
| probe_data.dwc = &appledwc->dwc; | |
| probe_data.res = appledwc->mmio_resource; | |
| probe_data.ignore_clocks_and_resets = true; | |
| probe_data.skip_core_init_mode = true; | |
| probe_data.properties = DWC3_DEFAULT_PROPERTIES; | |
| ret = dwc3_core_probe(&probe_data); | |
| if (ret) | |
| return ret; | |
| appledwc->state = DWC3_APPLE_NO_CABLE; | |
| return 0; | |
| } | |
| static int dwc3_apple_core_init(struct dwc3_apple *appledwc) | |
| { | |
| int ret; | |
| lockdep_assert_held(&appledwc->lock); | |
| switch (appledwc->state) { | |
| case DWC3_APPLE_PROBE_PENDING: | |
| ret = dwc3_apple_core_probe(appledwc); | |
| if (ret) | |
| dev_err(appledwc->dev, "Failed to probe DWC3 Core, err=%d\n", ret); | |
| break; | |
| case DWC3_APPLE_NO_CABLE: | |
| ret = dwc3_core_init(&appledwc->dwc); | |
| if (ret) | |
| dev_err(appledwc->dev, "Failed to initialize DWC3 Core, err=%d\n", ret); | |
| break; | |
| default: | |
| /* Unreachable unless there's a bug in this driver */ | |
| WARN_ON_ONCE(1); | |
| ret = -EINVAL; | |
| break; | |
| } | |
| return ret; | |
| } | |
| static int dwc3_apple_init(struct dwc3_apple *appledwc, enum dwc3_apple_state state) | |
| { | |
| int ret, ret_reset; | |
| lockdep_assert_held(&appledwc->lock); | |
| /* | |
| * The USB2 PHY on this platform must be configured for host or device mode while it is | |
| * still powered off and before dwc3 tries to access it. Otherwise, the new configuration | |
| * will sometimes only take affect after the *next* time dwc3 is brought up which causes | |
| * the connected device to just not work. | |
| * The USB3 PHY must be configured later after dwc3 has already been initialized. | |
| */ | |
| switch (state) { | |
| case DWC3_APPLE_HOST: | |
| phy_set_mode(appledwc->dwc.usb2_generic_phy[0], PHY_MODE_USB_HOST); | |
| break; | |
| case DWC3_APPLE_DEVICE: | |
| phy_set_mode(appledwc->dwc.usb2_generic_phy[0], PHY_MODE_USB_DEVICE); | |
| break; | |
| default: | |
| /* Unreachable unless there's a bug in this driver */ | |
| return -EINVAL; | |
| } | |
| ret = reset_control_deassert(appledwc->reset); | |
| if (ret) { | |
| dev_err(appledwc->dev, "Failed to deassert reset, err=%d\n", ret); | |
| return ret; | |
| } | |
| ret = dwc3_apple_core_init(appledwc); | |
| if (ret) | |
| goto reset_assert; | |
| /* | |
| * Now that the core is initialized and already went through dwc3_core_soft_reset we can | |
| * configure some unknown Apple-specific settings and then bring up xhci or gadget mode. | |
| */ | |
| dwc3_apple_setup_cio(appledwc); | |
| switch (state) { | |
| case DWC3_APPLE_HOST: | |
| appledwc->dwc.dr_mode = USB_DR_MODE_HOST; | |
| dwc3_apple_set_ptrcap(appledwc, DWC3_GCTL_PRTCAP_HOST); | |
| /* | |
| * This platform requires SUSPHY to be enabled here already in order to properly | |
| * configure the PHY and switch dwc3's PIPE interface to USB3 PHY. The USB2 PHY | |
| * has already been configured to the correct mode earlier. | |
| */ | |
| dwc3_enable_susphy(&appledwc->dwc, true); | |
| phy_set_mode(appledwc->dwc.usb3_generic_phy[0], PHY_MODE_USB_HOST); | |
| ret = dwc3_host_init(&appledwc->dwc); | |
| if (ret) { | |
| dev_err(appledwc->dev, "Failed to initialize host, ret=%d\n", ret); | |
| goto core_exit; | |
| } | |
| break; | |
| case DWC3_APPLE_DEVICE: | |
| appledwc->dwc.dr_mode = USB_DR_MODE_PERIPHERAL; | |
| dwc3_apple_set_ptrcap(appledwc, DWC3_GCTL_PRTCAP_DEVICE); | |
| /* | |
| * This platform requires SUSPHY to be enabled here already in order to properly | |
| * configure the PHY and switch dwc3's PIPE interface to USB3 PHY. The USB2 PHY | |
| * has already been configured to the correct mode earlier. | |
| */ | |
| dwc3_enable_susphy(&appledwc->dwc, true); | |
| phy_set_mode(appledwc->dwc.usb3_generic_phy[0], PHY_MODE_USB_DEVICE); | |
| ret = dwc3_gadget_init(&appledwc->dwc); | |
| if (ret) { | |
| dev_err(appledwc->dev, "Failed to initialize gadget, ret=%d\n", ret); | |
| goto core_exit; | |
| } | |
| break; | |
| default: | |
| /* Unreachable unless there's a bug in this driver */ | |
| WARN_ON_ONCE(1); | |
| ret = -EINVAL; | |
| goto core_exit; | |
| } | |
| appledwc->state = state; | |
| return 0; | |
| core_exit: | |
| dwc3_core_exit(&appledwc->dwc); | |
| reset_assert: | |
| ret_reset = reset_control_assert(appledwc->reset); | |
| if (ret_reset) | |
| dev_warn(appledwc->dev, "Failed to assert reset, err=%d\n", ret_reset); | |
| return ret; | |
| } | |
| static int dwc3_apple_exit(struct dwc3_apple *appledwc) | |
| { | |
| int ret = 0; | |
| lockdep_assert_held(&appledwc->lock); | |
| switch (appledwc->state) { | |
| case DWC3_APPLE_PROBE_PENDING: | |
| case DWC3_APPLE_NO_CABLE: | |
| /* Nothing to do if we're already off */ | |
| return 0; | |
| case DWC3_APPLE_DEVICE: | |
| dwc3_gadget_exit(&appledwc->dwc); | |
| break; | |
| case DWC3_APPLE_HOST: | |
| dwc3_host_exit(&appledwc->dwc); | |
| break; | |
| } | |
| /* | |
| * This platform requires SUSPHY to be enabled in order to properly power down the PHY | |
| * and switch dwc3's PIPE interface back to a dummy PHY (i.e. no USB3 support and USB2 via | |
| * a different PHY connected through ULPI). | |
| */ | |
| dwc3_enable_susphy(&appledwc->dwc, true); | |
| dwc3_core_exit(&appledwc->dwc); | |
| appledwc->state = DWC3_APPLE_NO_CABLE; | |
| ret = reset_control_assert(appledwc->reset); | |
| if (ret) { | |
| dev_err(appledwc->dev, "Failed to assert reset, err=%d\n", ret); | |
| return ret; | |
| } | |
| return 0; | |
| } | |
| static int dwc3_usb_role_switch_set(struct usb_role_switch *sw, enum usb_role role) | |
| { | |
| struct dwc3_apple *appledwc = usb_role_switch_get_drvdata(sw); | |
| int ret; | |
| guard(mutex)(&appledwc->lock); | |
| /* | |
| * Skip role switches if appledwc is already in the desired state. The | |
| * USB-C port controller on M2 and M1/M2 Pro/Max/Ultra devices issues | |
| * additional interrupts which results in usb_role_switch_set_role() | |
| * calls with the current role. | |
| * Ignore those calls here to ensure the USB-C port controller and | |
| * appledwc are in a consistent state. | |
| * This matches the behaviour in __dwc3_set_mode(). | |
| * Do no handle USB_ROLE_NONE for DWC3_APPLE_NO_CABLE and | |
| * DWC3_APPLE_PROBE_PENDING since that is no-op anyway. | |
| */ | |
| if (appledwc->state == DWC3_APPLE_HOST && role == USB_ROLE_HOST) | |
| return 0; | |
| if (appledwc->state == DWC3_APPLE_DEVICE && role == USB_ROLE_DEVICE) | |
| return 0; | |
| /* | |
| * We need to tear all of dwc3 down and re-initialize it every time a cable is | |
| * connected or disconnected or when the mode changes. See the documentation for enum | |
| * dwc3_apple_state for details. | |
| */ | |
| ret = dwc3_apple_exit(appledwc); | |
| if (ret) | |
| return ret; | |
| switch (role) { | |
| case USB_ROLE_NONE: | |
| /* Nothing to do if no cable is connected */ | |
| return 0; | |
| case USB_ROLE_HOST: | |
| return dwc3_apple_init(appledwc, DWC3_APPLE_HOST); | |
| case USB_ROLE_DEVICE: | |
| return dwc3_apple_init(appledwc, DWC3_APPLE_DEVICE); | |
| default: | |
| dev_err(appledwc->dev, "Invalid target role: %d\n", role); | |
| return -EINVAL; | |
| } | |
| } | |
| static enum usb_role dwc3_usb_role_switch_get(struct usb_role_switch *sw) | |
| { | |
| struct dwc3_apple *appledwc = usb_role_switch_get_drvdata(sw); | |
| guard(mutex)(&appledwc->lock); | |
| switch (appledwc->state) { | |
| case DWC3_APPLE_HOST: | |
| return USB_ROLE_HOST; | |
| case DWC3_APPLE_DEVICE: | |
| return USB_ROLE_DEVICE; | |
| case DWC3_APPLE_NO_CABLE: | |
| case DWC3_APPLE_PROBE_PENDING: | |
| return USB_ROLE_NONE; | |
| default: | |
| /* Unreachable unless there's a bug in this driver */ | |
| dev_err(appledwc->dev, "Invalid internal state: %d\n", appledwc->state); | |
| return USB_ROLE_NONE; | |
| } | |
| } | |
| static int dwc3_apple_setup_role_switch(struct dwc3_apple *appledwc) | |
| { | |
| struct usb_role_switch_desc dwc3_role_switch = { NULL }; | |
| dwc3_role_switch.fwnode = dev_fwnode(appledwc->dev); | |
| dwc3_role_switch.set = dwc3_usb_role_switch_set; | |
| dwc3_role_switch.get = dwc3_usb_role_switch_get; | |
| dwc3_role_switch.driver_data = appledwc; | |
| appledwc->role_sw = usb_role_switch_register(appledwc->dev, &dwc3_role_switch); | |
| if (IS_ERR(appledwc->role_sw)) | |
| return PTR_ERR(appledwc->role_sw); | |
| return 0; | |
| } | |
| static int dwc3_apple_probe(struct platform_device *pdev) | |
| { | |
| struct device *dev = &pdev->dev; | |
| struct dwc3_apple *appledwc; | |
| int ret; | |
| appledwc = devm_kzalloc(&pdev->dev, sizeof(*appledwc), GFP_KERNEL); | |
| if (!appledwc) | |
| return -ENOMEM; | |
| appledwc->dev = &pdev->dev; | |
| mutex_init(&appledwc->lock); | |
| appledwc->reset = devm_reset_control_get_exclusive(dev, NULL); | |
| if (IS_ERR(appledwc->reset)) | |
| return dev_err_probe(&pdev->dev, PTR_ERR(appledwc->reset), | |
| "Failed to get reset control\n"); | |
| ret = reset_control_assert(appledwc->reset); | |
| if (ret) { | |
| dev_err(&pdev->dev, "Failed to assert reset, err=%d\n", ret); | |
| return ret; | |
| } | |
| appledwc->mmio_resource = platform_get_resource_byname(pdev, IORESOURCE_MEM, "dwc3-core"); | |
| if (!appledwc->mmio_resource) { | |
| dev_err(dev, "Failed to get DWC3 MMIO\n"); | |
| return -EINVAL; | |
| } | |
| appledwc->apple_regs = devm_platform_ioremap_resource_byname(pdev, "dwc3-apple"); | |
| if (IS_ERR(appledwc->apple_regs)) | |
| return dev_err_probe(dev, PTR_ERR(appledwc->apple_regs), | |
| "Failed to map Apple-specific MMIO\n"); | |
| /* | |
| * On this platform, DWC3 can only be brought up after parts of the PHY have been | |
| * initialized with knowledge of the target mode and cable orientation from typec_set_mux. | |
| * Since this has not happened here we cannot setup DWC3 yet and instead defer this until | |
| * the first cable is connected. See the documentation for enum dwc3_apple_state for | |
| * details. | |
| */ | |
| appledwc->state = DWC3_APPLE_PROBE_PENDING; | |
| ret = dwc3_apple_setup_role_switch(appledwc); | |
| if (ret) | |
| return dev_err_probe(&pdev->dev, ret, "Failed to setup role switch\n"); | |
| return 0; | |
| } | |
| static void dwc3_apple_remove(struct platform_device *pdev) | |
| { | |
| struct dwc3 *dwc = platform_get_drvdata(pdev); | |
| struct dwc3_apple *appledwc = to_dwc3_apple(dwc); | |
| guard(mutex)(&appledwc->lock); | |
| usb_role_switch_unregister(appledwc->role_sw); | |
| /* | |
| * If we're still in DWC3_APPLE_PROBE_PENDING we never got any cable connected event and | |
| * dwc3_core_probe was never called and there's hence no need to call dwc3_core_remove. | |
| * dwc3_apple_exit can be called unconditionally because it checks the state itself. | |
| */ | |
| dwc3_apple_exit(appledwc); | |
| if (appledwc->state != DWC3_APPLE_PROBE_PENDING) | |
| dwc3_core_remove(&appledwc->dwc); | |
| } | |
| static const struct of_device_id dwc3_apple_of_match[] = { | |
| { .compatible = "apple,t8103-dwc3" }, | |
| {} | |
| }; | |
| MODULE_DEVICE_TABLE(of, dwc3_apple_of_match); | |
| static struct platform_driver dwc3_apple_driver = { | |
| .probe = dwc3_apple_probe, | |
| .remove = dwc3_apple_remove, | |
| .driver = { | |
| .name = "dwc3-apple", | |
| .of_match_table = dwc3_apple_of_match, | |
| }, | |
| }; | |
| module_platform_driver(dwc3_apple_driver); | |
| MODULE_LICENSE("GPL"); | |
| MODULE_AUTHOR("Sven Peter <sven@kernel.org>"); | |
| MODULE_DESCRIPTION("DesignWare DWC3 Apple Silicon Glue Driver"); |