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