1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * drd.c - DesignWare USB2 DRD Controller Dual-role support 4 * 5 * Copyright (C) 2020 STMicroelectronics 6 * 7 * Author(s): Amelie Delaunay <amelie.delaunay@st.com> 8 */ 9 10 #include <linux/clk.h> 11 #include <linux/iopoll.h> 12 #include <linux/platform_device.h> 13 #include <linux/usb/role.h> 14 #include "core.h" 15 16 #define dwc2_ovr_gotgctl(gotgctl) \ 17 ((gotgctl) |= GOTGCTL_BVALOEN | GOTGCTL_AVALOEN | GOTGCTL_VBVALOEN | \ 18 GOTGCTL_DBNCE_FLTR_BYPASS) 19 20 static void dwc2_ovr_init(struct dwc2_hsotg *hsotg) 21 { 22 unsigned long flags; 23 u32 gotgctl; 24 25 spin_lock_irqsave(&hsotg->lock, flags); 26 27 gotgctl = dwc2_readl(hsotg, GOTGCTL); 28 dwc2_ovr_gotgctl(gotgctl); 29 gotgctl &= ~(GOTGCTL_BVALOVAL | GOTGCTL_AVALOVAL | GOTGCTL_VBVALOVAL); 30 if (hsotg->role_sw_default_mode == USB_DR_MODE_HOST) 31 gotgctl |= GOTGCTL_AVALOVAL | GOTGCTL_VBVALOVAL; 32 else if (hsotg->role_sw_default_mode == USB_DR_MODE_PERIPHERAL) 33 gotgctl |= GOTGCTL_BVALOVAL | GOTGCTL_VBVALOVAL; 34 dwc2_writel(hsotg, gotgctl, GOTGCTL); 35 36 spin_unlock_irqrestore(&hsotg->lock, flags); 37 38 dwc2_force_mode(hsotg, (hsotg->dr_mode == USB_DR_MODE_HOST)); 39 } 40 41 static int dwc2_ovr_avalid(struct dwc2_hsotg *hsotg, bool valid) 42 { 43 u32 gotgctl = dwc2_readl(hsotg, GOTGCTL); 44 45 /* Check if A-Session is already in the right state */ 46 if ((valid && (gotgctl & GOTGCTL_ASESVLD)) || 47 (!valid && !(gotgctl & GOTGCTL_ASESVLD))) 48 return -EALREADY; 49 50 /* Always enable overrides to handle the resume case */ 51 dwc2_ovr_gotgctl(gotgctl); 52 53 gotgctl &= ~GOTGCTL_BVALOVAL; 54 if (valid) 55 gotgctl |= GOTGCTL_AVALOVAL | GOTGCTL_VBVALOVAL; 56 else 57 gotgctl &= ~(GOTGCTL_AVALOVAL | GOTGCTL_VBVALOVAL); 58 dwc2_writel(hsotg, gotgctl, GOTGCTL); 59 60 return 0; 61 } 62 63 static int dwc2_ovr_bvalid(struct dwc2_hsotg *hsotg, bool valid) 64 { 65 u32 gotgctl = dwc2_readl(hsotg, GOTGCTL); 66 67 /* Check if B-Session is already in the right state */ 68 if ((valid && (gotgctl & GOTGCTL_BSESVLD)) || 69 (!valid && !(gotgctl & GOTGCTL_BSESVLD))) 70 return -EALREADY; 71 72 /* Always enable overrides to handle the resume case */ 73 dwc2_ovr_gotgctl(gotgctl); 74 75 gotgctl &= ~GOTGCTL_AVALOVAL; 76 if (valid) 77 gotgctl |= GOTGCTL_BVALOVAL | GOTGCTL_VBVALOVAL; 78 else 79 gotgctl &= ~(GOTGCTL_BVALOVAL | GOTGCTL_VBVALOVAL); 80 dwc2_writel(hsotg, gotgctl, GOTGCTL); 81 82 return 0; 83 } 84 85 static int dwc2_drd_role_sw_set(struct usb_role_switch *sw, enum usb_role role) 86 { 87 struct dwc2_hsotg *hsotg = usb_role_switch_get_drvdata(sw); 88 unsigned long flags; 89 int already = 0; 90 91 /* Skip session not in line with dr_mode */ 92 if ((role == USB_ROLE_DEVICE && hsotg->dr_mode == USB_DR_MODE_HOST) || 93 (role == USB_ROLE_HOST && hsotg->dr_mode == USB_DR_MODE_PERIPHERAL)) 94 return -EINVAL; 95 96 #if IS_ENABLED(CONFIG_USB_DWC2_PERIPHERAL) || \ 97 IS_ENABLED(CONFIG_USB_DWC2_DUAL_ROLE) 98 /* Skip session if core is in test mode */ 99 if (role == USB_ROLE_NONE && hsotg->test_mode) { 100 dev_dbg(hsotg->dev, "Core is in test mode\n"); 101 return -EBUSY; 102 } 103 #endif 104 105 /* 106 * In case of USB_DR_MODE_PERIPHERAL, clock is disabled at the end of 107 * the probe and enabled on udc_start. 108 * If role-switch set is called before the udc_start, we need to enable 109 * the clock to read/write GOTGCTL and GUSBCFG registers to override 110 * mode and sessions. It is the case if cable is plugged at boot. 111 */ 112 if (!hsotg->ll_hw_enabled && hsotg->clk) { 113 int ret = clk_prepare_enable(hsotg->clk); 114 115 if (ret) 116 return ret; 117 } 118 119 spin_lock_irqsave(&hsotg->lock, flags); 120 121 if (role == USB_ROLE_NONE) { 122 /* default operation mode when usb role is USB_ROLE_NONE */ 123 if (hsotg->role_sw_default_mode == USB_DR_MODE_HOST) 124 role = USB_ROLE_HOST; 125 else if (hsotg->role_sw_default_mode == USB_DR_MODE_PERIPHERAL) 126 role = USB_ROLE_DEVICE; 127 } 128 129 if (role == USB_ROLE_HOST) { 130 already = dwc2_ovr_avalid(hsotg, true); 131 } else if (role == USB_ROLE_DEVICE) { 132 already = dwc2_ovr_bvalid(hsotg, true); 133 /* This clear DCTL.SFTDISCON bit */ 134 dwc2_hsotg_core_connect(hsotg); 135 } else { 136 if (dwc2_is_device_mode(hsotg)) { 137 if (!dwc2_ovr_bvalid(hsotg, false)) 138 /* This set DCTL.SFTDISCON bit */ 139 dwc2_hsotg_core_disconnect(hsotg); 140 } else { 141 dwc2_ovr_avalid(hsotg, false); 142 } 143 } 144 145 spin_unlock_irqrestore(&hsotg->lock, flags); 146 147 if (!already && hsotg->dr_mode == USB_DR_MODE_OTG) 148 /* This will raise a Connector ID Status Change Interrupt */ 149 dwc2_force_mode(hsotg, role == USB_ROLE_HOST); 150 151 if (!hsotg->ll_hw_enabled && hsotg->clk) 152 clk_disable_unprepare(hsotg->clk); 153 154 dev_dbg(hsotg->dev, "%s-session valid\n", 155 role == USB_ROLE_NONE ? "No" : 156 role == USB_ROLE_HOST ? "A" : "B"); 157 158 return 0; 159 } 160 161 int dwc2_drd_init(struct dwc2_hsotg *hsotg) 162 { 163 struct usb_role_switch_desc role_sw_desc = {0}; 164 struct usb_role_switch *role_sw; 165 int ret; 166 167 if (!device_property_read_bool(hsotg->dev, "usb-role-switch")) 168 return 0; 169 170 hsotg->role_sw_default_mode = usb_get_role_switch_default_mode(hsotg->dev); 171 role_sw_desc.driver_data = hsotg; 172 role_sw_desc.fwnode = dev_fwnode(hsotg->dev); 173 role_sw_desc.set = dwc2_drd_role_sw_set; 174 role_sw_desc.allow_userspace_control = true; 175 176 role_sw = usb_role_switch_register(hsotg->dev, &role_sw_desc); 177 if (IS_ERR(role_sw)) { 178 ret = PTR_ERR(role_sw); 179 dev_err(hsotg->dev, 180 "failed to register role switch: %d\n", ret); 181 return ret; 182 } 183 184 hsotg->role_sw = role_sw; 185 186 /* Enable override and initialize values */ 187 dwc2_ovr_init(hsotg); 188 189 return 0; 190 } 191 192 void dwc2_drd_suspend(struct dwc2_hsotg *hsotg) 193 { 194 u32 gintsts, gintmsk; 195 196 if (hsotg->role_sw && !hsotg->params.external_id_pin_ctl) { 197 gintmsk = dwc2_readl(hsotg, GINTMSK); 198 gintmsk &= ~GINTSTS_CONIDSTSCHNG; 199 dwc2_writel(hsotg, gintmsk, GINTMSK); 200 gintsts = dwc2_readl(hsotg, GINTSTS); 201 dwc2_writel(hsotg, gintsts | GINTSTS_CONIDSTSCHNG, GINTSTS); 202 } 203 } 204 205 void dwc2_drd_resume(struct dwc2_hsotg *hsotg) 206 { 207 u32 gintsts, gintmsk; 208 enum usb_role role; 209 210 if (hsotg->role_sw) { 211 /* get last known role (as the get ops isn't implemented by this driver) */ 212 role = usb_role_switch_get_role(hsotg->role_sw); 213 214 if (role == USB_ROLE_NONE) { 215 if (hsotg->role_sw_default_mode == USB_DR_MODE_HOST) 216 role = USB_ROLE_HOST; 217 else if (hsotg->role_sw_default_mode == USB_DR_MODE_PERIPHERAL) 218 role = USB_ROLE_DEVICE; 219 } 220 221 /* restore last role that may have been lost */ 222 if (role == USB_ROLE_HOST) 223 dwc2_ovr_avalid(hsotg, true); 224 else if (role == USB_ROLE_DEVICE) 225 dwc2_ovr_bvalid(hsotg, true); 226 227 dwc2_force_mode(hsotg, role == USB_ROLE_HOST); 228 229 dev_dbg(hsotg->dev, "resuming %s-session valid\n", 230 role == USB_ROLE_NONE ? "No" : 231 role == USB_ROLE_HOST ? "A" : "B"); 232 } 233 234 if (hsotg->role_sw && !hsotg->params.external_id_pin_ctl) { 235 gintsts = dwc2_readl(hsotg, GINTSTS); 236 dwc2_writel(hsotg, gintsts | GINTSTS_CONIDSTSCHNG, GINTSTS); 237 gintmsk = dwc2_readl(hsotg, GINTMSK); 238 gintmsk |= GINTSTS_CONIDSTSCHNG; 239 dwc2_writel(hsotg, gintmsk, GINTMSK); 240 } 241 } 242 243 void dwc2_drd_exit(struct dwc2_hsotg *hsotg) 244 { 245 if (hsotg->role_sw) 246 usb_role_switch_unregister(hsotg->role_sw); 247 } 248