drivers/usb/dwc_otg_310/dwc_otg_driver.c

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