Loading...
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
32static struct hc_driver __read_mostly ohci_da8xx_hc_driver;
33
34static int (*orig_ohci_hub_control)(struct usb_hcd *hcd, u16 typeReq,
35 u16 wValue, u16 wIndex, char *buf, u16 wLength);
36static int (*orig_ohci_hub_status_data)(struct usb_hcd *hcd, char *buf);
37
38struct 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 */
50static volatile u16 ocic_mask;
51
52static 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
71err_phy_power_on:
72 phy_exit(da8xx_ohci->usb11_phy);
73err_phy_init:
74 clk_disable_unprepare(da8xx_ohci->usb11_clk);
75
76 return ret;
77}
78
79static 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
88static 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
114static 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
124static 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
146static 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
156static 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
169static 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
180static 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
194static 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
210static 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
228static 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 */
281static 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 */
301static 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
337check_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
367static const struct of_device_id da8xx_ohci_ids[] = {
368 { .compatible = "ti,da830-ohci" },
369 { }
370};
371MODULE_DEVICE_TABLE(of, da8xx_ohci_ids);
372#endif
373
374static 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
465err_remove_hcd:
466 usb_remove_hcd(hcd);
467err:
468 usb_put_hcd(hcd);
469 return error;
470}
471
472static 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
481static 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
504static 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
524static 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 */
532static 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
546static 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}
571module_init(ohci_da8xx_init);
572
573static void __exit ohci_da8xx_exit(void)
574{
575 platform_driver_unregister(&ohci_hcd_da8xx_driver);
576}
577module_exit(ohci_da8xx_exit);
578MODULE_DESCRIPTION(DRIVER_DESC);
579MODULE_LICENSE("GPL");
580MODULE_ALIAS("platform:" DRV_NAME);
1/*
2 * OHCI HCD (Host Controller Driver) for USB.
3 *
4 * TI DA8xx (OMAP-L1x) Bus Glue
5 *
6 * Derived from: ohci-omap.c and ohci-s3c2410.c
7 * Copyright (C) 2008-2009 MontaVista Software, Inc. <source@mvista.com>
8 *
9 * This file is licensed under the terms of the GNU General Public License
10 * version 2. This program is licensed "as is" without any warranty of any
11 * kind, whether express or implied.
12 */
13
14#include <linux/interrupt.h>
15#include <linux/jiffies.h>
16#include <linux/platform_device.h>
17#include <linux/clk.h>
18
19#include <mach/da8xx.h>
20#include <linux/platform_data/usb-davinci.h>
21
22#ifndef CONFIG_ARCH_DAVINCI_DA8XX
23#error "This file is DA8xx bus glue. Define CONFIG_ARCH_DAVINCI_DA8XX."
24#endif
25
26#define CFGCHIP2 DA8XX_SYSCFG0_VIRT(DA8XX_CFGCHIP2_REG)
27
28static struct clk *usb11_clk;
29static struct clk *usb20_clk;
30
31/* Over-current indicator change bitmask */
32static volatile u16 ocic_mask;
33
34static void ohci_da8xx_clock(int on)
35{
36 u32 cfgchip2;
37
38 cfgchip2 = __raw_readl(CFGCHIP2);
39 if (on) {
40 clk_enable(usb11_clk);
41
42 /*
43 * If USB 1.1 reference clock is sourced from USB 2.0 PHY, we
44 * need to enable the USB 2.0 module clocking, start its PHY,
45 * and not allow it to stop the clock during USB 2.0 suspend.
46 */
47 if (!(cfgchip2 & CFGCHIP2_USB1PHYCLKMUX)) {
48 clk_enable(usb20_clk);
49
50 cfgchip2 &= ~(CFGCHIP2_RESET | CFGCHIP2_PHYPWRDN);
51 cfgchip2 |= CFGCHIP2_PHY_PLLON;
52 __raw_writel(cfgchip2, CFGCHIP2);
53
54 pr_info("Waiting for USB PHY clock good...\n");
55 while (!(__raw_readl(CFGCHIP2) & CFGCHIP2_PHYCLKGD))
56 cpu_relax();
57 }
58
59 /* Enable USB 1.1 PHY */
60 cfgchip2 |= CFGCHIP2_USB1SUSPENDM;
61 } else {
62 clk_disable(usb11_clk);
63 if (!(cfgchip2 & CFGCHIP2_USB1PHYCLKMUX))
64 clk_disable(usb20_clk);
65
66 /* Disable USB 1.1 PHY */
67 cfgchip2 &= ~CFGCHIP2_USB1SUSPENDM;
68 }
69 __raw_writel(cfgchip2, CFGCHIP2);
70}
71
72/*
73 * Handle the port over-current indicator change.
74 */
75static void ohci_da8xx_ocic_handler(struct da8xx_ohci_root_hub *hub,
76 unsigned port)
77{
78 ocic_mask |= 1 << port;
79
80 /* Once over-current is detected, the port needs to be powered down */
81 if (hub->get_oci(port) > 0)
82 hub->set_power(port, 0);
83}
84
85static int ohci_da8xx_init(struct usb_hcd *hcd)
86{
87 struct device *dev = hcd->self.controller;
88 struct da8xx_ohci_root_hub *hub = dev_get_platdata(dev);
89 struct ohci_hcd *ohci = hcd_to_ohci(hcd);
90 int result;
91 u32 rh_a;
92
93 dev_dbg(dev, "starting USB controller\n");
94
95 ohci_da8xx_clock(1);
96
97 /*
98 * DA8xx only have 1 port connected to the pins but the HC root hub
99 * register A reports 2 ports, thus we'll have to override it...
100 */
101 ohci->num_ports = 1;
102
103 result = ohci_init(ohci);
104 if (result < 0)
105 return result;
106
107 /*
108 * Since we're providing a board-specific root hub port power control
109 * and over-current reporting, we have to override the HC root hub A
110 * register's default value, so that ohci_hub_control() could return
111 * the correct hub descriptor...
112 */
113 rh_a = ohci_readl(ohci, &ohci->regs->roothub.a);
114 if (hub->set_power) {
115 rh_a &= ~RH_A_NPS;
116 rh_a |= RH_A_PSM;
117 }
118 if (hub->get_oci) {
119 rh_a &= ~RH_A_NOCP;
120 rh_a |= RH_A_OCPM;
121 }
122 rh_a &= ~RH_A_POTPGT;
123 rh_a |= hub->potpgt << 24;
124 ohci_writel(ohci, rh_a, &ohci->regs->roothub.a);
125
126 return result;
127}
128
129static void ohci_da8xx_stop(struct usb_hcd *hcd)
130{
131 ohci_stop(hcd);
132 ohci_da8xx_clock(0);
133}
134
135static int ohci_da8xx_start(struct usb_hcd *hcd)
136{
137 struct ohci_hcd *ohci = hcd_to_ohci(hcd);
138 int result;
139
140 result = ohci_run(ohci);
141 if (result < 0)
142 ohci_da8xx_stop(hcd);
143
144 return result;
145}
146
147/*
148 * Update the status data from the hub with the over-current indicator change.
149 */
150static int ohci_da8xx_hub_status_data(struct usb_hcd *hcd, char *buf)
151{
152 int length = ohci_hub_status_data(hcd, buf);
153
154 /* See if we have OCIC bit set on port 1 */
155 if (ocic_mask & (1 << 1)) {
156 dev_dbg(hcd->self.controller, "over-current indicator change "
157 "on port 1\n");
158
159 if (!length)
160 length = 1;
161
162 buf[0] |= 1 << 1;
163 }
164 return length;
165}
166
167/*
168 * Look at the control requests to the root hub and see if we need to override.
169 */
170static int ohci_da8xx_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
171 u16 wIndex, char *buf, u16 wLength)
172{
173 struct device *dev = hcd->self.controller;
174 struct da8xx_ohci_root_hub *hub = dev_get_platdata(dev);
175 int temp;
176
177 switch (typeReq) {
178 case GetPortStatus:
179 /* Check the port number */
180 if (wIndex != 1)
181 break;
182
183 dev_dbg(dev, "GetPortStatus(%u)\n", wIndex);
184
185 temp = roothub_portstatus(hcd_to_ohci(hcd), wIndex - 1);
186
187 /* The port power status (PPS) bit defaults to 1 */
188 if (hub->get_power && hub->get_power(wIndex) == 0)
189 temp &= ~RH_PS_PPS;
190
191 /* The port over-current indicator (POCI) bit is always 0 */
192 if (hub->get_oci && hub->get_oci(wIndex) > 0)
193 temp |= RH_PS_POCI;
194
195 /* The over-current indicator change (OCIC) bit is 0 too */
196 if (ocic_mask & (1 << wIndex))
197 temp |= RH_PS_OCIC;
198
199 put_unaligned(cpu_to_le32(temp), (__le32 *)buf);
200 return 0;
201 case SetPortFeature:
202 temp = 1;
203 goto check_port;
204 case ClearPortFeature:
205 temp = 0;
206
207check_port:
208 /* Check the port number */
209 if (wIndex != 1)
210 break;
211
212 switch (wValue) {
213 case USB_PORT_FEAT_POWER:
214 dev_dbg(dev, "%sPortFeature(%u): %s\n",
215 temp ? "Set" : "Clear", wIndex, "POWER");
216
217 if (!hub->set_power)
218 return -EPIPE;
219
220 return hub->set_power(wIndex, temp) ? -EPIPE : 0;
221 case USB_PORT_FEAT_C_OVER_CURRENT:
222 dev_dbg(dev, "%sPortFeature(%u): %s\n",
223 temp ? "Set" : "Clear", wIndex,
224 "C_OVER_CURRENT");
225
226 if (temp)
227 ocic_mask |= 1 << wIndex;
228 else
229 ocic_mask &= ~(1 << wIndex);
230 return 0;
231 }
232 }
233
234 return ohci_hub_control(hcd, typeReq, wValue, wIndex, buf, wLength);
235}
236
237static const struct hc_driver ohci_da8xx_hc_driver = {
238 .description = hcd_name,
239 .product_desc = "DA8xx OHCI",
240 .hcd_priv_size = sizeof(struct ohci_hcd),
241
242 /*
243 * generic hardware linkage
244 */
245 .irq = ohci_irq,
246 .flags = HCD_USB11 | HCD_MEMORY,
247
248 /*
249 * basic lifecycle operations
250 */
251 .reset = ohci_da8xx_init,
252 .start = ohci_da8xx_start,
253 .stop = ohci_da8xx_stop,
254 .shutdown = ohci_shutdown,
255
256 /*
257 * managing i/o requests and associated device resources
258 */
259 .urb_enqueue = ohci_urb_enqueue,
260 .urb_dequeue = ohci_urb_dequeue,
261 .endpoint_disable = ohci_endpoint_disable,
262
263 /*
264 * scheduling support
265 */
266 .get_frame_number = ohci_get_frame,
267
268 /*
269 * root hub support
270 */
271 .hub_status_data = ohci_da8xx_hub_status_data,
272 .hub_control = ohci_da8xx_hub_control,
273
274#ifdef CONFIG_PM
275 .bus_suspend = ohci_bus_suspend,
276 .bus_resume = ohci_bus_resume,
277#endif
278 .start_port_reset = ohci_start_port_reset,
279};
280
281/*-------------------------------------------------------------------------*/
282
283
284/**
285 * usb_hcd_da8xx_probe - initialize DA8xx-based HCDs
286 * Context: !in_interrupt()
287 *
288 * Allocates basic resources for this USB host controller, and
289 * then invokes the start() method for the HCD associated with it
290 * through the hotplug entry's driver_data.
291 */
292static int usb_hcd_da8xx_probe(const struct hc_driver *driver,
293 struct platform_device *pdev)
294{
295 struct da8xx_ohci_root_hub *hub = dev_get_platdata(&pdev->dev);
296 struct usb_hcd *hcd;
297 struct resource *mem;
298 int error, irq;
299
300 if (hub == NULL)
301 return -ENODEV;
302
303 usb11_clk = devm_clk_get(&pdev->dev, "usb11");
304 if (IS_ERR(usb11_clk))
305 return PTR_ERR(usb11_clk);
306
307 usb20_clk = devm_clk_get(&pdev->dev, "usb20");
308 if (IS_ERR(usb20_clk))
309 return PTR_ERR(usb20_clk);
310
311 hcd = usb_create_hcd(driver, &pdev->dev, dev_name(&pdev->dev));
312 if (!hcd)
313 return -ENOMEM;
314
315 mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
316 if (!mem)
317 return -ENODEV;
318 hcd->rsrc_start = mem->start;
319 hcd->rsrc_len = resource_size(mem);
320
321 hcd->regs = devm_ioremap_resource(&pdev->dev, mem);
322 if (IS_ERR(hcd->regs)) {
323 error = PTR_ERR(hcd->regs);
324 goto err;
325 }
326
327 ohci_hcd_init(hcd_to_ohci(hcd));
328
329 irq = platform_get_irq(pdev, 0);
330 if (irq < 0) {
331 error = -ENODEV;
332 goto err;
333 }
334 error = usb_add_hcd(hcd, irq, 0);
335 if (error)
336 goto err;
337
338 device_wakeup_enable(hcd->self.controller);
339
340 if (hub->ocic_notify) {
341 error = hub->ocic_notify(ohci_da8xx_ocic_handler);
342 if (!error)
343 return 0;
344 }
345
346 usb_remove_hcd(hcd);
347err:
348 usb_put_hcd(hcd);
349 return error;
350}
351
352/**
353 * usb_hcd_da8xx_remove - shutdown processing for DA8xx-based HCDs
354 * @dev: USB Host Controller being removed
355 * Context: !in_interrupt()
356 *
357 * Reverses the effect of usb_hcd_da8xx_probe(), first invoking
358 * the HCD's stop() method. It is always called from a thread
359 * context, normally "rmmod", "apmd", or something similar.
360 */
361static inline void
362usb_hcd_da8xx_remove(struct usb_hcd *hcd, struct platform_device *pdev)
363{
364 struct da8xx_ohci_root_hub *hub = dev_get_platdata(&pdev->dev);
365
366 hub->ocic_notify(NULL);
367 usb_remove_hcd(hcd);
368 usb_put_hcd(hcd);
369}
370
371static int ohci_hcd_da8xx_drv_probe(struct platform_device *dev)
372{
373 return usb_hcd_da8xx_probe(&ohci_da8xx_hc_driver, dev);
374}
375
376static int ohci_hcd_da8xx_drv_remove(struct platform_device *dev)
377{
378 struct usb_hcd *hcd = platform_get_drvdata(dev);
379
380 usb_hcd_da8xx_remove(hcd, dev);
381
382 return 0;
383}
384
385#ifdef CONFIG_PM
386static int ohci_da8xx_suspend(struct platform_device *pdev,
387 pm_message_t message)
388{
389 struct usb_hcd *hcd = platform_get_drvdata(pdev);
390 struct ohci_hcd *ohci = hcd_to_ohci(hcd);
391 bool do_wakeup = device_may_wakeup(&pdev->dev);
392 int ret;
393
394
395 if (time_before(jiffies, ohci->next_statechange))
396 msleep(5);
397 ohci->next_statechange = jiffies;
398
399 ret = ohci_suspend(hcd, do_wakeup);
400 if (ret)
401 return ret;
402
403 ohci_da8xx_clock(0);
404 hcd->state = HC_STATE_SUSPENDED;
405
406 return ret;
407}
408
409static int ohci_da8xx_resume(struct platform_device *dev)
410{
411 struct usb_hcd *hcd = platform_get_drvdata(dev);
412 struct ohci_hcd *ohci = hcd_to_ohci(hcd);
413
414 if (time_before(jiffies, ohci->next_statechange))
415 msleep(5);
416 ohci->next_statechange = jiffies;
417
418 ohci_da8xx_clock(1);
419 dev->dev.power.power_state = PMSG_ON;
420 usb_hcd_resume_root_hub(hcd);
421 return 0;
422}
423#endif
424
425/*
426 * Driver definition to register with platform structure.
427 */
428static struct platform_driver ohci_hcd_da8xx_driver = {
429 .probe = ohci_hcd_da8xx_drv_probe,
430 .remove = ohci_hcd_da8xx_drv_remove,
431 .shutdown = usb_hcd_platform_shutdown,
432#ifdef CONFIG_PM
433 .suspend = ohci_da8xx_suspend,
434 .resume = ohci_da8xx_resume,
435#endif
436 .driver = {
437 .owner = THIS_MODULE,
438 .name = "ohci",
439 },
440};
441
442MODULE_ALIAS("platform:ohci");