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