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