Loading...
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Cadence USBSS and USBSSP DRD Driver.
4 *
5 * Copyright (C) 2018-2020 Cadence.
6 * Copyright (C) 2019 Texas Instruments
7 *
8 * Author: Pawel Laszczak <pawell@cadence.com>
9 * Roger Quadros <rogerq@ti.com>
10 *
11 */
12#include <linux/kernel.h>
13#include <linux/interrupt.h>
14#include <linux/delay.h>
15#include <linux/iopoll.h>
16#include <linux/usb/otg.h>
17
18#include "drd.h"
19#include "core.h"
20
21/**
22 * cdns_set_mode - change mode of OTG Core
23 * @cdns: pointer to context structure
24 * @mode: selected mode from cdns_role
25 *
26 * Returns 0 on success otherwise negative errno
27 */
28static int cdns_set_mode(struct cdns *cdns, enum usb_dr_mode mode)
29{
30 void __iomem *override_reg;
31 u32 reg;
32
33 switch (mode) {
34 case USB_DR_MODE_PERIPHERAL:
35 break;
36 case USB_DR_MODE_HOST:
37 break;
38 case USB_DR_MODE_OTG:
39 dev_dbg(cdns->dev, "Set controller to OTG mode\n");
40
41 if (cdns->version == CDNSP_CONTROLLER_V2)
42 override_reg = &cdns->otg_cdnsp_regs->override;
43 else if (cdns->version == CDNS3_CONTROLLER_V1)
44 override_reg = &cdns->otg_v1_regs->override;
45 else
46 override_reg = &cdns->otg_v0_regs->ctrl1;
47
48 reg = readl(override_reg);
49
50 if (cdns->version != CDNS3_CONTROLLER_V0)
51 reg |= OVERRIDE_IDPULLUP;
52 else
53 reg |= OVERRIDE_IDPULLUP_V0;
54
55 writel(reg, override_reg);
56
57 if (cdns->version == CDNS3_CONTROLLER_V1) {
58 /*
59 * Enable work around feature built into the
60 * controller to address issue with RX Sensitivity
61 * est (EL_17) for USB2 PHY. The issue only occures
62 * for 0x0002450D controller version.
63 */
64 if (cdns->phyrst_a_enable) {
65 reg = readl(&cdns->otg_v1_regs->phyrst_cfg);
66 reg |= PHYRST_CFG_PHYRST_A_ENABLE;
67 writel(reg, &cdns->otg_v1_regs->phyrst_cfg);
68 }
69 }
70
71 /*
72 * Hardware specification says: "ID_VALUE must be valid within
73 * 50ms after idpullup is set to '1" so driver must wait
74 * 50ms before reading this pin.
75 */
76 usleep_range(50000, 60000);
77 break;
78 default:
79 dev_err(cdns->dev, "Unsupported mode of operation %d\n", mode);
80 return -EINVAL;
81 }
82
83 return 0;
84}
85
86int cdns_get_id(struct cdns *cdns)
87{
88 int id;
89
90 id = readl(&cdns->otg_regs->sts) & OTGSTS_ID_VALUE;
91 dev_dbg(cdns->dev, "OTG ID: %d", id);
92
93 return id;
94}
95
96int cdns_get_vbus(struct cdns *cdns)
97{
98 int vbus;
99
100 vbus = !!(readl(&cdns->otg_regs->sts) & OTGSTS_VBUS_VALID);
101 dev_dbg(cdns->dev, "OTG VBUS: %d", vbus);
102
103 return vbus;
104}
105
106void cdns_clear_vbus(struct cdns *cdns)
107{
108 u32 reg;
109
110 if (cdns->version != CDNSP_CONTROLLER_V2)
111 return;
112
113 reg = readl(&cdns->otg_cdnsp_regs->override);
114 reg |= OVERRIDE_SESS_VLD_SEL;
115 writel(reg, &cdns->otg_cdnsp_regs->override);
116}
117EXPORT_SYMBOL_GPL(cdns_clear_vbus);
118
119void cdns_set_vbus(struct cdns *cdns)
120{
121 u32 reg;
122
123 if (cdns->version != CDNSP_CONTROLLER_V2)
124 return;
125
126 reg = readl(&cdns->otg_cdnsp_regs->override);
127 reg &= ~OVERRIDE_SESS_VLD_SEL;
128 writel(reg, &cdns->otg_cdnsp_regs->override);
129}
130EXPORT_SYMBOL_GPL(cdns_set_vbus);
131
132bool cdns_is_host(struct cdns *cdns)
133{
134 if (cdns->dr_mode == USB_DR_MODE_HOST)
135 return true;
136 else if (cdns_get_id(cdns) == CDNS3_ID_HOST)
137 return true;
138
139 return false;
140}
141
142bool cdns_is_device(struct cdns *cdns)
143{
144 if (cdns->dr_mode == USB_DR_MODE_PERIPHERAL)
145 return true;
146 else if (cdns->dr_mode == USB_DR_MODE_OTG)
147 if (cdns_get_id(cdns) == CDNS3_ID_PERIPHERAL)
148 return true;
149
150 return false;
151}
152
153/**
154 * cdns_otg_disable_irq - Disable all OTG interrupts
155 * @cdns: Pointer to controller context structure
156 */
157static void cdns_otg_disable_irq(struct cdns *cdns)
158{
159 writel(0, &cdns->otg_irq_regs->ien);
160}
161
162/**
163 * cdns_otg_enable_irq - enable id and sess_valid interrupts
164 * @cdns: Pointer to controller context structure
165 */
166static void cdns_otg_enable_irq(struct cdns *cdns)
167{
168 writel(OTGIEN_ID_CHANGE_INT | OTGIEN_VBUSVALID_RISE_INT |
169 OTGIEN_VBUSVALID_FALL_INT, &cdns->otg_irq_regs->ien);
170}
171
172/**
173 * cdns_drd_host_on - start host.
174 * @cdns: Pointer to controller context structure.
175 *
176 * Returns 0 on success otherwise negative errno.
177 */
178int cdns_drd_host_on(struct cdns *cdns)
179{
180 u32 val, ready_bit;
181 int ret;
182
183 /* Enable host mode. */
184 writel(OTGCMD_HOST_BUS_REQ | OTGCMD_OTG_DIS,
185 &cdns->otg_regs->cmd);
186
187 if (cdns->version == CDNSP_CONTROLLER_V2)
188 ready_bit = OTGSTS_CDNSP_XHCI_READY;
189 else
190 ready_bit = OTGSTS_CDNS3_XHCI_READY;
191
192 dev_dbg(cdns->dev, "Waiting till Host mode is turned on\n");
193 ret = readl_poll_timeout_atomic(&cdns->otg_regs->sts, val,
194 val & ready_bit, 1, 100000);
195
196 if (ret)
197 dev_err(cdns->dev, "timeout waiting for xhci_ready\n");
198
199 phy_set_mode(cdns->usb3_phy, PHY_MODE_USB_HOST);
200 return ret;
201}
202
203/**
204 * cdns_drd_host_off - stop host.
205 * @cdns: Pointer to controller context structure.
206 */
207void cdns_drd_host_off(struct cdns *cdns)
208{
209 u32 val;
210
211 writel(OTGCMD_HOST_BUS_DROP | OTGCMD_DEV_BUS_DROP |
212 OTGCMD_DEV_POWER_OFF | OTGCMD_HOST_POWER_OFF,
213 &cdns->otg_regs->cmd);
214
215 /* Waiting till H_IDLE state.*/
216 readl_poll_timeout_atomic(&cdns->otg_regs->state, val,
217 !(val & OTGSTATE_HOST_STATE_MASK),
218 1, 2000000);
219 phy_set_mode(cdns->usb3_phy, PHY_MODE_INVALID);
220}
221
222/**
223 * cdns_drd_gadget_on - start gadget.
224 * @cdns: Pointer to controller context structure.
225 *
226 * Returns 0 on success otherwise negative errno
227 */
228int cdns_drd_gadget_on(struct cdns *cdns)
229{
230 u32 reg = OTGCMD_OTG_DIS;
231 u32 ready_bit;
232 int ret, val;
233
234 /* switch OTG core */
235 writel(OTGCMD_DEV_BUS_REQ | reg, &cdns->otg_regs->cmd);
236
237 dev_dbg(cdns->dev, "Waiting till Device mode is turned on\n");
238
239 if (cdns->version == CDNSP_CONTROLLER_V2)
240 ready_bit = OTGSTS_CDNSP_DEV_READY;
241 else
242 ready_bit = OTGSTS_CDNS3_DEV_READY;
243
244 ret = readl_poll_timeout_atomic(&cdns->otg_regs->sts, val,
245 val & ready_bit, 1, 100000);
246 if (ret) {
247 dev_err(cdns->dev, "timeout waiting for dev_ready\n");
248 return ret;
249 }
250
251 phy_set_mode(cdns->usb3_phy, PHY_MODE_USB_DEVICE);
252 return 0;
253}
254EXPORT_SYMBOL_GPL(cdns_drd_gadget_on);
255
256/**
257 * cdns_drd_gadget_off - stop gadget.
258 * @cdns: Pointer to controller context structure.
259 */
260void cdns_drd_gadget_off(struct cdns *cdns)
261{
262 u32 val;
263
264 /*
265 * Driver should wait at least 10us after disabling Device
266 * before turning-off Device (DEV_BUS_DROP).
267 */
268 usleep_range(20, 30);
269 writel(OTGCMD_HOST_BUS_DROP | OTGCMD_DEV_BUS_DROP |
270 OTGCMD_DEV_POWER_OFF | OTGCMD_HOST_POWER_OFF,
271 &cdns->otg_regs->cmd);
272 /* Waiting till DEV_IDLE state.*/
273 readl_poll_timeout_atomic(&cdns->otg_regs->state, val,
274 !(val & OTGSTATE_DEV_STATE_MASK),
275 1, 2000000);
276 phy_set_mode(cdns->usb3_phy, PHY_MODE_INVALID);
277}
278EXPORT_SYMBOL_GPL(cdns_drd_gadget_off);
279
280/**
281 * cdns_init_otg_mode - initialize drd controller
282 * @cdns: Pointer to controller context structure
283 *
284 * Returns 0 on success otherwise negative errno
285 */
286static int cdns_init_otg_mode(struct cdns *cdns)
287{
288 int ret;
289
290 cdns_otg_disable_irq(cdns);
291 /* clear all interrupts */
292 writel(~0, &cdns->otg_irq_regs->ivect);
293
294 ret = cdns_set_mode(cdns, USB_DR_MODE_OTG);
295 if (ret)
296 return ret;
297
298 cdns_otg_enable_irq(cdns);
299
300 return 0;
301}
302
303/**
304 * cdns_drd_update_mode - initialize mode of operation
305 * @cdns: Pointer to controller context structure
306 *
307 * Returns 0 on success otherwise negative errno
308 */
309int cdns_drd_update_mode(struct cdns *cdns)
310{
311 int ret;
312
313 switch (cdns->dr_mode) {
314 case USB_DR_MODE_PERIPHERAL:
315 ret = cdns_set_mode(cdns, USB_DR_MODE_PERIPHERAL);
316 break;
317 case USB_DR_MODE_HOST:
318 ret = cdns_set_mode(cdns, USB_DR_MODE_HOST);
319 break;
320 case USB_DR_MODE_OTG:
321 ret = cdns_init_otg_mode(cdns);
322 break;
323 default:
324 dev_err(cdns->dev, "Unsupported mode of operation %d\n",
325 cdns->dr_mode);
326 return -EINVAL;
327 }
328
329 return ret;
330}
331
332static irqreturn_t cdns_drd_thread_irq(int irq, void *data)
333{
334 struct cdns *cdns = data;
335
336 cdns_hw_role_switch(cdns);
337
338 return IRQ_HANDLED;
339}
340
341/**
342 * cdns_drd_irq - interrupt handler for OTG events
343 *
344 * @irq: irq number for cdns core device
345 * @data: structure of cdns
346 *
347 * Returns IRQ_HANDLED or IRQ_NONE
348 */
349static irqreturn_t cdns_drd_irq(int irq, void *data)
350{
351 irqreturn_t ret = IRQ_NONE;
352 struct cdns *cdns = data;
353 u32 reg;
354
355 if (cdns->dr_mode != USB_DR_MODE_OTG)
356 return IRQ_NONE;
357
358 if (cdns->in_lpm)
359 return ret;
360
361 reg = readl(&cdns->otg_irq_regs->ivect);
362
363 if (!reg)
364 return IRQ_NONE;
365
366 if (reg & OTGIEN_ID_CHANGE_INT) {
367 dev_dbg(cdns->dev, "OTG IRQ: new ID: %d\n",
368 cdns_get_id(cdns));
369
370 ret = IRQ_WAKE_THREAD;
371 }
372
373 if (reg & (OTGIEN_VBUSVALID_RISE_INT | OTGIEN_VBUSVALID_FALL_INT)) {
374 dev_dbg(cdns->dev, "OTG IRQ: new VBUS: %d\n",
375 cdns_get_vbus(cdns));
376
377 ret = IRQ_WAKE_THREAD;
378 }
379
380 writel(~0, &cdns->otg_irq_regs->ivect);
381 return ret;
382}
383
384int cdns_drd_init(struct cdns *cdns)
385{
386 void __iomem *regs;
387 u32 state;
388 int ret;
389
390 regs = devm_ioremap_resource(cdns->dev, &cdns->otg_res);
391 if (IS_ERR(regs))
392 return PTR_ERR(regs);
393
394 /* Detection of DRD version. Controller has been released
395 * in three versions. All are very similar and are software compatible,
396 * but they have same changes in register maps.
397 * The first register in oldest version is command register and it's
398 * read only. Driver should read 0 from it. On the other hand, in v1
399 * and v2 the first register contains device ID number which is not
400 * set to 0. Driver uses this fact to detect the proper version of
401 * controller.
402 */
403 cdns->otg_v0_regs = regs;
404 if (!readl(&cdns->otg_v0_regs->cmd)) {
405 cdns->version = CDNS3_CONTROLLER_V0;
406 cdns->otg_v1_regs = NULL;
407 cdns->otg_cdnsp_regs = NULL;
408 cdns->otg_regs = regs;
409 cdns->otg_irq_regs = (struct cdns_otg_irq_regs __iomem *)
410 &cdns->otg_v0_regs->ien;
411 writel(1, &cdns->otg_v0_regs->simulate);
412 dev_dbg(cdns->dev, "DRD version v0 (%08x)\n",
413 readl(&cdns->otg_v0_regs->version));
414 } else {
415 cdns->otg_v0_regs = NULL;
416 cdns->otg_v1_regs = regs;
417 cdns->otg_cdnsp_regs = regs;
418
419 cdns->otg_regs = (void __iomem *)&cdns->otg_v1_regs->cmd;
420
421 if (readl(&cdns->otg_cdnsp_regs->did) == OTG_CDNSP_DID) {
422 cdns->otg_irq_regs = (struct cdns_otg_irq_regs __iomem *)
423 &cdns->otg_cdnsp_regs->ien;
424 cdns->version = CDNSP_CONTROLLER_V2;
425 } else {
426 cdns->otg_irq_regs = (struct cdns_otg_irq_regs __iomem *)
427 &cdns->otg_v1_regs->ien;
428 writel(1, &cdns->otg_v1_regs->simulate);
429 cdns->version = CDNS3_CONTROLLER_V1;
430 }
431
432 dev_dbg(cdns->dev, "DRD version v1 (ID: %08x, rev: %08x)\n",
433 readl(&cdns->otg_v1_regs->did),
434 readl(&cdns->otg_v1_regs->rid));
435 }
436
437 state = OTGSTS_STRAP(readl(&cdns->otg_regs->sts));
438
439 /* Update dr_mode according to STRAP configuration. */
440 cdns->dr_mode = USB_DR_MODE_OTG;
441
442 if ((cdns->version == CDNSP_CONTROLLER_V2 &&
443 state == OTGSTS_CDNSP_STRAP_HOST) ||
444 (cdns->version != CDNSP_CONTROLLER_V2 &&
445 state == OTGSTS_STRAP_HOST)) {
446 dev_dbg(cdns->dev, "Controller strapped to HOST\n");
447 cdns->dr_mode = USB_DR_MODE_HOST;
448 } else if ((cdns->version == CDNSP_CONTROLLER_V2 &&
449 state == OTGSTS_CDNSP_STRAP_GADGET) ||
450 (cdns->version != CDNSP_CONTROLLER_V2 &&
451 state == OTGSTS_STRAP_GADGET)) {
452 dev_dbg(cdns->dev, "Controller strapped to PERIPHERAL\n");
453 cdns->dr_mode = USB_DR_MODE_PERIPHERAL;
454 }
455
456 ret = devm_request_threaded_irq(cdns->dev, cdns->otg_irq,
457 cdns_drd_irq,
458 cdns_drd_thread_irq,
459 IRQF_SHARED,
460 dev_name(cdns->dev), cdns);
461 if (ret) {
462 dev_err(cdns->dev, "couldn't get otg_irq\n");
463 return ret;
464 }
465
466 state = readl(&cdns->otg_regs->sts);
467 if (OTGSTS_OTG_NRDY(state)) {
468 dev_err(cdns->dev, "Cadence USB3 OTG device not ready\n");
469 return -ENODEV;
470 }
471
472 return 0;
473}
474
475int cdns_drd_exit(struct cdns *cdns)
476{
477 cdns_otg_disable_irq(cdns);
478
479 return 0;
480}
481
482
483/* Indicate the cdns3 core was power lost before */
484bool cdns_power_is_lost(struct cdns *cdns)
485{
486 if (cdns->version == CDNS3_CONTROLLER_V0) {
487 if (!(readl(&cdns->otg_v0_regs->simulate) & BIT(0)))
488 return true;
489 } else {
490 if (!(readl(&cdns->otg_v1_regs->simulate) & BIT(0)))
491 return true;
492 }
493 return false;
494}
495EXPORT_SYMBOL_GPL(cdns_power_is_lost);
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 */
30int 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
66int 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
76int 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
86bool 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
96bool 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 */
111static 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 */
120static 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 */
132int 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 */
155void 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 */
175int 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 */
200void 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 */
224static 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 */
247int 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
270static 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 */
287static 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
319int 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
388int cdns3_drd_exit(struct cdns3 *cdns)
389{
390 cdns3_otg_disable_irq(cdns);
391 return 0;
392}