1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Cadence USBSS DRD Driver. 4 * 5 * Copyright (C) 2018-2019 Cadence. 6 * Copyright (C) 2019 Texas Instruments 7 * 8 * Author: Pawel Laszczak <pawell@cadence.com> 9 * Roger Quadros <rogerq@ti.com> 10 * 11 * 12 */ 13 #include <linux/kernel.h> 14 #include <linux/interrupt.h> 15 #include <linux/delay.h> 16 #include <linux/iopoll.h> 17 #include <linux/usb/otg.h> 18 19 #include "gadget.h" 20 #include "drd.h" 21 #include "core.h" 22 23 /** 24 * cdns3_set_mode - change mode of OTG Core 25 * @cdns: pointer to context structure 26 * @mode: selected mode from cdns_role 27 * 28 * Returns 0 on success otherwise negative errno 29 */ 30 int cdns3_set_mode(struct cdns3 *cdns, enum usb_dr_mode mode) 31 { 32 u32 reg; 33 34 switch (mode) { 35 case USB_DR_MODE_PERIPHERAL: 36 break; 37 case USB_DR_MODE_HOST: 38 break; 39 case USB_DR_MODE_OTG: 40 dev_dbg(cdns->dev, "Set controller to OTG mode\n"); 41 if (cdns->version == CDNS3_CONTROLLER_V1) { 42 reg = readl(&cdns->otg_v1_regs->override); 43 reg |= OVERRIDE_IDPULLUP; 44 writel(reg, &cdns->otg_v1_regs->override); 45 } else { 46 reg = readl(&cdns->otg_v0_regs->ctrl1); 47 reg |= OVERRIDE_IDPULLUP_V0; 48 writel(reg, &cdns->otg_v0_regs->ctrl1); 49 } 50 51 /* 52 * Hardware specification says: "ID_VALUE must be valid within 53 * 50ms after idpullup is set to '1" so driver must wait 54 * 50ms before reading this pin. 55 */ 56 usleep_range(50000, 60000); 57 break; 58 default: 59 dev_err(cdns->dev, "Unsupported mode of operation %d\n", mode); 60 return -EINVAL; 61 } 62 63 return 0; 64 } 65 66 int cdns3_get_id(struct cdns3 *cdns) 67 { 68 int id; 69 70 id = readl(&cdns->otg_regs->sts) & OTGSTS_ID_VALUE; 71 dev_dbg(cdns->dev, "OTG ID: %d", id); 72 73 return id; 74 } 75 76 int cdns3_get_vbus(struct cdns3 *cdns) 77 { 78 int vbus; 79 80 vbus = !!(readl(&cdns->otg_regs->sts) & OTGSTS_VBUS_VALID); 81 dev_dbg(cdns->dev, "OTG VBUS: %d", vbus); 82 83 return vbus; 84 } 85 86 bool cdns3_is_host(struct cdns3 *cdns) 87 { 88 if (cdns->dr_mode == USB_DR_MODE_HOST) 89 return true; 90 else if (cdns3_get_id(cdns) == CDNS3_ID_HOST) 91 return true; 92 93 return false; 94 } 95 96 bool cdns3_is_device(struct cdns3 *cdns) 97 { 98 if (cdns->dr_mode == USB_DR_MODE_PERIPHERAL) 99 return true; 100 else if (cdns->dr_mode == USB_DR_MODE_OTG) 101 if (cdns3_get_id(cdns) == CDNS3_ID_PERIPHERAL) 102 return true; 103 104 return false; 105 } 106 107 /** 108 * cdns3_otg_disable_irq - Disable all OTG interrupts 109 * @cdns: Pointer to controller context structure 110 */ 111 static void cdns3_otg_disable_irq(struct cdns3 *cdns) 112 { 113 writel(0, &cdns->otg_regs->ien); 114 } 115 116 /** 117 * cdns3_otg_enable_irq - enable id and sess_valid interrupts 118 * @cdns: Pointer to controller context structure 119 */ 120 static void cdns3_otg_enable_irq(struct cdns3 *cdns) 121 { 122 writel(OTGIEN_ID_CHANGE_INT | OTGIEN_VBUSVALID_RISE_INT | 123 OTGIEN_VBUSVALID_FALL_INT, &cdns->otg_regs->ien); 124 } 125 126 /** 127 * cdns3_drd_host_on - start host. 128 * @cdns: Pointer to controller context structure. 129 * 130 * Returns 0 on success otherwise negative errno. 131 */ 132 int cdns3_drd_host_on(struct cdns3 *cdns) 133 { 134 u32 val; 135 int ret; 136 137 /* Enable host mode. */ 138 writel(OTGCMD_HOST_BUS_REQ | OTGCMD_OTG_DIS, 139 &cdns->otg_regs->cmd); 140 141 dev_dbg(cdns->dev, "Waiting till Host mode is turned on\n"); 142 ret = readl_poll_timeout_atomic(&cdns->otg_regs->sts, val, 143 val & OTGSTS_XHCI_READY, 1, 100000); 144 145 if (ret) 146 dev_err(cdns->dev, "timeout waiting for xhci_ready\n"); 147 148 return ret; 149 } 150 151 /** 152 * cdns3_drd_host_off - stop host. 153 * @cdns: Pointer to controller context structure. 154 */ 155 void cdns3_drd_host_off(struct cdns3 *cdns) 156 { 157 u32 val; 158 159 writel(OTGCMD_HOST_BUS_DROP | OTGCMD_DEV_BUS_DROP | 160 OTGCMD_DEV_POWER_OFF | OTGCMD_HOST_POWER_OFF, 161 &cdns->otg_regs->cmd); 162 163 /* Waiting till H_IDLE state.*/ 164 readl_poll_timeout_atomic(&cdns->otg_regs->state, val, 165 !(val & OTGSTATE_HOST_STATE_MASK), 166 1, 2000000); 167 } 168 169 /** 170 * cdns3_drd_gadget_on - start gadget. 171 * @cdns: Pointer to controller context structure. 172 * 173 * Returns 0 on success otherwise negative errno 174 */ 175 int cdns3_drd_gadget_on(struct cdns3 *cdns) 176 { 177 int ret, val; 178 u32 reg = OTGCMD_OTG_DIS; 179 180 /* switch OTG core */ 181 writel(OTGCMD_DEV_BUS_REQ | reg, &cdns->otg_regs->cmd); 182 183 dev_dbg(cdns->dev, "Waiting till Device mode is turned on\n"); 184 185 ret = readl_poll_timeout_atomic(&cdns->otg_regs->sts, val, 186 val & OTGSTS_DEV_READY, 187 1, 100000); 188 if (ret) { 189 dev_err(cdns->dev, "timeout waiting for dev_ready\n"); 190 return ret; 191 } 192 193 return 0; 194 } 195 196 /** 197 * cdns3_drd_gadget_off - stop gadget. 198 * @cdns: Pointer to controller context structure. 199 */ 200 void cdns3_drd_gadget_off(struct cdns3 *cdns) 201 { 202 u32 val; 203 204 /* 205 * Driver should wait at least 10us after disabling Device 206 * before turning-off Device (DEV_BUS_DROP). 207 */ 208 usleep_range(20, 30); 209 writel(OTGCMD_HOST_BUS_DROP | OTGCMD_DEV_BUS_DROP | 210 OTGCMD_DEV_POWER_OFF | OTGCMD_HOST_POWER_OFF, 211 &cdns->otg_regs->cmd); 212 /* Waiting till DEV_IDLE state.*/ 213 readl_poll_timeout_atomic(&cdns->otg_regs->state, val, 214 !(val & OTGSTATE_DEV_STATE_MASK), 215 1, 2000000); 216 } 217 218 /** 219 * cdns3_init_otg_mode - initialize drd controller 220 * @cdns: Pointer to controller context structure 221 * 222 * Returns 0 on success otherwise negative errno 223 */ 224 static int cdns3_init_otg_mode(struct cdns3 *cdns) 225 { 226 int ret; 227 228 cdns3_otg_disable_irq(cdns); 229 /* clear all interrupts */ 230 writel(~0, &cdns->otg_regs->ivect); 231 232 ret = cdns3_set_mode(cdns, USB_DR_MODE_OTG); 233 if (ret) 234 return ret; 235 236 cdns3_otg_enable_irq(cdns); 237 238 return 0; 239 } 240 241 /** 242 * cdns3_drd_update_mode - initialize mode of operation 243 * @cdns: Pointer to controller context structure 244 * 245 * Returns 0 on success otherwise negative errno 246 */ 247 int cdns3_drd_update_mode(struct cdns3 *cdns) 248 { 249 int ret; 250 251 switch (cdns->dr_mode) { 252 case USB_DR_MODE_PERIPHERAL: 253 ret = cdns3_set_mode(cdns, USB_DR_MODE_PERIPHERAL); 254 break; 255 case USB_DR_MODE_HOST: 256 ret = cdns3_set_mode(cdns, USB_DR_MODE_HOST); 257 break; 258 case USB_DR_MODE_OTG: 259 ret = cdns3_init_otg_mode(cdns); 260 break; 261 default: 262 dev_err(cdns->dev, "Unsupported mode of operation %d\n", 263 cdns->dr_mode); 264 return -EINVAL; 265 } 266 267 return ret; 268 } 269 270 static irqreturn_t cdns3_drd_thread_irq(int irq, void *data) 271 { 272 struct cdns3 *cdns = data; 273 274 cdns3_hw_role_switch(cdns); 275 276 return IRQ_HANDLED; 277 } 278 279 /** 280 * cdns3_drd_irq - interrupt handler for OTG events 281 * 282 * @irq: irq number for cdns3 core device 283 * @data: structure of cdns3 284 * 285 * Returns IRQ_HANDLED or IRQ_NONE 286 */ 287 static irqreturn_t cdns3_drd_irq(int irq, void *data) 288 { 289 irqreturn_t ret = IRQ_NONE; 290 struct cdns3 *cdns = data; 291 u32 reg; 292 293 if (cdns->dr_mode != USB_DR_MODE_OTG) 294 return IRQ_NONE; 295 296 reg = readl(&cdns->otg_regs->ivect); 297 298 if (!reg) 299 return IRQ_NONE; 300 301 if (reg & OTGIEN_ID_CHANGE_INT) { 302 dev_dbg(cdns->dev, "OTG IRQ: new ID: %d\n", 303 cdns3_get_id(cdns)); 304 305 ret = IRQ_WAKE_THREAD; 306 } 307 308 if (reg & (OTGIEN_VBUSVALID_RISE_INT | OTGIEN_VBUSVALID_FALL_INT)) { 309 dev_dbg(cdns->dev, "OTG IRQ: new VBUS: %d\n", 310 cdns3_get_vbus(cdns)); 311 312 ret = IRQ_WAKE_THREAD; 313 } 314 315 writel(~0, &cdns->otg_regs->ivect); 316 return ret; 317 } 318 319 int cdns3_drd_init(struct cdns3 *cdns) 320 { 321 void __iomem *regs; 322 u32 state; 323 int ret; 324 325 regs = devm_ioremap_resource(cdns->dev, &cdns->otg_res); 326 if (IS_ERR(regs)) 327 return PTR_ERR(regs); 328 329 /* Detection of DRD version. Controller has been released 330 * in two versions. Both are similar, but they have same changes 331 * in register maps. 332 * The first register in old version is command register and it's read 333 * only, so driver should read 0 from it. On the other hand, in v1 334 * the first register contains device ID number which is not set to 0. 335 * Driver uses this fact to detect the proper version of 336 * controller. 337 */ 338 cdns->otg_v0_regs = regs; 339 if (!readl(&cdns->otg_v0_regs->cmd)) { 340 cdns->version = CDNS3_CONTROLLER_V0; 341 cdns->otg_v1_regs = NULL; 342 cdns->otg_regs = regs; 343 writel(1, &cdns->otg_v0_regs->simulate); 344 dev_dbg(cdns->dev, "DRD version v0 (%08x)\n", 345 readl(&cdns->otg_v0_regs->version)); 346 } else { 347 cdns->otg_v0_regs = NULL; 348 cdns->otg_v1_regs = regs; 349 cdns->otg_regs = (void *)&cdns->otg_v1_regs->cmd; 350 cdns->version = CDNS3_CONTROLLER_V1; 351 writel(1, &cdns->otg_v1_regs->simulate); 352 dev_dbg(cdns->dev, "DRD version v1 (ID: %08x, rev: %08x)\n", 353 readl(&cdns->otg_v1_regs->did), 354 readl(&cdns->otg_v1_regs->rid)); 355 } 356 357 state = OTGSTS_STRAP(readl(&cdns->otg_regs->sts)); 358 359 /* Update dr_mode according to STRAP configuration. */ 360 cdns->dr_mode = USB_DR_MODE_OTG; 361 if (state == OTGSTS_STRAP_HOST) { 362 dev_dbg(cdns->dev, "Controller strapped to HOST\n"); 363 cdns->dr_mode = USB_DR_MODE_HOST; 364 } else if (state == OTGSTS_STRAP_GADGET) { 365 dev_dbg(cdns->dev, "Controller strapped to PERIPHERAL\n"); 366 cdns->dr_mode = USB_DR_MODE_PERIPHERAL; 367 } 368 369 ret = devm_request_threaded_irq(cdns->dev, cdns->otg_irq, 370 cdns3_drd_irq, 371 cdns3_drd_thread_irq, 372 IRQF_SHARED, 373 dev_name(cdns->dev), cdns); 374 if (ret) { 375 dev_err(cdns->dev, "couldn't get otg_irq\n"); 376 return ret; 377 } 378 379 state = readl(&cdns->otg_regs->sts); 380 if (OTGSTS_OTG_NRDY(state)) { 381 dev_err(cdns->dev, "Cadence USB3 OTG device not ready\n"); 382 return -ENODEV; 383 } 384 385 return 0; 386 } 387 388 int cdns3_drd_exit(struct cdns3 *cdns) 389 { 390 cdns3_otg_disable_irq(cdns); 391 return 0; 392 } 393