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  */
cdns_set_mode(struct cdns * cdns,enum usb_dr_mode mode)28 static 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 
cdns_get_id(struct cdns * cdns)86 int 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 
cdns_get_vbus(struct cdns * cdns)96 int 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 
cdns_clear_vbus(struct cdns * cdns)106 void 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 }
117 EXPORT_SYMBOL_GPL(cdns_clear_vbus);
118 
cdns_set_vbus(struct cdns * cdns)119 void 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 }
130 EXPORT_SYMBOL_GPL(cdns_set_vbus);
131 
cdns_is_host(struct cdns * cdns)132 bool 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 
cdns_is_device(struct cdns * cdns)142 bool 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  */
cdns_otg_disable_irq(struct cdns * cdns)157 static 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  */
cdns_otg_enable_irq(struct cdns * cdns)166 static 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  */
cdns_drd_host_on(struct cdns * cdns)178 int 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  */
cdns_drd_host_off(struct cdns * cdns)207 void 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  */
cdns_drd_gadget_on(struct cdns * cdns)228 int 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 }
254 EXPORT_SYMBOL_GPL(cdns_drd_gadget_on);
255 
256 /**
257  * cdns_drd_gadget_off - stop gadget.
258  * @cdns: Pointer to controller context structure.
259  */
cdns_drd_gadget_off(struct cdns * cdns)260 void 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 }
278 EXPORT_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  */
cdns_init_otg_mode(struct cdns * cdns)286 static 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  */
cdns_drd_update_mode(struct cdns * cdns)309 int 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 
cdns_drd_thread_irq(int irq,void * data)332 static 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  */
cdns_drd_irq(int irq,void * data)349 static 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 
cdns_drd_init(struct cdns * cdns)384 int 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 
cdns_drd_exit(struct cdns * cdns)475 int 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 */
cdns_power_is_lost(struct cdns * cdns)484 bool 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 }
495 EXPORT_SYMBOL_GPL(cdns_power_is_lost);
496