arch/arm/mach-omap1/usb.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Platform level USB initialization for FS USB OTG controller on omap1
   4  *
   5  * Copyright (C) 2004 Texas Instruments, Inc.
   6  */
   7
   8 #include <linux/module.h>
   9 #include <linux/kernel.h>
  10 #include <linux/init.h>
  11 #include <linux/platform_device.h>
  12 #include <linux/dma-map-ops.h>
  13 #include <linux/io.h>
  14
  15 #include <asm/irq.h>
  16
  17 #include <mach/mux.h>
  18
  19 #include <mach/usb.h>
  20
  21 #include "common.h"
  22
  23 /* These routines should handle the standard chip-specific modes
  24  * for usb0/1/2 ports, covering basic mux and transceiver setup.
  25  *
  26  * Some board-*.c files will need to set up additional mux options,
  27  * like for suspend handling, vbus sensing, GPIOs, and the D+ pullup.
  28  */
  29
  30 /* TESTED ON:
  31  *  - 1611B H2 (with usb1 mini-AB) using standard Mini-B or OTG cables
  32  *  - 5912 OSK OHCI (with usb0 standard-A), standard A-to-B cables
  33  *  - 5912 OSK UDC, with *nonstandard* A-to-A cable
  34  *  - 1510 Innovator UDC with bundled usb0 cable
  35  *  - 1510 Innovator OHCI with bundled usb1/usb2 cable
  36  *  - 1510 Innovator OHCI with custom usb0 cable, feeding 5V VBUS
  37  *  - 1710 custom development board using alternate pin group
  38  *  - 1710 H3 (with usb1 mini-AB) using standard Mini-B or OTG cables
  39  */
  40
  41 #define INT_USB_IRQ_GEN         IH2_BASE + 20
  42 #define INT_USB_IRQ_NISO        IH2_BASE + 30
  43 #define INT_USB_IRQ_ISO         IH2_BASE + 29
  44 #define INT_USB_IRQ_HGEN        INT_USB_HHC_1
  45 #define INT_USB_IRQ_OTG         IH2_BASE + 8
  46
  47 #ifdef  CONFIG_ARCH_OMAP_OTG
  48
  49 static void __init
  50 omap_otg_init(struct omap_usb_config *config)
  51 {
  52         u32             syscon;
  53         int             alt_pingroup = 0;
  54         u16             w;
  55
  56         /* NOTE:  no bus or clock setup (yet?) */
  57
  58         syscon = omap_readl(OTG_SYSCON_1) & 0xffff;
  59         if (!(syscon & OTG_RESET_DONE))
  60                 pr_debug("USB resets not complete?\n");
  61
  62         //omap_writew(0, OTG_IRQ_EN);
  63
  64         /* pin muxing and transceiver pinouts */
  65         if (config->pins[0] > 2)        /* alt pingroup 2 */
  66                 alt_pingroup = 1;
  67         syscon |= config->usb0_init(config->pins[0], is_usb0_device(config));
  68         syscon |= config->usb1_init(config->pins[1]);
  69         syscon |= config->usb2_init(config->pins[2], alt_pingroup);
  70         pr_debug("OTG_SYSCON_1 = %08x\n", omap_readl(OTG_SYSCON_1));
  71         omap_writel(syscon, OTG_SYSCON_1);
  72
  73         syscon = config->hmc_mode;
  74         syscon |= USBX_SYNCHRO | (4 << 16) /* B_ASE0_BRST */;
  75 #ifdef  CONFIG_USB_OTG
  76         if (config->otg)
  77                 syscon |= OTG_EN;
  78 #endif
  79         pr_debug("USB_TRANSCEIVER_CTRL = %03x\n",
  80                  omap_readl(USB_TRANSCEIVER_CTRL));
  81         pr_debug("OTG_SYSCON_2 = %08x\n", omap_readl(OTG_SYSCON_2));
  82         omap_writel(syscon, OTG_SYSCON_2);
  83
  84         printk("USB: hmc %d", config->hmc_mode);
  85         if (!alt_pingroup)
  86                 pr_cont(", usb2 alt %d wires", config->pins[2]);
  87         else if (config->pins[0])
  88                 pr_cont(", usb0 %d wires%s", config->pins[0],
  89                         is_usb0_device(config) ? " (dev)" : "");
  90         if (config->pins[1])
  91                 pr_cont(", usb1 %d wires", config->pins[1]);
  92         if (!alt_pingroup && config->pins[2])
  93                 pr_cont(", usb2 %d wires", config->pins[2]);
  94         if (config->otg)
  95                 pr_cont(", Mini-AB on usb%d", config->otg - 1);
  96         pr_cont("\n");
  97
  98         /* leave USB clocks/controllers off until needed */
  99         w = omap_readw(ULPD_SOFT_REQ);
 100         w &= ~SOFT_USB_CLK_REQ;
 101         omap_writew(w, ULPD_SOFT_REQ);
 102
 103         w = omap_readw(ULPD_CLOCK_CTRL);
 104         w &= ~USB_MCLK_EN;
 105         w |= DIS_USB_PVCI_CLK;
 106         omap_writew(w, ULPD_CLOCK_CTRL);
 107
 108         syscon = omap_readl(OTG_SYSCON_1);
 109         syscon |= HST_IDLE_EN|DEV_IDLE_EN|OTG_IDLE_EN;
 110
 111 #if IS_ENABLED(CONFIG_USB_OMAP)
 112         if (config->otg || config->register_dev) {
 113                 struct platform_device *udc_device = config->udc_device;
 114                 int status;
 115
 116                 syscon &= ~DEV_IDLE_EN;
 117                 udc_device->dev.platform_data = config;
 118                 status = platform_device_register(udc_device);
 119                 if (status)
 120                         pr_debug("can't register UDC device, %d\n", status);
 121         }
 122 #endif
 123
 124 #if     IS_ENABLED(CONFIG_USB_OHCI_HCD)
 125         if (config->otg || config->register_host) {
 126                 struct platform_device *ohci_device = config->ohci_device;
 127                 int status;
 128
 129                 syscon &= ~HST_IDLE_EN;
 130                 ohci_device->dev.platform_data = config;
 131                 status = platform_device_register(ohci_device);
 132                 if (status)
 133                         pr_debug("can't register OHCI device, %d\n", status);
 134         }
 135 #endif
 136
 137 #ifdef  CONFIG_USB_OTG
 138         if (config->otg) {
 139                 struct platform_device *otg_device = config->otg_device;
 140                 int status;
 141
 142                 syscon &= ~OTG_IDLE_EN;
 143                 otg_device->dev.platform_data = config;
 144                 status = platform_device_register(otg_device);
 145                 if (status)
 146                         pr_debug("can't register OTG device, %d\n", status);
 147         }
 148 #endif
 149         pr_debug("OTG_SYSCON_1 = %08x\n", omap_readl(OTG_SYSCON_1));
 150         omap_writel(syscon, OTG_SYSCON_1);
 151 }
 152
 153 #else
 154 static void omap_otg_init(struct omap_usb_config *config) {}
 155 #endif
 156
 157 #if IS_ENABLED(CONFIG_USB_OMAP)
 158
 159 static struct resource udc_resources[] = {
 160         /* order is significant! */
 161         {               /* registers */
 162                 .start          = UDC_BASE,
 163                 .end            = UDC_BASE + 0xff,
 164                 .flags          = IORESOURCE_MEM,
 165         }, {            /* general IRQ */
 166                 .start          = INT_USB_IRQ_GEN,
 167                 .flags          = IORESOURCE_IRQ,
 168         }, {            /* PIO IRQ */
 169                 .start          = INT_USB_IRQ_NISO,
 170                 .flags          = IORESOURCE_IRQ,
 171         }, {            /* SOF IRQ */
 172                 .start          = INT_USB_IRQ_ISO,
 173                 .flags          = IORESOURCE_IRQ,
 174         },
 175 };
 176
 177 static u64 udc_dmamask = ~(u32)0;
 178
 179 static struct platform_device udc_device = {
 180         .name           = "omap_udc",
 181         .id             = -1,
 182         .dev = {
 183                 .dma_mask               = &udc_dmamask,
 184                 .coherent_dma_mask      = 0xffffffff,
 185         },
 186         .num_resources  = ARRAY_SIZE(udc_resources),
 187         .resource       = udc_resources,
 188 };
 189
 190 static inline void udc_device_init(struct omap_usb_config *pdata)
 191 {
 192         /* IRQ numbers for omap7xx */
 193         if(cpu_is_omap7xx()) {
 194                 udc_resources[1].start = INT_7XX_USB_GENI;
 195                 udc_resources[2].start = INT_7XX_USB_NON_ISO;
 196                 udc_resources[3].start = INT_7XX_USB_ISO;
 197         }
 198         pdata->udc_device = &udc_device;
 199 }
 200
 201 #else
 202
 203 static inline void udc_device_init(struct omap_usb_config *pdata)
 204 {
 205 }
 206
 207 #endif
 208
 209 #if     IS_ENABLED(CONFIG_USB_OHCI_HCD)
 210
 211 /* The dmamask must be set for OHCI to work */
 212 static u64 ohci_dmamask = ~(u32)0;
 213
 214 static struct resource ohci_resources[] = {
 215         {
 216                 .start  = OMAP_OHCI_BASE,
 217                 .end    = OMAP_OHCI_BASE + 0xff,
 218                 .flags  = IORESOURCE_MEM,
 219         },
 220         {
 221                 .start  = INT_USB_IRQ_HGEN,
 222                 .flags  = IORESOURCE_IRQ,
 223         },
 224 };
 225
 226 static struct platform_device ohci_device = {
 227         .name                   = "ohci",
 228         .id                     = -1,
 229         .dev = {
 230                 .dma_mask               = &ohci_dmamask,
 231                 .coherent_dma_mask      = 0xffffffff,
 232         },
 233         .num_resources  = ARRAY_SIZE(ohci_resources),
 234         .resource               = ohci_resources,
 235 };
 236
 237 static inline void ohci_device_init(struct omap_usb_config *pdata)
 238 {
 239         if (cpu_is_omap7xx())
 240                 ohci_resources[1].start = INT_7XX_USB_HHC_1;
 241         pdata->ohci_device = &ohci_device;
 242         pdata->ocpi_enable = &ocpi_enable;
 243 }
 244
 245 #else
 246
 247 static inline void ohci_device_init(struct omap_usb_config *pdata)
 248 {
 249 }
 250
 251 #endif
 252
 253 #if     defined(CONFIG_USB_OTG) && defined(CONFIG_ARCH_OMAP_OTG)
 254
 255 static struct resource otg_resources[] = {
 256         /* order is significant! */
 257         {
 258                 .start          = OTG_BASE,
 259                 .end            = OTG_BASE + 0xff,
 260                 .flags          = IORESOURCE_MEM,
 261         }, {
 262                 .start          = INT_USB_IRQ_OTG,
 263                 .flags          = IORESOURCE_IRQ,
 264         },
 265 };
 266
 267 static struct platform_device otg_device = {
 268         .name           = "omap_otg",
 269         .id             = -1,
 270         .num_resources  = ARRAY_SIZE(otg_resources),
 271         .resource       = otg_resources,
 272 };
 273
 274 static inline void otg_device_init(struct omap_usb_config *pdata)
 275 {
 276         if (cpu_is_omap7xx())
 277                 otg_resources[1].start = INT_7XX_USB_OTG;
 278         pdata->otg_device = &otg_device;
 279 }
 280
 281 #else
 282
 283 static inline void otg_device_init(struct omap_usb_config *pdata)
 284 {
 285 }
 286
 287 #endif
 288
 289 static u32 __init omap1_usb0_init(unsigned nwires, unsigned is_device)
 290 {
 291         u32     syscon1 = 0;
 292
 293         if (nwires == 0) {
 294                 if (!cpu_is_omap15xx()) {
 295                         u32 l;
 296
 297                         /* pulldown D+/D- */
 298                         l = omap_readl(USB_TRANSCEIVER_CTRL);
 299                         l &= ~(3 << 1);
 300                         omap_writel(l, USB_TRANSCEIVER_CTRL);
 301                 }
 302                 return 0;
 303         }
 304
 305         if (is_device) {
 306                 if (cpu_is_omap7xx()) {
 307                         omap_cfg_reg(AA17_7XX_USB_DM);
 308                         omap_cfg_reg(W16_7XX_USB_PU_EN);
 309                         omap_cfg_reg(W17_7XX_USB_VBUSI);
 310                         omap_cfg_reg(W18_7XX_USB_DMCK_OUT);
 311                         omap_cfg_reg(W19_7XX_USB_DCRST);
 312                 } else
 313                         omap_cfg_reg(W4_USB_PUEN);
 314         }
 315
 316         if (nwires == 2) {
 317                 u32 l;
 318
 319                 // omap_cfg_reg(P9_USB_DP);
 320                 // omap_cfg_reg(R8_USB_DM);
 321
 322                 if (cpu_is_omap15xx()) {
 323                         /* This works on 1510-Innovator */
 324                         return 0;
 325                 }
 326
 327                 /* NOTES:
 328                  *  - peripheral should configure VBUS detection!
 329                  *  - only peripherals may use the internal D+/D- pulldowns
 330                  *  - OTG support on this port not yet written
 331                  */
 332
 333                 /* Don't do this for omap7xx -- it causes USB to not work correctly */
 334                 if (!cpu_is_omap7xx()) {
 335                         l = omap_readl(USB_TRANSCEIVER_CTRL);
 336                         l &= ~(7 << 4);
 337                         if (!is_device)
 338                                 l |= (3 << 1);
 339                         omap_writel(l, USB_TRANSCEIVER_CTRL);
 340                 }
 341
 342                 return 3 << 16;
 343         }
 344
 345         /* alternate pin config, external transceiver */
 346         if (cpu_is_omap15xx()) {
 347                 printk(KERN_ERR "no usb0 alt pin config on 15xx\n");
 348                 return 0;
 349         }
 350
 351         omap_cfg_reg(V6_USB0_TXD);
 352         omap_cfg_reg(W9_USB0_TXEN);
 353         omap_cfg_reg(W5_USB0_SE0);
 354         if (nwires != 3)
 355                 omap_cfg_reg(Y5_USB0_RCV);
 356
 357         /* NOTE:  SPEED and SUSP aren't configured here.  OTG hosts
 358          * may be able to use I2C requests to set those bits along
 359          * with VBUS switching and overcurrent detection.
 360          */
 361
 362         if (nwires != 6) {
 363                 u32 l;
 364
 365                 l = omap_readl(USB_TRANSCEIVER_CTRL);
 366                 l &= ~CONF_USB2_UNI_R;
 367                 omap_writel(l, USB_TRANSCEIVER_CTRL);
 368         }
 369
 370         switch (nwires) {
 371         case 3:
 372                 syscon1 = 2;
 373                 break;
 374         case 4:
 375                 syscon1 = 1;
 376                 break;
 377         case 6:
 378                 syscon1 = 3;
 379                 {
 380                         u32 l;
 381
 382                         omap_cfg_reg(AA9_USB0_VP);
 383                         omap_cfg_reg(R9_USB0_VM);
 384                         l = omap_readl(USB_TRANSCEIVER_CTRL);
 385                         l |= CONF_USB2_UNI_R;
 386                         omap_writel(l, USB_TRANSCEIVER_CTRL);
 387                 }
 388                 break;
 389         default:
 390                 printk(KERN_ERR "illegal usb%d %d-wire transceiver\n",
 391                         0, nwires);
 392         }
 393
 394         return syscon1 << 16;
 395 }
 396
 397 static u32 __init omap1_usb1_init(unsigned nwires)
 398 {
 399         u32     syscon1 = 0;
 400
 401         if (!cpu_is_omap15xx() && nwires != 6) {
 402                 u32 l;
 403
 404                 l = omap_readl(USB_TRANSCEIVER_CTRL);
 405                 l &= ~CONF_USB1_UNI_R;
 406                 omap_writel(l, USB_TRANSCEIVER_CTRL);
 407         }
 408         if (nwires == 0)
 409                 return 0;
 410
 411         /* external transceiver */
 412         omap_cfg_reg(USB1_TXD);
 413         omap_cfg_reg(USB1_TXEN);
 414         if (nwires != 3)
 415                 omap_cfg_reg(USB1_RCV);
 416
 417         if (cpu_is_omap15xx()) {
 418                 omap_cfg_reg(USB1_SEO);
 419                 omap_cfg_reg(USB1_SPEED);
 420                 // SUSP
 421         } else if (cpu_is_omap1610() || cpu_is_omap5912()) {
 422                 omap_cfg_reg(W13_1610_USB1_SE0);
 423                 omap_cfg_reg(R13_1610_USB1_SPEED);
 424                 // SUSP
 425         } else if (cpu_is_omap1710()) {
 426                 omap_cfg_reg(R13_1710_USB1_SE0);
 427                 // SUSP
 428         } else {
 429                 pr_debug("usb%d cpu unrecognized\n", 1);
 430                 return 0;
 431         }
 432
 433         switch (nwires) {
 434         case 2:
 435                 goto bad;
 436         case 3:
 437                 syscon1 = 2;
 438                 break;
 439         case 4:
 440                 syscon1 = 1;
 441                 break;
 442         case 6:
 443                 syscon1 = 3;
 444                 omap_cfg_reg(USB1_VP);
 445                 omap_cfg_reg(USB1_VM);
 446                 if (!cpu_is_omap15xx()) {
 447                         u32 l;
 448
 449                         l = omap_readl(USB_TRANSCEIVER_CTRL);
 450                         l |= CONF_USB1_UNI_R;
 451                         omap_writel(l, USB_TRANSCEIVER_CTRL);
 452                 }
 453                 break;
 454         default:
 455 bad:
 456                 printk(KERN_ERR "illegal usb%d %d-wire transceiver\n",
 457                         1, nwires);
 458         }
 459
 460         return syscon1 << 20;
 461 }
 462
 463 static u32 __init omap1_usb2_init(unsigned nwires, unsigned alt_pingroup)
 464 {
 465         u32     syscon1 = 0;
 466
 467         /* NOTE omap1 erratum: must leave USB2_UNI_R set if usb0 in use */
 468         if (alt_pingroup || nwires == 0)
 469                 return 0;
 470
 471         if (!cpu_is_omap15xx() && nwires != 6) {
 472                 u32 l;
 473
 474                 l = omap_readl(USB_TRANSCEIVER_CTRL);
 475                 l &= ~CONF_USB2_UNI_R;
 476                 omap_writel(l, USB_TRANSCEIVER_CTRL);
 477         }
 478
 479         /* external transceiver */
 480         if (cpu_is_omap15xx()) {
 481                 omap_cfg_reg(USB2_TXD);
 482                 omap_cfg_reg(USB2_TXEN);
 483                 omap_cfg_reg(USB2_SEO);
 484                 if (nwires != 3)
 485                         omap_cfg_reg(USB2_RCV);
 486                 /* there is no USB2_SPEED */
 487         } else if (cpu_is_omap16xx()) {
 488                 omap_cfg_reg(V6_USB2_TXD);
 489                 omap_cfg_reg(W9_USB2_TXEN);
 490                 omap_cfg_reg(W5_USB2_SE0);
 491                 if (nwires != 3)
 492                         omap_cfg_reg(Y5_USB2_RCV);
 493                 // FIXME omap_cfg_reg(USB2_SPEED);
 494         } else {
 495                 pr_debug("usb%d cpu unrecognized\n", 1);
 496                 return 0;
 497         }
 498
 499         // omap_cfg_reg(USB2_SUSP);
 500
 501         switch (nwires) {
 502         case 2:
 503                 goto bad;
 504         case 3:
 505                 syscon1 = 2;
 506                 break;
 507         case 4:
 508                 syscon1 = 1;
 509                 break;
 510         case 5:
 511                 goto bad;
 512         case 6:
 513                 syscon1 = 3;
 514                 if (cpu_is_omap15xx()) {
 515                         omap_cfg_reg(USB2_VP);
 516                         omap_cfg_reg(USB2_VM);
 517                 } else {
 518                         u32 l;
 519
 520                         omap_cfg_reg(AA9_USB2_VP);
 521                         omap_cfg_reg(R9_USB2_VM);
 522                         l = omap_readl(USB_TRANSCEIVER_CTRL);
 523                         l |= CONF_USB2_UNI_R;
 524                         omap_writel(l, USB_TRANSCEIVER_CTRL);
 525                 }
 526                 break;
 527         default:
 528 bad:
 529                 printk(KERN_ERR "illegal usb%d %d-wire transceiver\n",
 530                         2, nwires);
 531         }
 532
 533         return syscon1 << 24;
 534 }
 535
 536 #ifdef  CONFIG_ARCH_OMAP15XX
 537
 538 /* ULPD_DPLL_CTRL */
 539 #define DPLL_IOB                (1 << 13)
 540 #define DPLL_PLL_ENABLE         (1 << 4)
 541 #define DPLL_LOCK               (1 << 0)
 542
 543 /* ULPD_APLL_CTRL */
 544 #define APLL_NDPLL_SWITCH       (1 << 0)
 545
 546 static int omap_1510_usb_ohci_notifier(struct notifier_block *nb,
 547                 unsigned long event, void *data)
 548 {
 549         struct device *dev = data;
 550
 551         if (event != BUS_NOTIFY_ADD_DEVICE)
 552                 return NOTIFY_DONE;
 553
 554         if (strncmp(dev_name(dev), "ohci", 4) == 0 &&
 555             dma_direct_set_offset(dev, PHYS_OFFSET, OMAP1510_LB_OFFSET,
 556                         (u64)-1))
 557                 WARN_ONCE(1, "failed to set DMA offset\n");
 558         return NOTIFY_OK;
 559 }
 560
 561 static struct notifier_block omap_1510_usb_ohci_nb = {
 562         .notifier_call          = omap_1510_usb_ohci_notifier,
 563 };
 564
 565 static void __init omap_1510_usb_init(struct omap_usb_config *config)
 566 {
 567         unsigned int val;
 568         u16 w;
 569
 570         config->usb0_init(config->pins[0], is_usb0_device(config));
 571         config->usb1_init(config->pins[1]);
 572         config->usb2_init(config->pins[2], 0);
 573
 574         val = omap_readl(MOD_CONF_CTRL_0) & ~(0x3f << 1);
 575         val |= (config->hmc_mode << 1);
 576         omap_writel(val, MOD_CONF_CTRL_0);
 577
 578         printk("USB: hmc %d", config->hmc_mode);
 579         if (config->pins[0])
 580                 pr_cont(", usb0 %d wires%s", config->pins[0],
 581                         is_usb0_device(config) ? " (dev)" : "");
 582         if (config->pins[1])
 583                 pr_cont(", usb1 %d wires", config->pins[1]);
 584         if (config->pins[2])
 585                 pr_cont(", usb2 %d wires", config->pins[2]);
 586         pr_cont("\n");
 587
 588         /* use DPLL for 48 MHz function clock */
 589         pr_debug("APLL %04x DPLL %04x REQ %04x\n", omap_readw(ULPD_APLL_CTRL),
 590                         omap_readw(ULPD_DPLL_CTRL), omap_readw(ULPD_SOFT_REQ));
 591
 592         w = omap_readw(ULPD_APLL_CTRL);
 593         w &= ~APLL_NDPLL_SWITCH;
 594         omap_writew(w, ULPD_APLL_CTRL);
 595
 596         w = omap_readw(ULPD_DPLL_CTRL);
 597         w |= DPLL_IOB | DPLL_PLL_ENABLE;
 598         omap_writew(w, ULPD_DPLL_CTRL);
 599
 600         w = omap_readw(ULPD_SOFT_REQ);
 601         w |= SOFT_UDC_REQ | SOFT_DPLL_REQ;
 602         omap_writew(w, ULPD_SOFT_REQ);
 603
 604         while (!(omap_readw(ULPD_DPLL_CTRL) & DPLL_LOCK))
 605                 cpu_relax();
 606
 607 #if IS_ENABLED(CONFIG_USB_OMAP)
 608         if (config->register_dev) {
 609                 int status;
 610
 611                 udc_device.dev.platform_data = config;
 612                 status = platform_device_register(&udc_device);
 613                 if (status)
 614                         pr_debug("can't register UDC device, %d\n", status);
 615                 /* udc driver gates 48MHz by D+ pullup */
 616         }
 617 #endif
 618
 619 #if     IS_ENABLED(CONFIG_USB_OHCI_HCD)
 620         if (config->register_host) {
 621                 int status;
 622
 623                 bus_register_notifier(&platform_bus_type,
 624                                       &omap_1510_usb_ohci_nb);
 625                 ohci_device.dev.platform_data = config;
 626                 status = platform_device_register(&ohci_device);
 627                 if (status)
 628                         pr_debug("can't register OHCI device, %d\n", status);
 629                 /* hcd explicitly gates 48MHz */
 630         }
 631 #endif
 632 }
 633
 634 #else
 635 static inline void omap_1510_usb_init(struct omap_usb_config *config) {}
 636 #endif
 637
 638 void __init omap1_usb_init(struct omap_usb_config *_pdata)
 639 {
 640         struct omap_usb_config *pdata;
 641
 642         pdata = kmemdup(_pdata, sizeof(*pdata), GFP_KERNEL);
 643         if (!pdata)
 644                 return;
 645
 646         pdata->usb0_init = omap1_usb0_init;
 647         pdata->usb1_init = omap1_usb1_init;
 648         pdata->usb2_init = omap1_usb2_init;
 649         udc_device_init(pdata);
 650         ohci_device_init(pdata);
 651         otg_device_init(pdata);
 652
 653         if (cpu_is_omap7xx() || cpu_is_omap16xx())
 654                 omap_otg_init(pdata);
 655         else if (cpu_is_omap15xx())
 656                 omap_1510_usb_init(pdata);
 657         else
 658                 printk(KERN_ERR "USB: No init for your chip yet\n");
 659 }