projects/linux·blob master · refs

551 lines · 12.7 KiB

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 <[email protected]>
9 * Roger Quadros <[email protected]>
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 if (cdns->no_drd)
91 return 0;
92
93 id = readl(&cdns->otg_regs->sts) & OTGSTS_ID_VALUE;
94 dev_dbg(cdns->dev, "OTG ID: %d", id);
95
96 return id;
97}
98
99int cdns_get_vbus(struct cdns *cdns)
100{
101 int vbus;
102
103 vbus = !!(readl(&cdns->otg_regs->sts) & OTGSTS_VBUS_VALID);
104 dev_dbg(cdns->dev, "OTG VBUS: %d", vbus);
105
106 return vbus;
107}
108
109void cdns_clear_vbus(struct cdns *cdns)
110{
111 u32 reg;
112
113 if (cdns->version != CDNSP_CONTROLLER_V2 || cdns->no_drd)
114 return;
115
116 reg = readl(&cdns->otg_cdnsp_regs->override);
117 reg |= OVERRIDE_SESS_VLD_SEL;
118 writel(reg, &cdns->otg_cdnsp_regs->override);
119}
120EXPORT_SYMBOL_GPL(cdns_clear_vbus);
121
122void cdns_set_vbus(struct cdns *cdns)
123{
124 u32 reg;
125
126 if (cdns->version != CDNSP_CONTROLLER_V2 || cdns->no_drd)
127 return;
128
129 reg = readl(&cdns->otg_cdnsp_regs->override);
130 reg &= ~OVERRIDE_SESS_VLD_SEL;
131 writel(reg, &cdns->otg_cdnsp_regs->override);
132}
133EXPORT_SYMBOL_GPL(cdns_set_vbus);
134
135bool cdns_is_host(struct cdns *cdns)
136{
137 if (cdns->dr_mode == USB_DR_MODE_HOST)
138 return true;
139 else if (cdns_get_id(cdns) == CDNS3_ID_HOST)
140 return true;
141
142 return false;
143}
144
145bool cdns_is_device(struct cdns *cdns)
146{
147 if (cdns->dr_mode == USB_DR_MODE_PERIPHERAL)
148 return true;
149 else if (cdns->dr_mode == USB_DR_MODE_OTG)
150 if (cdns_get_id(cdns) == CDNS3_ID_PERIPHERAL)
151 return true;
152
153 return false;
154}
155
156/**
157 * cdns_otg_disable_irq - Disable all OTG interrupts
158 * @cdns: Pointer to controller context structure
159 */
160static void cdns_otg_disable_irq(struct cdns *cdns)
161{
162 if (cdns->version)
163 writel(0, &cdns->otg_irq_regs->ien);
164}
165
166/**
167 * cdns_otg_enable_irq - enable id and sess_valid interrupts
168 * @cdns: Pointer to controller context structure
169 */
170static void cdns_otg_enable_irq(struct cdns *cdns)
171{
172 writel(OTGIEN_ID_CHANGE_INT | OTGIEN_VBUSVALID_RISE_INT |
173 OTGIEN_VBUSVALID_FALL_INT, &cdns->otg_irq_regs->ien);
174}
175
176/**
177 * cdns_drd_host_on - start host.
178 * @cdns: Pointer to controller context structure.
179 *
180 * Returns 0 on success otherwise negative errno.
181 */
182int cdns_drd_host_on(struct cdns *cdns)
183{
184 u32 val, ready_bit;
185 int ret = 0;
186
187 if (cdns->no_drd)
188 goto phy_set;
189
190 /* Enable host mode. */
191 writel(OTGCMD_HOST_BUS_REQ | OTGCMD_OTG_DIS,
192 &cdns->otg_regs->cmd);
193
194 if (cdns->version == CDNSP_CONTROLLER_V2)
195 ready_bit = OTGSTS_CDNSP_XHCI_READY;
196 else
197 ready_bit = OTGSTS_CDNS3_XHCI_READY;
198
199 dev_dbg(cdns->dev, "Waiting till Host mode is turned on\n");
200 ret = readl_poll_timeout_atomic(&cdns->otg_regs->sts, val,
201 val & ready_bit, 1, 100000);
202
203 if (ret)
204 dev_err(cdns->dev, "timeout waiting for xhci_ready\n");
205
206phy_set:
207 phy_set_mode(cdns->usb2_phy, PHY_MODE_USB_HOST);
208 phy_set_mode(cdns->usb3_phy, PHY_MODE_USB_HOST);
209 return ret;
210}
211
212/**
213 * cdns_drd_host_off - stop host.
214 * @cdns: Pointer to controller context structure.
215 */
216void cdns_drd_host_off(struct cdns *cdns)
217{
218 u32 val;
219
220 if (cdns->no_drd)
221 goto phy_set;
222
223 writel(OTGCMD_HOST_BUS_DROP | OTGCMD_DEV_BUS_DROP |
224 OTGCMD_DEV_POWER_OFF | OTGCMD_HOST_POWER_OFF,
225 &cdns->otg_regs->cmd);
226
227 /* Waiting till H_IDLE state.*/
228 readl_poll_timeout_atomic(&cdns->otg_regs->state, val,
229 !(val & OTGSTATE_HOST_STATE_MASK),
230 1, 2000000);
231
232phy_set:
233 phy_set_mode(cdns->usb2_phy, PHY_MODE_INVALID);
234 phy_set_mode(cdns->usb3_phy, PHY_MODE_INVALID);
235}
236
237/**
238 * cdns_drd_gadget_on - start gadget.
239 * @cdns: Pointer to controller context structure.
240 *
241 * Returns 0 on success otherwise negative errno
242 */
243int cdns_drd_gadget_on(struct cdns *cdns)
244{
245 u32 reg = OTGCMD_OTG_DIS;
246 u32 ready_bit;
247 int ret, val;
248
249 if (cdns->no_drd)
250 goto phy_set;
251
252 /* switch OTG core */
253 writel(OTGCMD_DEV_BUS_REQ | reg, &cdns->otg_regs->cmd);
254
255 dev_dbg(cdns->dev, "Waiting till Device mode is turned on\n");
256
257 if (cdns->version == CDNSP_CONTROLLER_V2)
258 ready_bit = OTGSTS_CDNSP_DEV_READY;
259 else
260 ready_bit = OTGSTS_CDNS3_DEV_READY;
261
262 ret = readl_poll_timeout_atomic(&cdns->otg_regs->sts, val,
263 val & ready_bit, 1, 100000);
264 if (ret) {
265 dev_err(cdns->dev, "timeout waiting for dev_ready\n");
266 return ret;
267 }
268
269phy_set:
270 phy_set_mode(cdns->usb2_phy, PHY_MODE_USB_DEVICE);
271 phy_set_mode(cdns->usb3_phy, PHY_MODE_USB_DEVICE);
272 return 0;
273}
274EXPORT_SYMBOL_GPL(cdns_drd_gadget_on);
275
276/**
277 * cdns_drd_gadget_off - stop gadget.
278 * @cdns: Pointer to controller context structure.
279 */
280void cdns_drd_gadget_off(struct cdns *cdns)
281{
282 u32 val;
283
284 if (cdns->no_drd)
285 goto phy_set;
286
287 /*
288 * Driver should wait at least 10us after disabling Device
289 * before turning-off Device (DEV_BUS_DROP).
290 */
291 usleep_range(20, 30);
292 writel(OTGCMD_HOST_BUS_DROP | OTGCMD_DEV_BUS_DROP |
293 OTGCMD_DEV_POWER_OFF | OTGCMD_HOST_POWER_OFF,
294 &cdns->otg_regs->cmd);
295 /* Waiting till DEV_IDLE state.*/
296 readl_poll_timeout_atomic(&cdns->otg_regs->state, val,
297 !(val & OTGSTATE_DEV_STATE_MASK),
298 1, 2000000);
299
300phy_set:
301 phy_set_mode(cdns->usb2_phy, PHY_MODE_INVALID);
302 phy_set_mode(cdns->usb3_phy, PHY_MODE_INVALID);
303}
304EXPORT_SYMBOL_GPL(cdns_drd_gadget_off);
305
306/**
307 * cdns_init_otg_mode - initialize drd controller
308 * @cdns: Pointer to controller context structure
309 *
310 * Returns 0 on success otherwise negative errno
311 */
312static int cdns_init_otg_mode(struct cdns *cdns)
313{
314 int ret;
315
316 cdns_otg_disable_irq(cdns);
317 /* clear all interrupts */
318 writel(~0, &cdns->otg_irq_regs->ivect);
319
320 ret = cdns_set_mode(cdns, USB_DR_MODE_OTG);
321 if (ret)
322 return ret;
323
324 cdns_otg_enable_irq(cdns);
325
326 return 0;
327}
328
329/**
330 * cdns_drd_update_mode - initialize mode of operation
331 * @cdns: Pointer to controller context structure
332 *
333 * Returns 0 on success otherwise negative errno
334 */
335int cdns_drd_update_mode(struct cdns *cdns)
336{
337 int ret;
338
339 switch (cdns->dr_mode) {
340 case USB_DR_MODE_PERIPHERAL:
341 ret = cdns_set_mode(cdns, USB_DR_MODE_PERIPHERAL);
342 break;
343 case USB_DR_MODE_HOST:
344 ret = cdns_set_mode(cdns, USB_DR_MODE_HOST);
345 break;
346 case USB_DR_MODE_OTG:
347 ret = cdns_init_otg_mode(cdns);
348 break;
349 default:
350 dev_err(cdns->dev, "Unsupported mode of operation %d\n",
351 cdns->dr_mode);
352 return -EINVAL;
353 }
354
355 return ret;
356}
357
358static irqreturn_t cdns_drd_thread_irq(int irq, void *data)
359{
360 struct cdns *cdns = data;
361
362 cdns_hw_role_switch(cdns);
363
364 return IRQ_HANDLED;
365}
366
367/**
368 * cdns_drd_irq - interrupt handler for OTG events
369 *
370 * @irq: irq number for cdns core device
371 * @data: structure of cdns
372 *
373 * Returns IRQ_HANDLED or IRQ_NONE
374 */
375static irqreturn_t cdns_drd_irq(int irq, void *data)
376{
377 irqreturn_t ret = IRQ_NONE;
378 struct cdns *cdns = data;
379 u32 reg;
380
381 if (cdns->dr_mode != USB_DR_MODE_OTG)
382 return IRQ_NONE;
383
384 if (cdns->in_lpm)
385 return ret;
386
387 reg = readl(&cdns->otg_irq_regs->ivect);
388
389 if (!reg)
390 return IRQ_NONE;
391
392 if (reg & OTGIEN_ID_CHANGE_INT) {
393 dev_dbg(cdns->dev, "OTG IRQ: new ID: %d\n",
394 cdns_get_id(cdns));
395
396 ret = IRQ_WAKE_THREAD;
397 }
398
399 if (reg & (OTGIEN_VBUSVALID_RISE_INT | OTGIEN_VBUSVALID_FALL_INT)) {
400 dev_dbg(cdns->dev, "OTG IRQ: new VBUS: %d\n",
401 cdns_get_vbus(cdns));
402
403 ret = IRQ_WAKE_THREAD;
404 }
405
406 writel(~0, &cdns->otg_irq_regs->ivect);
407 return ret;
408}
409
410int cdns_drd_init(struct cdns *cdns)
411{
412 void __iomem *regs;
413 u32 state, reg;
414 int ret;
415
416 if (cdns->no_drd) {
417 cdns->dr_mode = usb_get_dr_mode(cdns->dev);
418
419 if (cdns->dr_mode != USB_DR_MODE_HOST &&
420 cdns->dr_mode != USB_DR_MODE_PERIPHERAL) {
421 dev_err(cdns->dev, "Incorrect dr_mode\n");
422 return -EINVAL;
423 }
424
425 return 0;
426 }
427
428 regs = devm_ioremap_resource(cdns->dev, &cdns->otg_res);
429 if (IS_ERR(regs))
430 return PTR_ERR(regs);
431
432 /* Detection of DRD version. Controller has been released
433 * in three versions. All are very similar and are software compatible,
434 * but they have same changes in register maps.
435 * The first register in oldest version is command register and it's
436 * read only. Driver should read 0 from it. On the other hand, in v1
437 * and v2 the first register contains device ID number which is not
438 * set to 0. Driver uses this fact to detect the proper version of
439 * controller.
440 */
441 cdns->otg_v0_regs = regs;
442 if (!readl(&cdns->otg_v0_regs->cmd)) {
443 cdns->version = CDNS3_CONTROLLER_V0;
444 cdns->otg_v1_regs = NULL;
445 cdns->otg_cdnsp_regs = NULL;
446 cdns->otg_regs = regs;
447 cdns->otg_irq_regs = (struct cdns_otg_irq_regs __iomem *)
448 &cdns->otg_v0_regs->ien;
449 writel(1, &cdns->otg_v0_regs->simulate);
450 dev_dbg(cdns->dev, "DRD version v0 (%08x)\n",
451 readl(&cdns->otg_v0_regs->version));
452 } else {
453 cdns->otg_v0_regs = NULL;
454 cdns->otg_v1_regs = regs;
455 cdns->otg_cdnsp_regs = regs;
456
457 cdns->otg_regs = (void __iomem *)&cdns->otg_v1_regs->cmd;
458
459 state = readl(&cdns->otg_cdnsp_regs->did);
460
461 if (OTG_CDNSP_CHECK_DID(state)) {
462 cdns->otg_irq_regs = (struct cdns_otg_irq_regs __iomem *)
463 &cdns->otg_cdnsp_regs->ien;
464 cdns->version = CDNSP_CONTROLLER_V2;
465 } else if (OTG_CDNS3_CHECK_DID(state)) {
466 cdns->otg_irq_regs = (struct cdns_otg_irq_regs __iomem *)
467 &cdns->otg_v1_regs->ien;
468 writel(1, &cdns->otg_v1_regs->simulate);
469
470 if (cdns->pdata &&
471 (cdns->pdata->quirks & CDNS3_DRD_SUSPEND_RESIDENCY_ENABLE)) {
472 reg = readl(&cdns->otg_v1_regs->susp_ctrl);
473 reg |= SUSP_CTRL_SUSPEND_RESIDENCY_ENABLE;
474 writel(reg, &cdns->otg_v1_regs->susp_ctrl);
475 }
476
477 cdns->version = CDNS3_CONTROLLER_V1;
478 } else {
479 dev_err(cdns->dev, "not supported DID=0x%08x\n", state);
480 return -EINVAL;
481 }
482
483 dev_dbg(cdns->dev, "DRD version v1 (ID: %08x, rev: %08x)\n",
484 readl(&cdns->otg_v1_regs->did),
485 readl(&cdns->otg_v1_regs->rid));
486 }
487
488 state = OTGSTS_STRAP(readl(&cdns->otg_regs->sts));
489
490 /* Update dr_mode according to STRAP configuration. */
491 cdns->dr_mode = USB_DR_MODE_OTG;
492
493 if ((cdns->version == CDNSP_CONTROLLER_V2 &&
494 state == OTGSTS_CDNSP_STRAP_HOST) ||
495 (cdns->version != CDNSP_CONTROLLER_V2 &&
496 state == OTGSTS_STRAP_HOST)) {
497 dev_dbg(cdns->dev, "Controller strapped to HOST\n");
498 cdns->dr_mode = USB_DR_MODE_HOST;
499 } else if ((cdns->version == CDNSP_CONTROLLER_V2 &&
500 state == OTGSTS_CDNSP_STRAP_GADGET) ||
501 (cdns->version != CDNSP_CONTROLLER_V2 &&
502 state == OTGSTS_STRAP_GADGET)) {
503 dev_dbg(cdns->dev, "Controller strapped to PERIPHERAL\n");
504 cdns->dr_mode = USB_DR_MODE_PERIPHERAL;
505 }
506
507 ret = devm_request_threaded_irq(cdns->dev, cdns->otg_irq,
508 cdns_drd_irq,
509 cdns_drd_thread_irq,
510 IRQF_SHARED,
511 dev_name(cdns->dev), cdns);
512 if (ret) {
513 dev_err(cdns->dev, "couldn't get otg_irq\n");
514 return ret;
515 }
516
517 state = readl(&cdns->otg_regs->sts);
518 if (OTGSTS_OTG_NRDY(state)) {
519 dev_err(cdns->dev, "Cadence USB3 OTG device not ready\n");
520 return -ENODEV;
521 }
522
523 return 0;
524}
525
526int cdns_drd_exit(struct cdns *cdns)
527{
528 if (cdns->no_drd)
529 return 0;
530
531 cdns_otg_disable_irq(cdns);
532
533 return 0;
534}
535
536/* Indicate the cdns3 core was power lost before */
537bool cdns_power_is_lost(struct cdns *cdns)
538{
539 if (cdns->no_drd)
540 return false;
541
542 if (cdns->version == CDNS3_CONTROLLER_V0) {
543 if (!(readl(&cdns->otg_v0_regs->simulate) & BIT(0)))
544 return true;
545 } else {
546 if (!(readl(&cdns->otg_v1_regs->simulate) & BIT(0)))
547 return true;
548 }
549 return false;
550}
551EXPORT_SYMBOL_GPL(cdns_power_is_lost);