xref: /openbmc/linux/drivers/usb/host/ohci-da8xx.c (revision 54a15a7e)
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * OHCI HCD (Host Controller Driver) for USB.
4  *
5  * TI DA8xx (OMAP-L1x) Bus Glue
6  *
7  * Derived from: ohci-omap.c and ohci-s3c2410.c
8  * Copyright (C) 2008-2009 MontaVista Software, Inc. <source@mvista.com>
9  */
10 
11 #include <linux/clk.h>
12 #include <linux/gpio/consumer.h>
13 #include <linux/io.h>
14 #include <linux/interrupt.h>
15 #include <linux/jiffies.h>
16 #include <linux/kernel.h>
17 #include <linux/module.h>
18 #include <linux/of.h>
19 #include <linux/platform_device.h>
20 #include <linux/phy/phy.h>
21 #include <linux/platform_data/usb-davinci.h>
22 #include <linux/regulator/consumer.h>
23 #include <linux/usb.h>
24 #include <linux/usb/hcd.h>
25 #include <asm/unaligned.h>
26 
27 #include "ohci.h"
28 
29 #define DRIVER_DESC "DA8XX"
30 #define DRV_NAME "ohci-da8xx"
31 
32 static struct hc_driver __read_mostly ohci_da8xx_hc_driver;
33 
34 static int (*orig_ohci_hub_control)(struct usb_hcd  *hcd, u16 typeReq,
35 			u16 wValue, u16 wIndex, char *buf, u16 wLength);
36 static int (*orig_ohci_hub_status_data)(struct usb_hcd *hcd, char *buf);
37 
38 struct da8xx_ohci_hcd {
39 	struct usb_hcd *hcd;
40 	struct clk *usb11_clk;
41 	struct phy *usb11_phy;
42 	struct regulator *vbus_reg;
43 	struct notifier_block nb;
44 	struct gpio_desc *oc_gpio;
45 };
46 
47 #define to_da8xx_ohci(hcd) (struct da8xx_ohci_hcd *)(hcd_to_ohci(hcd)->priv)
48 
49 /* Over-current indicator change bitmask */
50 static volatile u16 ocic_mask;
51 
ohci_da8xx_enable(struct usb_hcd * hcd)52 static int ohci_da8xx_enable(struct usb_hcd *hcd)
53 {
54 	struct da8xx_ohci_hcd *da8xx_ohci = to_da8xx_ohci(hcd);
55 	int ret;
56 
57 	ret = clk_prepare_enable(da8xx_ohci->usb11_clk);
58 	if (ret)
59 		return ret;
60 
61 	ret = phy_init(da8xx_ohci->usb11_phy);
62 	if (ret)
63 		goto err_phy_init;
64 
65 	ret = phy_power_on(da8xx_ohci->usb11_phy);
66 	if (ret)
67 		goto err_phy_power_on;
68 
69 	return 0;
70 
71 err_phy_power_on:
72 	phy_exit(da8xx_ohci->usb11_phy);
73 err_phy_init:
74 	clk_disable_unprepare(da8xx_ohci->usb11_clk);
75 
76 	return ret;
77 }
78 
ohci_da8xx_disable(struct usb_hcd * hcd)79 static void ohci_da8xx_disable(struct usb_hcd *hcd)
80 {
81 	struct da8xx_ohci_hcd *da8xx_ohci = to_da8xx_ohci(hcd);
82 
83 	phy_power_off(da8xx_ohci->usb11_phy);
84 	phy_exit(da8xx_ohci->usb11_phy);
85 	clk_disable_unprepare(da8xx_ohci->usb11_clk);
86 }
87 
ohci_da8xx_set_power(struct usb_hcd * hcd,int on)88 static int ohci_da8xx_set_power(struct usb_hcd *hcd, int on)
89 {
90 	struct da8xx_ohci_hcd *da8xx_ohci = to_da8xx_ohci(hcd);
91 	struct device *dev = hcd->self.controller;
92 	int ret;
93 
94 	if (!da8xx_ohci->vbus_reg)
95 		return 0;
96 
97 	if (on) {
98 		ret = regulator_enable(da8xx_ohci->vbus_reg);
99 		if (ret) {
100 			dev_err(dev, "Failed to enable regulator: %d\n", ret);
101 			return ret;
102 		}
103 	} else {
104 		ret = regulator_disable(da8xx_ohci->vbus_reg);
105 		if (ret) {
106 			dev_err(dev, "Failed  to disable regulator: %d\n", ret);
107 			return ret;
108 		}
109 	}
110 
111 	return 0;
112 }
113 
ohci_da8xx_get_power(struct usb_hcd * hcd)114 static int ohci_da8xx_get_power(struct usb_hcd *hcd)
115 {
116 	struct da8xx_ohci_hcd *da8xx_ohci = to_da8xx_ohci(hcd);
117 
118 	if (da8xx_ohci->vbus_reg)
119 		return regulator_is_enabled(da8xx_ohci->vbus_reg);
120 
121 	return 1;
122 }
123 
ohci_da8xx_get_oci(struct usb_hcd * hcd)124 static int ohci_da8xx_get_oci(struct usb_hcd *hcd)
125 {
126 	struct da8xx_ohci_hcd *da8xx_ohci = to_da8xx_ohci(hcd);
127 	unsigned int flags;
128 	int ret;
129 
130 	if (da8xx_ohci->oc_gpio)
131 		return gpiod_get_value_cansleep(da8xx_ohci->oc_gpio);
132 
133 	if (!da8xx_ohci->vbus_reg)
134 		return 0;
135 
136 	ret = regulator_get_error_flags(da8xx_ohci->vbus_reg, &flags);
137 	if (ret)
138 		return ret;
139 
140 	if (flags & REGULATOR_ERROR_OVER_CURRENT)
141 		return 1;
142 
143 	return 0;
144 }
145 
ohci_da8xx_has_set_power(struct usb_hcd * hcd)146 static int ohci_da8xx_has_set_power(struct usb_hcd *hcd)
147 {
148 	struct da8xx_ohci_hcd *da8xx_ohci = to_da8xx_ohci(hcd);
149 
150 	if (da8xx_ohci->vbus_reg)
151 		return 1;
152 
153 	return 0;
154 }
155 
ohci_da8xx_has_oci(struct usb_hcd * hcd)156 static int ohci_da8xx_has_oci(struct usb_hcd *hcd)
157 {
158 	struct da8xx_ohci_hcd *da8xx_ohci = to_da8xx_ohci(hcd);
159 
160 	if (da8xx_ohci->oc_gpio)
161 		return 1;
162 
163 	if (da8xx_ohci->vbus_reg)
164 		return 1;
165 
166 	return 0;
167 }
168 
ohci_da8xx_has_potpgt(struct usb_hcd * hcd)169 static int ohci_da8xx_has_potpgt(struct usb_hcd *hcd)
170 {
171 	struct device *dev		= hcd->self.controller;
172 	struct da8xx_ohci_root_hub *hub	= dev_get_platdata(dev);
173 
174 	if (hub && hub->potpgt)
175 		return 1;
176 
177 	return 0;
178 }
179 
ohci_da8xx_regulator_event(struct notifier_block * nb,unsigned long event,void * data)180 static int ohci_da8xx_regulator_event(struct notifier_block *nb,
181 				unsigned long event, void *data)
182 {
183 	struct da8xx_ohci_hcd *da8xx_ohci =
184 				container_of(nb, struct da8xx_ohci_hcd, nb);
185 
186 	if (event & REGULATOR_EVENT_OVER_CURRENT) {
187 		ocic_mask |= 1 << 1;
188 		ohci_da8xx_set_power(da8xx_ohci->hcd, 0);
189 	}
190 
191 	return 0;
192 }
193 
ohci_da8xx_oc_thread(int irq,void * data)194 static irqreturn_t ohci_da8xx_oc_thread(int irq, void *data)
195 {
196 	struct da8xx_ohci_hcd *da8xx_ohci = data;
197 	struct device *dev = da8xx_ohci->hcd->self.controller;
198 	int ret;
199 
200 	if (gpiod_get_value_cansleep(da8xx_ohci->oc_gpio) &&
201 	    da8xx_ohci->vbus_reg) {
202 		ret = regulator_disable(da8xx_ohci->vbus_reg);
203 		if (ret)
204 			dev_err(dev, "Failed to disable regulator: %d\n", ret);
205 	}
206 
207 	return IRQ_HANDLED;
208 }
209 
ohci_da8xx_register_notify(struct usb_hcd * hcd)210 static int ohci_da8xx_register_notify(struct usb_hcd *hcd)
211 {
212 	struct da8xx_ohci_hcd *da8xx_ohci = to_da8xx_ohci(hcd);
213 	struct device *dev		= hcd->self.controller;
214 	int ret = 0;
215 
216 	if (!da8xx_ohci->oc_gpio && da8xx_ohci->vbus_reg) {
217 		da8xx_ohci->nb.notifier_call = ohci_da8xx_regulator_event;
218 		ret = devm_regulator_register_notifier(da8xx_ohci->vbus_reg,
219 						&da8xx_ohci->nb);
220 	}
221 
222 	if (ret)
223 		dev_err(dev, "Failed to register notifier: %d\n", ret);
224 
225 	return ret;
226 }
227 
ohci_da8xx_reset(struct usb_hcd * hcd)228 static int ohci_da8xx_reset(struct usb_hcd *hcd)
229 {
230 	struct device *dev		= hcd->self.controller;
231 	struct da8xx_ohci_root_hub *hub	= dev_get_platdata(dev);
232 	struct ohci_hcd	*ohci		= hcd_to_ohci(hcd);
233 	int result;
234 	u32 rh_a;
235 
236 	dev_dbg(dev, "starting USB controller\n");
237 
238 	result = ohci_da8xx_enable(hcd);
239 	if (result < 0)
240 		return result;
241 
242 	/*
243 	 * DA8xx only have 1 port connected to the pins but the HC root hub
244 	 * register A reports 2 ports, thus we'll have to override it...
245 	 */
246 	ohci->num_ports = 1;
247 
248 	result = ohci_setup(hcd);
249 	if (result < 0) {
250 		ohci_da8xx_disable(hcd);
251 		return result;
252 	}
253 
254 	/*
255 	 * Since we're providing a board-specific root hub port power control
256 	 * and over-current reporting, we have to override the HC root hub A
257 	 * register's default value, so that ohci_hub_control() could return
258 	 * the correct hub descriptor...
259 	 */
260 	rh_a = ohci_readl(ohci, &ohci->regs->roothub.a);
261 	if (ohci_da8xx_has_set_power(hcd)) {
262 		rh_a &= ~RH_A_NPS;
263 		rh_a |=  RH_A_PSM;
264 	}
265 	if (ohci_da8xx_has_oci(hcd)) {
266 		rh_a &= ~RH_A_NOCP;
267 		rh_a |=  RH_A_OCPM;
268 	}
269 	if (ohci_da8xx_has_potpgt(hcd)) {
270 		rh_a &= ~RH_A_POTPGT;
271 		rh_a |= hub->potpgt << 24;
272 	}
273 	ohci_writel(ohci, rh_a, &ohci->regs->roothub.a);
274 
275 	return result;
276 }
277 
278 /*
279  * Update the status data from the hub with the over-current indicator change.
280  */
ohci_da8xx_hub_status_data(struct usb_hcd * hcd,char * buf)281 static int ohci_da8xx_hub_status_data(struct usb_hcd *hcd, char *buf)
282 {
283 	int length		= orig_ohci_hub_status_data(hcd, buf);
284 
285 	/* See if we have OCIC bit set on port 1 */
286 	if (ocic_mask & (1 << 1)) {
287 		dev_dbg(hcd->self.controller, "over-current indicator change "
288 			"on port 1\n");
289 
290 		if (!length)
291 			length = 1;
292 
293 		buf[0] |= 1 << 1;
294 	}
295 	return length;
296 }
297 
298 /*
299  * Look at the control requests to the root hub and see if we need to override.
300  */
ohci_da8xx_hub_control(struct usb_hcd * hcd,u16 typeReq,u16 wValue,u16 wIndex,char * buf,u16 wLength)301 static int ohci_da8xx_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
302 				  u16 wIndex, char *buf, u16 wLength)
303 {
304 	struct device *dev		= hcd->self.controller;
305 	int temp;
306 
307 	switch (typeReq) {
308 	case GetPortStatus:
309 		/* Check the port number */
310 		if (wIndex != 1)
311 			break;
312 
313 		dev_dbg(dev, "GetPortStatus(%u)\n", wIndex);
314 
315 		temp = roothub_portstatus(hcd_to_ohci(hcd), wIndex - 1);
316 
317 		/* The port power status (PPS) bit defaults to 1 */
318 		if (!ohci_da8xx_get_power(hcd))
319 			temp &= ~RH_PS_PPS;
320 
321 		/* The port over-current indicator (POCI) bit is always 0 */
322 		if (ohci_da8xx_get_oci(hcd) > 0)
323 			temp |=  RH_PS_POCI;
324 
325 		/* The over-current indicator change (OCIC) bit is 0 too */
326 		if (ocic_mask & (1 << wIndex))
327 			temp |=  RH_PS_OCIC;
328 
329 		put_unaligned(cpu_to_le32(temp), (__le32 *)buf);
330 		return 0;
331 	case SetPortFeature:
332 		temp = 1;
333 		goto check_port;
334 	case ClearPortFeature:
335 		temp = 0;
336 
337 check_port:
338 		/* Check the port number */
339 		if (wIndex != 1)
340 			break;
341 
342 		switch (wValue) {
343 		case USB_PORT_FEAT_POWER:
344 			dev_dbg(dev, "%sPortFeature(%u): %s\n",
345 				temp ? "Set" : "Clear", wIndex, "POWER");
346 
347 			return ohci_da8xx_set_power(hcd, temp) ? -EPIPE : 0;
348 		case USB_PORT_FEAT_C_OVER_CURRENT:
349 			dev_dbg(dev, "%sPortFeature(%u): %s\n",
350 				temp ? "Set" : "Clear", wIndex,
351 				"C_OVER_CURRENT");
352 
353 			if (temp)
354 				ocic_mask |= 1 << wIndex;
355 			else
356 				ocic_mask &= ~(1 << wIndex);
357 			return 0;
358 		}
359 	}
360 
361 	return orig_ohci_hub_control(hcd, typeReq, wValue,
362 			wIndex, buf, wLength);
363 }
364 
365 /*-------------------------------------------------------------------------*/
366 #ifdef CONFIG_OF
367 static const struct of_device_id da8xx_ohci_ids[] = {
368 	{ .compatible = "ti,da830-ohci" },
369 	{ }
370 };
371 MODULE_DEVICE_TABLE(of, da8xx_ohci_ids);
372 #endif
373 
ohci_da8xx_probe(struct platform_device * pdev)374 static int ohci_da8xx_probe(struct platform_device *pdev)
375 {
376 	struct da8xx_ohci_hcd *da8xx_ohci;
377 	struct device *dev = &pdev->dev;
378 	int error, hcd_irq, oc_irq;
379 	struct usb_hcd	*hcd;
380 	struct resource *mem;
381 
382 	hcd = usb_create_hcd(&ohci_da8xx_hc_driver, dev, dev_name(dev));
383 	if (!hcd)
384 		return -ENOMEM;
385 
386 	da8xx_ohci = to_da8xx_ohci(hcd);
387 	da8xx_ohci->hcd = hcd;
388 
389 	da8xx_ohci->usb11_clk = devm_clk_get(dev, NULL);
390 	if (IS_ERR(da8xx_ohci->usb11_clk)) {
391 		error = PTR_ERR(da8xx_ohci->usb11_clk);
392 		if (error != -EPROBE_DEFER)
393 			dev_err(dev, "Failed to get clock.\n");
394 		goto err;
395 	}
396 
397 	da8xx_ohci->usb11_phy = devm_phy_get(dev, "usb-phy");
398 	if (IS_ERR(da8xx_ohci->usb11_phy)) {
399 		error = PTR_ERR(da8xx_ohci->usb11_phy);
400 		if (error != -EPROBE_DEFER)
401 			dev_err(dev, "Failed to get phy.\n");
402 		goto err;
403 	}
404 
405 	da8xx_ohci->vbus_reg = devm_regulator_get_optional(dev, "vbus");
406 	if (IS_ERR(da8xx_ohci->vbus_reg)) {
407 		error = PTR_ERR(da8xx_ohci->vbus_reg);
408 		if (error == -ENODEV) {
409 			da8xx_ohci->vbus_reg = NULL;
410 		} else if (error == -EPROBE_DEFER) {
411 			goto err;
412 		} else {
413 			dev_err(dev, "Failed to get regulator\n");
414 			goto err;
415 		}
416 	}
417 
418 	da8xx_ohci->oc_gpio = devm_gpiod_get_optional(dev, "oc", GPIOD_IN);
419 	if (IS_ERR(da8xx_ohci->oc_gpio)) {
420 		error = PTR_ERR(da8xx_ohci->oc_gpio);
421 		goto err;
422 	}
423 
424 	if (da8xx_ohci->oc_gpio) {
425 		oc_irq = gpiod_to_irq(da8xx_ohci->oc_gpio);
426 		if (oc_irq < 0) {
427 			error = oc_irq;
428 			goto err;
429 		}
430 
431 		error = devm_request_threaded_irq(dev, oc_irq, NULL,
432 				ohci_da8xx_oc_thread, IRQF_TRIGGER_RISING |
433 				IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
434 				"OHCI over-current indicator", da8xx_ohci);
435 		if (error)
436 			goto err;
437 	}
438 
439 	hcd->regs = devm_platform_get_and_ioremap_resource(pdev, 0, &mem);
440 	if (IS_ERR(hcd->regs)) {
441 		error = PTR_ERR(hcd->regs);
442 		goto err;
443 	}
444 	hcd->rsrc_start = mem->start;
445 	hcd->rsrc_len = resource_size(mem);
446 
447 	hcd_irq = platform_get_irq(pdev, 0);
448 	if (hcd_irq < 0) {
449 		error = -ENODEV;
450 		goto err;
451 	}
452 
453 	error = usb_add_hcd(hcd, hcd_irq, 0);
454 	if (error)
455 		goto err;
456 
457 	device_wakeup_enable(hcd->self.controller);
458 
459 	error = ohci_da8xx_register_notify(hcd);
460 	if (error)
461 		goto err_remove_hcd;
462 
463 	return 0;
464 
465 err_remove_hcd:
466 	usb_remove_hcd(hcd);
467 err:
468 	usb_put_hcd(hcd);
469 	return error;
470 }
471 
ohci_da8xx_remove(struct platform_device * pdev)472 static void ohci_da8xx_remove(struct platform_device *pdev)
473 {
474 	struct usb_hcd	*hcd = platform_get_drvdata(pdev);
475 
476 	usb_remove_hcd(hcd);
477 	usb_put_hcd(hcd);
478 }
479 
480 #ifdef CONFIG_PM
ohci_da8xx_suspend(struct platform_device * pdev,pm_message_t message)481 static int ohci_da8xx_suspend(struct platform_device *pdev,
482 				pm_message_t message)
483 {
484 	struct usb_hcd	*hcd	= platform_get_drvdata(pdev);
485 	struct ohci_hcd	*ohci	= hcd_to_ohci(hcd);
486 	bool		do_wakeup	= device_may_wakeup(&pdev->dev);
487 	int		ret;
488 
489 
490 	if (time_before(jiffies, ohci->next_statechange))
491 		msleep(5);
492 	ohci->next_statechange = jiffies;
493 
494 	ret = ohci_suspend(hcd, do_wakeup);
495 	if (ret)
496 		return ret;
497 
498 	ohci_da8xx_disable(hcd);
499 	hcd->state = HC_STATE_SUSPENDED;
500 
501 	return ret;
502 }
503 
ohci_da8xx_resume(struct platform_device * dev)504 static int ohci_da8xx_resume(struct platform_device *dev)
505 {
506 	struct usb_hcd	*hcd	= platform_get_drvdata(dev);
507 	struct ohci_hcd	*ohci	= hcd_to_ohci(hcd);
508 	int ret;
509 
510 	if (time_before(jiffies, ohci->next_statechange))
511 		msleep(5);
512 	ohci->next_statechange = jiffies;
513 
514 	ret = ohci_da8xx_enable(hcd);
515 	if (ret)
516 		return ret;
517 
518 	ohci_resume(hcd, false);
519 
520 	return 0;
521 }
522 #endif
523 
524 static const struct ohci_driver_overrides da8xx_overrides __initconst = {
525 	.reset		 = ohci_da8xx_reset,
526 	.extra_priv_size = sizeof(struct da8xx_ohci_hcd),
527 };
528 
529 /*
530  * Driver definition to register with platform structure.
531  */
532 static struct platform_driver ohci_hcd_da8xx_driver = {
533 	.probe		= ohci_da8xx_probe,
534 	.remove_new	= ohci_da8xx_remove,
535 	.shutdown 	= usb_hcd_platform_shutdown,
536 #ifdef	CONFIG_PM
537 	.suspend	= ohci_da8xx_suspend,
538 	.resume		= ohci_da8xx_resume,
539 #endif
540 	.driver		= {
541 		.name	= DRV_NAME,
542 		.of_match_table = of_match_ptr(da8xx_ohci_ids),
543 	},
544 };
545 
ohci_da8xx_init(void)546 static int __init ohci_da8xx_init(void)
547 {
548 
549 	if (usb_disabled())
550 		return -ENODEV;
551 
552 	ohci_init_driver(&ohci_da8xx_hc_driver, &da8xx_overrides);
553 
554 	/*
555 	 * The Davinci da8xx HW has some unusual quirks, which require
556 	 * da8xx-specific workarounds. We override certain hc_driver
557 	 * functions here to achieve that. We explicitly do not enhance
558 	 * ohci_driver_overrides to allow this more easily, since this
559 	 * is an unusual case, and we don't want to encourage others to
560 	 * override these functions by making it too easy.
561 	 */
562 
563 	orig_ohci_hub_control = ohci_da8xx_hc_driver.hub_control;
564 	orig_ohci_hub_status_data = ohci_da8xx_hc_driver.hub_status_data;
565 
566 	ohci_da8xx_hc_driver.hub_status_data     = ohci_da8xx_hub_status_data;
567 	ohci_da8xx_hc_driver.hub_control         = ohci_da8xx_hub_control;
568 
569 	return platform_driver_register(&ohci_hcd_da8xx_driver);
570 }
571 module_init(ohci_da8xx_init);
572 
ohci_da8xx_exit(void)573 static void __exit ohci_da8xx_exit(void)
574 {
575 	platform_driver_unregister(&ohci_hcd_da8xx_driver);
576 }
577 module_exit(ohci_da8xx_exit);
578 MODULE_DESCRIPTION(DRIVER_DESC);
579 MODULE_LICENSE("GPL");
580 MODULE_ALIAS("platform:" DRV_NAME);
581