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