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