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