/* ========================================================================== * $File: //dwh/usb_iip/dev/software/otg/linux/drivers/dwc_otg_driver.c $ * $Revision: #71 $ * $Date: 2009/02/04 $ * $Change: 1179630 $ * * Synopsys HS OTG Linux Software Driver and documentation (hereinafter, * "Software") is an Unsupported proprietary work of Synopsys, Inc. unless * otherwise expressly agreed to in writing between Synopsys and you. * * The Software IS NOT an item of Licensed Software or Licensed Product under * any End User Software License Agreement or Agreement for Licensed Product * with Synopsys or any supplement thereto. You are permitted to use and * redistribute this Software in source and binary forms, with or without * modification, provided that redistributions of source code must retain this * notice. You may not view, use, disclose, copy or distribute this file or * any information contained herein except pursuant to this license grant from * Synopsys. If you do not agree with this notice, including the disclaimer * below, then you are not authorized to use the Software. * * THIS SOFTWARE IS BEING DISTRIBUTED BY SYNOPSYS SOLELY ON AN "AS IS" BASIS * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE HEREBY DISCLAIMED. IN NO EVENT SHALL SYNOPSYS BE LIABLE FOR ANY DIRECT, * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH * DAMAGE. * ========================================================================== */ /** @file * The dwc_otg_driver module provides the initialization and cleanup entry * points for the DWC_otg driver. This module will be dynamically installed * after Linux is booted using the insmod command. When the module is * installed, the dwc_otg_driver_init function is called. When the module is * removed (using rmmod), the dwc_otg_driver_cleanup function is called. * * This module also defines a data structure for the dwc_otg_driver, which is * used in conjunction with the standard ARM lm_device structure. These * structures allow the OTG driver to comply with the standard Linux driver * model in which devices and drivers are registered with a bus driver. This * has the benefit that Linux can expose attributes of the driver and device * in its special sysfs file system. Users can then read or write files in * this file system to perform diagnostics on the driver components or the * device. */ #include #include #include #include #include #include #include #include /* permission constants */ #include #include #include # include #include #include #ifdef CONFIG_OF #include #include #include #endif #include "dwc_os.h" #include "dwc_otg_dbg.h" #include "dwc_otg_attr.h" #include "dwc_otg_driver.h" #include "dwc_otg_core_if.h" #include "dwc_otg_pcd_if.h" #include "usb_hw.h" #define DWC_DRIVER_VERSION "2.81a 04-FEB-2009" #define DWC_DRIVER_DESC "HS OTG USB Controller driver" /* USB_GUSBCFG for set USC28C SPRD USB PHY Width:8/16 bits */ #if defined(CONFIG_ARCH_SCX20) unsigned int USB_GUSBCFG_REG; #define GUSBCFG_OFFSET 0x0c #endif static const char dwc_driver_name[] = "dwc_otg"; extern int pcd_init( struct platform_device *_dev ); extern int hcd_init( struct platform_device *_dev ); extern int pcd_remove( struct platform_device *_dev ); extern void hcd_remove( struct platform_device *_dev ); extern void dwc_udc_startup( void ); extern void dwc_udc_shutdown( void ); extern int dwc_udc_state( void ); extern void usb_phy_init( struct platform_device *_dev ); /*-------------------------------------------------------------------------*/ /* Encapsulate the module parameter settings */ struct dwc_otg_driver_module_params { int32_t opt; int32_t otg_cap; int32_t dma_enable; int32_t dma_desc_enable; int32_t dma_burst_size; int32_t speed; int32_t host_support_fs_ls_low_power; int32_t host_ls_low_power_phy_clk; int32_t enable_dynamic_fifo; int32_t data_fifo_size; int32_t dev_rx_fifo_size; int32_t dev_nperio_tx_fifo_size; uint32_t dev_perio_tx_fifo_size[MAX_PERIO_FIFOS]; int32_t host_rx_fifo_size; int32_t host_nperio_tx_fifo_size; int32_t host_perio_tx_fifo_size; int32_t max_transfer_size; int32_t max_packet_count; int32_t host_channels; int32_t dev_endpoints; int32_t phy_type; int32_t phy_utmi_width; int32_t phy_ulpi_ddr; int32_t phy_ulpi_ext_vbus; int32_t i2c_enable; int32_t ulpi_fs_ls; int32_t ts_dline; int32_t en_multiple_tx_fifo; uint32_t dev_tx_fifo_size[MAX_TX_FIFOS]; uint32_t thr_ctl; uint32_t tx_thr_length; uint32_t rx_thr_length; int32_t pti_enable; int32_t mpi_enable; int32_t lpm_enable; int32_t ic_usb_cap; int32_t ahb_thr_ratio; }; static struct dwc_otg_driver_module_params dwc_otg_module_params = { .opt = -1, .otg_cap = 2, .dma_enable = 1, .dma_desc_enable = 1, .dma_burst_size = -1, .speed = -1, .host_support_fs_ls_low_power = -1, .host_ls_low_power_phy_clk = -1, .enable_dynamic_fifo = -1, .data_fifo_size = -1, .dev_rx_fifo_size = 0x114, .dev_nperio_tx_fifo_size = 0x10, .dev_perio_tx_fifo_size = { /* dev_perio_tx_fifo_size_1 */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 /* 15 */ }, .host_rx_fifo_size = -1, .host_nperio_tx_fifo_size = -1, .host_perio_tx_fifo_size = -1, .max_transfer_size = -1, .max_packet_count = -1, .host_channels = -1, .dev_endpoints = -1, .phy_type = -1, .phy_utmi_width = -1, .phy_ulpi_ddr = -1, .phy_ulpi_ext_vbus = -1, .i2c_enable = -1, .ulpi_fs_ls = -1, .ts_dline = -1, .en_multiple_tx_fifo = -1, #if defined(CONFIG_ARCH_SCX35) .dev_tx_fifo_size = { /* dev_tx_fifo_size */ 0x40, 0x40, 0x100, 0x100, 0x100, 0x100, 0x100, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x200 /* 15 */ }, #else .dev_tx_fifo_size = { /* dev_tx_fifo_size */ 0x100, 0x100, 0x80, 0x80, 0x80, 0x80, -1, -1, -1, -1, -1, -1, -1, -1, -1 /* 15 */ }, #endif .thr_ctl = -1, .tx_thr_length = -1, .rx_thr_length = -1, .pti_enable = -1, .mpi_enable = -1, .lpm_enable = -1, .ic_usb_cap = -1, .ahb_thr_ratio = -1, }; /** * This function shows the driver whether support otg. */ static ssize_t is_support_otg_show(struct device_driver *dev, char *buf) { #ifdef DWC_DEVICE_ONLY return sprintf(buf, "%x\n", 0); #else return sprintf(buf, "%x\n", 1); #endif } static DRIVER_ATTR(is_support_otg, S_IRUGO, is_support_otg_show, NULL); /** * This function shows the Driver Version. */ static ssize_t version_show(struct device_driver *dev, char *buf) { return snprintf(buf, sizeof(DWC_DRIVER_VERSION) + 2, "%s\n", DWC_DRIVER_VERSION); } static DRIVER_ATTR(version, S_IRUGO, version_show, NULL); /** * Global Debug Level Mask. */ uint32_t g_dbg_lvl = 0x0; /* OFF */ /** * This function shows the driver Debug Level. */ static ssize_t dbg_level_show(struct device_driver *drv, char *buf) { return sprintf(buf, "0x%0x\n", g_dbg_lvl); } /** * This function stores the driver Debug Level. */ static ssize_t dbg_level_store(struct device_driver *drv, const char *buf, size_t count) { g_dbg_lvl = simple_strtoul(buf, NULL, 16); return count; } static DRIVER_ATTR(debuglevel, S_IRUGO | S_IWUSR, dbg_level_show, dbg_level_store); /** * This function shows the usb controller's power state */ static ssize_t dwc_udc_power_show(struct device_driver *drv, char *buf) { return sprintf(buf, "%s\n", dwc_udc_state() ? "on" : "off"); } /** * This function setting the usb controller's power */ static ssize_t dbg_udc_power_set(struct device_driver *drv, const char *buf, size_t count) { int power; power = simple_strtoul(buf, NULL, 16); if (power) { dwc_udc_startup(); } else { dwc_udc_shutdown(); } return count; } static DRIVER_ATTR(udcpower, S_IRUGO | S_IWUSR, dwc_udc_power_show, dbg_udc_power_set); /** * This function is called during module intialization * to pass module parameters to the DWC_OTG CORE. */ static int set_parameters(dwc_otg_core_if_t * core_if) { int retval = 0; int i; if (dwc_otg_module_params.otg_cap != -1) { retval += dwc_otg_set_param_otg_cap(core_if, dwc_otg_module_params.otg_cap); } if (dwc_otg_module_params.dma_enable != -1) { retval += dwc_otg_set_param_dma_enable(core_if, dwc_otg_module_params. dma_enable); } if (dwc_otg_module_params.dma_desc_enable != -1) { retval += dwc_otg_set_param_dma_desc_enable(core_if, dwc_otg_module_params. dma_desc_enable); } if (dwc_otg_module_params.opt != -1) { retval += dwc_otg_set_param_opt(core_if, dwc_otg_module_params.opt); } if (dwc_otg_module_params.dma_burst_size != -1) { retval += dwc_otg_set_param_dma_burst_size(core_if, dwc_otg_module_params. dma_burst_size); } if (dwc_otg_module_params.host_support_fs_ls_low_power != -1) { retval += dwc_otg_set_param_host_support_fs_ls_low_power(core_if, dwc_otg_module_params. host_support_fs_ls_low_power); } if (dwc_otg_module_params.enable_dynamic_fifo != -1) { retval += dwc_otg_set_param_enable_dynamic_fifo(core_if, dwc_otg_module_params. enable_dynamic_fifo); } if (dwc_otg_module_params.data_fifo_size != -1) { retval += dwc_otg_set_param_data_fifo_size(core_if, dwc_otg_module_params. data_fifo_size); } if (dwc_otg_module_params.dev_rx_fifo_size != -1) { retval += dwc_otg_set_param_dev_rx_fifo_size(core_if, dwc_otg_module_params. dev_rx_fifo_size); } if (dwc_otg_module_params.dev_nperio_tx_fifo_size != -1) { retval += dwc_otg_set_param_dev_nperio_tx_fifo_size(core_if, dwc_otg_module_params. dev_nperio_tx_fifo_size); } if (dwc_otg_module_params.host_rx_fifo_size != -1) { retval += dwc_otg_set_param_host_rx_fifo_size(core_if, dwc_otg_module_params.host_rx_fifo_size); } if (dwc_otg_module_params.host_nperio_tx_fifo_size != -1) { retval += dwc_otg_set_param_host_nperio_tx_fifo_size(core_if, dwc_otg_module_params. host_nperio_tx_fifo_size); } if (dwc_otg_module_params.host_perio_tx_fifo_size != -1) { retval += dwc_otg_set_param_host_perio_tx_fifo_size(core_if, dwc_otg_module_params. host_perio_tx_fifo_size); } if (dwc_otg_module_params.max_transfer_size != -1) { retval += dwc_otg_set_param_max_transfer_size(core_if, dwc_otg_module_params. max_transfer_size); } if (dwc_otg_module_params.max_packet_count != -1) { retval += dwc_otg_set_param_max_packet_count(core_if, dwc_otg_module_params. max_packet_count); } if (dwc_otg_module_params.host_channels != -1) { retval += dwc_otg_set_param_host_channels(core_if, dwc_otg_module_params. host_channels); } if (dwc_otg_module_params.dev_endpoints != -1) { retval += dwc_otg_set_param_dev_endpoints(core_if, dwc_otg_module_params. dev_endpoints); } if (dwc_otg_module_params.phy_type != -1) { retval += dwc_otg_set_param_phy_type(core_if, dwc_otg_module_params.phy_type); } if (dwc_otg_module_params.speed != -1) { retval += dwc_otg_set_param_speed(core_if, dwc_otg_module_params.speed); } if (dwc_otg_module_params.host_ls_low_power_phy_clk != -1) { retval += dwc_otg_set_param_host_ls_low_power_phy_clk(core_if, dwc_otg_module_params. host_ls_low_power_phy_clk); } if (dwc_otg_module_params.phy_ulpi_ddr != -1) { retval += dwc_otg_set_param_phy_ulpi_ddr(core_if, dwc_otg_module_params. phy_ulpi_ddr); } if (dwc_otg_module_params.phy_ulpi_ext_vbus != -1) { retval += dwc_otg_set_param_phy_ulpi_ext_vbus(core_if, dwc_otg_module_params. phy_ulpi_ext_vbus); } if (dwc_otg_module_params.phy_utmi_width != -1) { retval += dwc_otg_set_param_phy_utmi_width(core_if, dwc_otg_module_params. phy_utmi_width); } if (dwc_otg_module_params.ts_dline != -1) { retval += dwc_otg_set_param_ts_dline(core_if, dwc_otg_module_params.ts_dline); } if (dwc_otg_module_params.i2c_enable != -1) { retval += dwc_otg_set_param_i2c_enable(core_if, dwc_otg_module_params. i2c_enable); } if (dwc_otg_module_params.en_multiple_tx_fifo != -1) { retval += dwc_otg_set_param_en_multiple_tx_fifo(core_if, dwc_otg_module_params. en_multiple_tx_fifo); } for (i = 0; i < 15; i++) { if (dwc_otg_module_params.dev_perio_tx_fifo_size[i] != -1) { retval += dwc_otg_set_param_dev_perio_tx_fifo_size(core_if, dwc_otg_module_params. dev_perio_tx_fifo_size [i], i); } } for (i = 0; i < 15; i++) { if (dwc_otg_module_params.dev_tx_fifo_size[i] != -1) { retval += dwc_otg_set_param_dev_tx_fifo_size(core_if, dwc_otg_module_params. dev_tx_fifo_size [i], i); } } if (dwc_otg_module_params.thr_ctl != -1) { retval += dwc_otg_set_param_thr_ctl(core_if, dwc_otg_module_params.thr_ctl); } if (dwc_otg_module_params.mpi_enable != -1) { retval += dwc_otg_set_param_mpi_enable(core_if, dwc_otg_module_params. mpi_enable); } if (dwc_otg_module_params.pti_enable != -1) { retval += dwc_otg_set_param_pti_enable(core_if, dwc_otg_module_params. pti_enable); } if (dwc_otg_module_params.lpm_enable != -1) { retval += dwc_otg_set_param_lpm_enable(core_if, dwc_otg_module_params. lpm_enable); } if (dwc_otg_module_params.ic_usb_cap != -1) { retval += dwc_otg_set_param_ic_usb_cap(core_if, dwc_otg_module_params. ic_usb_cap); } if (dwc_otg_module_params.tx_thr_length != -1) { retval += dwc_otg_set_param_tx_thr_length(core_if, dwc_otg_module_params.tx_thr_length); } if (dwc_otg_module_params.rx_thr_length != -1) { retval += dwc_otg_set_param_rx_thr_length(core_if, dwc_otg_module_params. rx_thr_length); } if(dwc_otg_module_params.ahb_thr_ratio != -1) { retval += dwc_otg_set_param_ahb_thr_ratio(core_if, dwc_otg_module_params.ahb_thr_ratio); } return retval; } /** * This function is the top level interrupt handler for the Common * (Device and host modes) interrupts. */ /**static irqreturn_t dwc_otg_common_irq(int irq, void *dev) * __attribute__((unused)); *need to confirm if need comm_irq */ static irqreturn_t dwc_otg_common_irq(int irq, void *dev) { dwc_otg_device_t *otg_dev = dev; int32_t retval = IRQ_NONE; retval = dwc_otg_handle_common_intr(otg_dev->core_if); if (retval != 0) { S3C2410X_CLEAR_EINTPEND(); } return IRQ_RETVAL(retval); } /** * This function is called when a lm_device is unregistered with the * dwc_otg_driver. This happens, for example, when the rmmod command is * executed. The device may or may not be electrically present. If it is * present, the driver stops device processing. Any resources used on behalf * of this device are freed. * * @param[in] _dev */ static int dwc_otg_driver_remove( struct platform_device *_dev ) { dwc_otg_device_t *otg_dev = platform_get_drvdata(_dev); DWC_DEBUGPL(DBG_ANY, "%s(%p)\n", __func__, _dev); if (!otg_dev) { /* Memory allocation for the dwc_otg_device failed. */ DWC_DEBUGPL(DBG_ANY, "%s: otg_dev NULL!\n", __func__); return -1; } #ifndef DWC_DEVICE_ONLY if (otg_dev->hcd) { hcd_remove(_dev); } else { DWC_DEBUGPL(DBG_ANY, "%s: otg_dev->hcd NULL!\n", __func__); return -1; } #endif #ifndef DWC_HOST_ONLY if (otg_dev->pcd) { pcd_remove(_dev); } #endif /* * Free the IRQ */ #ifndef DWC_DEVICE_ONLY /*if otg is supported*/ if (otg_dev->common_irq_installed) { free_irq(platform_get_irq(_dev, 0), otg_dev); } #endif if (otg_dev->core_if) { dwc_otg_cil_remove(otg_dev->core_if); } /* * Remove the device attributes */ dwc_otg_attr_remove(_dev); /* * Return the memory. */ if (otg_dev->os_dep.base) { iounmap(otg_dev->os_dep.base); } dwc_free(otg_dev); #ifdef CONFIG_OF dwc_free(_dev->dev.platform_data ); #endif /* * Clear the drvdata pointer. */ platform_set_drvdata(_dev, 0); return 0; } #ifdef CONFIG_PM static int dwc_otg_suspend(struct platform_device *dev, pm_message_t state) { pr_info("%s\n", __func__); return 0; } static int dwc_otg_resume(struct platform_device *dev) { pr_info("%s\n", __func__); return 0; } #else #define dwc_otg_suspend NULL #define dwc_otg_resume NULL #endif /** * This function is called when an lm_device is bound to a * dwc_otg_driver. It creates the driver components required to * control the device (CIL, HCD, and PCD) and it initializes the * device. The driver components are stored in a dwc_otg_device * structure. A reference to the dwc_otg_device is saved in the * lm_device. This allows the driver to access the dwc_otg_device * structure on subsequent calls to driver methods for this device. * * @param[in] _dev Bus device */ static int dwc_otg_driver_probe( struct platform_device *_dev ) { int retval = 0; dwc_otg_device_t *dwc_otg_device; int irq; #ifndef CONFIG_OF struct sprd_usb_platform_data *pdata= _dev->dev.platform_data; #else int ret; struct device_node *np = _dev->dev.of_node; struct resource res; if (np) _dev->id = of_alias_get_id(np, "usb"); ret = of_address_to_resource(np, 0, &res); if(ret < 0){ dev_err(&_dev->dev, "no reg of property specified\n"); return NULL; } #endif usb_phy_init(_dev); dev_dbg(&_dev->dev, "dwc_otg_driver_probe(%p)\n", _dev); dwc_otg_device = dwc_alloc(sizeof(dwc_otg_device_t)); if (!dwc_otg_device) { dev_err(&_dev->dev, "kmalloc of dwc_otg_device failed\n"); retval = -ENOMEM; goto fail; } memset(dwc_otg_device, 0, sizeof(*dwc_otg_device)); dwc_otg_device->os_dep.reg_offset = 0xFFFFFFFF; /* * Map the DWC_otg Core memory into virtual address space. */ #ifdef CONFIG_OF dwc_otg_device->os_dep.base = (unsigned long)ioremap_nocache(res.start, resource_size(&res)); #if defined(CONFIG_ARCH_SCX20) USB_GUSBCFG_REG = dwc_otg_device->os_dep.base + GUSBCFG_OFFSET; #endif #else dwc_otg_device->os_dep.base = (void *)platform_get_resource(_dev, IORESOURCE_MEM, 0)->start; #endif if (!dwc_otg_device->os_dep.base) { dev_err(&_dev->dev, "ioremap() failed\n"); retval = -ENOMEM; goto fail; } dev_dbg(&_dev->dev, "base=0x%08x\n", (unsigned)dwc_otg_device->os_dep.base); irq = platform_get_irq(_dev, 0); dev_dbg(&_dev->dev, "base=0x%08x irq:%d\n", (unsigned)dwc_otg_device->os_dep.base, irq); /* * Initialize driver data to point to the global DWC_otg * Device structure. */ #ifdef CONFIG_OF if(np){ struct sprd_usb_platform_data *pdata; pdata = __DWC_ALLOC(NULL,sizeof(struct sprd_usb_platform_data)); if(!pdata){ dev_err(&_dev->dev, "fail to malloc memory for platform_data\n"); return -ENOMEM; } if (of_property_read_u32(np, "ngpios", &pdata->gpio_num)) { pr_info("read gpio number error\n"); __DWC_FREE(NULL , pdata); return -ENODEV; } if (1 == pdata->gpio_num) { pdata->gpio_chgdet = of_get_gpio(np, 0); if(pdata->gpio_chgdet<0){ printk(" get charge detect error ,gpio is %d\n",pdata->gpio_chgdet); pdata->gpio_chgdet = 0xffffffff; } pdata->gpio_otgdet = 0xffffffff; pdata->gpio_boost = 0xffffffff; }else if(2 == pdata->gpio_num){ pdata->gpio_chgdet = of_get_gpio(np, 0); if(pdata->gpio_chgdet<0){ printk(" get charge detect error ,gpio is %d\n",pdata->gpio_chgdet); pdata->gpio_chgdet = 0xffffffff; } pdata->gpio_otgdet = of_get_gpio(np, 1); if(pdata->gpio_otgdet<0){ printk(" get otg cable detect error ,gpio is %d\n",pdata->gpio_otgdet); pdata->gpio_otgdet = 0xffffffff; } pdata->gpio_boost = 0xffffffff; }else if(3 == pdata->gpio_num){ pdata->gpio_chgdet = of_get_gpio(np, 0); if(pdata->gpio_chgdet<0){ printk(" get charge detect error ,gpio is %d\n",pdata->gpio_chgdet); pdata->gpio_chgdet = 0xffffffff; } pdata->gpio_otgdet = of_get_gpio(np, 1); if(pdata->gpio_otgdet<0){ printk(" get otg cable detect error ,gpio is %d\n",pdata->gpio_otgdet); pdata->gpio_otgdet = 0xffffffff; } pdata->gpio_boost = of_get_gpio(np, 2); if(pdata->gpio_boost<0){ printk("get boost error ,gpio is %d\n",pdata->gpio_boost); pdata->gpio_boost = 0xffffffff; } }else{ printk("gpio number more than three,gpio number %d\n",pdata->gpio_num); } _dev->dev.platform_data = (void *)pdata; memcpy(&dwc_otg_device->platform_data,pdata,sizeof(pdata)); } #else memcpy(&dwc_otg_device->platform_data,pdata,sizeof(pdata)); #endif platform_set_drvdata(_dev, dwc_otg_device); dev_dbg(&_dev->dev, "dwc_otg_device=0x%p\n", dwc_otg_device); udc_enable(); dwc_otg_device->core_if = dwc_otg_cil_init(dwc_otg_device->os_dep.base); if (!dwc_otg_device->core_if) { dev_err(&_dev->dev, "CIL initialization failed!\n"); retval = -ENOMEM; goto fail; } /* * Attempt to ensure this device is really a DWC_otg Controller. * Read and verify the SNPSID register contents. The value should be * 0x45F42XXX, which corresponds to "OT2", as in "OTG version 2.XX". */ if ((dwc_otg_get_gsnpsid(dwc_otg_device->core_if) & 0xFFFFF000) != 0x4F542000) { dev_err(&_dev->dev, "Bad value for SNPSID: 0x%08x\n", dwc_otg_get_gsnpsid(dwc_otg_device->core_if)); dwc_otg_cil_remove(dwc_otg_device->core_if); dwc_free(dwc_otg_device); retval = -EINVAL; goto fail; } /* * Validate parameter values. */ if (set_parameters(dwc_otg_device->core_if)) { dwc_otg_cil_remove(dwc_otg_device->core_if); retval = -EINVAL; goto fail; } /* * Create Device Attributes in sysfs */ dwc_otg_attr_create(_dev); dev_dbg(&_dev->dev, "number EP=%d\n", dwc_otg_get_param_dev_endpoints(dwc_otg_device->core_if)); /* * Disable the global interrupt until all the interrupt * handlers are installed. */ dwc_otg_disable_global_interrupts(dwc_otg_device->core_if); /* * Install the interrupt handler for the common interrupts before * enabling common interrupts in core_init below. */ DWC_DEBUGPL(DBG_CIL, "registering (common) handler for irq%d\n", irq); /* *no need to use comm_irq if the usb IP core can work only in device mode *but if support otg, we should use common_irq *such as device disconnect when usb cable is connected,plug out udisk */ retval = request_irq(irq, dwc_otg_common_irq, IRQF_SHARED, "dwc_otg", dwc_otg_device); //SA_SHIRQ, "dwc_otg", dwc_otg_device); if (retval) { DWC_ERROR("request of irq%d failed\n", irq); retval = -EBUSY; goto fail; } else { dwc_otg_device->common_irq_installed = 1; } #if 0//ndef DWC_DEVICE_ONLY //no need /* * judge wheather otg cable is connected */ if(!usb_get_id_state()) dwc_otg_core_fore_host(dwc_otg_device->core_if); #endif /* * Initialize the DWC_otg core. */ dwc_otg_core_init(dwc_otg_device->core_if); #ifndef DWC_HOST_ONLY /* * Initialize the PCD */ retval = pcd_init(_dev); if (retval != 0) { DWC_ERROR("pcd_init failed\n"); dwc_otg_device->pcd = NULL; goto fail; } #endif #ifndef DWC_DEVICE_ONLY /* * Initialize the HCD */ retval = hcd_init(_dev); if (retval != 0) { DWC_ERROR("hcd_init failed\n"); dwc_otg_device->hcd = NULL; goto fail; } #endif /*Recover from drvdata having been overwritten by hcd_init()*/ platform_set_drvdata(_dev, dwc_otg_device); dwc_otg_device->os_dep.platformdev = _dev; /* * Enable the global interrupt after all the interrupt * handlers are installed. */ //dwc_otg_enable_global_interrupts(dwc_otg_device->core_if); return 0; fail: dwc_otg_driver_remove(_dev); return retval; } /** * This structure defines the methods to be called by a bus driver * during the lifecycle of a device on that bus. Both drivers and * devices are registered with a bus driver. The bus driver matches * devices to drivers based on information in the device and driver * structures. * * The probe function is called when the bus driver matches a device * to this driver. The remove function is called when a device is * unregistered with the bus driver. */ #ifdef CONFIG_OF static const struct of_device_id usb_ids [] = { { .compatible = "sprd,usb" }, {} }; #endif static struct platform_driver dwc_otg_driver = { .driver = { .name = "dwc_otg", .owner = THIS_MODULE, #ifdef CONFIG_OF .of_match_table = of_match_ptr(usb_ids), #endif }, .probe = dwc_otg_driver_probe, .remove = dwc_otg_driver_remove, //.suspend = dwc_otg_suspend, //.resume = dwc_otg_resume, }; /** * This function is called when the dwc_otg_driver is installed with the * insmod command. It registers the dwc_otg_driver structure with the * appropriate bus driver. This will cause the dwc_otg_driver_probe function * to be called. In addition, the bus driver will automatically expose * attributes defined for the device and driver in the special sysfs file * system. * * @return */ static int __init dwc_otg_driver_init(void) { int retval = 0; int error; printk(KERN_INFO "%s: version %s\n", dwc_driver_name, DWC_DRIVER_VERSION); printk(KERN_INFO "Working version %s\n", "No 007 - 10/24/2007"); retval = platform_driver_probe(&dwc_otg_driver, dwc_otg_driver_probe); if (retval < 0) { printk(KERN_ERR "%s retval=%d\n", __func__, retval); return retval; } error = driver_create_file(&dwc_otg_driver.driver, &driver_attr_version); error = driver_create_file(&dwc_otg_driver.driver, &driver_attr_debuglevel); error = driver_create_file(&dwc_otg_driver.driver, &driver_attr_udcpower); error = driver_create_file(&dwc_otg_driver.driver, &driver_attr_is_support_otg); return retval; } module_init(dwc_otg_driver_init); /** * This function is called when the driver is removed from the kernel * with the rmmod command. The driver unregisters itself with its bus * driver. * */ static void __exit dwc_otg_driver_cleanup(void) { printk(KERN_DEBUG "dwc_otg_driver_cleanup()\n"); driver_remove_file(&dwc_otg_driver.driver, &driver_attr_debuglevel); driver_remove_file(&dwc_otg_driver.driver, &driver_attr_version); driver_remove_file(&dwc_otg_driver.driver, &driver_attr_udcpower); driver_remove_file(&dwc_otg_driver.driver, &driver_attr_is_support_otg); platform_driver_unregister(&dwc_otg_driver); printk(KERN_INFO "%s module removed\n", dwc_driver_name); } module_exit(dwc_otg_driver_cleanup); MODULE_DESCRIPTION(DWC_DRIVER_DESC); MODULE_AUTHOR("Synopsys Inc."); MODULE_LICENSE("GPL"); module_param_named(otg_cap, dwc_otg_module_params.otg_cap, int, 0444); MODULE_PARM_DESC(otg_cap, "OTG Capabilities 0=HNP&SRP 1=SRP Only 2=None"); module_param_named(opt, dwc_otg_module_params.opt, int, 0444); MODULE_PARM_DESC(opt, "OPT Mode"); module_param_named(dma_enable, dwc_otg_module_params.dma_enable, int, 0444); MODULE_PARM_DESC(dma_enable, "DMA Mode 0=Slave 1=DMA enabled"); module_param_named(dma_desc_enable, dwc_otg_module_params.dma_desc_enable, int, 0444); MODULE_PARM_DESC(dma_desc_enable, "DMA Desc Mode 0=Address DMA 1=DMA Descriptor enabled"); module_param_named(dma_burst_size, dwc_otg_module_params.dma_burst_size, int, 0444); MODULE_PARM_DESC(dma_burst_size, "DMA Burst Size 1, 4, 8, 16, 32, 64, 128, 256"); module_param_named(speed, dwc_otg_module_params.speed, int, 0444); MODULE_PARM_DESC(speed, "Speed 0=High Speed 1=Full Speed"); module_param_named(host_support_fs_ls_low_power, dwc_otg_module_params.host_support_fs_ls_low_power, int, 0444); MODULE_PARM_DESC(host_support_fs_ls_low_power, "Support Low Power w/FS or LS 0=Support 1=Don't Support"); module_param_named(host_ls_low_power_phy_clk, dwc_otg_module_params.host_ls_low_power_phy_clk, int, 0444); MODULE_PARM_DESC(host_ls_low_power_phy_clk, "Low Speed Low Power Clock 0=48Mhz 1=6Mhz"); module_param_named(enable_dynamic_fifo, dwc_otg_module_params.enable_dynamic_fifo, int, 0444); MODULE_PARM_DESC(enable_dynamic_fifo, "0=cC Setting 1=Allow Dynamic Sizing"); module_param_named(data_fifo_size, dwc_otg_module_params.data_fifo_size, int, 0444); MODULE_PARM_DESC(data_fifo_size, "Total number of words in the data FIFO memory 32-32768"); module_param_named(dev_rx_fifo_size, dwc_otg_module_params.dev_rx_fifo_size, int, 0444); MODULE_PARM_DESC(dev_rx_fifo_size, "Number of words in the Rx FIFO 16-32768"); module_param_named(dev_nperio_tx_fifo_size, dwc_otg_module_params.dev_nperio_tx_fifo_size, int, 0444); MODULE_PARM_DESC(dev_nperio_tx_fifo_size, "Number of words in the non-periodic Tx FIFO 16-32768"); module_param_named(dev_perio_tx_fifo_size_1, dwc_otg_module_params.dev_perio_tx_fifo_size[0], int, 0444); MODULE_PARM_DESC(dev_perio_tx_fifo_size_1, "Number of words in the periodic Tx FIFO 4-768"); module_param_named(dev_perio_tx_fifo_size_2, dwc_otg_module_params.dev_perio_tx_fifo_size[1], int, 0444); MODULE_PARM_DESC(dev_perio_tx_fifo_size_2, "Number of words in the periodic Tx FIFO 4-768"); module_param_named(dev_perio_tx_fifo_size_3, dwc_otg_module_params.dev_perio_tx_fifo_size[2], int, 0444); MODULE_PARM_DESC(dev_perio_tx_fifo_size_3, "Number of words in the periodic Tx FIFO 4-768"); module_param_named(dev_perio_tx_fifo_size_4, dwc_otg_module_params.dev_perio_tx_fifo_size[3], int, 0444); MODULE_PARM_DESC(dev_perio_tx_fifo_size_4, "Number of words in the periodic Tx FIFO 4-768"); module_param_named(dev_perio_tx_fifo_size_5, dwc_otg_module_params.dev_perio_tx_fifo_size[4], int, 0444); MODULE_PARM_DESC(dev_perio_tx_fifo_size_5, "Number of words in the periodic Tx FIFO 4-768"); module_param_named(dev_perio_tx_fifo_size_6, dwc_otg_module_params.dev_perio_tx_fifo_size[5], int, 0444); MODULE_PARM_DESC(dev_perio_tx_fifo_size_6, "Number of words in the periodic Tx FIFO 4-768"); module_param_named(dev_perio_tx_fifo_size_7, dwc_otg_module_params.dev_perio_tx_fifo_size[6], int, 0444); MODULE_PARM_DESC(dev_perio_tx_fifo_size_7, "Number of words in the periodic Tx FIFO 4-768"); module_param_named(dev_perio_tx_fifo_size_8, dwc_otg_module_params.dev_perio_tx_fifo_size[7], int, 0444); MODULE_PARM_DESC(dev_perio_tx_fifo_size_8, "Number of words in the periodic Tx FIFO 4-768"); module_param_named(dev_perio_tx_fifo_size_9, dwc_otg_module_params.dev_perio_tx_fifo_size[8], int, 0444); MODULE_PARM_DESC(dev_perio_tx_fifo_size_9, "Number of words in the periodic Tx FIFO 4-768"); module_param_named(dev_perio_tx_fifo_size_10, dwc_otg_module_params.dev_perio_tx_fifo_size[9], int, 0444); MODULE_PARM_DESC(dev_perio_tx_fifo_size_10, "Number of words in the periodic Tx FIFO 4-768"); module_param_named(dev_perio_tx_fifo_size_11, dwc_otg_module_params.dev_perio_tx_fifo_size[10], int, 0444); MODULE_PARM_DESC(dev_perio_tx_fifo_size_11, "Number of words in the periodic Tx FIFO 4-768"); module_param_named(dev_perio_tx_fifo_size_12, dwc_otg_module_params.dev_perio_tx_fifo_size[11], int, 0444); MODULE_PARM_DESC(dev_perio_tx_fifo_size_12, "Number of words in the periodic Tx FIFO 4-768"); module_param_named(dev_perio_tx_fifo_size_13, dwc_otg_module_params.dev_perio_tx_fifo_size[12], int, 0444); MODULE_PARM_DESC(dev_perio_tx_fifo_size_13, "Number of words in the periodic Tx FIFO 4-768"); module_param_named(dev_perio_tx_fifo_size_14, dwc_otg_module_params.dev_perio_tx_fifo_size[13], int, 0444); MODULE_PARM_DESC(dev_perio_tx_fifo_size_14, "Number of words in the periodic Tx FIFO 4-768"); module_param_named(dev_perio_tx_fifo_size_15, dwc_otg_module_params.dev_perio_tx_fifo_size[14], int, 0444); MODULE_PARM_DESC(dev_perio_tx_fifo_size_15, "Number of words in the periodic Tx FIFO 4-768"); module_param_named(host_rx_fifo_size, dwc_otg_module_params.host_rx_fifo_size, int, 0444); MODULE_PARM_DESC(host_rx_fifo_size, "Number of words in the Rx FIFO 16-32768"); module_param_named(host_nperio_tx_fifo_size, dwc_otg_module_params.host_nperio_tx_fifo_size, int, 0444); MODULE_PARM_DESC(host_nperio_tx_fifo_size, "Number of words in the non-periodic Tx FIFO 16-32768"); module_param_named(host_perio_tx_fifo_size, dwc_otg_module_params.host_perio_tx_fifo_size, int, 0444); MODULE_PARM_DESC(host_perio_tx_fifo_size, "Number of words in the host periodic Tx FIFO 16-32768"); module_param_named(max_transfer_size, dwc_otg_module_params.max_transfer_size, int, 0444); /** @todo Set the max to 512K, modify checks */ MODULE_PARM_DESC(max_transfer_size, "The maximum transfer size supported in bytes 2047-65535"); module_param_named(max_packet_count, dwc_otg_module_params.max_packet_count, int, 0444); MODULE_PARM_DESC(max_packet_count, "The maximum number of packets in a transfer 15-511"); module_param_named(host_channels, dwc_otg_module_params.host_channels, int, 0444); MODULE_PARM_DESC(host_channels, "The number of host channel registers to use 1-16"); module_param_named(dev_endpoints, dwc_otg_module_params.dev_endpoints, int, 0444); MODULE_PARM_DESC(dev_endpoints, "The number of endpoints in addition to EP0 available for device mode 1-15"); module_param_named(phy_type, dwc_otg_module_params.phy_type, int, 0444); MODULE_PARM_DESC(phy_type, "0=Reserved 1=UTMI+ 2=ULPI"); module_param_named(phy_utmi_width, dwc_otg_module_params.phy_utmi_width, int, 0444); MODULE_PARM_DESC(phy_utmi_width, "Specifies the UTMI+ Data Width 8 or 16 bits"); module_param_named(phy_ulpi_ddr, dwc_otg_module_params.phy_ulpi_ddr, int, 0444); MODULE_PARM_DESC(phy_ulpi_ddr, "ULPI at double or single data rate 0=Single 1=Double"); module_param_named(phy_ulpi_ext_vbus, dwc_otg_module_params.phy_ulpi_ext_vbus, int, 0444); MODULE_PARM_DESC(phy_ulpi_ext_vbus, "ULPI PHY using internal or external vbus 0=Internal"); module_param_named(i2c_enable, dwc_otg_module_params.i2c_enable, int, 0444); MODULE_PARM_DESC(i2c_enable, "FS PHY Interface"); module_param_named(ulpi_fs_ls, dwc_otg_module_params.ulpi_fs_ls, int, 0444); MODULE_PARM_DESC(ulpi_fs_ls, "ULPI PHY FS/LS mode only"); module_param_named(ts_dline, dwc_otg_module_params.ts_dline, int, 0444); MODULE_PARM_DESC(ts_dline, "Term select Dline pulsing for all PHYs"); module_param_named(debug, g_dbg_lvl, int, 0444); MODULE_PARM_DESC(debug, ""); module_param_named(en_multiple_tx_fifo, dwc_otg_module_params.en_multiple_tx_fifo, int, 0444); MODULE_PARM_DESC(en_multiple_tx_fifo, "Dedicated Non Periodic Tx FIFOs 0=disabled 1=enabled"); module_param_named(dev_tx_fifo_size_1, dwc_otg_module_params.dev_tx_fifo_size[0], int, 0444); MODULE_PARM_DESC(dev_tx_fifo_size_1, "Number of words in the Tx FIFO 4-768"); module_param_named(dev_tx_fifo_size_2, dwc_otg_module_params.dev_tx_fifo_size[1], int, 0444); MODULE_PARM_DESC(dev_tx_fifo_size_2, "Number of words in the Tx FIFO 4-768"); module_param_named(dev_tx_fifo_size_3, dwc_otg_module_params.dev_tx_fifo_size[2], int, 0444); MODULE_PARM_DESC(dev_tx_fifo_size_3, "Number of words in the Tx FIFO 4-768"); module_param_named(dev_tx_fifo_size_4, dwc_otg_module_params.dev_tx_fifo_size[3], int, 0444); MODULE_PARM_DESC(dev_tx_fifo_size_4, "Number of words in the Tx FIFO 4-768"); module_param_named(dev_tx_fifo_size_5, dwc_otg_module_params.dev_tx_fifo_size[4], int, 0444); MODULE_PARM_DESC(dev_tx_fifo_size_5, "Number of words in the Tx FIFO 4-768"); module_param_named(dev_tx_fifo_size_6, dwc_otg_module_params.dev_tx_fifo_size[5], int, 0444); MODULE_PARM_DESC(dev_tx_fifo_size_6, "Number of words in the Tx FIFO 4-768"); module_param_named(dev_tx_fifo_size_7, dwc_otg_module_params.dev_tx_fifo_size[6], int, 0444); MODULE_PARM_DESC(dev_tx_fifo_size_7, "Number of words in the Tx FIFO 4-768"); module_param_named(dev_tx_fifo_size_8, dwc_otg_module_params.dev_tx_fifo_size[7], int, 0444); MODULE_PARM_DESC(dev_tx_fifo_size_8, "Number of words in the Tx FIFO 4-768"); module_param_named(dev_tx_fifo_size_9, dwc_otg_module_params.dev_tx_fifo_size[8], int, 0444); MODULE_PARM_DESC(dev_tx_fifo_size_9, "Number of words in the Tx FIFO 4-768"); module_param_named(dev_tx_fifo_size_10, dwc_otg_module_params.dev_tx_fifo_size[9], int, 0444); MODULE_PARM_DESC(dev_tx_fifo_size_10, "Number of words in the Tx FIFO 4-768"); module_param_named(dev_tx_fifo_size_11, dwc_otg_module_params.dev_tx_fifo_size[10], int, 0444); MODULE_PARM_DESC(dev_tx_fifo_size_11, "Number of words in the Tx FIFO 4-768"); module_param_named(dev_tx_fifo_size_12, dwc_otg_module_params.dev_tx_fifo_size[11], int, 0444); MODULE_PARM_DESC(dev_tx_fifo_size_12, "Number of words in the Tx FIFO 4-768"); module_param_named(dev_tx_fifo_size_13, dwc_otg_module_params.dev_tx_fifo_size[12], int, 0444); MODULE_PARM_DESC(dev_tx_fifo_size_13, "Number of words in the Tx FIFO 4-768"); module_param_named(dev_tx_fifo_size_14, dwc_otg_module_params.dev_tx_fifo_size[13], int, 0444); MODULE_PARM_DESC(dev_tx_fifo_size_14, "Number of words in the Tx FIFO 4-768"); module_param_named(dev_tx_fifo_size_15, dwc_otg_module_params.dev_tx_fifo_size[14], int, 0444); MODULE_PARM_DESC(dev_tx_fifo_size_15, "Number of words in the Tx FIFO 4-768"); module_param_named(thr_ctl, dwc_otg_module_params.thr_ctl, int, 0444); MODULE_PARM_DESC(thr_ctl, "Thresholding enable flag bit 0 - non ISO Tx thr., 1 - ISO Tx thr., 2 - Rx thr.- bit 0=disabled 1=enabled"); module_param_named(tx_thr_length, dwc_otg_module_params.tx_thr_length, int, 0444); MODULE_PARM_DESC(tx_thr_length, "Tx Threshold length in 32 bit DWORDs"); module_param_named(rx_thr_length, dwc_otg_module_params.rx_thr_length, int, 0444); MODULE_PARM_DESC(rx_thr_length, "Rx Threshold length in 32 bit DWORDs"); module_param_named(pti_enable, dwc_otg_module_params.pti_enable, int, 0444); module_param_named(mpi_enable, dwc_otg_module_params.mpi_enable, int, 0444); module_param_named(lpm_enable, dwc_otg_module_params.lpm_enable, int, 0444); MODULE_PARM_DESC(lpm_enable, "LPM Enable 0=LPM Disabled 1=LPM Enabled"); module_param_named(ic_usb_cap, dwc_otg_module_params.ic_usb_cap, int, 0444); MODULE_PARM_DESC(ic_usb_cap, "IC_USB Capability 0=IC_USB Disabled 1=IC_USB Enabled"); module_param_named(ahb_thr_ratio, dwc_otg_module_params.ahb_thr_ratio, int, 0444); MODULE_PARM_DESC(ahb_thr_ratio, "AHB Threshold Ratio"); /** @page "Module Parameters" * * The following parameters may be specified when starting the module. * These parameters define how the DWC_otg controller should be * configured. Parameter values are passed to the CIL initialization * function dwc_otg_cil_init * * Example: modprobe dwc_otg speed=1 otg_cap=1 * */
Parameter NameMeaning
otg_cap Specifies the OTG capabilities. The driver will automatically detect the value for this parameter if none is specified. - 0: HNP and SRP capable (default, if available) - 1: SRP Only capable - 2: No HNP/SRP capable
dma_enable Specifies whether to use slave or DMA mode for accessing the data FIFOs. The driver will automatically detect the value for this parameter if none is specified. - 0: Slave - 1: DMA (default, if available)
dma_burst_size The DMA Burst size (applicable only for External DMA Mode). - Values: 1, 4, 8 16, 32, 64, 128, 256 (default 32)
speed Specifies the maximum speed of operation in host and device mode. The actual speed depends on the speed of the attached device and the value of phy_type. - 0: High Speed (default) - 1: Full Speed
host_support_fs_ls_low_power Specifies whether low power mode is supported when attached to a Full Speed or Low Speed device in host mode. - 0: Don't support low power mode (default) - 1: Support low power mode
host_ls_low_power_phy_clk Specifies the PHY clock rate in low power mode when connected to a Low Speed device in host mode. This parameter is applicable only if HOST_SUPPORT_FS_LS_LOW_POWER is enabled. - 0: 48 MHz (default) - 1: 6 MHz
enable_dynamic_fifo Specifies whether FIFOs may be resized by the driver software. - 0: Use cC FIFO size parameters - 1: Allow dynamic FIFO sizing (default)
data_fifo_size Total number of 4-byte words in the data FIFO memory. This memory includes the Rx FIFO, non-periodic Tx FIFO, and periodic Tx FIFOs. - Values: 32 to 32768 (default 8192) Note: The total FIFO memory depth in the FPGA configuration is 8192.
dev_rx_fifo_size Number of 4-byte words in the Rx FIFO in device mode when dynamic FIFO sizing is enabled. - Values: 16 to 32768 (default 1064)
dev_nperio_tx_fifo_size Number of 4-byte words in the non-periodic Tx FIFO in device mode when dynamic FIFO sizing is enabled. - Values: 16 to 32768 (default 1024)
dev_perio_tx_fifo_size_n (n = 1 to 15) Number of 4-byte words in each of the periodic Tx FIFOs in device mode when dynamic FIFO sizing is enabled. - Values: 4 to 768 (default 256)
host_rx_fifo_size Number of 4-byte words in the Rx FIFO in host mode when dynamic FIFO sizing is enabled. - Values: 16 to 32768 (default 1024)
host_nperio_tx_fifo_size Number of 4-byte words in the non-periodic Tx FIFO in host mode when dynamic FIFO sizing is enabled in the core. - Values: 16 to 32768 (default 1024)
host_perio_tx_fifo_size Number of 4-byte words in the host periodic Tx FIFO when dynamic FIFO sizing is enabled. - Values: 16 to 32768 (default 1024)
max_transfer_size The maximum transfer size supported in bytes. - Values: 2047 to 65,535 (default 65,535)
max_packet_count The maximum number of packets in a transfer. - Values: 15 to 511 (default 511)
host_channels The number of host channel registers to use. - Values: 1 to 16 (default 12) Note: The FPGA configuration supports a maximum of 12 host channels.
dev_endpoints The number of endpoints in addition to EP0 available for device mode operations. - Values: 1 to 15 (default 6 IN and OUT) Note: The FPGA configuration supports a maximum of 6 IN and OUT endpoints in addition to EP0.
phy_type Specifies the type of PHY interface to use. By default, the driver will automatically detect the phy_type. - 0: Full Speed - 1: UTMI+ (default, if available) - 2: ULPI
phy_utmi_width Specifies the UTMI+ Data Width. This parameter is applicable for a phy_type of UTMI+. Also, this parameter is applicable only if the OTG_HSPHY_WIDTH cC parameter was set to "8 and 16 bits", meaning that the core has been configured to work at either data path width. - Values: 8 or 16 bits (default 16)
phy_ulpi_ddr Specifies whether the ULPI operates at double or single data rate. This parameter is only applicable if phy_type is ULPI. - 0: single data rate ULPI interface with 8 bit wide data bus (default) - 1: double data rate ULPI interface with 4 bit wide data bus
i2c_enable Specifies whether to use the I2C interface for full speed PHY. This parameter is only applicable if PHY_TYPE is FS. - 0: Disabled (default) - 1: Enabled
otg_en_multiple_tx_fifo Specifies whether dedicatedto tx fifos are enabled for non periodic IN EPs. The driver will automatically detect the value for this parameter if none is specified. - 0: Disabled - 1: Enabled (default, if available)
dev_tx_fifo_size_n (n = 1 to 15) Number of 4-byte words in each of the Tx FIFOs in device mode when dynamic FIFO sizing is enabled. - Values: 4 to 768 (default 256)
tx_thr_length Transmit Threshold length in 32 bit double words - Values: 8 to 128 (default 64)
rx_thr_length Receive Threshold length in 32 bit double words - Values: 8 to 128 (default 64)
thr_ctl Specifies whether to enable Thresholding for Device mode. Bits 0, 1, 2 of this parmater specifies if thresholding is enabled for non-Iso Tx, Iso Tx and Rx transfers accordingly. The driver will automatically detect the value for this parameter if none is specified. - Values: 0 to 7 (default 0) Bit values indicate: - 0: Thresholding disabled - 1: Thresholding enabled
dma_desc_enable Specifies whether to enable Descriptor DMA mode. The driver will automatically detect the value for this parameter if none is specified. - 0: Descriptor DMA disabled - 1: Descriptor DMA (default, if available)
mpi_enable Specifies whether to enable MPI enhancement mode. The driver will automatically detect the value for this parameter if none is specified. - 0: MPI disabled (default) - 1: MPI enable
pti_enable Specifies whether to enable PTI enhancement support. The driver will automatically detect the value for this parameter if none is specified. - 0: PTI disabled (default) - 1: PTI enable
lpm_enable Specifies whether to enable LPM support. The driver will automatically detect the value for this parameter if none is specified. - 0: LPM disabled - 1: LPM enable (default, if available)
ahb_thr_ratio Specifies AHB Threshold ratio. - Values: 0 to 3 (default 0)