drivers/usb/dwc_otg_310/dwc_otg_driver.c

   1 /* ==========================================================================
   2  * $File: //dwh/usb_iip/dev/software/otg/linux/drivers/dwc_otg_driver.c $
   3  * $Revision: #94 $
   4  * $Date: 2012/12/21 $
   5  * $Change: 2131568 $
   6  *
   7  * Synopsys HS OTG Linux Software Driver and documentation (hereinafter,
   8  * "Software") is an Unsupported proprietary work of Synopsys, Inc. unless
   9  * otherwise expressly agreed to in writing between Synopsys and you.
  10  *
  11  * The Software IS NOT an item of Licensed Software or Licensed Product under
  12  * any End User Software License Agreement or Agreement for Licensed Product
  13  * with Synopsys or any supplement thereto. You are permitted to use and
  14  * redistribute this Software in source and binary forms, with or without
  15  * modification, provided that redistributions of source code must retain this
  16  * notice. You may not view, use, disclose, copy or distribute this file or
  17  * any information contained herein except pursuant to this license grant from
  18  * Synopsys. If you do not agree with this notice, including the disclaimer
  19  * below, then you are not authorized to use the Software.
  20  *
  21  * THIS SOFTWARE IS BEING DISTRIBUTED BY SYNOPSYS SOLELY ON AN "AS IS" BASIS
  22  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE HEREBY DISCLAIMED. IN NO EVENT SHALL SYNOPSYS BE LIABLE FOR ANY DIRECT,
  25  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  26  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  27  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  28  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
  31  * DAMAGE.
  32  * ========================================================================== */
  33
  34 /** @file
  35  * The dwc_otg_driver module provides the initialization and cleanup entry
  36  * points for the DWC_otg driver. This module will be dynamically installed
  37  * after Linux is booted using the insmod command. When the module is
  38  * installed, the dwc_otg_driver_init function is called. When the module is
  39  * removed (using rmmod), the dwc_otg_driver_cleanup function is called.
  40  *
  41  * This module also defines a data structure for the dwc_otg_driver, which is
  42  * used in conjunction with the standard ARM lm_device structure. These
  43  * structures allow the OTG driver to comply with the standard Linux driver
  44  * model in which devices and drivers are registered with a bus driver. This
  45  * has the benefit that Linux can expose attributes of the driver and device
  46  * in its special sysfs file system. Users can then read or write files in
  47  * this file system to perform diagnostics on the driver components or the
  48  * device.
  49  */
  50
  51 #include "dwc_otg_os_dep.h"
  52 #include "common_port/dwc_os.h"
  53 #include "dwc_otg_dbg.h"
  54 #include "dwc_otg_driver.h"
  55 #include "dwc_otg_attr.h"
  56 #include "dwc_otg_core_if.h"
  57 #include "dwc_otg_pcd_if.h"
  58 #include "dwc_otg_hcd_if.h"
  59 #include "dwc_otg_cil.h"
  60 #include "dwc_otg_pcd.h"
  61
  62 #include "usbdev_rk.h"
  63
  64 #define DWC_DRIVER_VERSION      "3.10a 21-DEC-2012"
  65 #define DWC_DRIVER_DESC         "HS OTG USB Controller driver"
  66
  67 static const char dwc_host20_driver_name[] = "usb20_host";
  68 static const char dwc_otg20_driver_name[] = "usb20_otg";
  69
  70 dwc_otg_device_t *g_otgdev;
  71
  72 extern int pcd_init(struct platform_device *_dev);
  73 extern int otg20_hcd_init(struct platform_device *_dev);
  74 extern int host20_hcd_init(struct platform_device *_dev);
  75 extern int pcd_remove(struct platform_device *_dev);
  76 extern void hcd_remove(struct platform_device *_dev);
  77 extern void dwc_otg_adp_start(dwc_otg_core_if_t *core_if, uint8_t is_host);
  78
  79 #ifdef CONFIG_USB20_OTG
  80 static struct usb20otg_pdata_id usb20otg_pdata[] = {
  81         {
  82          .name = "rk3188-usb20otg",
  83          .pdata = &usb20otg_pdata_rk3188,
  84          },
  85         {
  86          .name = "rk3288-usb20otg",
  87          .pdata = &usb20otg_pdata_rk3288,
  88          },
  89         {
  90          .name = "rk3036-usb20otg",
  91          .pdata = &usb20otg_pdata_rk3036,
  92          },
  93         {},
  94 };
  95 #endif
  96
  97 #ifdef CONFIG_USB20_HOST
  98 static struct usb20host_pdata_id usb20host_pdata[] = {
  99         {
 100          .name = "rk3188-usb20host",
 101          .pdata = &usb20host_pdata_rk3188,
 102          },
 103         {
 104          .name = "rk3288-usb20host",
 105          .pdata = &usb20host_pdata_rk3288,
 106          },
 107         {
 108          .name = "rk3288-usb20host",
 109          .pdata = &usb20host_pdata_rk3036,
 110          },
 111         {},
 112 };
 113 #endif
 114
 115 #ifdef CONFIG_RK_USB_UART
 116 static u32 usb_to_uart_status;
 117 #endif
 118 /*-------------------------------------------------------------------------*/
 119 /* Encapsulate the module parameter settings */
 120
 121 struct dwc_otg_driver_module_params {
 122         int32_t opt;
 123         int32_t otg_cap;
 124         int32_t dma_enable;
 125         int32_t dma_desc_enable;
 126         int32_t dma_burst_size;
 127         int32_t speed;
 128         int32_t host_support_fs_ls_low_power;
 129         int32_t host_ls_low_power_phy_clk;
 130         int32_t enable_dynamic_fifo;
 131         int32_t data_fifo_size;
 132         int32_t dev_rx_fifo_size;
 133         int32_t dev_nperio_tx_fifo_size;
 134         uint32_t dev_perio_tx_fifo_size[MAX_PERIO_FIFOS];
 135         int32_t host_rx_fifo_size;
 136         int32_t host_nperio_tx_fifo_size;
 137         int32_t host_perio_tx_fifo_size;
 138         int32_t max_transfer_size;
 139         int32_t max_packet_count;
 140         int32_t host_channels;
 141         int32_t dev_endpoints;
 142         int32_t phy_type;
 143         int32_t phy_utmi_width;
 144         int32_t phy_ulpi_ddr;
 145         int32_t phy_ulpi_ext_vbus;
 146         int32_t i2c_enable;
 147         int32_t ulpi_fs_ls;
 148         int32_t ts_dline;
 149         int32_t en_multiple_tx_fifo;
 150         uint32_t dev_tx_fifo_size[MAX_TX_FIFOS];
 151         uint32_t thr_ctl;
 152         uint32_t tx_thr_length;
 153         uint32_t rx_thr_length;
 154         int32_t pti_enable;
 155         int32_t mpi_enable;
 156         int32_t lpm_enable;
 157         int32_t besl_enable;
 158         int32_t baseline_besl;
 159         int32_t deep_besl;
 160         int32_t ic_usb_cap;
 161         int32_t ahb_thr_ratio;
 162         int32_t power_down;
 163         int32_t reload_ctl;
 164         int32_t dev_out_nak;
 165         int32_t cont_on_bna;
 166         int32_t ahb_single;
 167         int32_t otg_ver;
 168         int32_t adp_enable;
 169 };
 170
 171 static struct dwc_otg_driver_module_params dwc_otg_module_params = {
 172         .opt = -1,
 173         .otg_cap = DWC_OTG_CAP_PARAM_NO_HNP_SRP_CAPABLE,
 174         .dma_enable = -1,
 175         .dma_desc_enable = 0,
 176         .dma_burst_size = -1,
 177         .speed = -1,
 178         .host_support_fs_ls_low_power = -1,
 179         .host_ls_low_power_phy_clk = -1,
 180         .enable_dynamic_fifo = 1,
 181         .data_fifo_size = -1,
 182         .dev_rx_fifo_size = 0x120,
 183         .dev_nperio_tx_fifo_size = 0x10,
 184         .dev_perio_tx_fifo_size = {
 185                                    /* dev_perio_tx_fifo_size_1 */
 186                                    -1,
 187                                    -1,
 188                                    -1,
 189                                    -1,
 190                                    -1,
 191                                    -1,
 192                                    -1,
 193                                    -1,
 194                                    -1,
 195                                    -1,
 196                                    -1,
 197                                    -1,
 198                                    -1,
 199                                    -1,
 200                                    -1
 201                                    /* 15 */
 202                                    },
 203         .host_rx_fifo_size = -1,
 204         .host_nperio_tx_fifo_size = -1,
 205         .host_perio_tx_fifo_size = -1,
 206         .max_transfer_size = -1,
 207         .max_packet_count = -1,
 208         .host_channels = -1,
 209         .dev_endpoints = -1,
 210         .phy_type = -1,
 211         .phy_utmi_width = -1,
 212         .phy_ulpi_ddr = -1,
 213         .phy_ulpi_ext_vbus = -1,
 214         .i2c_enable = -1,
 215         .ulpi_fs_ls = -1,
 216         .ts_dline = -1,
 217         .en_multiple_tx_fifo = -1,
 218         .dev_tx_fifo_size = {
 219                              /* dev_tx_fifo_size */
 220                              0x100,
 221                              0x80,
 222                              0x80,
 223                              0x60,
 224                              0x10,
 225                              0x10,
 226                              -1,
 227                              -1,
 228                              -1,
 229                              -1,
 230                              -1,
 231                              -1,
 232                              -1,
 233                              -1,
 234                              -1
 235                              /* 15 */
 236                              },
 237         .thr_ctl = -1,
 238         .tx_thr_length = -1,
 239         .rx_thr_length = -1,
 240         .pti_enable = -1,
 241         .mpi_enable = -1,
 242         .lpm_enable = -1,
 243         .besl_enable = -1,
 244         .baseline_besl = -1,
 245         .deep_besl = -1,
 246         .ic_usb_cap = -1,
 247         .ahb_thr_ratio = -1,
 248         .power_down = -1,
 249         .reload_ctl = -1,
 250         .dev_out_nak = -1,
 251         .cont_on_bna = -1,
 252         .ahb_single = -1,
 253         .otg_ver = -1,
 254         .adp_enable = 0,
 255 };
 256
 257 #ifdef CONFIG_USB20_HOST
 258 static struct dwc_otg_driver_module_params dwc_host_module_params = {
 259         .opt = -1,
 260         .otg_cap = DWC_OTG_CAP_PARAM_NO_HNP_SRP_CAPABLE,
 261         .dma_enable = -1,
 262         .dma_desc_enable = 0,
 263         .dma_burst_size = -1,
 264         .speed = -1,
 265         .host_support_fs_ls_low_power = -1,
 266         .host_ls_low_power_phy_clk = -1,
 267         .enable_dynamic_fifo = -1,
 268         .data_fifo_size = -1,
 269         .dev_rx_fifo_size = -1,
 270         .dev_nperio_tx_fifo_size = -1,
 271         .dev_perio_tx_fifo_size = {
 272                                    /* dev_perio_tx_fifo_size_1 */
 273                                    -1,
 274                                    -1,
 275                                    -1,
 276                                    -1,
 277                                    -1,
 278                                    -1,
 279                                    -1,
 280                                    -1,
 281                                    -1,
 282                                    -1,
 283                                    -1,
 284                                    -1,
 285                                    -1,
 286                                    -1,
 287                                    -1
 288                                    /* 15 */
 289                                    },
 290         .host_rx_fifo_size = -1,
 291         .host_nperio_tx_fifo_size = -1,
 292         .host_perio_tx_fifo_size = -1,
 293         .max_transfer_size = -1,
 294         .max_packet_count = -1,
 295         .host_channels = -1,
 296         .dev_endpoints = -1,
 297         .phy_type = -1,
 298         .phy_utmi_width = -1,
 299         .phy_ulpi_ddr = -1,
 300         .phy_ulpi_ext_vbus = -1,
 301         .i2c_enable = -1,
 302         .ulpi_fs_ls = -1,
 303         .ts_dline = -1,
 304         .en_multiple_tx_fifo = -1,
 305         .dev_tx_fifo_size = {
 306                              /* dev_tx_fifo_size */
 307                              -1,
 308                              -1,
 309                              -1,
 310                              -1,
 311                              -1,
 312                              -1,
 313                              -1,
 314                              -1,
 315                              -1,
 316                              -1,
 317                              -1,
 318                              -1,
 319                              -1,
 320                              -1,
 321                              -1
 322                              /* 15 */
 323                              },
 324         .thr_ctl = -1,
 325         .tx_thr_length = -1,
 326         .rx_thr_length = -1,
 327         .pti_enable = -1,
 328         .mpi_enable = -1,
 329         .lpm_enable = -1,
 330         .besl_enable = -1,
 331         .baseline_besl = -1,
 332         .deep_besl = -1,
 333         .ic_usb_cap = -1,
 334         .ahb_thr_ratio = -1,
 335         .power_down = -1,
 336         .reload_ctl = -1,
 337         .dev_out_nak = -1,
 338         .cont_on_bna = -1,
 339         .ahb_single = -1,
 340         .otg_ver = -1,
 341         .adp_enable = 0,
 342 };
 343 #endif
 344
 345 /**
 346  * This function shows the Driver Version.
 347  */
 348 static ssize_t version_show(struct device_driver *dev, char *buf)
 349 {
 350         return snprintf(buf, sizeof(DWC_DRIVER_VERSION) + 2, "%s\n",
 351                         DWC_DRIVER_VERSION);
 352 }
 353
 354 static DRIVER_ATTR(version, S_IRUGO, version_show, NULL);
 355
 356 /**
 357  * Global Debug Level Mask.
 358  */
 359 uint32_t g_dbg_lvl = DBG_OFF;   /* OFF */
 360
 361 /**
 362  * This function shows the driver Debug Level.
 363  */
 364 static ssize_t dbg_level_show(struct device_driver *drv, char *buf)
 365 {
 366         return sprintf(buf, "0x%0x\n", g_dbg_lvl);
 367 }
 368
 369 /**
 370  * This function stores the driver Debug Level.
 371  */
 372 static ssize_t dbg_level_store(struct device_driver *drv, const char *buf,
 373                                size_t count)
 374 {
 375         g_dbg_lvl = simple_strtoul(buf, NULL, 16);
 376         return count;
 377 }
 378
 379 static DRIVER_ATTR(debuglevel, S_IRUGO | S_IWUSR, dbg_level_show,
 380                    dbg_level_store);
 381
 382 extern void hcd_start(dwc_otg_core_if_t *core_if);
 383 extern struct usb_hub *g_dwc_otg_root_hub20;
 384 extern void dwc_otg_hub_disconnect_device(struct usb_hub *hub);
 385
 386 void dwc_otg_force_host(dwc_otg_core_if_t *core_if)
 387 {
 388         dwc_otg_device_t *otg_dev = core_if->otg_dev;
 389         dctl_data_t dctl = {.d32 = 0 };
 390         unsigned long flags;
 391
 392         if (core_if->op_state == A_HOST) {
 393                 printk("dwc_otg_force_host,already in A_HOST mode,everest\n");
 394                 return;
 395         }
 396         core_if->op_state = A_HOST;
 397
 398         cancel_delayed_work(&otg_dev->pcd->check_vbus_work);
 399         dctl.d32 = DWC_READ_REG32(&core_if->dev_if->dev_global_regs->dctl);
 400         dctl.b.sftdiscon = 1;
 401         DWC_WRITE_REG32(&core_if->dev_if->dev_global_regs->dctl, dctl.d32);
 402
 403         local_irq_save(flags);
 404         cil_pcd_stop(core_if);
 405         /*
 406          * Initialize the Core for Host mode.
 407          */
 408
 409         dwc_otg_core_init(core_if);
 410         dwc_otg_enable_global_interrupts(core_if);
 411         cil_hcd_start(core_if);
 412         local_irq_restore(flags);
 413 }
 414
 415 void dwc_otg_force_device(dwc_otg_core_if_t *core_if)
 416 {
 417         dwc_otg_device_t *otg_dev = core_if->otg_dev;
 418         unsigned long flags;
 419
 420         local_irq_save(flags);
 421
 422         if (core_if->op_state == B_PERIPHERAL) {
 423                 printk
 424                     ("dwc_otg_force_device,already in B_PERIPHERAL,everest\n");
 425                 return;
 426         }
 427         core_if->op_state = B_PERIPHERAL;
 428         cil_hcd_stop(core_if);
 429         /* dwc_otg_hub_disconnect_device(g_dwc_otg_root_hub20); */
 430         otg_dev->pcd->phy_suspend = 1;
 431         otg_dev->pcd->vbus_status = 0;
 432         dwc_otg_pcd_start_check_vbus_work(otg_dev->pcd);
 433
 434         /* Reset the Controller */
 435         dwc_otg_core_reset(core_if);
 436
 437         dwc_otg_core_init(core_if);
 438         dwc_otg_disable_global_interrupts(core_if);
 439         cil_pcd_start(core_if);
 440
 441         local_irq_restore(flags);
 442 }
 443
 444 static void dwc_otg_set_force_mode(dwc_otg_core_if_t *core_if, int mode)
 445 {
 446         gusbcfg_data_t usbcfg = {.d32 = 0 };
 447         printk("!!!dwc_otg_set_force_mode\n");
 448         usbcfg.d32 = DWC_READ_REG32(&core_if->core_global_regs->gusbcfg);
 449         switch (mode) {
 450         case USB_MODE_FORCE_HOST:
 451                 usbcfg.b.force_host_mode = 1;
 452                 usbcfg.b.force_dev_mode = 0;
 453                 break;
 454         case USB_MODE_FORCE_DEVICE:
 455                 usbcfg.b.force_host_mode = 0;
 456                 usbcfg.b.force_dev_mode = 1;
 457                 break;
 458         case USB_MODE_NORMAL:
 459                 usbcfg.b.force_host_mode = 0;
 460                 usbcfg.b.force_dev_mode = 0;
 461                 break;
 462         }
 463         DWC_WRITE_REG32(&core_if->core_global_regs->gusbcfg, usbcfg.d32);
 464 }
 465
 466 static ssize_t force_usb_mode_show(struct device_driver *drv, char *buf)
 467 {
 468         dwc_otg_device_t *otg_dev = g_otgdev;
 469         dwc_otg_core_if_t *core_if = otg_dev->core_if;
 470
 471         return sprintf(buf, "%d\n", core_if->usb_mode);
 472 }
 473
 474 static ssize_t force_usb_mode_store(struct device_driver *drv, const char *buf,
 475                                     size_t count)
 476 {
 477         int new_mode = simple_strtoul(buf, NULL, 16);
 478         dwc_otg_device_t *otg_dev = g_otgdev;
 479         dwc_otg_core_if_t *core_if;
 480         struct dwc_otg_platform_data *pldata;
 481
 482         if (!otg_dev)
 483                 return -EINVAL;
 484
 485         core_if = otg_dev->core_if;
 486         pldata = otg_dev->pldata;
 487
 488         DWC_PRINTF("%s %d->%d\n", __func__, core_if->usb_mode, new_mode);
 489
 490         if (core_if->usb_mode == new_mode) {
 491                 return count;
 492         }
 493
 494         if (pldata->phy_status == USB_PHY_SUSPEND) {
 495                 pldata->clock_enable(pldata, 1);
 496                 pldata->phy_suspend(pldata, USB_PHY_ENABLED);
 497         }
 498
 499         switch (new_mode) {
 500         case USB_MODE_FORCE_HOST:
 501                 if (USB_MODE_FORCE_DEVICE == core_if->usb_mode) {
 502                         /* device-->host */
 503                         core_if->usb_mode = new_mode;
 504                         dwc_otg_force_host(core_if);
 505                 } else if (USB_MODE_NORMAL == core_if->usb_mode) {
 506                         core_if->usb_mode = new_mode;
 507                         if (dwc_otg_is_host_mode(core_if))
 508                                 dwc_otg_set_force_mode(core_if, new_mode);
 509                         else
 510                                 dwc_otg_force_host(core_if);
 511                 }
 512                 break;
 513
 514         case USB_MODE_FORCE_DEVICE:
 515                 if (USB_MODE_FORCE_HOST == core_if->usb_mode) {
 516                         core_if->usb_mode = new_mode;
 517                         dwc_otg_force_device(core_if);
 518                 } else if (USB_MODE_NORMAL == core_if->usb_mode) {
 519                         core_if->usb_mode = new_mode;
 520                         if (dwc_otg_is_device_mode(core_if))
 521                                 dwc_otg_set_force_mode(core_if, new_mode);
 522                         else
 523                                 dwc_otg_force_device(core_if);
 524                 }
 525                 break;
 526
 527         case USB_MODE_NORMAL:
 528                 if (USB_MODE_FORCE_DEVICE == core_if->usb_mode) {
 529                         core_if->usb_mode = new_mode;
 530                         cancel_delayed_work(&otg_dev->pcd->check_vbus_work);
 531                         dwc_otg_set_force_mode(core_if, new_mode);
 532                         /* msleep(100); */
 533                         if (dwc_otg_is_host_mode(core_if)) {
 534                                 dwc_otg_force_host(core_if);
 535                         } else {
 536                                 dwc_otg_pcd_start_check_vbus_work(otg_dev->pcd);
 537                         }
 538                 } else if (USB_MODE_FORCE_HOST == core_if->usb_mode) {
 539                         core_if->usb_mode = new_mode;
 540                         dwc_otg_set_force_mode(core_if, new_mode);
 541                         /* msleep(100); */
 542                         if (dwc_otg_is_device_mode(core_if)) {
 543                                 dwc_otg_force_device(core_if);
 544                         }
 545                 }
 546                 break;
 547
 548         default:
 549                 break;
 550         }
 551         return count;
 552 }
 553
 554 static DRIVER_ATTR(force_usb_mode, S_IRUGO | S_IWUSR, force_usb_mode_show,
 555                    force_usb_mode_store);
 556
 557 static ssize_t dwc_otg_conn_en_show(struct device_driver *_drv, char *_buf)
 558 {
 559
 560         dwc_otg_device_t *otg_dev = g_otgdev;
 561         dwc_otg_pcd_t *_pcd = otg_dev->pcd;
 562         return sprintf(_buf, "%d\n", _pcd->conn_en);
 563
 564 }
 565
 566 static ssize_t dwc_otg_conn_en_store(struct device_driver *_drv,
 567                                      const char *_buf, size_t _count)
 568 {
 569         int enable = simple_strtoul(_buf, NULL, 10);
 570         dwc_otg_device_t *otg_dev = g_otgdev;
 571         dwc_otg_pcd_t *_pcd = otg_dev->pcd;
 572         DWC_PRINTF("%s %d->%d\n", __func__, _pcd->conn_en, enable);
 573
 574         _pcd->conn_en = enable;
 575         return _count;
 576 }
 577
 578 static DRIVER_ATTR(dwc_otg_conn_en, S_IRUGO | S_IWUSR, dwc_otg_conn_en_show,
 579                    dwc_otg_conn_en_store);
 580
 581 /* used for product vbus power control, SDK not need.
 582  * If dwc_otg is host mode, enable vbus power.
 583  * If dwc_otg is device mode, disable vbus power.
 584  * return 1 - host mode, 0 - device mode.
 585  */
 586 int dwc_otg_usb_state(void)
 587 {
 588         dwc_otg_device_t *otg_dev = g_otgdev;
 589
 590         if (otg_dev) {
 591                 /* op_state is A_HOST */
 592                 if (1 == otg_dev->core_if->op_state)
 593                         return 1;
 594                 /* op_state is B_PERIPHERAL */
 595                 else if (4 == otg_dev->core_if->op_state)
 596                         return 0;
 597                 else
 598                         return 0;
 599         } else {
 600                 DWC_WARN("g_otgdev is NULL, maybe otg probe is failed!\n");
 601                 return 0;
 602         }
 603 }
 604 EXPORT_SYMBOL(dwc_otg_usb_state);
 605
 606 static ssize_t dwc_otg_op_state_show(struct device_driver *_drv, char *_buf)
 607 {
 608         dwc_otg_device_t *otg_dev = g_otgdev;
 609
 610         if (otg_dev) {
 611                 return sprintf(_buf, "%d\n", otg_dev->core_if->op_state);
 612         } else {
 613                 return sprintf(_buf, "%d\n", 0);
 614         }
 615 }
 616 static DRIVER_ATTR(op_state, S_IRUGO, dwc_otg_op_state_show, NULL);
 617
 618 static ssize_t vbus_status_show(struct device_driver *_drv, char *_buf)
 619 {
 620         dwc_otg_device_t *otg_dev = g_otgdev;
 621         dwc_otg_pcd_t *_pcd = otg_dev->pcd;
 622         return sprintf(_buf, "%d\n", _pcd->vbus_status);
 623 }
 624
 625 static DRIVER_ATTR(vbus_status, S_IRUGO, vbus_status_show, NULL);
 626
 627 /**
 628  * This function is called during module intialization
 629  * to pass module parameters to the DWC_OTG CORE.
 630  */
 631 static int set_parameters(dwc_otg_core_if_t *core_if,
 632                           struct dwc_otg_driver_module_params module_params)
 633 {
 634         int retval = 0;
 635         int i;
 636
 637         if (module_params.otg_cap != -1) {
 638                 retval +=
 639                     dwc_otg_set_param_otg_cap(core_if, module_params.otg_cap);
 640         }
 641         if (module_params.dma_enable != -1) {
 642                 retval +=
 643                     dwc_otg_set_param_dma_enable(core_if,
 644                                                  module_params.dma_enable);
 645         }
 646         if (module_params.dma_desc_enable != -1) {
 647                 retval +=
 648                     dwc_otg_set_param_dma_desc_enable(core_if,
 649                                                       module_params.dma_desc_enable);
 650         }
 651         if (module_params.opt != -1) {
 652                 retval += dwc_otg_set_param_opt(core_if, module_params.opt);
 653         }
 654         if (module_params.dma_burst_size != -1) {
 655                 retval +=
 656                     dwc_otg_set_param_dma_burst_size(core_if,
 657                                                      module_params.dma_burst_size);
 658         }
 659         if (module_params.host_support_fs_ls_low_power != -1) {
 660                 retval +=
 661                     dwc_otg_set_param_host_support_fs_ls_low_power(core_if,
 662                                                                    module_params.host_support_fs_ls_low_power);
 663         }
 664         if (module_params.enable_dynamic_fifo != -1) {
 665                 retval +=
 666                     dwc_otg_set_param_enable_dynamic_fifo(core_if,
 667                                                           module_params.enable_dynamic_fifo);
 668         }
 669         if (module_params.data_fifo_size != -1) {
 670                 retval +=
 671                     dwc_otg_set_param_data_fifo_size(core_if,
 672                                                      module_params.data_fifo_size);
 673         }
 674         if (module_params.dev_rx_fifo_size != -1) {
 675                 retval +=
 676                     dwc_otg_set_param_dev_rx_fifo_size(core_if,
 677                                                        module_params.dev_rx_fifo_size);
 678         }
 679         if (module_params.dev_nperio_tx_fifo_size != -1) {
 680                 retval +=
 681                     dwc_otg_set_param_dev_nperio_tx_fifo_size(core_if,
 682                                                               module_params.dev_nperio_tx_fifo_size);
 683         }
 684         if (module_params.host_rx_fifo_size != -1) {
 685                 retval +=
 686                     dwc_otg_set_param_host_rx_fifo_size(core_if,
 687                                                         module_params.
 688                                                         host_rx_fifo_size);
 689         }
 690         if (module_params.host_nperio_tx_fifo_size != -1) {
 691                 retval +=
 692                     dwc_otg_set_param_host_nperio_tx_fifo_size(core_if,
 693                                                                module_params.host_nperio_tx_fifo_size);
 694         }
 695         if (module_params.host_perio_tx_fifo_size != -1) {
 696                 retval +=
 697                     dwc_otg_set_param_host_perio_tx_fifo_size(core_if,
 698                                                               module_params.host_perio_tx_fifo_size);
 699         }
 700         if (module_params.max_transfer_size != -1) {
 701                 retval +=
 702                     dwc_otg_set_param_max_transfer_size(core_if,
 703                                                         module_params.max_transfer_size);
 704         }
 705         if (module_params.max_packet_count != -1) {
 706                 retval +=
 707                     dwc_otg_set_param_max_packet_count(core_if,
 708                                                        module_params.max_packet_count);
 709         }
 710         if (module_params.host_channels != -1) {
 711                 retval +=
 712                     dwc_otg_set_param_host_channels(core_if,
 713                                                     module_params.host_channels);
 714         }
 715         if (module_params.dev_endpoints != -1) {
 716                 retval +=
 717                     dwc_otg_set_param_dev_endpoints(core_if,
 718                                                     module_params.dev_endpoints);
 719         }
 720         if (module_params.phy_type != -1) {
 721                 retval +=
 722                     dwc_otg_set_param_phy_type(core_if, module_params.phy_type);
 723         }
 724         if (module_params.speed != -1) {
 725                 retval += dwc_otg_set_param_speed(core_if, module_params.speed);
 726         }
 727         if (module_params.host_ls_low_power_phy_clk != -1) {
 728                 retval +=
 729                     dwc_otg_set_param_host_ls_low_power_phy_clk(core_if,
 730                                                                 module_params.host_ls_low_power_phy_clk);
 731         }
 732         if (module_params.phy_ulpi_ddr != -1) {
 733                 retval +=
 734                     dwc_otg_set_param_phy_ulpi_ddr(core_if,
 735                                                    module_params.phy_ulpi_ddr);
 736         }
 737         if (module_params.phy_ulpi_ext_vbus != -1) {
 738                 retval +=
 739                     dwc_otg_set_param_phy_ulpi_ext_vbus(core_if,
 740                                                         module_params.phy_ulpi_ext_vbus);
 741         }
 742         if (module_params.phy_utmi_width != -1) {
 743                 retval +=
 744                     dwc_otg_set_param_phy_utmi_width(core_if,
 745                                                      module_params.phy_utmi_width);
 746         }
 747         if (module_params.ulpi_fs_ls != -1) {
 748                 retval +=
 749                     dwc_otg_set_param_ulpi_fs_ls(core_if,
 750                                                  module_params.ulpi_fs_ls);
 751         }
 752         if (module_params.ts_dline != -1) {
 753                 retval +=
 754                     dwc_otg_set_param_ts_dline(core_if, module_params.ts_dline);
 755         }
 756         if (module_params.i2c_enable != -1) {
 757                 retval +=
 758                     dwc_otg_set_param_i2c_enable(core_if,
 759                                                  module_params.i2c_enable);
 760         }
 761         if (module_params.en_multiple_tx_fifo != -1) {
 762                 retval +=
 763                     dwc_otg_set_param_en_multiple_tx_fifo(core_if,
 764                                                           module_params.en_multiple_tx_fifo);
 765         }
 766         for (i = 0; i < 15; i++) {
 767                 if (module_params.dev_perio_tx_fifo_size[i] != -1) {
 768                         retval +=
 769                             dwc_otg_set_param_dev_perio_tx_fifo_size(core_if,
 770                                                                      module_params.dev_perio_tx_fifo_size
 771                                                                      [i], i);
 772                 }
 773         }
 774
 775         for (i = 0; i < 15; i++) {
 776                 if (module_params.dev_tx_fifo_size[i] != -1) {
 777                         retval += dwc_otg_set_param_dev_tx_fifo_size(core_if,
 778                                                                      module_params.dev_tx_fifo_size
 779                                                                      [i], i);
 780                 }
 781         }
 782         if (module_params.thr_ctl != -1) {
 783                 retval +=
 784                     dwc_otg_set_param_thr_ctl(core_if, module_params.thr_ctl);
 785         }
 786         if (module_params.mpi_enable != -1) {
 787                 retval +=
 788                     dwc_otg_set_param_mpi_enable(core_if,
 789                                                  module_params.mpi_enable);
 790         }
 791         if (module_params.pti_enable != -1) {
 792                 retval +=
 793                     dwc_otg_set_param_pti_enable(core_if,
 794                                                  module_params.pti_enable);
 795         }
 796         if (module_params.lpm_enable != -1) {
 797                 retval +=
 798                     dwc_otg_set_param_lpm_enable(core_if,
 799                                                  module_params.lpm_enable);
 800         }
 801         if (module_params.besl_enable != -1) {
 802                 retval +=
 803                     dwc_otg_set_param_besl_enable(core_if,
 804                                                   module_params.besl_enable);
 805         }
 806         if (module_params.baseline_besl != -1) {
 807                 retval +=
 808                     dwc_otg_set_param_baseline_besl(core_if,
 809                                                     module_params.baseline_besl);
 810         }
 811         if (module_params.deep_besl != -1) {
 812                 retval +=
 813                     dwc_otg_set_param_deep_besl(core_if,
 814                                                 module_params.deep_besl);
 815         }
 816         if (module_params.ic_usb_cap != -1) {
 817                 retval +=
 818                     dwc_otg_set_param_ic_usb_cap(core_if,
 819                                                  module_params.ic_usb_cap);
 820         }
 821         if (module_params.tx_thr_length != -1) {
 822                 retval +=
 823                     dwc_otg_set_param_tx_thr_length(core_if,
 824                                                     module_params.
 825                                                     tx_thr_length);
 826         }
 827         if (module_params.rx_thr_length != -1) {
 828                 retval +=
 829                     dwc_otg_set_param_rx_thr_length(core_if,
 830                                                     module_params.rx_thr_length);
 831         }
 832         if (module_params.ahb_thr_ratio != -1) {
 833                 retval +=
 834                     dwc_otg_set_param_ahb_thr_ratio(core_if,
 835                                                     module_params.
 836                                                     ahb_thr_ratio);
 837         }
 838         if (module_params.power_down != -1) {
 839                 retval +=
 840                     dwc_otg_set_param_power_down(core_if,
 841                                                  module_params.power_down);
 842         }
 843         if (module_params.reload_ctl != -1) {
 844                 retval +=
 845                     dwc_otg_set_param_reload_ctl(core_if,
 846                                                  module_params.reload_ctl);
 847         }
 848
 849         if (module_params.dev_out_nak != -1) {
 850                 retval +=
 851                     dwc_otg_set_param_dev_out_nak(core_if,
 852                                                   module_params.dev_out_nak);
 853         }
 854
 855         if (module_params.cont_on_bna != -1) {
 856                 retval +=
 857                     dwc_otg_set_param_cont_on_bna(core_if,
 858                                                   module_params.cont_on_bna);
 859         }
 860
 861         if (module_params.ahb_single != -1) {
 862                 retval +=
 863                     dwc_otg_set_param_ahb_single(core_if,
 864                                                  module_params.ahb_single);
 865         }
 866
 867         if (module_params.otg_ver != -1) {
 868                 retval +=
 869                     dwc_otg_set_param_otg_ver(core_if, module_params.otg_ver);
 870         }
 871         if (module_params.adp_enable != -1) {
 872                 retval +=
 873                     dwc_otg_set_param_adp_enable(core_if,
 874                                                  module_params.adp_enable);
 875         }
 876         return retval;
 877 }
 878
 879 /**
 880  * This function is the top level interrupt handler for the Common
 881  * (Device and host modes) interrupts.
 882  */
 883 static irqreturn_t dwc_otg_common_irq(int irq, void *dev)
 884 {
 885         int32_t retval = IRQ_NONE;
 886
 887         retval = dwc_otg_handle_common_intr(dev);
 888         if (retval != 0) {
 889                 /* S3C2410X_CLEAR_EINTPEND(); */
 890         }
 891         return IRQ_RETVAL(retval);
 892 }
 893
 894 #ifdef CONFIG_USB20_HOST
 895 /**
 896  * This function is called when a lm_device is unregistered with the
 897  * dwc_otg_driver. This happens, for example, when the rmmod command is
 898  * executed. The device may or may not be electrically present. If it is
 899  * present, the driver stops device processing. Any resources used on behalf
 900  * of this device are freed.
 901  *
 902  * @param _dev
 903  */
 904 static int host20_driver_remove(struct platform_device *_dev)
 905 {
 906
 907         dwc_otg_device_t *otg_dev = dwc_get_device_platform_data(_dev);
 908         DWC_DEBUGPL(DBG_ANY, "%s(%p)\n", __func__, _dev);
 909
 910         if (!otg_dev) {
 911                 /* Memory allocation for the dwc_otg_device failed. */
 912                 DWC_DEBUGPL(DBG_ANY, "%s: otg_dev NULL!\n", __func__);
 913                 return 0;
 914         }
 915 #ifndef DWC_DEVICE_ONLY
 916         if (otg_dev->hcd) {
 917                 hcd_remove(_dev);
 918         } else {
 919                 DWC_DEBUGPL(DBG_ANY, "%s: otg_dev->hcd NULL!\n", __func__);
 920                 return 0;
 921         }
 922 #endif
 923
 924 #ifndef DWC_HOST_ONLY
 925         if (otg_dev->pcd) {
 926                 pcd_remove(_dev);
 927         } else {
 928                 DWC_DEBUGPL(DBG_ANY, "%s: otg_dev->pcd NULL!\n", __func__);
 929                 return 0;
 930         }
 931 #endif
 932
 933         /*
 934          * Free the IRQ
 935          */
 936         if (otg_dev->common_irq_installed) {
 937                 /* free_irq(_dev->irq, otg_dev); */
 938                 free_irq(platform_get_irq(_dev, 0), otg_dev);
 939         } else {
 940                 DWC_DEBUGPL(DBG_ANY, "%s: There is no installed irq!\n",
 941                             __func__);
 942                 return 0;
 943         }
 944
 945         if (otg_dev->core_if) {
 946                 dwc_otg_cil_remove(otg_dev->core_if);
 947         } else {
 948                 DWC_DEBUGPL(DBG_ANY, "%s: otg_dev->core_if NULL!\n", __func__);
 949                 return 0;
 950         }
 951
 952         /*
 953          * Remove the device attributes
 954          */
 955         dwc_otg_attr_remove(_dev);
 956
 957         /*
 958          * Return the memory.
 959          */
 960         if (otg_dev->os_dep.base) {
 961                 iounmap(otg_dev->os_dep.base);
 962         }
 963         DWC_FREE(otg_dev);
 964
 965         /*
 966          * Clear the drvdata pointer.
 967          */
 968
 969         dwc_set_device_platform_data(_dev, 0);
 970
 971         return 0;
 972 }
 973
 974 static const struct of_device_id usb20_host_of_match[] = {
 975         {
 976          .compatible = "rockchip,rk3188_usb20_host",
 977          .data = &usb20host_pdata[RK3188_USB_CTLR],
 978          },
 979         {
 980          .compatible = "rockchip,rk3288_usb20_host",
 981          .data = &usb20host_pdata[RK3288_USB_CTLR],
 982          },
 983         {
 984          .compatible = "rockchip,rk3036_usb20_host",
 985          .data = &usb20host_pdata[RK3036_USB_CTLR],
 986          },
 987         {},
 988 };
 989
 990 MODULE_DEVICE_TABLE(of, usb20_host_of_match);
 991
 992 /**
 993  * This function is called when an lm_device is bound to a
 994  * dwc_otg_driver. It creates the driver components required to
 995  * control the device (CIL, HCD, and PCD) and it initializes the
 996  * device. The driver components are stored in a dwc_otg_device
 997  * structure. A reference to the dwc_otg_device is saved in the
 998  * lm_device. This allows the driver to access the dwc_otg_device
 999  * structure on subsequent calls to driver methods for this device.
1000  *
1001  * @param _dev Bus device
1002  */
1003 static int host20_driver_probe(struct platform_device *_dev)
1004 {
1005         int retval = 0;
1006         int irq;
1007         struct resource *res_base;
1008         dwc_otg_device_t *dwc_otg_device;
1009         struct device *dev = &_dev->dev;
1010         struct device_node *node = _dev->dev.of_node;
1011         struct dwc_otg_platform_data *pldata;
1012         struct usb20host_pdata_id *p;
1013         const struct of_device_id *match =
1014             of_match_device(of_match_ptr(usb20_host_of_match), &_dev->dev);
1015
1016         if (match) {
1017                 p = (struct usb20host_pdata_id *)match->data;
1018         } else {
1019                 dev_err(dev, "usb20host match failed\n");
1020                 return -EINVAL;
1021         }
1022
1023         dev->platform_data = p->pdata;
1024         pldata = dev->platform_data;
1025         pldata->dev = dev;
1026
1027         if (!node) {
1028                 dev_err(dev, "device node not found\n");
1029                 return -EINVAL;
1030         }
1031
1032         if (pldata->hw_init)
1033                 pldata->hw_init();
1034
1035         if (pldata->clock_init) {
1036                 pldata->clock_init(pldata);
1037                 pldata->clock_enable(pldata, 1);
1038         }
1039
1040         if (pldata->phy_suspend)
1041                 pldata->phy_suspend(pldata, USB_PHY_ENABLED);
1042
1043         if (pldata->soft_reset)
1044                 pldata->soft_reset(pldata, RST_POR);
1045
1046         res_base = platform_get_resource(_dev, IORESOURCE_MEM, 0);
1047
1048         dwc_otg_device = DWC_ALLOC(sizeof(dwc_otg_device_t));
1049
1050         if (!dwc_otg_device) {
1051                 dev_err(&_dev->dev, "kmalloc of dwc_otg_device failed\n");
1052                 retval = -ENOMEM;
1053                 goto clk_disable;
1054         }
1055
1056         memset(dwc_otg_device, 0, sizeof(*dwc_otg_device));
1057         dwc_otg_device->os_dep.reg_offset = 0xFFFFFFFF;
1058
1059         /*
1060          * Map the DWC_otg Core memory into virtual address space.
1061          */
1062
1063         dwc_otg_device->os_dep.base = devm_ioremap_resource(dev, res_base);
1064
1065         if (!dwc_otg_device->os_dep.base) {
1066                 dev_err(&_dev->dev, "ioremap() failed\n");
1067                 DWC_FREE(dwc_otg_device);
1068                 retval = -ENOMEM;
1069                 goto clk_disable;
1070         }
1071         dev_dbg(&_dev->dev, "base=0x%08x\n",
1072                 (unsigned)dwc_otg_device->os_dep.base);
1073
1074         /*
1075          * Initialize driver data to point to the global DWC_otg
1076          * Device structure.
1077          */
1078
1079         dwc_set_device_platform_data(_dev, dwc_otg_device);
1080         pldata->privdata = dwc_otg_device;
1081         dwc_otg_device->pldata = (void *)pldata;
1082
1083         dev_dbg(&_dev->dev, "dwc_otg_device=0x%p\n", dwc_otg_device);
1084
1085         dwc_otg_device->core_if = dwc_otg_cil_init(dwc_otg_device->os_dep.base);
1086
1087         if (!dwc_otg_device->core_if) {
1088                 dev_err(&_dev->dev, "CIL initialization failed!\n");
1089                 retval = -ENOMEM;
1090                 goto fail;
1091         }
1092
1093         dwc_otg_device->core_if->otg_dev = dwc_otg_device;
1094
1095         /*
1096          * Attempt to ensure this device is really a DWC_otg Controller.
1097          * Read and verify the SNPSID register contents. The value should be
1098          * 0x45F42XXX or 0x45F42XXX, which corresponds to either "OT2" or "OTG3",
1099          * as in "OTG version 2.XX" or "OTG version 3.XX".
1100          */
1101
1102         if (((dwc_otg_get_gsnpsid(dwc_otg_device->core_if) & 0xFFFFF000) !=
1103              0x4F542000)
1104             && ((dwc_otg_get_gsnpsid(dwc_otg_device->core_if) & 0xFFFFF000) !=
1105                 0x4F543000)) {
1106                 dev_err(&_dev->dev, "Bad value for SNPSID: 0x%08x\n",
1107                         dwc_otg_get_gsnpsid(dwc_otg_device->core_if));
1108                 retval = -EINVAL;
1109                 goto fail;
1110         }
1111
1112         /*
1113          * Validate parameter values.
1114          */
1115         if (set_parameters(dwc_otg_device->core_if, dwc_host_module_params)) {
1116                 retval = -EINVAL;
1117                 goto fail;
1118         }
1119
1120         /*
1121          * Create Device Attributes in sysfs
1122          */
1123         dwc_otg_attr_create(_dev);
1124
1125         /*
1126          * Disable the global interrupt until all the interrupt
1127          * handlers are installed.
1128          */
1129         dwc_otg_disable_global_interrupts(dwc_otg_device->core_if);
1130
1131         /*
1132          * Install the interrupt handler for the common interrupts before
1133          * enabling common interrupts in core_init below.
1134          */
1135         irq = platform_get_irq(_dev, 0);
1136         DWC_DEBUGPL(DBG_CIL, "registering (common) handler for irq%d\n", irq);
1137         retval = request_irq(irq, dwc_otg_common_irq,
1138                              IRQF_SHARED, "dwc_otg", dwc_otg_device);
1139         if (retval) {
1140                 DWC_ERROR("request of irq%d failed\n", irq);
1141                 retval = -EBUSY;
1142                 goto fail;
1143         } else {
1144                 dwc_otg_device->common_irq_installed = 1;
1145         }
1146
1147         /*
1148          * Initialize the DWC_otg core.
1149          * In order to reduce the time of initialization,
1150          * we do core soft reset after connection detected.
1151          */
1152         dwc_otg_core_init_no_reset(dwc_otg_device->core_if);
1153
1154         /*
1155          * Initialize the HCD
1156          */
1157         retval = host20_hcd_init(_dev);
1158         if (retval != 0) {
1159                 DWC_ERROR("hcd_init failed\n");
1160                 dwc_otg_device->hcd = NULL;
1161                 goto fail;
1162         }
1163
1164         clk_set_rate(pldata->phyclk_480m, 480000000);
1165         /*
1166          * Enable the global interrupt after all the interrupt
1167          * handlers are installed if there is no ADP support else
1168          * perform initial actions required for Internal ADP logic.
1169          */
1170         if (!dwc_otg_get_param_adp_enable(dwc_otg_device->core_if)) {
1171                 if (pldata->phy_status == USB_PHY_ENABLED) {
1172                         pldata->phy_suspend(pldata, USB_PHY_SUSPEND);
1173                         udelay(3);
1174                         pldata->clock_enable(pldata, 0);
1175                 }
1176                 /* dwc_otg_enable_global_interrupts(dwc_otg_device->core_if); */
1177         } else
1178                 dwc_otg_adp_start(dwc_otg_device->core_if,
1179                                   dwc_otg_is_host_mode(dwc_otg_device->
1180                                                        core_if));
1181
1182         return 0;
1183
1184 fail:
1185         host20_driver_remove(_dev);
1186 clk_disable:
1187         if (pldata->clock_enable)
1188                 pldata->clock_enable(pldata, 0);
1189
1190         return retval;
1191 }
1192 #endif
1193
1194 static int dwc_otg_driver_suspend(struct platform_device *_dev,
1195                                   pm_message_t state)
1196 {
1197         return 0;
1198 }
1199
1200 static int dwc_otg_driver_resume(struct platform_device *_dev)
1201 {
1202         return 0;
1203 }
1204
1205 static void dwc_otg_driver_shutdown(struct platform_device *_dev)
1206 {
1207         struct device *dev = &_dev->dev;
1208         dwc_otg_device_t *otg_dev = dev->platform_data;
1209         dwc_otg_core_if_t *core_if = otg_dev->core_if;
1210         dctl_data_t dctl = {.d32 = 0 };
1211
1212         DWC_PRINTF("%s: disconnect USB %s mode\n", __func__,
1213                    dwc_otg_is_host_mode(core_if) ? "host" : "device");
1214         if (dwc_otg_is_host_mode(core_if)) {
1215                 if (core_if->hcd_cb && core_if->hcd_cb->stop)
1216                         core_if->hcd_cb->stop(core_if->hcd_cb_p);
1217         } else {
1218                 /* soft disconnect */
1219                 dctl.d32 =
1220                     DWC_READ_REG32(&core_if->dev_if->dev_global_regs->dctl);
1221                 dctl.b.sftdiscon = 1;
1222                 DWC_WRITE_REG32(&core_if->dev_if->dev_global_regs->dctl,
1223                                 dctl.d32);
1224         }
1225         /* Clear any pending interrupts */
1226         DWC_WRITE_REG32(&core_if->core_global_regs->gintsts, 0xFFFFFFFF);
1227
1228 }
1229
1230 /**
1231  * This structure defines the methods to be called by a bus driver
1232  * during the lifecycle of a device on that bus. Both drivers and
1233  * devices are registered with a bus driver. The bus driver matches
1234  * devices to drivers based on information in the device and driver
1235  * structures.
1236  *
1237  * The probe function is called when the bus driver matches a device
1238  * to this driver. The remove function is called when a device is
1239  * unregistered with the bus driver.
1240  */
1241 #ifdef CONFIG_USB20_HOST
1242 static struct platform_driver dwc_host_driver = {
1243         .driver = {
1244                    .name = (char *)dwc_host20_driver_name,
1245                    .of_match_table = of_match_ptr(usb20_host_of_match),
1246                    },
1247         .probe = host20_driver_probe,
1248         .remove = host20_driver_remove,
1249         .suspend = dwc_otg_driver_suspend,
1250         .resume = dwc_otg_driver_resume,
1251 };
1252 #endif
1253
1254 #ifdef CONFIG_USB20_OTG
1255 /**
1256  * This function is called when a lm_device is unregistered with the
1257  * dwc_otg_driver. This happens, for example, when the rmmod command is
1258  * executed. The device may or may not be electrically present. If it is
1259  * present, the driver stops device processing. Any resources used on behalf
1260  * of this device are freed.
1261  *
1262  * @param _dev
1263  */
1264 static int otg20_driver_remove(struct platform_device *_dev)
1265 {
1266
1267         dwc_otg_device_t *otg_dev = dwc_get_device_platform_data(_dev);
1268         DWC_DEBUGPL(DBG_ANY, "%s(%p)\n", __func__, _dev);
1269
1270         if (!otg_dev) {
1271                 /* Memory allocation for the dwc_otg_device failed. */
1272                 DWC_DEBUGPL(DBG_ANY, "%s: otg_dev NULL!\n", __func__);
1273                 return 0;
1274         }
1275 #ifndef DWC_DEVICE_ONLY
1276         if (otg_dev->hcd) {
1277                 hcd_remove(_dev);
1278         } else {
1279                 DWC_DEBUGPL(DBG_ANY, "%s: otg_dev->hcd NULL!\n", __func__);
1280                 return 0;
1281         }
1282 #endif
1283
1284 #ifndef DWC_HOST_ONLY
1285         if (otg_dev->pcd) {
1286                 pcd_remove(_dev);
1287         } else {
1288                 DWC_DEBUGPL(DBG_ANY, "%s: otg_dev->pcd NULL!\n", __func__);
1289                 return 0;
1290         }
1291 #endif
1292         /*
1293          * Free the IRQ
1294          */
1295         if (otg_dev->common_irq_installed) {
1296                 /* free_irq(_dev->irq, otg_dev); */
1297                 free_irq(platform_get_irq(_dev, 0), otg_dev);
1298         } else {
1299                 DWC_DEBUGPL(DBG_ANY, "%s: There is no installed irq!\n",
1300                             __func__);
1301                 return 0;
1302         }
1303
1304         if (otg_dev->core_if) {
1305                 dwc_otg_cil_remove(otg_dev->core_if);
1306         } else {
1307                 DWC_DEBUGPL(DBG_ANY, "%s: otg_dev->core_if NULL!\n", __func__);
1308                 return 0;
1309         }
1310
1311         /*
1312          * Remove the device attributes
1313          */
1314         dwc_otg_attr_remove(_dev);
1315
1316         /*
1317          * Return the memory.
1318          */
1319         if (otg_dev->os_dep.base)
1320                 iounmap(otg_dev->os_dep.base);
1321         DWC_FREE(otg_dev);
1322
1323         /*
1324          * Clear the drvdata pointer.
1325          */
1326
1327         dwc_set_device_platform_data(_dev, 0);
1328
1329         return 0;
1330 }
1331
1332 static const struct of_device_id usb20_otg_of_match[] = {
1333         {
1334          .compatible = "rockchip,rk3188_usb20_otg",
1335          .data = &usb20otg_pdata[RK3188_USB_CTLR],
1336          },
1337         {
1338          .compatible = "rockchip,rk3288_usb20_otg",
1339          .data = &usb20otg_pdata[RK3288_USB_CTLR],
1340          },
1341         {
1342          .compatible = "rockchip,rk3036_usb20_otg",
1343          .data = &usb20otg_pdata[RK3036_USB_CTLR],
1344          },
1345         {
1346          },
1347 };
1348
1349 MODULE_DEVICE_TABLE(of, usb20_otg_of_match);
1350
1351 /**
1352  * This function is called when an lm_device is bound to a
1353  * dwc_otg_driver. It creates the driver components required to
1354  * control the device (CIL, HCD, and PCD) and it initializes the
1355  * device. The driver components are stored in a dwc_otg_device
1356  * structure. A reference to the dwc_otg_device is saved in the
1357  * lm_device. This allows the driver to access the dwc_otg_device
1358  * structure on subsequent calls to driver methods for this device.
1359  *
1360  * @param _dev Bus device
1361  */
1362 static int otg20_driver_probe(struct platform_device *_dev)
1363 {
1364         int retval = 0;
1365         int irq;
1366         uint32_t val;
1367         struct resource *res_base;
1368         dwc_otg_device_t *dwc_otg_device;
1369         struct device *dev = &_dev->dev;
1370         struct device_node *node = _dev->dev.of_node;
1371         struct dwc_otg_platform_data *pldata;
1372         struct usb20otg_pdata_id *p;
1373         const struct of_device_id *match =
1374             of_match_device(of_match_ptr(usb20_otg_of_match), &_dev->dev);
1375
1376         if (match) {
1377                 p = (struct usb20otg_pdata_id *)match->data;
1378         } else {
1379                 dev_err(dev, "usb20otg match failed\n");
1380                 return -EINVAL;
1381         }
1382
1383         dev->platform_data = p->pdata;
1384         /* dev->platform_data = &usb20otg_pdata; */
1385         pldata = dev->platform_data;
1386         pldata->dev = dev;
1387
1388         if (!node) {
1389                 dev_err(dev, "device node not found\n");
1390                 return -EINVAL;
1391         }
1392         /*todo : move to usbdev_rk-XX.c */
1393         if (pldata->hw_init)
1394                 pldata->hw_init();
1395
1396         if (pldata->clock_init) {
1397                 pldata->clock_init(pldata);
1398                 pldata->clock_enable(pldata, 1);
1399         }
1400
1401         if (pldata->phy_suspend)
1402                 pldata->phy_suspend(pldata, USB_PHY_ENABLED);
1403
1404         if (pldata->dwc_otg_uart_mode)
1405                 pldata->dwc_otg_uart_mode(pldata, PHY_USB_MODE);
1406
1407         /* do reset later, because reset need about
1408          * 100ms to ensure otg id state change.
1409          */
1410         /*
1411            if(pldata->soft_reset)
1412            pldata->soft_reset();
1413          */
1414         /*end todo */
1415
1416         res_base = platform_get_resource(_dev, IORESOURCE_MEM, 0);
1417
1418         dwc_otg_device = DWC_ALLOC(sizeof(dwc_otg_device_t));
1419
1420         if (!dwc_otg_device) {
1421                 dev_err(&_dev->dev, "kmalloc of dwc_otg_device failed\n");
1422                 retval = -ENOMEM;
1423                 goto clk_disable;
1424         }
1425
1426         memset(dwc_otg_device, 0, sizeof(*dwc_otg_device));
1427         dwc_otg_device->os_dep.reg_offset = 0xFFFFFFFF;
1428
1429         /*
1430          * Map the DWC_otg Core memory into virtual address space.
1431          */
1432
1433         dwc_otg_device->os_dep.base = devm_ioremap_resource(dev, res_base);
1434
1435         if (!dwc_otg_device->os_dep.base) {
1436                 dev_err(&_dev->dev, "ioremap() failed\n");
1437                 DWC_FREE(dwc_otg_device);
1438                 retval = -ENOMEM;
1439                 goto clk_disable;
1440         }
1441         dev_dbg(&_dev->dev, "base=0x%08x\n",
1442                 (unsigned)dwc_otg_device->os_dep.base);
1443
1444         /*
1445          * Initialize driver data to point to the global DWC_otg
1446          * Device structure.
1447          */
1448
1449         g_otgdev = dwc_otg_device;
1450         pldata->privdata = dwc_otg_device;
1451         dwc_otg_device->pldata = pldata;
1452
1453         dwc_set_device_platform_data(_dev, dwc_otg_device);
1454
1455         dev_dbg(&_dev->dev, "dwc_otg_device=0x%p\n", dwc_otg_device);
1456
1457         dwc_otg_device->core_if = dwc_otg_cil_init(dwc_otg_device->os_dep.base);
1458         if (!dwc_otg_device->core_if) {
1459                 dev_err(&_dev->dev, "CIL initialization failed!\n");
1460                 retval = -ENOMEM;
1461                 goto fail;
1462         }
1463
1464         dwc_otg_device->core_if->otg_dev = dwc_otg_device;
1465         /*
1466          * Attempt to ensure this device is really a DWC_otg Controller.
1467          * Read and verify the SNPSID register contents. The value should be
1468          * 0x45F42XXX or 0x45F42XXX, which corresponds to either "OT2" or "OTG3",
1469          * as in "OTG version 2.XX" or "OTG version 3.XX".
1470          */
1471
1472         if (((dwc_otg_get_gsnpsid(dwc_otg_device->core_if) & 0xFFFFF000) !=
1473              0x4F542000)
1474             && ((dwc_otg_get_gsnpsid(dwc_otg_device->core_if) & 0xFFFFF000) !=
1475                 0x4F543000)) {
1476                 dev_err(&_dev->dev, "Bad value for SNPSID: 0x%08x\n",
1477                         dwc_otg_get_gsnpsid(dwc_otg_device->core_if));
1478                 retval = -EINVAL;
1479                 goto fail;
1480         }
1481
1482         /*
1483          * Validate parameter values.
1484          */
1485         if (set_parameters(dwc_otg_device->core_if, dwc_otg_module_params)) {
1486                 retval = -EINVAL;
1487                 goto fail;
1488         }
1489
1490         /*
1491          * Create Device Attributes in sysfs
1492          */
1493         dwc_otg_attr_create(_dev);
1494
1495         /*
1496          * Disable the global interrupt until all the interrupt
1497          * handlers are installed.
1498          */
1499         dwc_otg_disable_global_interrupts(dwc_otg_device->core_if);
1500
1501         /*
1502          * Install the interrupt handler for the common interrupts before
1503          * enabling common interrupts in core_init below.
1504          */
1505         irq = platform_get_irq(_dev, 0);
1506         DWC_DEBUGPL(DBG_CIL, "registering (common) handler for irq%d\n", irq);
1507         retval = request_irq(irq, dwc_otg_common_irq,
1508                              IRQF_SHARED, "dwc_otg", dwc_otg_device);
1509         if (retval) {
1510                 DWC_ERROR("request of irq%d failed\n", irq);
1511                 retval = -EBUSY;
1512                 goto fail;
1513         } else {
1514                 dwc_otg_device->common_irq_installed = 1;
1515         }
1516
1517         /*
1518          * Initialize the DWC_otg core.
1519          * In order to reduce the time of initialization,
1520          * we do core soft reset after connection detected.
1521          */
1522         dwc_otg_core_init_no_reset(dwc_otg_device->core_if);
1523
1524         /* set otg mode
1525          * 0 - USB_MODE_NORMAL
1526          * 1 - USB_MODE_FORCE_HOST
1527          * 2 - USB_MODE_FORCE_DEVICE
1528          */
1529         of_property_read_u32(node, "rockchip,usb-mode", &val);
1530         dwc_otg_device->core_if->usb_mode = val;
1531
1532 #ifndef DWC_HOST_ONLY
1533         /*
1534          * Initialize the PCD
1535          */
1536         retval = pcd_init(_dev);
1537         if (retval != 0) {
1538                 DWC_ERROR("pcd_init failed\n");
1539                 dwc_otg_device->pcd = NULL;
1540                 goto fail;
1541         }
1542 #endif
1543 #ifndef DWC_DEVICE_ONLY
1544         /*
1545          * Initialize the HCD
1546          */
1547         retval = otg20_hcd_init(_dev);
1548         if (retval != 0) {
1549                 DWC_ERROR("hcd_init failed\n");
1550                 dwc_otg_device->hcd = NULL;
1551                 goto fail;
1552         }
1553 #endif
1554         /*
1555          * Enable the global interrupt after all the interrupt
1556          * handlers are installed if there is no ADP support else
1557          * perform initial actions required for Internal ADP logic.
1558          */
1559         if (!dwc_otg_get_param_adp_enable(dwc_otg_device->core_if)) {
1560                 if (pldata->phy_status == USB_PHY_ENABLED) {
1561                         pldata->phy_suspend(pldata, USB_PHY_SUSPEND);
1562                         udelay(3);
1563                         pldata->clock_enable(pldata, 0);
1564                 }
1565                 /* dwc_otg_enable_global_interrupts(dwc_otg_device->core_if); */
1566         } else
1567                 dwc_otg_adp_start(dwc_otg_device->core_if,
1568                                   dwc_otg_is_host_mode(dwc_otg_device->
1569                                                        core_if));
1570
1571         return 0;
1572
1573 fail:
1574         otg20_driver_remove(_dev);
1575
1576 clk_disable:
1577         if (pldata->clock_enable)
1578                 pldata->clock_enable(pldata, 0);
1579
1580         return retval;
1581 }
1582
1583 static struct platform_driver dwc_otg_driver = {
1584         .driver = {
1585                    .name = (char *)dwc_otg20_driver_name,
1586                    .of_match_table = of_match_ptr(usb20_otg_of_match),
1587                    },
1588         .probe = otg20_driver_probe,
1589         .remove = otg20_driver_remove,
1590         .suspend = dwc_otg_driver_suspend,
1591         .resume = dwc_otg_driver_resume,
1592         .shutdown = dwc_otg_driver_shutdown,
1593 };
1594 #endif
1595
1596 void rk_usb_power_up(void)
1597 {
1598         struct dwc_otg_platform_data *pldata_otg;
1599         struct dwc_otg_platform_data *pldata_host;
1600         struct rkehci_platform_data *pldata_ehci;
1601
1602         if (cpu_is_rk3288()) {
1603 #ifdef CONFIG_RK_USB_UART
1604                 /* enable USB bypass UART function  */
1605                 writel_relaxed(0x00c00000 | usb_to_uart_status,
1606                                RK_GRF_VIRT + RK3288_GRF_UOC0_CON3);
1607
1608 #endif
1609                 /* unset siddq,the analog blocks are powered up */
1610 #ifdef CONFIG_USB20_OTG
1611                 pldata_otg = &usb20otg_pdata_rk3288;
1612                 if (pldata_otg) {
1613                         if (pldata_otg->phy_status == USB_PHY_SUSPEND)
1614                                 writel_relaxed((0x01 << 13) << 16,
1615                                                RK_GRF_VIRT +
1616                                                RK3288_GRF_UOC0_CON0);
1617                 }
1618 #endif
1619 #ifdef CONFIG_USB20_HOST
1620                 pldata_host = &usb20host_pdata_rk3288;
1621                 if (pldata_host) {
1622                         if (pldata_host->phy_status == USB_PHY_SUSPEND)
1623                                 writel_relaxed((0x01 << 13) << 16,
1624                                                RK_GRF_VIRT +
1625                                                RK3288_GRF_UOC2_CON0);
1626                 }
1627 #endif
1628 #ifdef CONFIG_USB_EHCI_RK
1629                 pldata_ehci = &rkehci_pdata_rk3288;
1630                 if (pldata_ehci) {
1631                         if (pldata_ehci->phy_status == USB_PHY_SUSPEND)
1632                                 writel_relaxed((0x01 << 13) << 16,
1633                                                RK_GRF_VIRT +
1634                                                RK3288_GRF_UOC1_CON0);
1635                 }
1636 #endif
1637
1638         }
1639 }
1640
1641 void rk_usb_power_down(void)
1642 {
1643         struct dwc_otg_platform_data *pldata_otg;
1644         struct dwc_otg_platform_data *pldata_host;
1645         struct rkehci_platform_data *pldata_ehci;
1646
1647         if (cpu_is_rk3288()) {
1648 #ifdef CONFIG_RK_USB_UART
1649                 /* disable USB bypass UART function */
1650                 usb_to_uart_status =
1651                     readl_relaxed(RK_GRF_VIRT + RK3288_GRF_UOC0_CON3);
1652                 writel_relaxed(0x00c00000, RK_GRF_VIRT + RK3288_GRF_UOC0_CON3);
1653 #endif
1654                 /* set siddq,the analog blocks are powered down
1655                  * note:
1656                  * 1. Before asserting SIDDQ, ensure that VDATSRCENB0,
1657                  * VDATDETENB0, DCDENB0, BYPASSSEL0, ADPPRBENB0,
1658                  * and TESTBURNIN are set to 1'b0.
1659                  * 2. Before asserting SIDDQ, ensure that phy enter suspend.*/
1660 #ifdef CONFIG_USB20_OTG
1661                 pldata_otg = &usb20otg_pdata_rk3288;
1662                 if (pldata_otg) {
1663                         if (pldata_otg->phy_status == USB_PHY_SUSPEND)
1664                                 writel_relaxed((0x01 << 13) |
1665                                                ((0x01 << 13) << 16),
1666                                                RK_GRF_VIRT +
1667                                                RK3288_GRF_UOC0_CON0);
1668                 }
1669 #endif
1670 #ifdef CONFIG_USB20_HOST
1671                 pldata_host = &usb20host_pdata_rk3288;
1672                 if (pldata_host) {
1673                         if (pldata_host->phy_status == USB_PHY_SUSPEND)
1674                                 writel_relaxed((0x01 << 13) |
1675                                                ((0x01 << 13) << 16),
1676                                                RK_GRF_VIRT +
1677                                                RK3288_GRF_UOC2_CON0);
1678                 }
1679 #endif
1680 #ifdef CONFIG_USB_EHCI_RK
1681                 pldata_ehci = &rkehci_pdata_rk3288;
1682                 if (pldata_ehci) {
1683                         if (pldata_ehci->phy_status == USB_PHY_SUSPEND)
1684                                 writel_relaxed((0x01 << 13) |
1685                                                ((0x01 << 13) << 16),
1686                                                RK_GRF_VIRT +
1687                                                RK3288_GRF_UOC1_CON0);
1688                 }
1689 #endif
1690         }
1691 }
1692
1693 EXPORT_SYMBOL(rk_usb_power_up);
1694 EXPORT_SYMBOL(rk_usb_power_down);
1695 /**
1696  * This function is called when the dwc_otg_driver is installed with the
1697  * insmod command. It registers the dwc_otg_driver structure with the
1698  * appropriate bus driver. This will cause the dwc_otg_driver_probe function
1699  * to be called. In addition, the bus driver will automatically expose
1700  * attributes defined for the device and driver in the special sysfs file
1701  * system.
1702  *
1703  * @return
1704  */
1705 static int __init dwc_otg_driver_init(void)
1706 {
1707         int retval = 0;
1708         int error;
1709
1710 #ifdef CONFIG_USB20_OTG
1711         /* register otg20 */
1712         printk(KERN_INFO "%s: version %s\n", dwc_otg20_driver_name,
1713                DWC_DRIVER_VERSION);
1714
1715         retval = platform_driver_register(&dwc_otg_driver);
1716         if (retval < 0) {
1717                 printk(KERN_ERR "%s retval=%d\n", __func__, retval);
1718                 return retval;
1719         }
1720
1721         error =
1722             driver_create_file(&dwc_otg_driver.driver, &driver_attr_version);
1723         error =
1724             driver_create_file(&dwc_otg_driver.driver, &driver_attr_debuglevel);
1725         error =
1726             driver_create_file(&dwc_otg_driver.driver,
1727                                &driver_attr_dwc_otg_conn_en);
1728         error =
1729             driver_create_file(&dwc_otg_driver.driver,
1730                                &driver_attr_vbus_status);
1731         error =
1732             driver_create_file(&dwc_otg_driver.driver,
1733                                &driver_attr_force_usb_mode);
1734         error =
1735             driver_create_file(&dwc_otg_driver.driver,
1736                                &driver_attr_op_state);
1737
1738 #endif
1739
1740         /* register host20 */
1741 #ifdef CONFIG_USB20_HOST
1742         printk(KERN_INFO "%s: version %s\n", dwc_host20_driver_name,
1743                DWC_DRIVER_VERSION);
1744
1745         retval = platform_driver_register(&dwc_host_driver);
1746         if (retval < 0) {
1747                 printk(KERN_ERR "%s retval=%d\n", __func__, retval);
1748                 return retval;
1749         }
1750
1751         error =
1752             driver_create_file(&dwc_host_driver.driver, &driver_attr_version);
1753         error =
1754             driver_create_file(&dwc_host_driver.driver,
1755                                &driver_attr_debuglevel);
1756 #endif
1757         return retval;
1758 }
1759
1760 module_init(dwc_otg_driver_init);
1761
1762 /**
1763  * This function is called when the driver is removed from the kernel
1764  * with the rmmod command. The driver unregisters itself with its bus
1765  * driver.
1766  *
1767  */
1768 static void __exit dwc_otg_driver_cleanup(void)
1769 {
1770         printk(KERN_DEBUG "dwc_otg_driver_cleanup()\n");
1771
1772 #ifdef CONFIG_USB20_HOST
1773         /*for host20 */
1774         driver_remove_file(&dwc_host_driver.driver, &driver_attr_debuglevel);
1775         driver_remove_file(&dwc_host_driver.driver, &driver_attr_version);
1776         platform_driver_unregister(&dwc_host_driver);
1777         printk(KERN_INFO "%s module removed\n", dwc_host20_driver_name);
1778 #endif
1779
1780 #ifdef CONFIG_USB20_OTG
1781         /*for otg */
1782         driver_remove_file(&dwc_otg_driver.driver,
1783                            &driver_attr_dwc_otg_conn_en);
1784         driver_remove_file(&dwc_otg_driver.driver, &driver_attr_debuglevel);
1785         driver_remove_file(&dwc_otg_driver.driver, &driver_attr_version);
1786         driver_remove_file(&dwc_otg_driver.driver, &driver_attr_vbus_status);
1787         driver_remove_file(&dwc_otg_driver.driver, &driver_attr_force_usb_mode);
1788         driver_remove_file(&dwc_otg_driver.driver, &driver_attr_op_state);
1789         platform_driver_unregister(&dwc_otg_driver);
1790         printk(KERN_INFO "%s module removed\n", dwc_otg20_driver_name);
1791 #endif
1792 }
1793
1794 module_exit(dwc_otg_driver_cleanup);
1795
1796 MODULE_DESCRIPTION(DWC_DRIVER_DESC);
1797 MODULE_AUTHOR("Synopsys Inc.");
1798 MODULE_LICENSE("GPL");
1799
1800 module_param_named(otg_cap, dwc_otg_module_params.otg_cap, int, 0444);
1801 MODULE_PARM_DESC(otg_cap, "OTG Capabilities 0=HNP&SRP 1=SRP Only 2=None");
1802 module_param_named(opt, dwc_otg_module_params.opt, int, 0444);
1803 MODULE_PARM_DESC(opt, "OPT Mode");
1804 module_param_named(dma_enable, dwc_otg_module_params.dma_enable, int, 0444);
1805 MODULE_PARM_DESC(dma_enable, "DMA Mode 0=Slave 1=DMA enabled");
1806
1807 module_param_named(dma_desc_enable, dwc_otg_module_params.dma_desc_enable, int,
1808                    0444);
1809 MODULE_PARM_DESC(dma_desc_enable,
1810                  "DMA Desc Mode 0=Address DMA 1=DMA Descriptor enabled");
1811
1812 module_param_named(dma_burst_size, dwc_otg_module_params.dma_burst_size, int,
1813                    0444);
1814 MODULE_PARM_DESC(dma_burst_size,
1815                  "DMA Burst Size 1, 4, 8, 16, 32, 64, 128, 256");
1816 module_param_named(speed, dwc_otg_module_params.speed, int, 0444);
1817 MODULE_PARM_DESC(speed, "Speed 0=High Speed 1=Full Speed");
1818 module_param_named(host_support_fs_ls_low_power,
1819                    dwc_otg_module_params.host_support_fs_ls_low_power, int,
1820                    0444);
1821 MODULE_PARM_DESC(host_support_fs_ls_low_power,
1822                  "Support Low Power w/FS or LS 0=Support 1=Don't Support");
1823 module_param_named(host_ls_low_power_phy_clk,
1824                    dwc_otg_module_params.host_ls_low_power_phy_clk, int, 0444);
1825 MODULE_PARM_DESC(host_ls_low_power_phy_clk,
1826                  "Low Speed Low Power Clock 0=48Mhz 1=6Mhz");
1827 module_param_named(enable_dynamic_fifo,
1828                    dwc_otg_module_params.enable_dynamic_fifo, int, 0444);
1829 MODULE_PARM_DESC(enable_dynamic_fifo, "0=cC Setting 1=Allow Dynamic Sizing");
1830 module_param_named(data_fifo_size, dwc_otg_module_params.data_fifo_size, int,
1831                    0444);
1832 MODULE_PARM_DESC(data_fifo_size,
1833                  "Total number of words in the data FIFO memory 32-32768");
1834 module_param_named(dev_rx_fifo_size, dwc_otg_module_params.dev_rx_fifo_size,
1835                    int, 0444);
1836 MODULE_PARM_DESC(dev_rx_fifo_size, "Number of words in the Rx FIFO 16-32768");
1837 module_param_named(dev_nperio_tx_fifo_size,
1838                    dwc_otg_module_params.dev_nperio_tx_fifo_size, int, 0444);
1839 MODULE_PARM_DESC(dev_nperio_tx_fifo_size,
1840                  "Number of words in the non-periodic Tx FIFO 16-32768");
1841 module_param_named(dev_perio_tx_fifo_size_1,
1842                    dwc_otg_module_params.dev_perio_tx_fifo_size[0], int, 0444);
1843 MODULE_PARM_DESC(dev_perio_tx_fifo_size_1,
1844                  "Number of words in the periodic Tx FIFO 4-768");
1845 module_param_named(dev_perio_tx_fifo_size_2,
1846                    dwc_otg_module_params.dev_perio_tx_fifo_size[1], int, 0444);
1847 MODULE_PARM_DESC(dev_perio_tx_fifo_size_2,
1848                  "Number of words in the periodic Tx FIFO 4-768");
1849 module_param_named(dev_perio_tx_fifo_size_3,
1850                    dwc_otg_module_params.dev_perio_tx_fifo_size[2], int, 0444);
1851 MODULE_PARM_DESC(dev_perio_tx_fifo_size_3,
1852                  "Number of words in the periodic Tx FIFO 4-768");
1853 module_param_named(dev_perio_tx_fifo_size_4,
1854                    dwc_otg_module_params.dev_perio_tx_fifo_size[3], int, 0444);
1855 MODULE_PARM_DESC(dev_perio_tx_fifo_size_4,
1856                  "Number of words in the periodic Tx FIFO 4-768");
1857 module_param_named(dev_perio_tx_fifo_size_5,
1858                    dwc_otg_module_params.dev_perio_tx_fifo_size[4], int, 0444);
1859 MODULE_PARM_DESC(dev_perio_tx_fifo_size_5,
1860                  "Number of words in the periodic Tx FIFO 4-768");
1861 module_param_named(dev_perio_tx_fifo_size_6,
1862                    dwc_otg_module_params.dev_perio_tx_fifo_size[5], int, 0444);
1863 MODULE_PARM_DESC(dev_perio_tx_fifo_size_6,
1864                  "Number of words in the periodic Tx FIFO 4-768");
1865 module_param_named(dev_perio_tx_fifo_size_7,
1866                    dwc_otg_module_params.dev_perio_tx_fifo_size[6], int, 0444);
1867 MODULE_PARM_DESC(dev_perio_tx_fifo_size_7,
1868                  "Number of words in the periodic Tx FIFO 4-768");
1869 module_param_named(dev_perio_tx_fifo_size_8,
1870                    dwc_otg_module_params.dev_perio_tx_fifo_size[7], int, 0444);
1871 MODULE_PARM_DESC(dev_perio_tx_fifo_size_8,
1872                  "Number of words in the periodic Tx FIFO 4-768");
1873 module_param_named(dev_perio_tx_fifo_size_9,
1874                    dwc_otg_module_params.dev_perio_tx_fifo_size[8], int, 0444);
1875 MODULE_PARM_DESC(dev_perio_tx_fifo_size_9,
1876                  "Number of words in the periodic Tx FIFO 4-768");
1877 module_param_named(dev_perio_tx_fifo_size_10,
1878                    dwc_otg_module_params.dev_perio_tx_fifo_size[9], int, 0444);
1879 MODULE_PARM_DESC(dev_perio_tx_fifo_size_10,
1880                  "Number of words in the periodic Tx FIFO 4-768");
1881 module_param_named(dev_perio_tx_fifo_size_11,
1882                    dwc_otg_module_params.dev_perio_tx_fifo_size[10], int, 0444);
1883 MODULE_PARM_DESC(dev_perio_tx_fifo_size_11,
1884                  "Number of words in the periodic Tx FIFO 4-768");
1885 module_param_named(dev_perio_tx_fifo_size_12,
1886                    dwc_otg_module_params.dev_perio_tx_fifo_size[11], int, 0444);
1887 MODULE_PARM_DESC(dev_perio_tx_fifo_size_12,
1888                  "Number of words in the periodic Tx FIFO 4-768");
1889 module_param_named(dev_perio_tx_fifo_size_13,
1890                    dwc_otg_module_params.dev_perio_tx_fifo_size[12], int, 0444);
1891 MODULE_PARM_DESC(dev_perio_tx_fifo_size_13,
1892                  "Number of words in the periodic Tx FIFO 4-768");
1893 module_param_named(dev_perio_tx_fifo_size_14,
1894                    dwc_otg_module_params.dev_perio_tx_fifo_size[13], int, 0444);
1895 MODULE_PARM_DESC(dev_perio_tx_fifo_size_14,
1896                  "Number of words in the periodic Tx FIFO 4-768");
1897 module_param_named(dev_perio_tx_fifo_size_15,
1898                    dwc_otg_module_params.dev_perio_tx_fifo_size[14], int, 0444);
1899 MODULE_PARM_DESC(dev_perio_tx_fifo_size_15,
1900                  "Number of words in the periodic Tx FIFO 4-768");
1901 module_param_named(host_rx_fifo_size, dwc_otg_module_params.host_rx_fifo_size,
1902                    int, 0444);
1903 MODULE_PARM_DESC(host_rx_fifo_size, "Number of words in the Rx FIFO 16-32768");
1904 module_param_named(host_nperio_tx_fifo_size,
1905                    dwc_otg_module_params.host_nperio_tx_fifo_size, int, 0444);
1906 MODULE_PARM_DESC(host_nperio_tx_fifo_size,
1907                  "Number of words in the non-periodic Tx FIFO 16-32768");
1908 module_param_named(host_perio_tx_fifo_size,
1909                    dwc_otg_module_params.host_perio_tx_fifo_size, int, 0444);
1910 MODULE_PARM_DESC(host_perio_tx_fifo_size,
1911                  "Number of words in the host periodic Tx FIFO 16-32768");
1912 module_param_named(max_transfer_size, dwc_otg_module_params.max_transfer_size,
1913                    int, 0444);
1914 /** @todo Set the max to 512K, modify checks */
1915 MODULE_PARM_DESC(max_transfer_size,
1916                  "The maximum transfer size supported in bytes 2047-65535");
1917 module_param_named(max_packet_count, dwc_otg_module_params.max_packet_count,
1918                    int, 0444);
1919 MODULE_PARM_DESC(max_packet_count,
1920                  "The maximum number of packets in a transfer 15-511");
1921 module_param_named(host_channels, dwc_otg_module_params.host_channels, int,
1922                    0444);
1923 MODULE_PARM_DESC(host_channels,
1924                  "The number of host channel registers to use 1-16");
1925 module_param_named(dev_endpoints, dwc_otg_module_params.dev_endpoints, int,
1926                    0444);
1927 MODULE_PARM_DESC(dev_endpoints,
1928                  "The number of endpoints in addition to EP0 available for device mode 1-15");
1929 module_param_named(phy_type, dwc_otg_module_params.phy_type, int, 0444);
1930 MODULE_PARM_DESC(phy_type, "0=Reserved 1=UTMI+ 2=ULPI");
1931 module_param_named(phy_utmi_width, dwc_otg_module_params.phy_utmi_width, int,
1932                    0444);
1933 MODULE_PARM_DESC(phy_utmi_width, "Specifies the UTMI+ Data Width 8 or 16 bits");
1934 module_param_named(phy_ulpi_ddr, dwc_otg_module_params.phy_ulpi_ddr, int, 0444);
1935 MODULE_PARM_DESC(phy_ulpi_ddr,
1936                  "ULPI at double or single data rate 0=Single 1=Double");
1937 module_param_named(phy_ulpi_ext_vbus, dwc_otg_module_params.phy_ulpi_ext_vbus,
1938                    int, 0444);
1939 MODULE_PARM_DESC(phy_ulpi_ext_vbus,
1940                  "ULPI PHY using internal or external vbus 0=Internal");
1941 module_param_named(i2c_enable, dwc_otg_module_params.i2c_enable, int, 0444);
1942 MODULE_PARM_DESC(i2c_enable, "FS PHY Interface");
1943 module_param_named(ulpi_fs_ls, dwc_otg_module_params.ulpi_fs_ls, int, 0444);
1944 MODULE_PARM_DESC(ulpi_fs_ls, "ULPI PHY FS/LS mode only");
1945 module_param_named(ts_dline, dwc_otg_module_params.ts_dline, int, 0444);
1946 MODULE_PARM_DESC(ts_dline, "Term select Dline pulsing for all PHYs");
1947 module_param_named(debug, g_dbg_lvl, int, 0444);
1948 MODULE_PARM_DESC(debug, "");
1949
1950 module_param_named(en_multiple_tx_fifo,
1951                    dwc_otg_module_params.en_multiple_tx_fifo, int, 0444);
1952 MODULE_PARM_DESC(en_multiple_tx_fifo,
1953                  "Dedicated Non Periodic Tx FIFOs 0=disabled 1=enabled");
1954 module_param_named(dev_tx_fifo_size_1,
1955                    dwc_otg_module_params.dev_tx_fifo_size[0], int, 0444);
1956 MODULE_PARM_DESC(dev_tx_fifo_size_1, "Number of words in the Tx FIFO 4-768");
1957 module_param_named(dev_tx_fifo_size_2,
1958                    dwc_otg_module_params.dev_tx_fifo_size[1], int, 0444);
1959 MODULE_PARM_DESC(dev_tx_fifo_size_2, "Number of words in the Tx FIFO 4-768");
1960 module_param_named(dev_tx_fifo_size_3,
1961                    dwc_otg_module_params.dev_tx_fifo_size[2], int, 0444);
1962 MODULE_PARM_DESC(dev_tx_fifo_size_3, "Number of words in the Tx FIFO 4-768");
1963 module_param_named(dev_tx_fifo_size_4,
1964                    dwc_otg_module_params.dev_tx_fifo_size[3], int, 0444);
1965 MODULE_PARM_DESC(dev_tx_fifo_size_4, "Number of words in the Tx FIFO 4-768");
1966 module_param_named(dev_tx_fifo_size_5,
1967                    dwc_otg_module_params.dev_tx_fifo_size[4], int, 0444);
1968 MODULE_PARM_DESC(dev_tx_fifo_size_5, "Number of words in the Tx FIFO 4-768");
1969 module_param_named(dev_tx_fifo_size_6,
1970                    dwc_otg_module_params.dev_tx_fifo_size[5], int, 0444);
1971 MODULE_PARM_DESC(dev_tx_fifo_size_6, "Number of words in the Tx FIFO 4-768");
1972 module_param_named(dev_tx_fifo_size_7,
1973                    dwc_otg_module_params.dev_tx_fifo_size[6], int, 0444);
1974 MODULE_PARM_DESC(dev_tx_fifo_size_7, "Number of words in the Tx FIFO 4-768");
1975 module_param_named(dev_tx_fifo_size_8,
1976                    dwc_otg_module_params.dev_tx_fifo_size[7], int, 0444);
1977 MODULE_PARM_DESC(dev_tx_fifo_size_8, "Number of words in the Tx FIFO 4-768");
1978 module_param_named(dev_tx_fifo_size_9,
1979                    dwc_otg_module_params.dev_tx_fifo_size[8], int, 0444);
1980 MODULE_PARM_DESC(dev_tx_fifo_size_9, "Number of words in the Tx FIFO 4-768");
1981 module_param_named(dev_tx_fifo_size_10,
1982                    dwc_otg_module_params.dev_tx_fifo_size[9], int, 0444);
1983 MODULE_PARM_DESC(dev_tx_fifo_size_10, "Number of words in the Tx FIFO 4-768");
1984 module_param_named(dev_tx_fifo_size_11,
1985                    dwc_otg_module_params.dev_tx_fifo_size[10], int, 0444);
1986 MODULE_PARM_DESC(dev_tx_fifo_size_11, "Number of words in the Tx FIFO 4-768");
1987 module_param_named(dev_tx_fifo_size_12,
1988                    dwc_otg_module_params.dev_tx_fifo_size[11], int, 0444);
1989 MODULE_PARM_DESC(dev_tx_fifo_size_12, "Number of words in the Tx FIFO 4-768");
1990 module_param_named(dev_tx_fifo_size_13,
1991                    dwc_otg_module_params.dev_tx_fifo_size[12], int, 0444);
1992 MODULE_PARM_DESC(dev_tx_fifo_size_13, "Number of words in the Tx FIFO 4-768");
1993 module_param_named(dev_tx_fifo_size_14,
1994                    dwc_otg_module_params.dev_tx_fifo_size[13], int, 0444);
1995 MODULE_PARM_DESC(dev_tx_fifo_size_14, "Number of words in the Tx FIFO 4-768");
1996 module_param_named(dev_tx_fifo_size_15,
1997                    dwc_otg_module_params.dev_tx_fifo_size[14], int, 0444);
1998 MODULE_PARM_DESC(dev_tx_fifo_size_15, "Number of words in the Tx FIFO 4-768");
1999
2000 module_param_named(thr_ctl, dwc_otg_module_params.thr_ctl, int, 0444);
2001 MODULE_PARM_DESC(thr_ctl,
2002                  "Thresholding enable flag bit 0 - non ISO Tx thr., 1 - ISO Tx thr., 2 - Rx thr.- bit 0=disabled 1=enabled");
2003 module_param_named(tx_thr_length, dwc_otg_module_params.tx_thr_length, int,
2004                    0444);
2005 MODULE_PARM_DESC(tx_thr_length, "Tx Threshold length in 32 bit DWORDs");
2006 module_param_named(rx_thr_length, dwc_otg_module_params.rx_thr_length, int,
2007                    0444);
2008 MODULE_PARM_DESC(rx_thr_length, "Rx Threshold length in 32 bit DWORDs");
2009
2010 module_param_named(pti_enable, dwc_otg_module_params.pti_enable, int, 0444);
2011 module_param_named(mpi_enable, dwc_otg_module_params.mpi_enable, int, 0444);
2012 module_param_named(lpm_enable, dwc_otg_module_params.lpm_enable, int, 0444);
2013 MODULE_PARM_DESC(lpm_enable, "LPM Enable 0=LPM Disabled 1=LPM Enabled");
2014
2015 module_param_named(besl_enable, dwc_otg_module_params.besl_enable, int, 0444);
2016 MODULE_PARM_DESC(besl_enable, "BESL Enable 0=BESL Disabled 1=BESL Enabled");
2017 module_param_named(baseline_besl, dwc_otg_module_params.baseline_besl, int,
2018                    0444);
2019 MODULE_PARM_DESC(baseline_besl, "Set the baseline besl value");
2020 module_param_named(deep_besl, dwc_otg_module_params.deep_besl, int, 0444);
2021 MODULE_PARM_DESC(deep_besl, "Set the deep besl value");
2022
2023 module_param_named(ic_usb_cap, dwc_otg_module_params.ic_usb_cap, int, 0444);
2024 MODULE_PARM_DESC(ic_usb_cap,
2025                  "IC_USB Capability 0=IC_USB Disabled 1=IC_USB Enabled");
2026 module_param_named(ahb_thr_ratio, dwc_otg_module_params.ahb_thr_ratio, int,
2027                    0444);
2028 MODULE_PARM_DESC(ahb_thr_ratio, "AHB Threshold Ratio");
2029 module_param_named(power_down, dwc_otg_module_params.power_down, int, 0444);
2030 MODULE_PARM_DESC(power_down, "Power Down Mode");
2031 module_param_named(reload_ctl, dwc_otg_module_params.reload_ctl, int, 0444);
2032 MODULE_PARM_DESC(reload_ctl, "HFIR Reload Control");
2033 module_param_named(dev_out_nak, dwc_otg_module_params.dev_out_nak, int, 0444);
2034 MODULE_PARM_DESC(dev_out_nak, "Enable Device OUT NAK");
2035 module_param_named(cont_on_bna, dwc_otg_module_params.cont_on_bna, int, 0444);
2036 MODULE_PARM_DESC(cont_on_bna, "Enable Enable Continue on BNA");
2037 module_param_named(ahb_single, dwc_otg_module_params.ahb_single, int, 0444);
2038 MODULE_PARM_DESC(ahb_single, "Enable AHB Single Support");
2039 module_param_named(adp_enable, dwc_otg_module_params.adp_enable, int, 0444);
2040 MODULE_PARM_DESC(adp_enable, "ADP Enable 0=ADP Disabled 1=ADP Enabled");
2041 module_param_named(otg_ver, dwc_otg_module_params.otg_ver, int, 0444);
2042 MODULE_PARM_DESC(otg_ver, "OTG revision supported 0=OTG 1.3 1=OTG 2.0");
2043
2044 /** @page "Module Parameters"
2045  *
2046  * The following parameters may be specified when starting the module.
2047  * These parameters define how the DWC_otg controller should be
2048  * configured. Parameter values are passed to the CIL initialization
2049  * function dwc_otg_cil_init
2050  *
2051  * Example: <code>modprobe dwc_otg speed=1 otg_cap=1</code>
2052  *
2053
2054  <table>
2055  <tr><td>Parameter Name</td><td>Meaning</td></tr>
2056
2057  <tr>
2058  <td>otg_cap</td>
2059  <td>Specifies the OTG capabilities. The driver will automatically detect the
2060  value for this parameter if none is specified.
2061  - 0: HNP and SRP capable (default, if available)
2062  - 1: SRP Only capable
2063  - 2: No HNP/SRP capable
2064  </td></tr>
2065
2066  <tr>
2067  <td>dma_enable</td>
2068  <td>Specifies whether to use slave or DMA mode for accessing the data FIFOs.
2069  The driver will automatically detect the value for this parameter if none is
2070  specified.
2071  - 0: Slave
2072  - 1: DMA (default, if available)
2073  </td></tr>
2074
2075  <tr>
2076  <td>dma_burst_size</td>
2077  <td>The DMA Burst size (applicable only for External DMA Mode).
2078  - Values: 1, 4, 8 16, 32, 64, 128, 256 (default 32)
2079  </td></tr>
2080
2081  <tr>
2082  <td>speed</td>
2083  <td>Specifies the maximum speed of operation in host and device mode. The
2084  actual speed depends on the speed of the attached device and the value of
2085  phy_type.
2086  - 0: High Speed (default)
2087  - 1: Full Speed
2088  </td></tr>
2089
2090  <tr>
2091  <td>host_support_fs_ls_low_power</td>
2092  <td>Specifies whether low power mode is supported when attached to a Full
2093  Speed or Low Speed device in host mode.
2094  - 0: Don't support low power mode (default)
2095  - 1: Support low power mode
2096  </td></tr>
2097
2098  <tr>
2099  <td>host_ls_low_power_phy_clk</td>
2100  <td>Specifies the PHY clock rate in low power mode when connected to a Low
2101  Speed device in host mode. This parameter is applicable only if
2102  HOST_SUPPORT_FS_LS_LOW_POWER is enabled.
2103  - 0: 48 MHz (default)
2104  - 1: 6 MHz
2105  </td></tr>
2106
2107  <tr>
2108  <td>enable_dynamic_fifo</td>
2109  <td> Specifies whether FIFOs may be resized by the driver software.
2110  - 0: Use cC FIFO size parameters
2111  - 1: Allow dynamic FIFO sizing (default)
2112  </td></tr>
2113
2114  <tr>
2115  <td>data_fifo_size</td>
2116  <td>Total number of 4-byte words in the data FIFO memory. This memory
2117  includes the Rx FIFO, non-periodic Tx FIFO, and periodic Tx FIFOs.
2118  - Values: 32 to 32768 (default 8192)
2119
2120  Note: The total FIFO memory depth in the FPGA configuration is 8192.
2121  </td></tr>
2122
2123  <tr>
2124  <td>dev_rx_fifo_size</td>
2125  <td>Number of 4-byte words in the Rx FIFO in device mode when dynamic
2126  FIFO sizing is enabled.
2127  - Values: 16 to 32768 (default 1064)
2128  </td></tr>
2129
2130  <tr>
2131  <td>dev_nperio_tx_fifo_size</td>
2132  <td>Number of 4-byte words in the non-periodic Tx FIFO in device mode when
2133  dynamic FIFO sizing is enabled.
2134  - Values: 16 to 32768 (default 1024)
2135  </td></tr>
2136
2137  <tr>
2138  <td>dev_perio_tx_fifo_size_n (n = 1 to 15)</td>
2139  <td>Number of 4-byte words in each of the periodic Tx FIFOs in device mode
2140  when dynamic FIFO sizing is enabled.
2141  - Values: 4 to 768 (default 256)
2142  </td></tr>
2143
2144  <tr>
2145  <td>host_rx_fifo_size</td>
2146  <td>Number of 4-byte words in the Rx FIFO in host mode when dynamic FIFO
2147  sizing is enabled.
2148  - Values: 16 to 32768 (default 1024)
2149  </td></tr>
2150
2151  <tr>
2152  <td>host_nperio_tx_fifo_size</td>
2153  <td>Number of 4-byte words in the non-periodic Tx FIFO in host mode when
2154  dynamic FIFO sizing is enabled in the core.
2155  - Values: 16 to 32768 (default 1024)
2156  </td></tr>
2157
2158  <tr>
2159  <td>host_perio_tx_fifo_size</td>
2160  <td>Number of 4-byte words in the host periodic Tx FIFO when dynamic FIFO
2161  sizing is enabled.
2162  - Values: 16 to 32768 (default 1024)
2163  </td></tr>
2164
2165  <tr>
2166  <td>max_transfer_size</td>
2167  <td>The maximum transfer size supported in bytes.
2168  - Values: 2047 to 65,535 (default 65,535)
2169  </td></tr>
2170
2171  <tr>
2172  <td>max_packet_count</td>
2173  <td>The maximum number of packets in a transfer.
2174  - Values: 15 to 511 (default 511)
2175  </td></tr>
2176
2177  <tr>
2178  <td>host_channels</td>
2179  <td>The number of host channel registers to use.
2180  - Values: 1 to 16 (default 12)
2181
2182  Note: The FPGA configuration supports a maximum of 12 host channels.
2183  </td></tr>
2184
2185  <tr>
2186  <td>dev_endpoints</td>
2187  <td>The number of endpoints in addition to EP0 available for device mode
2188  operations.
2189  - Values: 1 to 15 (default 6 IN and OUT)
2190
2191  Note: The FPGA configuration supports a maximum of 6 IN and OUT endpoints in
2192  addition to EP0.
2193  </td></tr>
2194
2195  <tr>
2196  <td>phy_type</td>
2197  <td>Specifies the type of PHY interface to use. By default, the driver will
2198  automatically detect the phy_type.
2199  - 0: Full Speed
2200  - 1: UTMI+ (default, if available)
2201  - 2: ULPI
2202  </td></tr>
2203
2204  <tr>
2205  <td>phy_utmi_width</td>
2206  <td>Specifies the UTMI+ Data Width. This parameter is applicable for a
2207  phy_type of UTMI+. Also, this parameter is applicable only if the
2208  OTG_HSPHY_WIDTH cC parameter was set to "8 and 16 bits", meaning that the
2209  core has been configured to work at either data path width.
2210  - Values: 8 or 16 bits (default 16)
2211  </td></tr>
2212
2213  <tr>
2214  <td>phy_ulpi_ddr</td>
2215  <td>Specifies whether the ULPI operates at double or single data rate. This
2216  parameter is only applicable if phy_type is ULPI.
2217  - 0: single data rate ULPI interface with 8 bit wide data bus (default)
2218  - 1: double data rate ULPI interface with 4 bit wide data bus
2219  </td></tr>
2220
2221  <tr>
2222  <td>i2c_enable</td>
2223  <td>Specifies whether to use the I2C interface for full speed PHY. This
2224  parameter is only applicable if PHY_TYPE is FS.
2225  - 0: Disabled (default)
2226  - 1: Enabled
2227  </td></tr>
2228
2229  <tr>
2230  <td>ulpi_fs_ls</td>
2231  <td>Specifies whether to use ULPI FS/LS mode only.
2232  - 0: Disabled (default)
2233  - 1: Enabled
2234  </td></tr>
2235
2236  <tr>
2237  <td>ts_dline</td>
2238  <td>Specifies whether term select D-Line pulsing for all PHYs is enabled.
2239  - 0: Disabled (default)
2240  - 1: Enabled
2241  </td></tr>
2242
2243  <tr>
2244  <td>en_multiple_tx_fifo</td>
2245  <td>Specifies whether dedicatedto tx fifos are enabled for non periodic IN EPs.
2246  The driver will automatically detect the value for this parameter if none is
2247  specified.
2248  - 0: Disabled
2249  - 1: Enabled (default, if available)
2250  </td></tr>
2251
2252  <tr>
2253  <td>dev_tx_fifo_size_n (n = 1 to 15)</td>
2254  <td>Number of 4-byte words in each of the Tx FIFOs in device mode
2255  when dynamic FIFO sizing is enabled.
2256  - Values: 4 to 768 (default 256)
2257  </td></tr>
2258
2259  <tr>
2260  <td>tx_thr_length</td>
2261  <td>Transmit Threshold length in 32 bit double words
2262  - Values: 8 to 128 (default 64)
2263  </td></tr>
2264
2265  <tr>
2266  <td>rx_thr_length</td>
2267  <td>Receive Threshold length in 32 bit double words
2268  - Values: 8 to 128 (default 64)
2269  </td></tr>
2270
2271 <tr>
2272  <td>thr_ctl</td>
2273  <td>Specifies whether to enable Thresholding for Device mode. Bits 0, 1, 2 of
2274  this parmater specifies if thresholding is enabled for non-Iso Tx, Iso Tx and
2275  Rx transfers accordingly.
2276  The driver will automatically detect the value for this parameter if none is
2277  specified.
2278  - Values: 0 to 7 (default 0)
2279  Bit values indicate:
2280  - 0: Thresholding disabled
2281  - 1: Thresholding enabled
2282  </td></tr>
2283
2284 <tr>
2285  <td>dma_desc_enable</td>
2286  <td>Specifies whether to enable Descriptor DMA mode.
2287  The driver will automatically detect the value for this parameter if none is
2288  specified.
2289  - 0: Descriptor DMA disabled
2290  - 1: Descriptor DMA (default, if available)
2291  </td></tr>
2292
2293 <tr>
2294  <td>mpi_enable</td>
2295  <td>Specifies whether to enable MPI enhancement mode.
2296  The driver will automatically detect the value for this parameter if none is
2297  specified.
2298  - 0: MPI disabled (default)
2299  - 1: MPI enable
2300  </td></tr>
2301
2302 <tr>
2303  <td>pti_enable</td>
2304  <td>Specifies whether to enable PTI enhancement support.
2305  The driver will automatically detect the value for this parameter if none is
2306  specified.
2307  - 0: PTI disabled (default)
2308  - 1: PTI enable
2309  </td></tr>
2310
2311 <tr>
2312  <td>lpm_enable</td>
2313  <td>Specifies whether to enable LPM support.
2314  The driver will automatically detect the value for this parameter if none is
2315  specified.
2316  - 0: LPM disabled
2317  - 1: LPM enable (default, if available)
2318  </td></tr>
2319
2320  <tr>
2321  <td>besl_enable</td>
2322  <td>Specifies whether to enable LPM Errata support.
2323  The driver will automatically detect the value for this parameter if none is
2324  specified.
2325  - 0: LPM Errata disabled (default)
2326  - 1: LPM Errata enable
2327  </td></tr>
2328
2329   <tr>
2330  <td>baseline_besl</td>
2331  <td>Specifies the baseline besl value.
2332  - Values: 0 to 15 (default 0)
2333  </td></tr>
2334
2335   <tr>
2336  <td>deep_besl</td>
2337  <td>Specifies the deep besl value.
2338  - Values: 0 to 15 (default 15)
2339  </td></tr>
2340
2341 <tr>
2342  <td>ic_usb_cap</td>
2343  <td>Specifies whether to enable IC_USB capability.
2344  The driver will automatically detect the value for this parameter if none is
2345  specified.
2346  - 0: IC_USB disabled (default, if available)
2347  - 1: IC_USB enable
2348  </td></tr>
2349
2350 <tr>
2351  <td>ahb_thr_ratio</td>
2352  <td>Specifies AHB Threshold ratio.
2353  - Values: 0 to 3 (default 0)
2354  </td></tr>
2355
2356 <tr>
2357  <td>power_down</td>
2358  <td>Specifies Power Down(Hibernation) Mode.
2359  The driver will automatically detect the value for this parameter if none is
2360  specified.
2361  - 0: Power Down disabled (default)
2362  - 2: Power Down enabled
2363  </td></tr>
2364
2365  <tr>
2366  <td>reload_ctl</td>
2367  <td>Specifies whether dynamic reloading of the HFIR register is allowed during
2368  run time. The driver will automatically detect the value for this parameter if
2369  none is specified. In case the HFIR value is reloaded when HFIR.RldCtrl == 1'b0
2370  the core might misbehave.
2371  - 0: Reload Control disabled (default)
2372  - 1: Reload Control enabled
2373  </td></tr>
2374
2375  <tr>
2376  <td>dev_out_nak</td>
2377  <td>Specifies whether  Device OUT NAK enhancement enabled or no.
2378  The driver will automatically detect the value for this parameter if
2379  none is specified. This parameter is valid only when OTG_EN_DESC_DMA == 1\92b1.
2380  - 0: The core does not set NAK after Bulk OUT transfer complete (default)
2381  - 1: The core sets NAK after Bulk OUT transfer complete
2382  </td></tr>
2383
2384  <tr>
2385  <td>cont_on_bna</td>
2386  <td>Specifies whether Enable Continue on BNA enabled or no.
2387  After receiving BNA interrupt the core disables the endpoint,when the
2388  endpoint is re-enabled by the application the
2389  - 0: Core starts processing from the DOEPDMA descriptor (default)
2390  - 1: Core starts processing from the descriptor which received the BNA.
2391  This parameter is valid only when OTG_EN_DESC_DMA == 1\92b1.
2392  </td></tr>
2393
2394  <tr>
2395  <td>ahb_single</td>
2396  <td>This bit when programmed supports SINGLE transfers for remainder data
2397  in a transfer for DMA mode of operation.
2398  - 0: The remainder data will be sent using INCR burst size (default)
2399  - 1: The remainder data will be sent using SINGLE burst size.
2400  </td></tr>
2401
2402 <tr>
2403  <td>adp_enable</td>
2404  <td>Specifies whether ADP feature is enabled.
2405  The driver will automatically detect the value for this parameter if none is
2406  specified.
2407  - 0: ADP feature disabled (default)
2408  - 1: ADP feature enabled
2409  </td></tr>
2410
2411   <tr>
2412  <td>otg_ver</td>
2413  <td>Specifies whether OTG is performing as USB OTG Revision 2.0 or Revision 1.3
2414  USB OTG device.
2415  - 0: OTG 2.0 support disabled (default)
2416  - 1: OTG 2.0 support enabled
2417  </td></tr>
2418
2419 */