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