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         struct resource *res_base;
1344         dwc_otg_device_t *dwc_otg_device;
1345         struct device           *dev = &_dev->dev;
1346         struct device_node      *node = _dev->dev.of_node;
1347         struct dwc_otg_platform_data *pldata;
1348         struct usb20otg_pdata_id *p;
1349         const struct of_device_id *match =
1350                 of_match_device(of_match_ptr( usb20_otg_of_match ), &_dev->dev);
1351
1352         if (match){
1353                 p = (struct usb20otg_pdata_id *)match->data;
1354         }else{
1355                 dev_err(dev, "usb20otg match failed\n");
1356                 return -EINVAL;
1357         }
1358
1359         dev->platform_data = p->pdata;
1360 //      dev->platform_data = &usb20otg_pdata;
1361         pldata =  dev->platform_data;
1362         pldata->dev = dev;
1363
1364         if (!node) {
1365                 dev_err(dev, "device node not found\n");
1366                 return -EINVAL;
1367         }
1368         /*todo : move to usbdev_rk-XX.c*/
1369         if(pldata->hw_init)
1370                 pldata->hw_init();
1371
1372         if(pldata->clock_init){
1373                 pldata->clock_init(pldata);
1374                 pldata->clock_enable(pldata, 1);
1375         }
1376
1377         if(pldata->phy_suspend)
1378                 pldata->phy_suspend(pldata, USB_PHY_ENABLED);
1379
1380         if(pldata->dwc_otg_uart_mode)
1381                 pldata->dwc_otg_uart_mode(pldata, PHY_USB_MODE);
1382
1383         if(pldata->soft_reset)
1384                 pldata->soft_reset();
1385         /*end todo*/
1386
1387         res_base=platform_get_resource(_dev, IORESOURCE_MEM, 0);
1388
1389         dwc_otg_device = DWC_ALLOC(sizeof(dwc_otg_device_t));
1390
1391         if (!dwc_otg_device) {
1392                 dev_err(&_dev->dev, "kmalloc of dwc_otg_device failed\n");
1393                 retval = -ENOMEM;
1394                 goto clk_disable;
1395         }
1396
1397         memset(dwc_otg_device, 0, sizeof(*dwc_otg_device));
1398         dwc_otg_device->os_dep.reg_offset = 0xFFFFFFFF;
1399
1400         /*
1401          * Map the DWC_otg Core memory into virtual address space.
1402          */
1403
1404         dwc_otg_device->os_dep.base = devm_ioremap_resource(dev, res_base);
1405
1406         if (!dwc_otg_device->os_dep.base) {
1407                 dev_err(&_dev->dev, "ioremap() failed\n");
1408                 DWC_FREE(dwc_otg_device);
1409                 retval = -ENOMEM;
1410                 goto clk_disable;
1411         }
1412         dev_dbg(&_dev->dev, "base=0x%08x\n",
1413                 (unsigned)dwc_otg_device->os_dep.base);
1414
1415         /*
1416          * Initialize driver data to point to the global DWC_otg
1417          * Device structure.
1418          */
1419
1420         g_otgdev = dwc_otg_device;
1421         pldata->privdata =  dwc_otg_device;
1422         dwc_otg_device->pldata = pldata;
1423
1424         dwc_set_device_platform_data(_dev, dwc_otg_device);
1425
1426         dev_dbg(&_dev->dev, "dwc_otg_device=0x%p\n", dwc_otg_device);
1427
1428         dwc_otg_device->core_if = dwc_otg_cil_init(dwc_otg_device->os_dep.base);
1429         if (!dwc_otg_device->core_if) {
1430                 dev_err(&_dev->dev, "CIL initialization failed!\n");
1431                 retval = -ENOMEM;
1432                 goto fail;
1433         }
1434
1435         dwc_otg_device->core_if->otg_dev = dwc_otg_device;
1436         /*
1437          * Attempt to ensure this device is really a DWC_otg Controller.
1438          * Read and verify the SNPSID register contents. The value should be
1439          * 0x45F42XXX or 0x45F42XXX, which corresponds to either "OT2" or "OTG3",
1440          * as in "OTG version 2.XX" or "OTG version 3.XX".
1441          */
1442
1443         if (((dwc_otg_get_gsnpsid(dwc_otg_device->core_if) & 0xFFFFF000) !=     0x4F542000) &&
1444                 ((dwc_otg_get_gsnpsid(dwc_otg_device->core_if) & 0xFFFFF000) != 0x4F543000)) {
1445                 dev_err(&_dev->dev, "Bad value for SNPSID: 0x%08x\n",
1446                         dwc_otg_get_gsnpsid(dwc_otg_device->core_if));
1447                 retval = -EINVAL;
1448                 goto fail;
1449         }
1450
1451         /*
1452          * Validate parameter values.
1453          */
1454         if (set_parameters(dwc_otg_device->core_if ,dwc_otg_module_params)) {
1455                 retval = -EINVAL;
1456                 goto fail;
1457         }
1458
1459         /*
1460          * Create Device Attributes in sysfs
1461          */
1462         dwc_otg_attr_create(_dev);
1463
1464         /*
1465          * Disable the global interrupt until all the interrupt
1466          * handlers are installed.
1467          */
1468         dwc_otg_disable_global_interrupts(dwc_otg_device->core_if);
1469
1470         /*
1471          * Install the interrupt handler for the common interrupts before
1472          * enabling common interrupts in core_init below.
1473          */
1474         irq = platform_get_irq(_dev,0);
1475         DWC_DEBUGPL(DBG_CIL, "registering (common) handler for irq%d\n",
1476                     irq);
1477         retval = request_irq(irq, dwc_otg_common_irq,
1478                              IRQF_SHARED , "dwc_otg",
1479                              dwc_otg_device);
1480         if (retval) {
1481                 DWC_ERROR("request of irq%d failed\n", irq);
1482                 retval = -EBUSY;
1483                 goto fail;
1484         } else {
1485                 dwc_otg_device->common_irq_installed = 1;
1486         }
1487
1488         /*
1489          * Initialize the DWC_otg core.
1490          * In order to reduce the time of initialization,
1491          * we do core soft reset after connection detected.
1492          */
1493         dwc_otg_core_init_no_reset(dwc_otg_device->core_if);
1494         dwc_otg_device->core_if->usb_mode = 0;// TODO: Can be read from Device-Tree
1495 #ifndef DWC_HOST_ONLY
1496         /*
1497          * Initialize the PCD
1498          */
1499         retval = pcd_init(_dev);
1500         if (retval != 0) {
1501                 DWC_ERROR("pcd_init failed\n");
1502                 dwc_otg_device->pcd = NULL;
1503                 goto fail;
1504         }
1505 #endif
1506 #ifndef DWC_DEVICE_ONLY
1507         /*
1508          * Initialize the HCD
1509          */
1510         retval = otg20_hcd_init(_dev);
1511         if (retval != 0) {
1512                 DWC_ERROR("hcd_init failed\n");
1513                 dwc_otg_device->hcd = NULL;
1514                 goto fail;
1515         }
1516 #endif
1517         /*
1518          * Enable the global interrupt after all the interrupt
1519          * handlers are installed if there is no ADP support else
1520          * perform initial actions required for Internal ADP logic.
1521          */
1522         if (!dwc_otg_get_param_adp_enable(dwc_otg_device->core_if)){
1523                 if( pldata->phy_status == USB_PHY_ENABLED ){
1524                         pldata->phy_suspend(pldata, USB_PHY_SUSPEND);
1525                         udelay(3);
1526                         pldata->clock_enable( pldata, 0);
1527                 }
1528 //              dwc_otg_enable_global_interrupts(dwc_otg_device->core_if);
1529         }
1530         else
1531                 dwc_otg_adp_start(dwc_otg_device->core_if,
1532                                                         dwc_otg_is_host_mode(dwc_otg_device->core_if));
1533
1534         return 0;
1535
1536 fail:
1537         otg20_driver_remove(_dev);
1538
1539 clk_disable:
1540         if(pldata->clock_enable)
1541                 pldata->clock_enable(pldata, 0);
1542
1543         return retval;
1544 }
1545
1546 static struct platform_driver dwc_otg_driver = {
1547         .driver = {
1548                 .name = (char *)dwc_otg20_driver_name,
1549                 .of_match_table = of_match_ptr(usb20_otg_of_match),
1550         },
1551         .probe = otg20_driver_probe,
1552         .remove = otg20_driver_remove,
1553         .suspend = dwc_otg_driver_suspend,
1554         .resume = dwc_otg_driver_resume,
1555         .shutdown = dwc_otg_driver_shutdown,
1556 };
1557 #endif
1558
1559 /**
1560  * This function is called when the dwc_otg_driver is installed with the
1561  * insmod command. It registers the dwc_otg_driver structure with the
1562  * appropriate bus driver. This will cause the dwc_otg_driver_probe function
1563  * to be called. In addition, the bus driver will automatically expose
1564  * attributes defined for the device and driver in the special sysfs file
1565  * system.
1566  *
1567  * @return
1568  */
1569 static int __init dwc_otg_driver_init(void)
1570 {
1571         int retval = 0;
1572         int error;
1573
1574 #ifdef CONFIG_USB20_OTG
1575         //register otg20
1576         printk(KERN_INFO "%s: version %s\n", dwc_otg20_driver_name,
1577                    DWC_DRIVER_VERSION);
1578
1579         retval = platform_driver_register(&dwc_otg_driver);
1580         if (retval < 0) {
1581                 printk(KERN_ERR "%s retval=%d\n", __func__, retval);
1582                 return retval;
1583         }
1584
1585         error = driver_create_file(&dwc_otg_driver.driver, &driver_attr_version);
1586         error = driver_create_file(&dwc_otg_driver.driver, &driver_attr_debuglevel);
1587         error = driver_create_file(&dwc_otg_driver.driver, &driver_attr_dwc_otg_conn_en);
1588         error = driver_create_file(&dwc_otg_driver.driver, &driver_attr_vbus_status);
1589         error = driver_create_file(&dwc_otg_driver.driver, &driver_attr_force_usb_mode);
1590
1591 #endif
1592
1593         //register host20
1594 #ifdef CONFIG_USB20_HOST
1595         printk(KERN_INFO "%s: version %s\n", dwc_host20_driver_name,
1596                DWC_DRIVER_VERSION);
1597
1598         retval = platform_driver_register(&dwc_host_driver);
1599         if (retval < 0) {
1600                 printk(KERN_ERR "%s retval=%d\n", __func__, retval);
1601                 return retval;
1602         }
1603
1604         error = driver_create_file(&dwc_host_driver.driver, &driver_attr_version);
1605         error = driver_create_file(&dwc_host_driver.driver, &driver_attr_debuglevel);
1606 #endif
1607         return retval;
1608 }
1609
1610 module_init(dwc_otg_driver_init);
1611
1612 /**
1613  * This function is called when the driver is removed from the kernel
1614  * with the rmmod command. The driver unregisters itself with its bus
1615  * driver.
1616  *
1617  */
1618 static void __exit dwc_otg_driver_cleanup(void)
1619 {
1620         printk(KERN_DEBUG "dwc_otg_driver_cleanup()\n");
1621
1622 #ifdef CONFIG_USB20_HOST
1623         /*for host20*/
1624         driver_remove_file(&dwc_host_driver.driver, &driver_attr_debuglevel);
1625         driver_remove_file(&dwc_host_driver.driver, &driver_attr_version);
1626         platform_driver_unregister(&dwc_host_driver);
1627         printk(KERN_INFO "%s module removed\n", dwc_host20_driver_name);
1628 #endif
1629
1630 #ifdef CONFIG_USB20_OTG
1631         /*for otg*/
1632         driver_remove_file(&dwc_otg_driver.driver, &driver_attr_dwc_otg_conn_en);
1633         driver_remove_file(&dwc_otg_driver.driver, &driver_attr_debuglevel);
1634         driver_remove_file(&dwc_otg_driver.driver, &driver_attr_version);
1635         driver_remove_file(&dwc_otg_driver.driver, &driver_attr_vbus_status);
1636         driver_remove_file(&dwc_otg_driver.driver, &driver_attr_force_usb_mode);
1637         platform_driver_unregister(&dwc_otg_driver);
1638         printk(KERN_INFO "%s module removed\n", dwc_otg20_driver_name);
1639 #endif
1640 }
1641
1642 module_exit(dwc_otg_driver_cleanup);
1643
1644 MODULE_DESCRIPTION(DWC_DRIVER_DESC);
1645 MODULE_AUTHOR("Synopsys Inc.");
1646 MODULE_LICENSE("GPL");
1647
1648 module_param_named(otg_cap, dwc_otg_module_params.otg_cap, int, 0444);
1649 MODULE_PARM_DESC(otg_cap, "OTG Capabilities 0=HNP&SRP 1=SRP Only 2=None");
1650 module_param_named(opt, dwc_otg_module_params.opt, int, 0444);
1651 MODULE_PARM_DESC(opt, "OPT Mode");
1652 module_param_named(dma_enable, dwc_otg_module_params.dma_enable, int, 0444);
1653 MODULE_PARM_DESC(dma_enable, "DMA Mode 0=Slave 1=DMA enabled");
1654
1655 module_param_named(dma_desc_enable, dwc_otg_module_params.dma_desc_enable, int,
1656                    0444);
1657 MODULE_PARM_DESC(dma_desc_enable,
1658                  "DMA Desc Mode 0=Address DMA 1=DMA Descriptor enabled");
1659
1660 module_param_named(dma_burst_size, dwc_otg_module_params.dma_burst_size, int,
1661                    0444);
1662 MODULE_PARM_DESC(dma_burst_size,
1663                  "DMA Burst Size 1, 4, 8, 16, 32, 64, 128, 256");
1664 module_param_named(speed, dwc_otg_module_params.speed, int, 0444);
1665 MODULE_PARM_DESC(speed, "Speed 0=High Speed 1=Full Speed");
1666 module_param_named(host_support_fs_ls_low_power,
1667                    dwc_otg_module_params.host_support_fs_ls_low_power, int,
1668                    0444);
1669 MODULE_PARM_DESC(host_support_fs_ls_low_power,
1670                  "Support Low Power w/FS or LS 0=Support 1=Don't Support");
1671 module_param_named(host_ls_low_power_phy_clk,
1672                    dwc_otg_module_params.host_ls_low_power_phy_clk, int, 0444);
1673 MODULE_PARM_DESC(host_ls_low_power_phy_clk,
1674                  "Low Speed Low Power Clock 0=48Mhz 1=6Mhz");
1675 module_param_named(enable_dynamic_fifo,
1676                    dwc_otg_module_params.enable_dynamic_fifo, int, 0444);
1677 MODULE_PARM_DESC(enable_dynamic_fifo, "0=cC Setting 1=Allow Dynamic Sizing");
1678 module_param_named(data_fifo_size, dwc_otg_module_params.data_fifo_size, int,
1679                    0444);
1680 MODULE_PARM_DESC(data_fifo_size,
1681                  "Total number of words in the data FIFO memory 32-32768");
1682 module_param_named(dev_rx_fifo_size, dwc_otg_module_params.dev_rx_fifo_size,
1683                    int, 0444);
1684 MODULE_PARM_DESC(dev_rx_fifo_size, "Number of words in the Rx FIFO 16-32768");
1685 module_param_named(dev_nperio_tx_fifo_size,
1686                    dwc_otg_module_params.dev_nperio_tx_fifo_size, int, 0444);
1687 MODULE_PARM_DESC(dev_nperio_tx_fifo_size,
1688                  "Number of words in the non-periodic Tx FIFO 16-32768");
1689 module_param_named(dev_perio_tx_fifo_size_1,
1690                    dwc_otg_module_params.dev_perio_tx_fifo_size[0], int, 0444);
1691 MODULE_PARM_DESC(dev_perio_tx_fifo_size_1,
1692                  "Number of words in the periodic Tx FIFO 4-768");
1693 module_param_named(dev_perio_tx_fifo_size_2,
1694                    dwc_otg_module_params.dev_perio_tx_fifo_size[1], int, 0444);
1695 MODULE_PARM_DESC(dev_perio_tx_fifo_size_2,
1696                  "Number of words in the periodic Tx FIFO 4-768");
1697 module_param_named(dev_perio_tx_fifo_size_3,
1698                    dwc_otg_module_params.dev_perio_tx_fifo_size[2], int, 0444);
1699 MODULE_PARM_DESC(dev_perio_tx_fifo_size_3,
1700                  "Number of words in the periodic Tx FIFO 4-768");
1701 module_param_named(dev_perio_tx_fifo_size_4,
1702                    dwc_otg_module_params.dev_perio_tx_fifo_size[3], int, 0444);
1703 MODULE_PARM_DESC(dev_perio_tx_fifo_size_4,
1704                  "Number of words in the periodic Tx FIFO 4-768");
1705 module_param_named(dev_perio_tx_fifo_size_5,
1706                    dwc_otg_module_params.dev_perio_tx_fifo_size[4], int, 0444);
1707 MODULE_PARM_DESC(dev_perio_tx_fifo_size_5,
1708                  "Number of words in the periodic Tx FIFO 4-768");
1709 module_param_named(dev_perio_tx_fifo_size_6,
1710                    dwc_otg_module_params.dev_perio_tx_fifo_size[5], int, 0444);
1711 MODULE_PARM_DESC(dev_perio_tx_fifo_size_6,
1712                  "Number of words in the periodic Tx FIFO 4-768");
1713 module_param_named(dev_perio_tx_fifo_size_7,
1714                    dwc_otg_module_params.dev_perio_tx_fifo_size[6], int, 0444);
1715 MODULE_PARM_DESC(dev_perio_tx_fifo_size_7,
1716                  "Number of words in the periodic Tx FIFO 4-768");
1717 module_param_named(dev_perio_tx_fifo_size_8,
1718                    dwc_otg_module_params.dev_perio_tx_fifo_size[7], int, 0444);
1719 MODULE_PARM_DESC(dev_perio_tx_fifo_size_8,
1720                  "Number of words in the periodic Tx FIFO 4-768");
1721 module_param_named(dev_perio_tx_fifo_size_9,
1722                    dwc_otg_module_params.dev_perio_tx_fifo_size[8], int, 0444);
1723 MODULE_PARM_DESC(dev_perio_tx_fifo_size_9,
1724                  "Number of words in the periodic Tx FIFO 4-768");
1725 module_param_named(dev_perio_tx_fifo_size_10,
1726                    dwc_otg_module_params.dev_perio_tx_fifo_size[9], int, 0444);
1727 MODULE_PARM_DESC(dev_perio_tx_fifo_size_10,
1728                  "Number of words in the periodic Tx FIFO 4-768");
1729 module_param_named(dev_perio_tx_fifo_size_11,
1730                    dwc_otg_module_params.dev_perio_tx_fifo_size[10], int, 0444);
1731 MODULE_PARM_DESC(dev_perio_tx_fifo_size_11,
1732                  "Number of words in the periodic Tx FIFO 4-768");
1733 module_param_named(dev_perio_tx_fifo_size_12,
1734                    dwc_otg_module_params.dev_perio_tx_fifo_size[11], int, 0444);
1735 MODULE_PARM_DESC(dev_perio_tx_fifo_size_12,
1736                  "Number of words in the periodic Tx FIFO 4-768");
1737 module_param_named(dev_perio_tx_fifo_size_13,
1738                    dwc_otg_module_params.dev_perio_tx_fifo_size[12], int, 0444);
1739 MODULE_PARM_DESC(dev_perio_tx_fifo_size_13,
1740                  "Number of words in the periodic Tx FIFO 4-768");
1741 module_param_named(dev_perio_tx_fifo_size_14,
1742                    dwc_otg_module_params.dev_perio_tx_fifo_size[13], int, 0444);
1743 MODULE_PARM_DESC(dev_perio_tx_fifo_size_14,
1744                  "Number of words in the periodic Tx FIFO 4-768");
1745 module_param_named(dev_perio_tx_fifo_size_15,
1746                    dwc_otg_module_params.dev_perio_tx_fifo_size[14], int, 0444);
1747 MODULE_PARM_DESC(dev_perio_tx_fifo_size_15,
1748                  "Number of words in the periodic Tx FIFO 4-768");
1749 module_param_named(host_rx_fifo_size, dwc_otg_module_params.host_rx_fifo_size,
1750                    int, 0444);
1751 MODULE_PARM_DESC(host_rx_fifo_size, "Number of words in the Rx FIFO 16-32768");
1752 module_param_named(host_nperio_tx_fifo_size,
1753                    dwc_otg_module_params.host_nperio_tx_fifo_size, int, 0444);
1754 MODULE_PARM_DESC(host_nperio_tx_fifo_size,
1755                  "Number of words in the non-periodic Tx FIFO 16-32768");
1756 module_param_named(host_perio_tx_fifo_size,
1757                    dwc_otg_module_params.host_perio_tx_fifo_size, int, 0444);
1758 MODULE_PARM_DESC(host_perio_tx_fifo_size,
1759                  "Number of words in the host periodic Tx FIFO 16-32768");
1760 module_param_named(max_transfer_size, dwc_otg_module_params.max_transfer_size,
1761                    int, 0444);
1762 /** @todo Set the max to 512K, modify checks */
1763 MODULE_PARM_DESC(max_transfer_size,
1764                  "The maximum transfer size supported in bytes 2047-65535");
1765 module_param_named(max_packet_count, dwc_otg_module_params.max_packet_count,
1766                    int, 0444);
1767 MODULE_PARM_DESC(max_packet_count,
1768                  "The maximum number of packets in a transfer 15-511");
1769 module_param_named(host_channels, dwc_otg_module_params.host_channels, int,
1770                    0444);
1771 MODULE_PARM_DESC(host_channels,
1772                  "The number of host channel registers to use 1-16");
1773 module_param_named(dev_endpoints, dwc_otg_module_params.dev_endpoints, int,
1774                    0444);
1775 MODULE_PARM_DESC(dev_endpoints,
1776                  "The number of endpoints in addition to EP0 available for device mode 1-15");
1777 module_param_named(phy_type, dwc_otg_module_params.phy_type, int, 0444);
1778 MODULE_PARM_DESC(phy_type, "0=Reserved 1=UTMI+ 2=ULPI");
1779 module_param_named(phy_utmi_width, dwc_otg_module_params.phy_utmi_width, int,
1780                    0444);
1781 MODULE_PARM_DESC(phy_utmi_width, "Specifies the UTMI+ Data Width 8 or 16 bits");
1782 module_param_named(phy_ulpi_ddr, dwc_otg_module_params.phy_ulpi_ddr, int, 0444);
1783 MODULE_PARM_DESC(phy_ulpi_ddr,
1784                  "ULPI at double or single data rate 0=Single 1=Double");
1785 module_param_named(phy_ulpi_ext_vbus, dwc_otg_module_params.phy_ulpi_ext_vbus,
1786                    int, 0444);
1787 MODULE_PARM_DESC(phy_ulpi_ext_vbus,
1788                  "ULPI PHY using internal or external vbus 0=Internal");
1789 module_param_named(i2c_enable, dwc_otg_module_params.i2c_enable, int, 0444);
1790 MODULE_PARM_DESC(i2c_enable, "FS PHY Interface");
1791 module_param_named(ulpi_fs_ls, dwc_otg_module_params.ulpi_fs_ls, int, 0444);
1792 MODULE_PARM_DESC(ulpi_fs_ls, "ULPI PHY FS/LS mode only");
1793 module_param_named(ts_dline, dwc_otg_module_params.ts_dline, int, 0444);
1794 MODULE_PARM_DESC(ts_dline, "Term select Dline pulsing for all PHYs");
1795 module_param_named(debug, g_dbg_lvl, int, 0444);
1796 MODULE_PARM_DESC(debug, "");
1797
1798 module_param_named(en_multiple_tx_fifo,
1799                    dwc_otg_module_params.en_multiple_tx_fifo, int, 0444);
1800 MODULE_PARM_DESC(en_multiple_tx_fifo,
1801                  "Dedicated Non Periodic Tx FIFOs 0=disabled 1=enabled");
1802 module_param_named(dev_tx_fifo_size_1,
1803                    dwc_otg_module_params.dev_tx_fifo_size[0], int, 0444);
1804 MODULE_PARM_DESC(dev_tx_fifo_size_1, "Number of words in the Tx FIFO 4-768");
1805 module_param_named(dev_tx_fifo_size_2,
1806                    dwc_otg_module_params.dev_tx_fifo_size[1], int, 0444);
1807 MODULE_PARM_DESC(dev_tx_fifo_size_2, "Number of words in the Tx FIFO 4-768");
1808 module_param_named(dev_tx_fifo_size_3,
1809                    dwc_otg_module_params.dev_tx_fifo_size[2], int, 0444);
1810 MODULE_PARM_DESC(dev_tx_fifo_size_3, "Number of words in the Tx FIFO 4-768");
1811 module_param_named(dev_tx_fifo_size_4,
1812                    dwc_otg_module_params.dev_tx_fifo_size[3], int, 0444);
1813 MODULE_PARM_DESC(dev_tx_fifo_size_4, "Number of words in the Tx FIFO 4-768");
1814 module_param_named(dev_tx_fifo_size_5,
1815                    dwc_otg_module_params.dev_tx_fifo_size[4], int, 0444);
1816 MODULE_PARM_DESC(dev_tx_fifo_size_5, "Number of words in the Tx FIFO 4-768");
1817 module_param_named(dev_tx_fifo_size_6,
1818                    dwc_otg_module_params.dev_tx_fifo_size[5], int, 0444);
1819 MODULE_PARM_DESC(dev_tx_fifo_size_6, "Number of words in the Tx FIFO 4-768");
1820 module_param_named(dev_tx_fifo_size_7,
1821                    dwc_otg_module_params.dev_tx_fifo_size[6], int, 0444);
1822 MODULE_PARM_DESC(dev_tx_fifo_size_7, "Number of words in the Tx FIFO 4-768");
1823 module_param_named(dev_tx_fifo_size_8,
1824                    dwc_otg_module_params.dev_tx_fifo_size[7], int, 0444);
1825 MODULE_PARM_DESC(dev_tx_fifo_size_8, "Number of words in the Tx FIFO 4-768");
1826 module_param_named(dev_tx_fifo_size_9,
1827                    dwc_otg_module_params.dev_tx_fifo_size[8], int, 0444);
1828 MODULE_PARM_DESC(dev_tx_fifo_size_9, "Number of words in the Tx FIFO 4-768");
1829 module_param_named(dev_tx_fifo_size_10,
1830                    dwc_otg_module_params.dev_tx_fifo_size[9], int, 0444);
1831 MODULE_PARM_DESC(dev_tx_fifo_size_10, "Number of words in the Tx FIFO 4-768");
1832 module_param_named(dev_tx_fifo_size_11,
1833                    dwc_otg_module_params.dev_tx_fifo_size[10], int, 0444);
1834 MODULE_PARM_DESC(dev_tx_fifo_size_11, "Number of words in the Tx FIFO 4-768");
1835 module_param_named(dev_tx_fifo_size_12,
1836                    dwc_otg_module_params.dev_tx_fifo_size[11], int, 0444);
1837 MODULE_PARM_DESC(dev_tx_fifo_size_12, "Number of words in the Tx FIFO 4-768");
1838 module_param_named(dev_tx_fifo_size_13,
1839                    dwc_otg_module_params.dev_tx_fifo_size[12], int, 0444);
1840 MODULE_PARM_DESC(dev_tx_fifo_size_13, "Number of words in the Tx FIFO 4-768");
1841 module_param_named(dev_tx_fifo_size_14,
1842                    dwc_otg_module_params.dev_tx_fifo_size[13], int, 0444);
1843 MODULE_PARM_DESC(dev_tx_fifo_size_14, "Number of words in the Tx FIFO 4-768");
1844 module_param_named(dev_tx_fifo_size_15,
1845                    dwc_otg_module_params.dev_tx_fifo_size[14], int, 0444);
1846 MODULE_PARM_DESC(dev_tx_fifo_size_15, "Number of words in the Tx FIFO 4-768");
1847
1848 module_param_named(thr_ctl, dwc_otg_module_params.thr_ctl, int, 0444);
1849 MODULE_PARM_DESC(thr_ctl,
1850                  "Thresholding enable flag bit 0 - non ISO Tx thr., 1 - ISO Tx thr., 2 - Rx thr.- bit 0=disabled 1=enabled");
1851 module_param_named(tx_thr_length, dwc_otg_module_params.tx_thr_length, int,
1852                    0444);
1853 MODULE_PARM_DESC(tx_thr_length, "Tx Threshold length in 32 bit DWORDs");
1854 module_param_named(rx_thr_length, dwc_otg_module_params.rx_thr_length, int,
1855                    0444);
1856 MODULE_PARM_DESC(rx_thr_length, "Rx Threshold length in 32 bit DWORDs");
1857
1858 module_param_named(pti_enable, dwc_otg_module_params.pti_enable, int, 0444);
1859 module_param_named(mpi_enable, dwc_otg_module_params.mpi_enable, int, 0444);
1860 module_param_named(lpm_enable, dwc_otg_module_params.lpm_enable, int, 0444);
1861 MODULE_PARM_DESC(lpm_enable, "LPM Enable 0=LPM Disabled 1=LPM Enabled");
1862
1863 module_param_named(besl_enable, dwc_otg_module_params.besl_enable, int, 0444);
1864 MODULE_PARM_DESC(besl_enable, "BESL Enable 0=BESL Disabled 1=BESL Enabled");
1865 module_param_named(baseline_besl, dwc_otg_module_params.baseline_besl, int, 0444);
1866 MODULE_PARM_DESC(baseline_besl, "Set the baseline besl value");
1867 module_param_named(deep_besl, dwc_otg_module_params.deep_besl, int, 0444);
1868 MODULE_PARM_DESC(deep_besl, "Set the deep besl value");
1869
1870 module_param_named(ic_usb_cap, dwc_otg_module_params.ic_usb_cap, int, 0444);
1871 MODULE_PARM_DESC(ic_usb_cap,
1872                  "IC_USB Capability 0=IC_USB Disabled 1=IC_USB Enabled");
1873 module_param_named(ahb_thr_ratio, dwc_otg_module_params.ahb_thr_ratio, int,
1874                    0444);
1875 MODULE_PARM_DESC(ahb_thr_ratio, "AHB Threshold Ratio");
1876 module_param_named(power_down, dwc_otg_module_params.power_down, int, 0444);
1877 MODULE_PARM_DESC(power_down, "Power Down Mode");
1878 module_param_named(reload_ctl, dwc_otg_module_params.reload_ctl, int, 0444);
1879 MODULE_PARM_DESC(reload_ctl, "HFIR Reload Control");
1880 module_param_named(dev_out_nak, dwc_otg_module_params.dev_out_nak, int, 0444);
1881 MODULE_PARM_DESC(dev_out_nak, "Enable Device OUT NAK");
1882 module_param_named(cont_on_bna, dwc_otg_module_params.cont_on_bna, int, 0444);
1883 MODULE_PARM_DESC(cont_on_bna, "Enable Enable Continue on BNA");
1884 module_param_named(ahb_single, dwc_otg_module_params.ahb_single, int, 0444);
1885 MODULE_PARM_DESC(ahb_single, "Enable AHB Single Support");
1886 module_param_named(adp_enable, dwc_otg_module_params.adp_enable, int, 0444);
1887 MODULE_PARM_DESC(adp_enable, "ADP Enable 0=ADP Disabled 1=ADP Enabled");
1888 module_param_named(otg_ver, dwc_otg_module_params.otg_ver, int, 0444);
1889 MODULE_PARM_DESC(otg_ver, "OTG revision supported 0=OTG 1.3 1=OTG 2.0");
1890
1891 /** @page "Module Parameters"
1892  *
1893  * The following parameters may be specified when starting the module.
1894  * These parameters define how the DWC_otg controller should be
1895  * configured. Parameter values are passed to the CIL initialization
1896  * function dwc_otg_cil_init
1897  *
1898  * Example: <code>modprobe dwc_otg speed=1 otg_cap=1</code>
1899  *
1900
1901  <table>
1902  <tr><td>Parameter Name</td><td>Meaning</td></tr>
1903
1904  <tr>
1905  <td>otg_cap</td>
1906  <td>Specifies the OTG capabilities. The driver will automatically detect the
1907  value for this parameter if none is specified.
1908  - 0: HNP and SRP capable (default, if available)
1909  - 1: SRP Only capable
1910  - 2: No HNP/SRP capable
1911  </td></tr>
1912
1913  <tr>
1914  <td>dma_enable</td>
1915  <td>Specifies whether to use slave or DMA mode for accessing the data FIFOs.
1916  The driver will automatically detect the value for this parameter if none is
1917  specified.
1918  - 0: Slave
1919  - 1: DMA (default, if available)
1920  </td></tr>
1921
1922  <tr>
1923  <td>dma_burst_size</td>
1924  <td>The DMA Burst size (applicable only for External DMA Mode).
1925  - Values: 1, 4, 8 16, 32, 64, 128, 256 (default 32)
1926  </td></tr>
1927
1928  <tr>
1929  <td>speed</td>
1930  <td>Specifies the maximum speed of operation in host and device mode. The
1931  actual speed depends on the speed of the attached device and the value of
1932  phy_type.
1933  - 0: High Speed (default)
1934  - 1: Full Speed
1935  </td></tr>
1936
1937  <tr>
1938  <td>host_support_fs_ls_low_power</td>
1939  <td>Specifies whether low power mode is supported when attached to a Full
1940  Speed or Low Speed device in host mode.
1941  - 0: Don't support low power mode (default)
1942  - 1: Support low power mode
1943  </td></tr>
1944
1945  <tr>
1946  <td>host_ls_low_power_phy_clk</td>
1947  <td>Specifies the PHY clock rate in low power mode when connected to a Low
1948  Speed device in host mode. This parameter is applicable only if
1949  HOST_SUPPORT_FS_LS_LOW_POWER is enabled.
1950  - 0: 48 MHz (default)
1951  - 1: 6 MHz
1952  </td></tr>
1953
1954  <tr>
1955  <td>enable_dynamic_fifo</td>
1956  <td> Specifies whether FIFOs may be resized by the driver software.
1957  - 0: Use cC FIFO size parameters
1958  - 1: Allow dynamic FIFO sizing (default)
1959  </td></tr>
1960
1961  <tr>
1962  <td>data_fifo_size</td>
1963  <td>Total number of 4-byte words in the data FIFO memory. This memory
1964  includes the Rx FIFO, non-periodic Tx FIFO, and periodic Tx FIFOs.
1965  - Values: 32 to 32768 (default 8192)
1966
1967  Note: The total FIFO memory depth in the FPGA configuration is 8192.
1968  </td></tr>
1969
1970  <tr>
1971  <td>dev_rx_fifo_size</td>
1972  <td>Number of 4-byte words in the Rx FIFO in device mode when dynamic
1973  FIFO sizing is enabled.
1974  - Values: 16 to 32768 (default 1064)
1975  </td></tr>
1976
1977  <tr>
1978  <td>dev_nperio_tx_fifo_size</td>
1979  <td>Number of 4-byte words in the non-periodic Tx FIFO in device mode when
1980  dynamic FIFO sizing is enabled.
1981  - Values: 16 to 32768 (default 1024)
1982  </td></tr>
1983
1984  <tr>
1985  <td>dev_perio_tx_fifo_size_n (n = 1 to 15)</td>
1986  <td>Number of 4-byte words in each of the periodic Tx FIFOs in device mode
1987  when dynamic FIFO sizing is enabled.
1988  - Values: 4 to 768 (default 256)
1989  </td></tr>
1990
1991  <tr>
1992  <td>host_rx_fifo_size</td>
1993  <td>Number of 4-byte words in the Rx FIFO in host mode when dynamic FIFO
1994  sizing is enabled.
1995  - Values: 16 to 32768 (default 1024)
1996  </td></tr>
1997
1998  <tr>
1999  <td>host_nperio_tx_fifo_size</td>
2000  <td>Number of 4-byte words in the non-periodic Tx FIFO in host mode when
2001  dynamic FIFO sizing is enabled in the core.
2002  - Values: 16 to 32768 (default 1024)
2003  </td></tr>
2004
2005  <tr>
2006  <td>host_perio_tx_fifo_size</td>
2007  <td>Number of 4-byte words in the host periodic Tx FIFO when dynamic FIFO
2008  sizing is enabled.
2009  - Values: 16 to 32768 (default 1024)
2010  </td></tr>
2011
2012  <tr>
2013  <td>max_transfer_size</td>
2014  <td>The maximum transfer size supported in bytes.
2015  - Values: 2047 to 65,535 (default 65,535)
2016  </td></tr>
2017
2018  <tr>
2019  <td>max_packet_count</td>
2020  <td>The maximum number of packets in a transfer.
2021  - Values: 15 to 511 (default 511)
2022  </td></tr>
2023
2024  <tr>
2025  <td>host_channels</td>
2026  <td>The number of host channel registers to use.
2027  - Values: 1 to 16 (default 12)
2028
2029  Note: The FPGA configuration supports a maximum of 12 host channels.
2030  </td></tr>
2031
2032  <tr>
2033  <td>dev_endpoints</td>
2034  <td>The number of endpoints in addition to EP0 available for device mode
2035  operations.
2036  - Values: 1 to 15 (default 6 IN and OUT)
2037
2038  Note: The FPGA configuration supports a maximum of 6 IN and OUT endpoints in
2039  addition to EP0.
2040  </td></tr>
2041
2042  <tr>
2043  <td>phy_type</td>
2044  <td>Specifies the type of PHY interface to use. By default, the driver will
2045  automatically detect the phy_type.
2046  - 0: Full Speed
2047  - 1: UTMI+ (default, if available)
2048  - 2: ULPI
2049  </td></tr>
2050
2051  <tr>
2052  <td>phy_utmi_width</td>
2053  <td>Specifies the UTMI+ Data Width. This parameter is applicable for a
2054  phy_type of UTMI+. Also, this parameter is applicable only if the
2055  OTG_HSPHY_WIDTH cC parameter was set to "8 and 16 bits", meaning that the
2056  core has been configured to work at either data path width.
2057  - Values: 8 or 16 bits (default 16)
2058  </td></tr>
2059
2060  <tr>
2061  <td>phy_ulpi_ddr</td>
2062  <td>Specifies whether the ULPI operates at double or single data rate. This
2063  parameter is only applicable if phy_type is ULPI.
2064  - 0: single data rate ULPI interface with 8 bit wide data bus (default)
2065  - 1: double data rate ULPI interface with 4 bit wide data bus
2066  </td></tr>
2067
2068  <tr>
2069  <td>i2c_enable</td>
2070  <td>Specifies whether to use the I2C interface for full speed PHY. This
2071  parameter is only applicable if PHY_TYPE is FS.
2072  - 0: Disabled (default)
2073  - 1: Enabled
2074  </td></tr>
2075
2076  <tr>
2077  <td>ulpi_fs_ls</td>
2078  <td>Specifies whether to use ULPI FS/LS mode only.
2079  - 0: Disabled (default)
2080  - 1: Enabled
2081  </td></tr>
2082
2083  <tr>
2084  <td>ts_dline</td>
2085  <td>Specifies whether term select D-Line pulsing for all PHYs is enabled.
2086  - 0: Disabled (default)
2087  - 1: Enabled
2088  </td></tr>
2089
2090  <tr>
2091  <td>en_multiple_tx_fifo</td>
2092  <td>Specifies whether dedicatedto tx fifos are enabled for non periodic IN EPs.
2093  The driver will automatically detect the value for this parameter if none is
2094  specified.
2095  - 0: Disabled
2096  - 1: Enabled (default, if available)
2097  </td></tr>
2098
2099  <tr>
2100  <td>dev_tx_fifo_size_n (n = 1 to 15)</td>
2101  <td>Number of 4-byte words in each of the Tx FIFOs in device mode
2102  when dynamic FIFO sizing is enabled.
2103  - Values: 4 to 768 (default 256)
2104  </td></tr>
2105
2106  <tr>
2107  <td>tx_thr_length</td>
2108  <td>Transmit Threshold length in 32 bit double words
2109  - Values: 8 to 128 (default 64)
2110  </td></tr>
2111
2112  <tr>
2113  <td>rx_thr_length</td>
2114  <td>Receive Threshold length in 32 bit double words
2115  - Values: 8 to 128 (default 64)
2116  </td></tr>
2117
2118 <tr>
2119  <td>thr_ctl</td>
2120  <td>Specifies whether to enable Thresholding for Device mode. Bits 0, 1, 2 of
2121  this parmater specifies if thresholding is enabled for non-Iso Tx, Iso Tx and
2122  Rx transfers accordingly.
2123  The driver will automatically detect the value for this parameter if none is
2124  specified.
2125  - Values: 0 to 7 (default 0)
2126  Bit values indicate:
2127  - 0: Thresholding disabled
2128  - 1: Thresholding enabled
2129  </td></tr>
2130
2131 <tr>
2132  <td>dma_desc_enable</td>
2133  <td>Specifies whether to enable Descriptor DMA mode.
2134  The driver will automatically detect the value for this parameter if none is
2135  specified.
2136  - 0: Descriptor DMA disabled
2137  - 1: Descriptor DMA (default, if available)
2138  </td></tr>
2139
2140 <tr>
2141  <td>mpi_enable</td>
2142  <td>Specifies whether to enable MPI enhancement mode.
2143  The driver will automatically detect the value for this parameter if none is
2144  specified.
2145  - 0: MPI disabled (default)
2146  - 1: MPI enable
2147  </td></tr>
2148
2149 <tr>
2150  <td>pti_enable</td>
2151  <td>Specifies whether to enable PTI enhancement support.
2152  The driver will automatically detect the value for this parameter if none is
2153  specified.
2154  - 0: PTI disabled (default)
2155  - 1: PTI enable
2156  </td></tr>
2157
2158 <tr>
2159  <td>lpm_enable</td>
2160  <td>Specifies whether to enable LPM support.
2161  The driver will automatically detect the value for this parameter if none is
2162  specified.
2163  - 0: LPM disabled
2164  - 1: LPM enable (default, if available)
2165  </td></tr>
2166
2167  <tr>
2168  <td>besl_enable</td>
2169  <td>Specifies whether to enable LPM Errata support.
2170  The driver will automatically detect the value for this parameter if none is
2171  specified.
2172  - 0: LPM Errata disabled (default)
2173  - 1: LPM Errata enable
2174  </td></tr>
2175
2176   <tr>
2177  <td>baseline_besl</td>
2178  <td>Specifies the baseline besl value.
2179  - Values: 0 to 15 (default 0)
2180  </td></tr>
2181
2182   <tr>
2183  <td>deep_besl</td>
2184  <td>Specifies the deep besl value.
2185  - Values: 0 to 15 (default 15)
2186  </td></tr>
2187
2188 <tr>
2189  <td>ic_usb_cap</td>
2190  <td>Specifies whether to enable IC_USB capability.
2191  The driver will automatically detect the value for this parameter if none is
2192  specified.
2193  - 0: IC_USB disabled (default, if available)
2194  - 1: IC_USB enable
2195  </td></tr>
2196
2197 <tr>
2198  <td>ahb_thr_ratio</td>
2199  <td>Specifies AHB Threshold ratio.
2200  - Values: 0 to 3 (default 0)
2201  </td></tr>
2202
2203 <tr>
2204  <td>power_down</td>
2205  <td>Specifies Power Down(Hibernation) Mode.
2206  The driver will automatically detect the value for this parameter if none is
2207  specified.
2208  - 0: Power Down disabled (default)
2209  - 2: Power Down enabled
2210  </td></tr>
2211
2212  <tr>
2213  <td>reload_ctl</td>
2214  <td>Specifies whether dynamic reloading of the HFIR register is allowed during
2215  run time. The driver will automatically detect the value for this parameter if
2216  none is specified. In case the HFIR value is reloaded when HFIR.RldCtrl == 1'b0
2217  the core might misbehave.
2218  - 0: Reload Control disabled (default)
2219  - 1: Reload Control enabled
2220  </td></tr>
2221
2222  <tr>
2223  <td>dev_out_nak</td>
2224  <td>Specifies whether  Device OUT NAK enhancement enabled or no.
2225  The driver will automatically detect the value for this parameter if
2226  none is specified. This parameter is valid only when OTG_EN_DESC_DMA == 1\92b1.
2227  - 0: The core does not set NAK after Bulk OUT transfer complete (default)
2228  - 1: The core sets NAK after Bulk OUT transfer complete
2229  </td></tr>
2230
2231  <tr>
2232  <td>cont_on_bna</td>
2233  <td>Specifies whether Enable Continue on BNA enabled or no.
2234  After receiving BNA interrupt the core disables the endpoint,when the
2235  endpoint is re-enabled by the application the
2236  - 0: Core starts processing from the DOEPDMA descriptor (default)
2237  - 1: Core starts processing from the descriptor which received the BNA.
2238  This parameter is valid only when OTG_EN_DESC_DMA == 1\92b1.
2239  </td></tr>
2240
2241  <tr>
2242  <td>ahb_single</td>
2243  <td>This bit when programmed supports SINGLE transfers for remainder data
2244  in a transfer for DMA mode of operation.
2245  - 0: The remainder data will be sent using INCR burst size (default)
2246  - 1: The remainder data will be sent using SINGLE burst size.
2247  </td></tr>
2248
2249 <tr>
2250  <td>adp_enable</td>
2251  <td>Specifies whether ADP feature is enabled.
2252  The driver will automatically detect the value for this parameter if none is
2253  specified.
2254  - 0: ADP feature disabled (default)
2255  - 1: ADP feature enabled
2256  </td></tr>
2257
2258   <tr>
2259  <td>otg_ver</td>
2260  <td>Specifies whether OTG is performing as USB OTG Revision 2.0 or Revision 1.3
2261  USB OTG device.
2262  - 0: OTG 2.0 support disabled (default)
2263  - 1: OTG 2.0 support enabled
2264  </td></tr>
2265
2266 */