xref: /openbmc/linux/drivers/usb/host/ohci-at91.c (revision 715f23b6)
1 // SPDX-License-Identifier: GPL-1.0+
2 /*
3  * OHCI HCD (Host Controller Driver) for USB.
4  *
5  *  Copyright (C) 2004 SAN People (Pty) Ltd.
6  *  Copyright (C) 2005 Thibaut VARENE <varenet@parisc-linux.org>
7  *
8  * AT91 Bus Glue
9  *
10  * Based on fragments of 2.4 driver by Rick Bronson.
11  * Based on ohci-omap.c
12  *
13  * This file is licenced under the GPL.
14  */
15 
16 #include <linux/clk.h>
17 #include <linux/dma-mapping.h>
18 #include <linux/gpio/consumer.h>
19 #include <linux/of_platform.h>
20 #include <linux/platform_device.h>
21 #include <linux/platform_data/atmel.h>
22 #include <linux/io.h>
23 #include <linux/kernel.h>
24 #include <linux/module.h>
25 #include <linux/mfd/syscon.h>
26 #include <linux/regmap.h>
27 #include <linux/usb.h>
28 #include <linux/usb/hcd.h>
29 #include <soc/at91/atmel-sfr.h>
30 
31 #include "ohci.h"
32 
33 #define valid_port(index)	((index) >= 0 && (index) < AT91_MAX_USBH_PORTS)
34 #define at91_for_each_port(index)	\
35 		for ((index) = 0; (index) < AT91_MAX_USBH_PORTS; (index)++)
36 
37 /* interface, function and usb clocks; sometimes also an AHB clock */
38 #define hcd_to_ohci_at91_priv(h) \
39 	((struct ohci_at91_priv *)hcd_to_ohci(h)->priv)
40 
41 #define AT91_MAX_USBH_PORTS	3
42 struct at91_usbh_data {
43 	struct gpio_desc *vbus_pin[AT91_MAX_USBH_PORTS];
44 	struct gpio_desc *overcurrent_pin[AT91_MAX_USBH_PORTS];
45 	u8 ports;				/* number of ports on root hub */
46 	u8 overcurrent_supported;
47 	u8 overcurrent_status[AT91_MAX_USBH_PORTS];
48 	u8 overcurrent_changed[AT91_MAX_USBH_PORTS];
49 };
50 
51 struct ohci_at91_priv {
52 	struct clk *iclk;
53 	struct clk *fclk;
54 	struct clk *hclk;
55 	bool clocked;
56 	bool wakeup;		/* Saved wake-up state for resume */
57 	struct regmap *sfr_regmap;
58 };
59 /* interface and function clocks; sometimes also an AHB clock */
60 
61 #define DRIVER_DESC "OHCI Atmel driver"
62 
63 static const char hcd_name[] = "ohci-atmel";
64 
65 static struct hc_driver __read_mostly ohci_at91_hc_driver;
66 
67 static const struct ohci_driver_overrides ohci_at91_drv_overrides __initconst = {
68 	.extra_priv_size = sizeof(struct ohci_at91_priv),
69 };
70 
71 /*-------------------------------------------------------------------------*/
72 
73 static void at91_start_clock(struct ohci_at91_priv *ohci_at91)
74 {
75 	if (ohci_at91->clocked)
76 		return;
77 
78 	clk_set_rate(ohci_at91->fclk, 48000000);
79 	clk_prepare_enable(ohci_at91->hclk);
80 	clk_prepare_enable(ohci_at91->iclk);
81 	clk_prepare_enable(ohci_at91->fclk);
82 	ohci_at91->clocked = true;
83 }
84 
85 static void at91_stop_clock(struct ohci_at91_priv *ohci_at91)
86 {
87 	if (!ohci_at91->clocked)
88 		return;
89 
90 	clk_disable_unprepare(ohci_at91->fclk);
91 	clk_disable_unprepare(ohci_at91->iclk);
92 	clk_disable_unprepare(ohci_at91->hclk);
93 	ohci_at91->clocked = false;
94 }
95 
96 static void at91_start_hc(struct platform_device *pdev)
97 {
98 	struct usb_hcd *hcd = platform_get_drvdata(pdev);
99 	struct ohci_regs __iomem *regs = hcd->regs;
100 	struct ohci_at91_priv *ohci_at91 = hcd_to_ohci_at91_priv(hcd);
101 
102 	dev_dbg(&pdev->dev, "start\n");
103 
104 	/*
105 	 * Start the USB clocks.
106 	 */
107 	at91_start_clock(ohci_at91);
108 
109 	/*
110 	 * The USB host controller must remain in reset.
111 	 */
112 	writel(0, &regs->control);
113 }
114 
115 static void at91_stop_hc(struct platform_device *pdev)
116 {
117 	struct usb_hcd *hcd = platform_get_drvdata(pdev);
118 	struct ohci_at91_priv *ohci_at91 = hcd_to_ohci_at91_priv(hcd);
119 
120 	dev_dbg(&pdev->dev, "stop\n");
121 
122 	/*
123 	 * Put the USB host controller into reset.
124 	 */
125 	usb_hcd_platform_shutdown(pdev);
126 
127 	/*
128 	 * Stop the USB clocks.
129 	 */
130 	at91_stop_clock(ohci_at91);
131 }
132 
133 
134 /*-------------------------------------------------------------------------*/
135 
136 static void usb_hcd_at91_remove (struct usb_hcd *, struct platform_device *);
137 
138 static struct regmap *at91_dt_syscon_sfr(void)
139 {
140 	struct regmap *regmap;
141 
142 	regmap = syscon_regmap_lookup_by_compatible("atmel,sama5d2-sfr");
143 	if (IS_ERR(regmap)) {
144 		regmap = syscon_regmap_lookup_by_compatible("microchip,sam9x60-sfr");
145 		if (IS_ERR(regmap))
146 			regmap = NULL;
147 	}
148 
149 	return regmap;
150 }
151 
152 /* configure so an HC device and id are always provided */
153 /* always called with process context; sleeping is OK */
154 
155 
156 /**
157  * usb_hcd_at91_probe - initialize AT91-based HCDs
158  * Context: !in_interrupt()
159  *
160  * Allocates basic resources for this USB host controller, and
161  * then invokes the start() method for the HCD associated with it
162  * through the hotplug entry's driver_data.
163  */
164 static int usb_hcd_at91_probe(const struct hc_driver *driver,
165 			struct platform_device *pdev)
166 {
167 	struct at91_usbh_data *board;
168 	struct ohci_hcd *ohci;
169 	int retval;
170 	struct usb_hcd *hcd;
171 	struct ohci_at91_priv *ohci_at91;
172 	struct device *dev = &pdev->dev;
173 	struct resource *res;
174 	int irq;
175 
176 	irq = platform_get_irq(pdev, 0);
177 	if (irq < 0) {
178 		dev_dbg(dev, "hcd probe: missing irq resource\n");
179 		return irq;
180 	}
181 
182 	hcd = usb_create_hcd(driver, dev, "at91");
183 	if (!hcd)
184 		return -ENOMEM;
185 	ohci_at91 = hcd_to_ohci_at91_priv(hcd);
186 
187 	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
188 	hcd->regs = devm_ioremap_resource(dev, res);
189 	if (IS_ERR(hcd->regs)) {
190 		retval = PTR_ERR(hcd->regs);
191 		goto err;
192 	}
193 	hcd->rsrc_start = res->start;
194 	hcd->rsrc_len = resource_size(res);
195 
196 	ohci_at91->iclk = devm_clk_get(dev, "ohci_clk");
197 	if (IS_ERR(ohci_at91->iclk)) {
198 		dev_err(dev, "failed to get ohci_clk\n");
199 		retval = PTR_ERR(ohci_at91->iclk);
200 		goto err;
201 	}
202 	ohci_at91->fclk = devm_clk_get(dev, "uhpck");
203 	if (IS_ERR(ohci_at91->fclk)) {
204 		dev_err(dev, "failed to get uhpck\n");
205 		retval = PTR_ERR(ohci_at91->fclk);
206 		goto err;
207 	}
208 	ohci_at91->hclk = devm_clk_get(dev, "hclk");
209 	if (IS_ERR(ohci_at91->hclk)) {
210 		dev_err(dev, "failed to get hclk\n");
211 		retval = PTR_ERR(ohci_at91->hclk);
212 		goto err;
213 	}
214 
215 	ohci_at91->sfr_regmap = at91_dt_syscon_sfr();
216 	if (!ohci_at91->sfr_regmap)
217 		dev_dbg(dev, "failed to find sfr node\n");
218 
219 	board = hcd->self.controller->platform_data;
220 	ohci = hcd_to_ohci(hcd);
221 	ohci->num_ports = board->ports;
222 	at91_start_hc(pdev);
223 
224 	/*
225 	 * The RemoteWakeupConnected bit has to be set explicitly
226 	 * before calling ohci_run. The reset value of this bit is 0.
227 	 */
228 	ohci->hc_control = OHCI_CTRL_RWC;
229 
230 	retval = usb_add_hcd(hcd, irq, IRQF_SHARED);
231 	if (retval == 0) {
232 		device_wakeup_enable(hcd->self.controller);
233 		return retval;
234 	}
235 
236 	/* Error handling */
237 	at91_stop_hc(pdev);
238 
239  err:
240 	usb_put_hcd(hcd);
241 	return retval;
242 }
243 
244 
245 /* may be called with controller, bus, and devices active */
246 
247 /**
248  * usb_hcd_at91_remove - shutdown processing for AT91-based HCDs
249  * @dev: USB Host Controller being removed
250  * Context: !in_interrupt()
251  *
252  * Reverses the effect of usb_hcd_at91_probe(), first invoking
253  * the HCD's stop() method.  It is always called from a thread
254  * context, "rmmod" or something similar.
255  *
256  */
257 static void usb_hcd_at91_remove(struct usb_hcd *hcd,
258 				struct platform_device *pdev)
259 {
260 	usb_remove_hcd(hcd);
261 	at91_stop_hc(pdev);
262 	usb_put_hcd(hcd);
263 }
264 
265 /*-------------------------------------------------------------------------*/
266 static void ohci_at91_usb_set_power(struct at91_usbh_data *pdata, int port, int enable)
267 {
268 	if (!valid_port(port))
269 		return;
270 
271 	gpiod_set_value(pdata->vbus_pin[port], enable);
272 }
273 
274 static int ohci_at91_usb_get_power(struct at91_usbh_data *pdata, int port)
275 {
276 	if (!valid_port(port))
277 		return -EINVAL;
278 
279 	return gpiod_get_value(pdata->vbus_pin[port]);
280 }
281 
282 /*
283  * Update the status data from the hub with the over-current indicator change.
284  */
285 static int ohci_at91_hub_status_data(struct usb_hcd *hcd, char *buf)
286 {
287 	struct at91_usbh_data *pdata = hcd->self.controller->platform_data;
288 	int length = ohci_hub_status_data(hcd, buf);
289 	int port;
290 
291 	at91_for_each_port(port) {
292 		if (pdata->overcurrent_changed[port]) {
293 			if (!length)
294 				length = 1;
295 			buf[0] |= 1 << (port + 1);
296 		}
297 	}
298 
299 	return length;
300 }
301 
302 static int ohci_at91_port_suspend(struct regmap *regmap, u8 set)
303 {
304 	u32 regval;
305 	int ret;
306 
307 	if (!regmap)
308 		return 0;
309 
310 	ret = regmap_read(regmap, AT91_SFR_OHCIICR, &regval);
311 	if (ret)
312 		return ret;
313 
314 	if (set)
315 		regval |= AT91_OHCIICR_USB_SUSPEND;
316 	else
317 		regval &= ~AT91_OHCIICR_USB_SUSPEND;
318 
319 	regmap_write(regmap, AT91_SFR_OHCIICR, regval);
320 
321 	return 0;
322 }
323 
324 /*
325  * Look at the control requests to the root hub and see if we need to override.
326  */
327 static int ohci_at91_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
328 				 u16 wIndex, char *buf, u16 wLength)
329 {
330 	struct at91_usbh_data *pdata = dev_get_platdata(hcd->self.controller);
331 	struct ohci_at91_priv *ohci_at91 = hcd_to_ohci_at91_priv(hcd);
332 	struct usb_hub_descriptor *desc;
333 	int ret = -EINVAL;
334 	u32 *data = (u32 *)buf;
335 
336 	dev_dbg(hcd->self.controller,
337 		"ohci_at91_hub_control(%p,0x%04x,0x%04x,0x%04x,%p,%04x)\n",
338 		hcd, typeReq, wValue, wIndex, buf, wLength);
339 
340 	wIndex--;
341 
342 	switch (typeReq) {
343 	case SetPortFeature:
344 		switch (wValue) {
345 		case USB_PORT_FEAT_POWER:
346 			dev_dbg(hcd->self.controller, "SetPortFeat: POWER\n");
347 			if (valid_port(wIndex)) {
348 				ohci_at91_usb_set_power(pdata, wIndex, 1);
349 				ret = 0;
350 			}
351 
352 			goto out;
353 
354 		case USB_PORT_FEAT_SUSPEND:
355 			dev_dbg(hcd->self.controller, "SetPortFeat: SUSPEND\n");
356 			if (valid_port(wIndex) && ohci_at91->sfr_regmap) {
357 				ohci_at91_port_suspend(ohci_at91->sfr_regmap,
358 						       1);
359 				return 0;
360 			}
361 			break;
362 		}
363 		break;
364 
365 	case ClearPortFeature:
366 		switch (wValue) {
367 		case USB_PORT_FEAT_C_OVER_CURRENT:
368 			dev_dbg(hcd->self.controller,
369 				"ClearPortFeature: C_OVER_CURRENT\n");
370 
371 			if (valid_port(wIndex)) {
372 				pdata->overcurrent_changed[wIndex] = 0;
373 				pdata->overcurrent_status[wIndex] = 0;
374 			}
375 
376 			goto out;
377 
378 		case USB_PORT_FEAT_OVER_CURRENT:
379 			dev_dbg(hcd->self.controller,
380 				"ClearPortFeature: OVER_CURRENT\n");
381 
382 			if (valid_port(wIndex))
383 				pdata->overcurrent_status[wIndex] = 0;
384 
385 			goto out;
386 
387 		case USB_PORT_FEAT_POWER:
388 			dev_dbg(hcd->self.controller,
389 				"ClearPortFeature: POWER\n");
390 
391 			if (valid_port(wIndex)) {
392 				ohci_at91_usb_set_power(pdata, wIndex, 0);
393 				return 0;
394 			}
395 			break;
396 
397 		case USB_PORT_FEAT_SUSPEND:
398 			dev_dbg(hcd->self.controller, "ClearPortFeature: SUSPEND\n");
399 			if (valid_port(wIndex) && ohci_at91->sfr_regmap) {
400 				ohci_at91_port_suspend(ohci_at91->sfr_regmap,
401 						       0);
402 				return 0;
403 			}
404 			break;
405 		}
406 		break;
407 	}
408 
409 	ret = ohci_hub_control(hcd, typeReq, wValue, wIndex + 1, buf, wLength);
410 	if (ret)
411 		goto out;
412 
413 	switch (typeReq) {
414 	case GetHubDescriptor:
415 
416 		/* update the hub's descriptor */
417 
418 		desc = (struct usb_hub_descriptor *)buf;
419 
420 		dev_dbg(hcd->self.controller, "wHubCharacteristics 0x%04x\n",
421 			desc->wHubCharacteristics);
422 
423 		/* remove the old configurations for power-switching, and
424 		 * over-current protection, and insert our new configuration
425 		 */
426 
427 		desc->wHubCharacteristics &= ~cpu_to_le16(HUB_CHAR_LPSM);
428 		desc->wHubCharacteristics |=
429 			cpu_to_le16(HUB_CHAR_INDV_PORT_LPSM);
430 
431 		if (pdata->overcurrent_supported) {
432 			desc->wHubCharacteristics &= ~cpu_to_le16(HUB_CHAR_OCPM);
433 			desc->wHubCharacteristics |=
434 				cpu_to_le16(HUB_CHAR_INDV_PORT_OCPM);
435 		}
436 
437 		dev_dbg(hcd->self.controller, "wHubCharacteristics after 0x%04x\n",
438 			desc->wHubCharacteristics);
439 
440 		return ret;
441 
442 	case GetPortStatus:
443 		/* check port status */
444 
445 		dev_dbg(hcd->self.controller, "GetPortStatus(%d)\n", wIndex);
446 
447 		if (valid_port(wIndex)) {
448 			if (!ohci_at91_usb_get_power(pdata, wIndex))
449 				*data &= ~cpu_to_le32(RH_PS_PPS);
450 
451 			if (pdata->overcurrent_changed[wIndex])
452 				*data |= cpu_to_le32(RH_PS_OCIC);
453 
454 			if (pdata->overcurrent_status[wIndex])
455 				*data |= cpu_to_le32(RH_PS_POCI);
456 		}
457 	}
458 
459  out:
460 	return ret;
461 }
462 
463 /*-------------------------------------------------------------------------*/
464 
465 static irqreturn_t ohci_hcd_at91_overcurrent_irq(int irq, void *data)
466 {
467 	struct platform_device *pdev = data;
468 	struct at91_usbh_data *pdata = dev_get_platdata(&pdev->dev);
469 	int val, port;
470 
471 	/* From the GPIO notifying the over-current situation, find
472 	 * out the corresponding port */
473 	at91_for_each_port(port) {
474 		if (gpiod_to_irq(pdata->overcurrent_pin[port]) == irq)
475 			break;
476 	}
477 
478 	if (port == AT91_MAX_USBH_PORTS) {
479 		dev_err(& pdev->dev, "overcurrent interrupt from unknown GPIO\n");
480 		return IRQ_HANDLED;
481 	}
482 
483 	val = gpiod_get_value(pdata->overcurrent_pin[port]);
484 
485 	/* When notified of an over-current situation, disable power
486 	   on the corresponding port, and mark this port in
487 	   over-current. */
488 	if (!val) {
489 		ohci_at91_usb_set_power(pdata, port, 0);
490 		pdata->overcurrent_status[port]  = 1;
491 		pdata->overcurrent_changed[port] = 1;
492 	}
493 
494 	dev_dbg(& pdev->dev, "overcurrent situation %s\n",
495 		val ? "exited" : "notified");
496 
497 	return IRQ_HANDLED;
498 }
499 
500 static const struct of_device_id at91_ohci_dt_ids[] = {
501 	{ .compatible = "atmel,at91rm9200-ohci" },
502 	{ /* sentinel */ }
503 };
504 
505 MODULE_DEVICE_TABLE(of, at91_ohci_dt_ids);
506 
507 /*-------------------------------------------------------------------------*/
508 
509 static int ohci_hcd_at91_drv_probe(struct platform_device *pdev)
510 {
511 	struct device_node *np = pdev->dev.of_node;
512 	struct at91_usbh_data	*pdata;
513 	int			i;
514 	int			ret;
515 	int			err;
516 	u32			ports;
517 
518 	/* Right now device-tree probed devices don't get dma_mask set.
519 	 * Since shared usb code relies on it, set it here for now.
520 	 * Once we have dma capability bindings this can go away.
521 	 */
522 	ret = dma_coerce_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
523 	if (ret)
524 		return ret;
525 
526 	pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
527 	if (!pdata)
528 		return -ENOMEM;
529 
530 	pdev->dev.platform_data = pdata;
531 
532 	if (!of_property_read_u32(np, "num-ports", &ports))
533 		pdata->ports = ports;
534 
535 	at91_for_each_port(i) {
536 		if (i >= pdata->ports)
537 			break;
538 
539 		pdata->vbus_pin[i] =
540 			devm_gpiod_get_index_optional(&pdev->dev, "atmel,vbus",
541 						      i, GPIOD_OUT_HIGH);
542 		if (IS_ERR(pdata->vbus_pin[i])) {
543 			err = PTR_ERR(pdata->vbus_pin[i]);
544 			dev_err(&pdev->dev, "unable to claim gpio \"vbus\": %d\n", err);
545 			continue;
546 		}
547 	}
548 
549 	at91_for_each_port(i) {
550 		if (i >= pdata->ports)
551 			break;
552 
553 		pdata->overcurrent_pin[i] =
554 			devm_gpiod_get_index_optional(&pdev->dev, "atmel,oc",
555 						      i, GPIOD_IN);
556 		if (!pdata->overcurrent_pin[i])
557 			continue;
558 		if (IS_ERR(pdata->overcurrent_pin[i])) {
559 			err = PTR_ERR(pdata->overcurrent_pin[i]);
560 			dev_err(&pdev->dev, "unable to claim gpio \"overcurrent\": %d\n", err);
561 			continue;
562 		}
563 
564 		ret = devm_request_irq(&pdev->dev,
565 				       gpiod_to_irq(pdata->overcurrent_pin[i]),
566 				       ohci_hcd_at91_overcurrent_irq,
567 				       IRQF_SHARED,
568 				       "ohci_overcurrent", pdev);
569 		if (ret)
570 			dev_info(&pdev->dev, "failed to request gpio \"overcurrent\" IRQ\n");
571 	}
572 
573 	device_init_wakeup(&pdev->dev, 1);
574 	return usb_hcd_at91_probe(&ohci_at91_hc_driver, pdev);
575 }
576 
577 static int ohci_hcd_at91_drv_remove(struct platform_device *pdev)
578 {
579 	struct at91_usbh_data	*pdata = dev_get_platdata(&pdev->dev);
580 	int			i;
581 
582 	if (pdata) {
583 		at91_for_each_port(i)
584 			ohci_at91_usb_set_power(pdata, i, 0);
585 	}
586 
587 	device_init_wakeup(&pdev->dev, 0);
588 	usb_hcd_at91_remove(platform_get_drvdata(pdev), pdev);
589 	return 0;
590 }
591 
592 static int __maybe_unused
593 ohci_hcd_at91_drv_suspend(struct device *dev)
594 {
595 	struct usb_hcd	*hcd = dev_get_drvdata(dev);
596 	struct ohci_hcd	*ohci = hcd_to_ohci(hcd);
597 	struct ohci_at91_priv *ohci_at91 = hcd_to_ohci_at91_priv(hcd);
598 	int		ret;
599 
600 	/*
601 	 * Disable wakeup if we are going to sleep with slow clock mode
602 	 * enabled.
603 	 */
604 	ohci_at91->wakeup = device_may_wakeup(dev)
605 			&& !at91_suspend_entering_slow_clock();
606 
607 	if (ohci_at91->wakeup)
608 		enable_irq_wake(hcd->irq);
609 
610 	ohci_at91_port_suspend(ohci_at91->sfr_regmap, 1);
611 
612 	ret = ohci_suspend(hcd, ohci_at91->wakeup);
613 	if (ret) {
614 		if (ohci_at91->wakeup)
615 			disable_irq_wake(hcd->irq);
616 		return ret;
617 	}
618 	/*
619 	 * The integrated transceivers seem unable to notice disconnect,
620 	 * reconnect, or wakeup without the 48 MHz clock active.  so for
621 	 * correctness, always discard connection state (using reset).
622 	 *
623 	 * REVISIT: some boards will be able to turn VBUS off...
624 	 */
625 	if (!ohci_at91->wakeup) {
626 		ohci->rh_state = OHCI_RH_HALTED;
627 
628 		/* flush the writes */
629 		(void) ohci_readl (ohci, &ohci->regs->control);
630 		msleep(1);
631 		at91_stop_clock(ohci_at91);
632 	}
633 
634 	return ret;
635 }
636 
637 static int __maybe_unused
638 ohci_hcd_at91_drv_resume(struct device *dev)
639 {
640 	struct usb_hcd	*hcd = dev_get_drvdata(dev);
641 	struct ohci_at91_priv *ohci_at91 = hcd_to_ohci_at91_priv(hcd);
642 
643 	if (ohci_at91->wakeup)
644 		disable_irq_wake(hcd->irq);
645 	else
646 		at91_start_clock(ohci_at91);
647 
648 	ohci_resume(hcd, false);
649 
650 	ohci_at91_port_suspend(ohci_at91->sfr_regmap, 0);
651 
652 	return 0;
653 }
654 
655 static SIMPLE_DEV_PM_OPS(ohci_hcd_at91_pm_ops, ohci_hcd_at91_drv_suspend,
656 					ohci_hcd_at91_drv_resume);
657 
658 static struct platform_driver ohci_hcd_at91_driver = {
659 	.probe		= ohci_hcd_at91_drv_probe,
660 	.remove		= ohci_hcd_at91_drv_remove,
661 	.shutdown	= usb_hcd_platform_shutdown,
662 	.driver		= {
663 		.name	= "at91_ohci",
664 		.pm	= &ohci_hcd_at91_pm_ops,
665 		.of_match_table	= at91_ohci_dt_ids,
666 	},
667 };
668 
669 static int __init ohci_at91_init(void)
670 {
671 	if (usb_disabled())
672 		return -ENODEV;
673 
674 	pr_info("%s: " DRIVER_DESC "\n", hcd_name);
675 	ohci_init_driver(&ohci_at91_hc_driver, &ohci_at91_drv_overrides);
676 
677 	/*
678 	 * The Atmel HW has some unusual quirks, which require Atmel-specific
679 	 * workarounds. We override certain hc_driver functions here to
680 	 * achieve that. We explicitly do not enhance ohci_driver_overrides to
681 	 * allow this more easily, since this is an unusual case, and we don't
682 	 * want to encourage others to override these functions by making it
683 	 * too easy.
684 	 */
685 
686 	ohci_at91_hc_driver.hub_status_data	= ohci_at91_hub_status_data;
687 	ohci_at91_hc_driver.hub_control		= ohci_at91_hub_control;
688 
689 	return platform_driver_register(&ohci_hcd_at91_driver);
690 }
691 module_init(ohci_at91_init);
692 
693 static void __exit ohci_at91_cleanup(void)
694 {
695 	platform_driver_unregister(&ohci_hcd_at91_driver);
696 }
697 module_exit(ohci_at91_cleanup);
698 
699 MODULE_DESCRIPTION(DRIVER_DESC);
700 MODULE_LICENSE("GPL");
701 MODULE_ALIAS("platform:at91_ohci");
702