1 /* ==========================================================================
2 * $File: //dwh/usb_iip/dev/software/otg/linux/drivers/dwc_otg_driver.c $
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.
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.
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
32 * ========================================================================== */
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.
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
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"
62 #include "usbdev_rk.h"
64 #define DWC_DRIVER_VERSION "3.10a 21-DEC-2012"
65 #define DWC_DRIVER_DESC "HS OTG USB Controller driver"
67 static const char dwc_host20_driver_name[] = "usb20_host";
68 static const char dwc_otg20_driver_name[] = "usb20_otg";
70 dwc_otg_device_t *g_otgdev;
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);
81 static u32 usb_to_uart_status;
82 /*-------------------------------------------------------------------------*/
83 /* Encapsulate the module parameter settings */
85 struct dwc_otg_driver_module_params {
89 int32_t dma_desc_enable;
90 int32_t dma_burst_size;
92 int32_t host_support_fs_ls_low_power;
93 int32_t host_ls_low_power_phy_clk;
94 int32_t enable_dynamic_fifo;
95 int32_t data_fifo_size;
96 int32_t dev_rx_fifo_size;
97 int32_t dev_nperio_tx_fifo_size;
98 uint32_t dev_perio_tx_fifo_size[MAX_PERIO_FIFOS];
99 int32_t host_rx_fifo_size;
100 int32_t host_nperio_tx_fifo_size;
101 int32_t host_perio_tx_fifo_size;
102 int32_t max_transfer_size;
103 int32_t max_packet_count;
104 int32_t host_channels;
105 int32_t dev_endpoints;
107 int32_t phy_utmi_width;
108 int32_t phy_ulpi_ddr;
109 int32_t phy_ulpi_ext_vbus;
113 int32_t en_multiple_tx_fifo;
114 uint32_t dev_tx_fifo_size[MAX_TX_FIFOS];
116 uint32_t tx_thr_length;
117 uint32_t rx_thr_length;
122 int32_t baseline_besl;
125 int32_t ahb_thr_ratio;
135 static struct dwc_otg_driver_module_params dwc_otg_module_params = {
137 .otg_cap = DWC_OTG_CAP_PARAM_NO_HNP_SRP_CAPABLE,
139 .dma_desc_enable = 0,
140 .dma_burst_size = -1,
142 .host_support_fs_ls_low_power = -1,
143 .host_ls_low_power_phy_clk = -1,
144 .enable_dynamic_fifo = 1,
145 .data_fifo_size = -1,
146 .dev_rx_fifo_size = 0x120,
147 .dev_nperio_tx_fifo_size = 0x10,
148 .dev_perio_tx_fifo_size = {
149 /* dev_perio_tx_fifo_size_1 */
167 .host_rx_fifo_size = -1,
168 .host_nperio_tx_fifo_size = -1,
169 .host_perio_tx_fifo_size = -1,
170 .max_transfer_size = -1,
171 .max_packet_count = -1,
175 .phy_utmi_width = -1,
177 .phy_ulpi_ext_vbus = -1,
181 .en_multiple_tx_fifo = -1,
182 .dev_tx_fifo_size = {
183 /* dev_tx_fifo_size */
221 #ifdef CONFIG_USB20_HOST
222 static struct dwc_otg_driver_module_params dwc_host_module_params = {
224 .otg_cap = DWC_OTG_CAP_PARAM_NO_HNP_SRP_CAPABLE,
226 .dma_desc_enable = 0,
227 .dma_burst_size = -1,
229 .host_support_fs_ls_low_power = -1,
230 .host_ls_low_power_phy_clk = -1,
231 .enable_dynamic_fifo = -1,
232 .data_fifo_size = -1,
233 .dev_rx_fifo_size = -1,
234 .dev_nperio_tx_fifo_size = -1,
235 .dev_perio_tx_fifo_size = {
236 /* dev_perio_tx_fifo_size_1 */
254 .host_rx_fifo_size = -1,
255 .host_nperio_tx_fifo_size = -1,
256 .host_perio_tx_fifo_size = -1,
257 .max_transfer_size = -1,
258 .max_packet_count = -1,
262 .phy_utmi_width = -1,
264 .phy_ulpi_ext_vbus = -1,
268 .en_multiple_tx_fifo = -1,
269 .dev_tx_fifo_size = {
270 /* dev_tx_fifo_size */
310 * This function shows the Driver Version.
312 static ssize_t version_show(struct device_driver *dev, char *buf)
314 return snprintf(buf, sizeof(DWC_DRIVER_VERSION) + 2, "%s\n",
318 static DRIVER_ATTR(version, S_IRUGO, version_show, NULL);
321 * Global Debug Level Mask.
323 uint32_t g_dbg_lvl = DBG_OFF; /* OFF */
326 * This function shows the driver Debug Level.
328 static ssize_t dbg_level_show(struct device_driver *drv, char *buf)
330 return sprintf(buf, "0x%0x\n", g_dbg_lvl);
334 * This function stores the driver Debug Level.
336 static ssize_t dbg_level_store(struct device_driver *drv, const char *buf,
339 g_dbg_lvl = simple_strtoul(buf, NULL, 16);
343 static DRIVER_ATTR(debuglevel, S_IRUGO | S_IWUSR, dbg_level_show,
346 extern void hcd_start(dwc_otg_core_if_t *core_if);
347 extern struct usb_hub *g_dwc_otg_root_hub20;
348 extern void dwc_otg_hub_disconnect_device(struct usb_hub *hub);
350 void dwc_otg_force_host(dwc_otg_core_if_t *core_if)
352 dwc_otg_device_t *otg_dev = core_if->otg_dev;
353 dctl_data_t dctl = {.d32 = 0 };
356 if (core_if->op_state == A_HOST) {
357 printk("dwc_otg_force_host,already in A_HOST mode,everest\n");
360 core_if->op_state = A_HOST;
362 cancel_delayed_work(&otg_dev->pcd->check_vbus_work);
363 dctl.d32 = DWC_READ_REG32(&core_if->dev_if->dev_global_regs->dctl);
364 dctl.b.sftdiscon = 1;
365 DWC_WRITE_REG32(&core_if->dev_if->dev_global_regs->dctl, dctl.d32);
367 local_irq_save(flags);
368 cil_pcd_stop(core_if);
370 * Initialize the Core for Host mode.
373 dwc_otg_core_init(core_if);
374 dwc_otg_enable_global_interrupts(core_if);
375 cil_hcd_start(core_if);
376 local_irq_restore(flags);
379 void dwc_otg_force_device(dwc_otg_core_if_t *core_if)
381 dwc_otg_device_t *otg_dev = core_if->otg_dev;
384 local_irq_save(flags);
386 if (core_if->op_state == B_PERIPHERAL) {
388 ("dwc_otg_force_device,already in B_PERIPHERAL,everest\n");
391 core_if->op_state = B_PERIPHERAL;
392 cil_hcd_stop(core_if);
393 /* dwc_otg_hub_disconnect_device(g_dwc_otg_root_hub20); */
394 otg_dev->pcd->phy_suspend = 1;
395 otg_dev->pcd->vbus_status = 0;
396 dwc_otg_pcd_start_check_vbus_work(otg_dev->pcd);
398 /* Reset the Controller */
399 dwc_otg_core_reset(core_if);
401 dwc_otg_core_init(core_if);
402 dwc_otg_disable_global_interrupts(core_if);
403 cil_pcd_start(core_if);
405 local_irq_restore(flags);
408 static ssize_t force_usb_mode_show(struct device_driver *drv, char *buf)
410 dwc_otg_device_t *otg_dev = g_otgdev;
411 dwc_otg_core_if_t *core_if = otg_dev->core_if;
413 return sprintf(buf, "%d\n", core_if->usb_mode);
416 static ssize_t force_usb_mode_store(struct device_driver *drv, const char *buf,
419 int new_mode = simple_strtoul(buf, NULL, 16);
420 dwc_otg_device_t *otg_dev = g_otgdev;
421 dwc_otg_core_if_t *core_if;
422 struct dwc_otg_platform_data *pldata;
427 core_if = otg_dev->core_if;
428 pldata = otg_dev->pldata;
430 DWC_PRINTF("%s %d->%d\n", __func__, core_if->usb_mode, new_mode);
432 if (core_if->usb_mode == new_mode) {
436 if (pldata->phy_status == USB_PHY_SUSPEND) {
437 pldata->clock_enable(pldata, 1);
438 pldata->phy_suspend(pldata, USB_PHY_ENABLED);
442 case USB_MODE_FORCE_HOST:
443 if (USB_MODE_FORCE_DEVICE == core_if->usb_mode) {
445 core_if->usb_mode = new_mode;
446 dwc_otg_force_host(core_if);
447 } else if (USB_MODE_NORMAL == core_if->usb_mode) {
448 core_if->usb_mode = new_mode;
449 if (dwc_otg_is_host_mode(core_if))
450 dwc_otg_set_force_mode(core_if, new_mode);
452 dwc_otg_force_host(core_if);
456 case USB_MODE_FORCE_DEVICE:
457 if (USB_MODE_FORCE_HOST == core_if->usb_mode) {
458 core_if->usb_mode = new_mode;
459 dwc_otg_force_device(core_if);
460 } else if (USB_MODE_NORMAL == core_if->usb_mode) {
461 core_if->usb_mode = new_mode;
462 if (dwc_otg_is_device_mode(core_if))
463 dwc_otg_set_force_mode(core_if, new_mode);
465 dwc_otg_force_device(core_if);
469 case USB_MODE_NORMAL:
470 if (USB_MODE_FORCE_DEVICE == core_if->usb_mode) {
471 core_if->usb_mode = new_mode;
472 cancel_delayed_work(&otg_dev->pcd->check_vbus_work);
473 dwc_otg_set_force_mode(core_if, new_mode);
475 if (dwc_otg_is_host_mode(core_if)) {
476 dwc_otg_force_host(core_if);
478 dwc_otg_pcd_start_check_vbus_work(otg_dev->pcd);
480 } else if (USB_MODE_FORCE_HOST == core_if->usb_mode) {
481 core_if->usb_mode = new_mode;
482 dwc_otg_set_force_mode(core_if, new_mode);
484 if (dwc_otg_is_device_mode(core_if)) {
485 dwc_otg_force_device(core_if);
496 static DRIVER_ATTR(force_usb_mode, S_IRUGO | S_IWUSR, force_usb_mode_show,
497 force_usb_mode_store);
499 static ssize_t dwc_otg_conn_en_show(struct device_driver *_drv, char *_buf)
502 dwc_otg_device_t *otg_dev = g_otgdev;
503 dwc_otg_pcd_t *_pcd = otg_dev->pcd;
504 return sprintf(_buf, "%d\n", _pcd->conn_en);
508 static ssize_t dwc_otg_conn_en_store(struct device_driver *_drv,
509 const char *_buf, size_t _count)
511 int enable = simple_strtoul(_buf, NULL, 10);
512 dwc_otg_device_t *otg_dev = g_otgdev;
513 dwc_otg_pcd_t *_pcd = otg_dev->pcd;
514 DWC_PRINTF("%s %d->%d\n", __func__, _pcd->conn_en, enable);
516 _pcd->conn_en = enable;
520 static DRIVER_ATTR(dwc_otg_conn_en, S_IRUGO | S_IWUSR, dwc_otg_conn_en_show,
521 dwc_otg_conn_en_store);
523 /* used for product vbus power control, SDK not need.
524 * If dwc_otg is host mode, enable vbus power.
525 * If dwc_otg is device mode, disable vbus power.
526 * return 1 - host mode, 0 - device mode.
528 int dwc_otg_usb_state(void)
530 dwc_otg_device_t *otg_dev = g_otgdev;
533 /* op_state is A_HOST */
534 if (1 == otg_dev->core_if->op_state)
536 /* op_state is B_PERIPHERAL */
537 else if (4 == otg_dev->core_if->op_state)
542 DWC_WARN("g_otgdev is NULL, maybe otg probe is failed!\n");
546 EXPORT_SYMBOL(dwc_otg_usb_state);
548 static ssize_t dwc_otg_op_state_show(struct device_driver *_drv, char *_buf)
550 dwc_otg_device_t *otg_dev = g_otgdev;
553 return sprintf(_buf, "%d\n", otg_dev->core_if->op_state);
555 return sprintf(_buf, "%d\n", 0);
558 static DRIVER_ATTR(op_state, S_IRUGO, dwc_otg_op_state_show, NULL);
560 static ssize_t vbus_status_show(struct device_driver *_drv, char *_buf)
562 dwc_otg_device_t *otg_dev = g_otgdev;
563 dwc_otg_pcd_t *_pcd = otg_dev->pcd;
564 return sprintf(_buf, "%d\n", _pcd->vbus_status);
567 static DRIVER_ATTR(vbus_status, S_IRUGO, vbus_status_show, NULL);
570 * This function is called during module intialization
571 * to pass module parameters to the DWC_OTG CORE.
573 static int set_parameters(dwc_otg_core_if_t *core_if,
574 struct dwc_otg_driver_module_params module_params)
579 if (module_params.otg_cap != -1) {
581 dwc_otg_set_param_otg_cap(core_if, module_params.otg_cap);
583 if (module_params.dma_enable != -1) {
585 dwc_otg_set_param_dma_enable(core_if,
586 module_params.dma_enable);
588 if (module_params.dma_desc_enable != -1) {
590 dwc_otg_set_param_dma_desc_enable(core_if,
591 module_params.dma_desc_enable);
593 if (module_params.opt != -1) {
594 retval += dwc_otg_set_param_opt(core_if, module_params.opt);
596 if (module_params.dma_burst_size != -1) {
598 dwc_otg_set_param_dma_burst_size(core_if,
599 module_params.dma_burst_size);
601 if (module_params.host_support_fs_ls_low_power != -1) {
603 dwc_otg_set_param_host_support_fs_ls_low_power(core_if,
604 module_params.host_support_fs_ls_low_power);
606 if (module_params.enable_dynamic_fifo != -1) {
608 dwc_otg_set_param_enable_dynamic_fifo(core_if,
609 module_params.enable_dynamic_fifo);
611 if (module_params.data_fifo_size != -1) {
613 dwc_otg_set_param_data_fifo_size(core_if,
614 module_params.data_fifo_size);
616 if (module_params.dev_rx_fifo_size != -1) {
618 dwc_otg_set_param_dev_rx_fifo_size(core_if,
619 module_params.dev_rx_fifo_size);
621 if (module_params.dev_nperio_tx_fifo_size != -1) {
623 dwc_otg_set_param_dev_nperio_tx_fifo_size(core_if,
624 module_params.dev_nperio_tx_fifo_size);
626 if (module_params.host_rx_fifo_size != -1) {
628 dwc_otg_set_param_host_rx_fifo_size(core_if,
632 if (module_params.host_nperio_tx_fifo_size != -1) {
634 dwc_otg_set_param_host_nperio_tx_fifo_size(core_if,
635 module_params.host_nperio_tx_fifo_size);
637 if (module_params.host_perio_tx_fifo_size != -1) {
639 dwc_otg_set_param_host_perio_tx_fifo_size(core_if,
640 module_params.host_perio_tx_fifo_size);
642 if (module_params.max_transfer_size != -1) {
644 dwc_otg_set_param_max_transfer_size(core_if,
645 module_params.max_transfer_size);
647 if (module_params.max_packet_count != -1) {
649 dwc_otg_set_param_max_packet_count(core_if,
650 module_params.max_packet_count);
652 if (module_params.host_channels != -1) {
654 dwc_otg_set_param_host_channels(core_if,
655 module_params.host_channels);
657 if (module_params.dev_endpoints != -1) {
659 dwc_otg_set_param_dev_endpoints(core_if,
660 module_params.dev_endpoints);
662 if (module_params.phy_type != -1) {
664 dwc_otg_set_param_phy_type(core_if, module_params.phy_type);
666 if (module_params.speed != -1) {
667 retval += dwc_otg_set_param_speed(core_if, module_params.speed);
669 if (module_params.host_ls_low_power_phy_clk != -1) {
671 dwc_otg_set_param_host_ls_low_power_phy_clk(core_if,
672 module_params.host_ls_low_power_phy_clk);
674 if (module_params.phy_ulpi_ddr != -1) {
676 dwc_otg_set_param_phy_ulpi_ddr(core_if,
677 module_params.phy_ulpi_ddr);
679 if (module_params.phy_ulpi_ext_vbus != -1) {
681 dwc_otg_set_param_phy_ulpi_ext_vbus(core_if,
682 module_params.phy_ulpi_ext_vbus);
684 if (module_params.phy_utmi_width != -1) {
686 dwc_otg_set_param_phy_utmi_width(core_if,
687 module_params.phy_utmi_width);
689 if (module_params.ulpi_fs_ls != -1) {
691 dwc_otg_set_param_ulpi_fs_ls(core_if,
692 module_params.ulpi_fs_ls);
694 if (module_params.ts_dline != -1) {
696 dwc_otg_set_param_ts_dline(core_if, module_params.ts_dline);
698 if (module_params.i2c_enable != -1) {
700 dwc_otg_set_param_i2c_enable(core_if,
701 module_params.i2c_enable);
703 if (module_params.en_multiple_tx_fifo != -1) {
705 dwc_otg_set_param_en_multiple_tx_fifo(core_if,
706 module_params.en_multiple_tx_fifo);
708 for (i = 0; i < 15; i++) {
709 if (module_params.dev_perio_tx_fifo_size[i] != -1) {
711 dwc_otg_set_param_dev_perio_tx_fifo_size(core_if,
712 module_params.dev_perio_tx_fifo_size
717 for (i = 0; i < 15; i++) {
718 if (module_params.dev_tx_fifo_size[i] != -1) {
719 retval += dwc_otg_set_param_dev_tx_fifo_size(core_if,
720 module_params.dev_tx_fifo_size
724 if (module_params.thr_ctl != -1) {
726 dwc_otg_set_param_thr_ctl(core_if, module_params.thr_ctl);
728 if (module_params.mpi_enable != -1) {
730 dwc_otg_set_param_mpi_enable(core_if,
731 module_params.mpi_enable);
733 if (module_params.pti_enable != -1) {
735 dwc_otg_set_param_pti_enable(core_if,
736 module_params.pti_enable);
738 if (module_params.lpm_enable != -1) {
740 dwc_otg_set_param_lpm_enable(core_if,
741 module_params.lpm_enable);
743 if (module_params.besl_enable != -1) {
745 dwc_otg_set_param_besl_enable(core_if,
746 module_params.besl_enable);
748 if (module_params.baseline_besl != -1) {
750 dwc_otg_set_param_baseline_besl(core_if,
751 module_params.baseline_besl);
753 if (module_params.deep_besl != -1) {
755 dwc_otg_set_param_deep_besl(core_if,
756 module_params.deep_besl);
758 if (module_params.ic_usb_cap != -1) {
760 dwc_otg_set_param_ic_usb_cap(core_if,
761 module_params.ic_usb_cap);
763 if (module_params.tx_thr_length != -1) {
765 dwc_otg_set_param_tx_thr_length(core_if,
769 if (module_params.rx_thr_length != -1) {
771 dwc_otg_set_param_rx_thr_length(core_if,
772 module_params.rx_thr_length);
774 if (module_params.ahb_thr_ratio != -1) {
776 dwc_otg_set_param_ahb_thr_ratio(core_if,
780 if (module_params.power_down != -1) {
782 dwc_otg_set_param_power_down(core_if,
783 module_params.power_down);
785 if (module_params.reload_ctl != -1) {
787 dwc_otg_set_param_reload_ctl(core_if,
788 module_params.reload_ctl);
791 if (module_params.dev_out_nak != -1) {
793 dwc_otg_set_param_dev_out_nak(core_if,
794 module_params.dev_out_nak);
797 if (module_params.cont_on_bna != -1) {
799 dwc_otg_set_param_cont_on_bna(core_if,
800 module_params.cont_on_bna);
803 if (module_params.ahb_single != -1) {
805 dwc_otg_set_param_ahb_single(core_if,
806 module_params.ahb_single);
809 if (module_params.otg_ver != -1) {
811 dwc_otg_set_param_otg_ver(core_if, module_params.otg_ver);
813 if (module_params.adp_enable != -1) {
815 dwc_otg_set_param_adp_enable(core_if,
816 module_params.adp_enable);
822 * This function is the top level interrupt handler for the Common
823 * (Device and host modes) interrupts.
825 static irqreturn_t dwc_otg_common_irq(int irq, void *dev)
827 int32_t retval = IRQ_NONE;
829 retval = dwc_otg_handle_common_intr(dev);
831 /* S3C2410X_CLEAR_EINTPEND(); */
833 return IRQ_RETVAL(retval);
836 #ifdef CONFIG_USB20_HOST
838 * This function is called when a lm_device is unregistered with the
839 * dwc_otg_driver. This happens, for example, when the rmmod command is
840 * executed. The device may or may not be electrically present. If it is
841 * present, the driver stops device processing. Any resources used on behalf
842 * of this device are freed.
846 static int host20_driver_remove(struct platform_device *_dev)
849 dwc_otg_device_t *otg_dev = dwc_get_device_platform_data(_dev);
850 DWC_DEBUGPL(DBG_ANY, "%s(%p)\n", __func__, _dev);
853 /* Memory allocation for the dwc_otg_device failed. */
854 DWC_DEBUGPL(DBG_ANY, "%s: otg_dev NULL!\n", __func__);
857 #ifndef DWC_DEVICE_ONLY
861 DWC_DEBUGPL(DBG_ANY, "%s: otg_dev->hcd NULL!\n", __func__);
866 #ifndef DWC_HOST_ONLY
870 DWC_DEBUGPL(DBG_ANY, "%s: otg_dev->pcd NULL!\n", __func__);
878 if (otg_dev->common_irq_installed) {
879 /* free_irq(_dev->irq, otg_dev); */
880 free_irq(platform_get_irq(_dev, 0), otg_dev);
882 DWC_DEBUGPL(DBG_ANY, "%s: There is no installed irq!\n",
887 if (otg_dev->core_if) {
888 dwc_otg_cil_remove(otg_dev->core_if);
890 DWC_DEBUGPL(DBG_ANY, "%s: otg_dev->core_if NULL!\n", __func__);
895 * Remove the device attributes
897 dwc_otg_attr_remove(_dev);
902 if (otg_dev->os_dep.base) {
903 iounmap(otg_dev->os_dep.base);
908 * Clear the drvdata pointer.
911 dwc_set_device_platform_data(_dev, 0);
916 static const struct of_device_id usb20_host_of_match[] = {
918 .compatible = "rockchip,rk3188_usb20_host",
919 .data = &usb20host_pdata_rk3188,
922 .compatible = "rockchip,rk3288_usb20_host",
923 .data = &usb20host_pdata_rk3288,
926 .compatible = "rockchip,rk3036_usb20_host",
927 .data = &usb20host_pdata_rk3036,
930 .compatible = "rockchip,rk3126_usb20_host",
931 .data = &usb20host_pdata_rk3126,
936 MODULE_DEVICE_TABLE(of, usb20_host_of_match);
939 * This function is called when an lm_device is bound to a
940 * dwc_otg_driver. It creates the driver components required to
941 * control the device (CIL, HCD, and PCD) and it initializes the
942 * device. The driver components are stored in a dwc_otg_device
943 * structure. A reference to the dwc_otg_device is saved in the
944 * lm_device. This allows the driver to access the dwc_otg_device
945 * structure on subsequent calls to driver methods for this device.
947 * @param _dev Bus device
949 static int host20_driver_probe(struct platform_device *_dev)
953 struct resource *res_base;
954 dwc_otg_device_t *dwc_otg_device;
955 struct device *dev = &_dev->dev;
956 struct device_node *node = _dev->dev.of_node;
957 struct dwc_otg_platform_data *pldata;
958 const struct of_device_id *match =
959 of_match_device(of_match_ptr(usb20_host_of_match), &_dev->dev);
961 if (match && match->data) {
962 pldata = (void *)match->data;
965 dev_err(dev, "usb20otg match failed\n");
970 dev_err(dev, "device node not found\n");
977 if (pldata->clock_init) {
978 pldata->clock_init(pldata);
979 pldata->clock_enable(pldata, 1);
982 if (pldata->phy_suspend)
983 pldata->phy_suspend(pldata, USB_PHY_ENABLED);
985 if (pldata->soft_reset)
986 pldata->soft_reset(pldata, RST_POR);
988 res_base = platform_get_resource(_dev, IORESOURCE_MEM, 0);
990 dwc_otg_device = DWC_ALLOC(sizeof(dwc_otg_device_t));
992 if (!dwc_otg_device) {
993 dev_err(&_dev->dev, "kmalloc of dwc_otg_device failed\n");
998 memset(dwc_otg_device, 0, sizeof(*dwc_otg_device));
999 dwc_otg_device->os_dep.reg_offset = 0xFFFFFFFF;
1002 * Map the DWC_otg Core memory into virtual address space.
1005 dwc_otg_device->os_dep.base = devm_ioremap_resource(dev, res_base);
1007 if (!dwc_otg_device->os_dep.base) {
1008 dev_err(&_dev->dev, "ioremap() failed\n");
1009 DWC_FREE(dwc_otg_device);
1013 dev_dbg(&_dev->dev, "base=0x%p\n", dwc_otg_device->os_dep.base);
1015 /* Set device flags indicating whether the HCD supports DMA. */
1016 if (!_dev->dev.dma_mask)
1017 _dev->dev.dma_mask = &_dev->dev.coherent_dma_mask;
1018 retval = dma_set_coherent_mask(&_dev->dev, DMA_BIT_MASK(32));
1023 * Initialize driver data to point to the global DWC_otg
1027 dwc_set_device_platform_data(_dev, dwc_otg_device);
1028 pldata->privdata = dwc_otg_device;
1029 dwc_otg_device->pldata = (void *)pldata;
1031 dev_dbg(&_dev->dev, "dwc_otg_device=0x%p\n", dwc_otg_device);
1033 dwc_otg_device->core_if = dwc_otg_cil_init(dwc_otg_device->os_dep.base);
1035 if (!dwc_otg_device->core_if) {
1036 dev_err(&_dev->dev, "CIL initialization failed!\n");
1041 dwc_otg_device->core_if->otg_dev = dwc_otg_device;
1044 * Attempt to ensure this device is really a DWC_otg Controller.
1045 * Read and verify the SNPSID register contents. The value should be
1046 * 0x45F42XXX or 0x45F42XXX, which corresponds to either "OT2" or "OTG3",
1047 * as in "OTG version 2.XX" or "OTG version 3.XX".
1050 if (((dwc_otg_get_gsnpsid(dwc_otg_device->core_if) & 0xFFFFF000) !=
1052 && ((dwc_otg_get_gsnpsid(dwc_otg_device->core_if) & 0xFFFFF000) !=
1054 dev_err(&_dev->dev, "Bad value for SNPSID: 0x%08x\n",
1055 dwc_otg_get_gsnpsid(dwc_otg_device->core_if));
1061 * Validate parameter values.
1063 if (set_parameters(dwc_otg_device->core_if, dwc_host_module_params)) {
1069 * Create Device Attributes in sysfs
1071 dwc_otg_attr_create(_dev);
1074 * Disable the global interrupt until all the interrupt
1075 * handlers are installed.
1077 dwc_otg_disable_global_interrupts(dwc_otg_device->core_if);
1080 * Install the interrupt handler for the common interrupts before
1081 * enabling common interrupts in core_init below.
1083 irq = platform_get_irq(_dev, 0);
1084 DWC_DEBUGPL(DBG_CIL, "registering (common) handler for irq%d\n", irq);
1085 retval = request_irq(irq, dwc_otg_common_irq,
1086 IRQF_SHARED, "dwc_otg", dwc_otg_device);
1088 DWC_ERROR("request of irq%d failed\n", irq);
1092 dwc_otg_device->common_irq_installed = 1;
1096 * Initialize the DWC_otg core.
1097 * In order to reduce the time of initialization,
1098 * we do core soft reset after connection detected.
1100 dwc_otg_core_init_no_reset(dwc_otg_device->core_if);
1103 * Initialize the HCD
1105 retval = host20_hcd_init(_dev);
1107 DWC_ERROR("hcd_init failed\n");
1108 dwc_otg_device->hcd = NULL;
1112 clk_set_rate(pldata->phyclk_480m, 480000000);
1114 * Enable the global interrupt after all the interrupt
1115 * handlers are installed if there is no ADP support else
1116 * perform initial actions required for Internal ADP logic.
1118 if (!dwc_otg_get_param_adp_enable(dwc_otg_device->core_if)) {
1119 if (pldata->phy_status == USB_PHY_ENABLED) {
1120 pldata->phy_suspend(pldata, USB_PHY_SUSPEND);
1122 pldata->clock_enable(pldata, 0);
1124 /* dwc_otg_enable_global_interrupts(dwc_otg_device->core_if); */
1126 dwc_otg_adp_start(dwc_otg_device->core_if,
1127 dwc_otg_is_host_mode(dwc_otg_device->
1133 host20_driver_remove(_dev);
1135 if (pldata->clock_enable)
1136 pldata->clock_enable(pldata, 0);
1142 static int dwc_otg_driver_suspend(struct platform_device *_dev,
1148 static int dwc_otg_driver_resume(struct platform_device *_dev)
1153 static void dwc_otg_driver_shutdown(struct platform_device *_dev)
1155 struct device *dev = &_dev->dev;
1156 dwc_otg_device_t *otg_dev = dev->platform_data;
1157 dwc_otg_core_if_t *core_if = otg_dev->core_if;
1158 struct dwc_otg_platform_data *pldata = otg_dev->pldata;
1159 dctl_data_t dctl = {.d32 = 0 };
1161 DWC_PRINTF("%s: disconnect USB %s mode\n", __func__,
1162 dwc_otg_is_host_mode(core_if) ? "host" : "device");
1164 if (pldata->dwc_otg_uart_mode != NULL)
1165 pldata->dwc_otg_uart_mode(pldata, PHY_USB_MODE);
1166 if (pldata->phy_suspend != NULL)
1167 pldata->phy_suspend(pldata, USB_PHY_ENABLED);
1168 if (dwc_otg_is_host_mode(core_if)) {
1169 if (core_if->hcd_cb && core_if->hcd_cb->stop)
1170 core_if->hcd_cb->stop(core_if->hcd_cb_p);
1172 /* soft disconnect */
1174 DWC_READ_REG32(&core_if->dev_if->dev_global_regs->dctl);
1175 dctl.b.sftdiscon = 1;
1176 DWC_WRITE_REG32(&core_if->dev_if->dev_global_regs->dctl,
1179 /* Clear any pending interrupts */
1180 DWC_WRITE_REG32(&core_if->core_global_regs->gintsts, 0xFFFFFFFF);
1185 * This structure defines the methods to be called by a bus driver
1186 * during the lifecycle of a device on that bus. Both drivers and
1187 * devices are registered with a bus driver. The bus driver matches
1188 * devices to drivers based on information in the device and driver
1191 * The probe function is called when the bus driver matches a device
1192 * to this driver. The remove function is called when a device is
1193 * unregistered with the bus driver.
1195 #ifdef CONFIG_USB20_HOST
1196 static struct platform_driver dwc_host_driver = {
1198 .name = (char *)dwc_host20_driver_name,
1199 .of_match_table = of_match_ptr(usb20_host_of_match),
1201 .probe = host20_driver_probe,
1202 .remove = host20_driver_remove,
1203 .suspend = dwc_otg_driver_suspend,
1204 .resume = dwc_otg_driver_resume,
1208 #ifdef CONFIG_USB20_OTG
1210 * This function is called when a lm_device is unregistered with the
1211 * dwc_otg_driver. This happens, for example, when the rmmod command is
1212 * executed. The device may or may not be electrically present. If it is
1213 * present, the driver stops device processing. Any resources used on behalf
1214 * of this device are freed.
1218 static int otg20_driver_remove(struct platform_device *_dev)
1221 dwc_otg_device_t *otg_dev = dwc_get_device_platform_data(_dev);
1222 DWC_DEBUGPL(DBG_ANY, "%s(%p)\n", __func__, _dev);
1225 /* Memory allocation for the dwc_otg_device failed. */
1226 DWC_DEBUGPL(DBG_ANY, "%s: otg_dev NULL!\n", __func__);
1229 #ifndef DWC_DEVICE_ONLY
1233 DWC_DEBUGPL(DBG_ANY, "%s: otg_dev->hcd NULL!\n", __func__);
1238 #ifndef DWC_HOST_ONLY
1242 DWC_DEBUGPL(DBG_ANY, "%s: otg_dev->pcd NULL!\n", __func__);
1249 if (otg_dev->common_irq_installed) {
1250 /* free_irq(_dev->irq, otg_dev); */
1251 free_irq(platform_get_irq(_dev, 0), otg_dev);
1253 DWC_DEBUGPL(DBG_ANY, "%s: There is no installed irq!\n",
1258 if (otg_dev->core_if) {
1259 dwc_otg_cil_remove(otg_dev->core_if);
1261 DWC_DEBUGPL(DBG_ANY, "%s: otg_dev->core_if NULL!\n", __func__);
1266 * Remove the device attributes
1268 dwc_otg_attr_remove(_dev);
1271 * Return the memory.
1273 if (otg_dev->os_dep.base)
1274 iounmap(otg_dev->os_dep.base);
1278 * Clear the drvdata pointer.
1281 dwc_set_device_platform_data(_dev, 0);
1286 static const struct of_device_id usb20_otg_of_match[] = {
1288 .compatible = "rockchip,rk3188_usb20_otg",
1289 .data = &usb20otg_pdata_rk3188,
1292 .compatible = "rockchip,rk3288_usb20_otg",
1293 .data = &usb20otg_pdata_rk3288,
1296 .compatible = "rockchip,rk3036_usb20_otg",
1297 .data = &usb20otg_pdata_rk3036,
1300 .compatible = "rockchip,rk3126_usb20_otg",
1301 .data = &usb20otg_pdata_rk3126,
1304 .compatible = "rockchip,rk3368_usb20_otg",
1305 .data = &usb20otg_pdata_rk3368,
1310 MODULE_DEVICE_TABLE(of, usb20_otg_of_match);
1313 * This function is called when an lm_device is bound to a
1314 * dwc_otg_driver. It creates the driver components required to
1315 * control the device (CIL, HCD, and PCD) and it initializes the
1316 * device. The driver components are stored in a dwc_otg_device
1317 * structure. A reference to the dwc_otg_device is saved in the
1318 * lm_device. This allows the driver to access the dwc_otg_device
1319 * structure on subsequent calls to driver methods for this device.
1321 * @param _dev Bus device
1323 static int otg20_driver_probe(struct platform_device *_dev)
1328 struct resource *res_base;
1329 dwc_otg_device_t *dwc_otg_device;
1330 struct device *dev = &_dev->dev;
1331 struct device_node *node = _dev->dev.of_node;
1332 struct dwc_otg_platform_data *pldata;
1333 const struct of_device_id *match =
1334 of_match_device(of_match_ptr(usb20_otg_of_match), &_dev->dev);
1336 if (match && match->data) {
1337 pldata = (void *)match->data;
1340 dev_err(dev, "usb20otg match failed\n");
1345 dev_err(dev, "device node not found\n");
1349 if (pldata->hw_init)
1352 if (pldata->clock_init) {
1353 pldata->clock_init(pldata);
1354 pldata->clock_enable(pldata, 1);
1357 if (pldata->phy_suspend)
1358 pldata->phy_suspend(pldata, USB_PHY_ENABLED);
1360 if (pldata->dwc_otg_uart_mode)
1361 pldata->dwc_otg_uart_mode(pldata, PHY_USB_MODE);
1363 /* do reset later, because reset need about
1364 * 100ms to ensure otg id state change.
1367 if(pldata->soft_reset)
1368 pldata->soft_reset();
1372 res_base = platform_get_resource(_dev, IORESOURCE_MEM, 0);
1374 dwc_otg_device = DWC_ALLOC(sizeof(dwc_otg_device_t));
1376 if (!dwc_otg_device) {
1377 dev_err(&_dev->dev, "kmalloc of dwc_otg_device failed\n");
1382 memset(dwc_otg_device, 0, sizeof(*dwc_otg_device));
1383 dwc_otg_device->os_dep.reg_offset = 0xFFFFFFFF;
1386 * Map the DWC_otg Core memory into virtual address space.
1389 dwc_otg_device->os_dep.base = devm_ioremap_resource(dev, res_base);
1391 if (!dwc_otg_device->os_dep.base) {
1392 dev_err(&_dev->dev, "ioremap() failed\n");
1393 DWC_FREE(dwc_otg_device);
1397 dev_dbg(&_dev->dev, "base=0x%p\n", dwc_otg_device->os_dep.base);
1399 /* Set device flags indicating whether the HCD supports DMA. */
1400 if (!_dev->dev.dma_mask)
1401 _dev->dev.dma_mask = &_dev->dev.coherent_dma_mask;
1402 retval = dma_set_coherent_mask(&_dev->dev, DMA_BIT_MASK(32));
1407 * Initialize driver data to point to the global DWC_otg
1411 g_otgdev = dwc_otg_device;
1412 pldata->privdata = dwc_otg_device;
1413 dwc_otg_device->pldata = pldata;
1415 dwc_set_device_platform_data(_dev, dwc_otg_device);
1417 dev_dbg(&_dev->dev, "dwc_otg_device=0x%p\n", dwc_otg_device);
1419 dwc_otg_device->core_if = dwc_otg_cil_init(dwc_otg_device->os_dep.base);
1420 if (!dwc_otg_device->core_if) {
1421 dev_err(&_dev->dev, "CIL initialization failed!\n");
1426 dwc_otg_device->core_if->otg_dev = dwc_otg_device;
1428 * Attempt to ensure this device is really a DWC_otg Controller.
1429 * Read and verify the SNPSID register contents. The value should be
1430 * 0x45F42XXX or 0x45F42XXX, which corresponds to either "OT2" or "OTG3",
1431 * as in "OTG version 2.XX" or "OTG version 3.XX".
1434 if (((dwc_otg_get_gsnpsid(dwc_otg_device->core_if) & 0xFFFFF000) !=
1436 && ((dwc_otg_get_gsnpsid(dwc_otg_device->core_if) & 0xFFFFF000) !=
1438 dev_err(&_dev->dev, "Bad value for SNPSID: 0x%08x\n",
1439 dwc_otg_get_gsnpsid(dwc_otg_device->core_if));
1445 * Validate parameter values.
1447 if (set_parameters(dwc_otg_device->core_if, dwc_otg_module_params)) {
1453 * Create Device Attributes in sysfs
1455 dwc_otg_attr_create(_dev);
1458 * Disable the global interrupt until all the interrupt
1459 * handlers are installed.
1461 dwc_otg_disable_global_interrupts(dwc_otg_device->core_if);
1464 * Install the interrupt handler for the common interrupts before
1465 * enabling common interrupts in core_init below.
1467 irq = platform_get_irq(_dev, 0);
1468 DWC_DEBUGPL(DBG_CIL, "registering (common) handler for irq%d\n", irq);
1469 retval = request_irq(irq, dwc_otg_common_irq,
1470 IRQF_SHARED, "dwc_otg", dwc_otg_device);
1472 DWC_ERROR("request of irq%d failed\n", irq);
1476 dwc_otg_device->common_irq_installed = 1;
1480 * Initialize the DWC_otg core.
1481 * In order to reduce the time of initialization,
1482 * we do core soft reset after connection detected.
1484 dwc_otg_core_init_no_reset(dwc_otg_device->core_if);
1487 * 0 - USB_MODE_NORMAL
1488 * 1 - USB_MODE_FORCE_HOST
1489 * 2 - USB_MODE_FORCE_DEVICE
1491 of_property_read_u32(node, "rockchip,usb-mode", &val);
1492 dwc_otg_device->core_if->usb_mode = val;
1494 #ifndef DWC_HOST_ONLY
1496 * Initialize the PCD
1498 retval = pcd_init(_dev);
1500 DWC_ERROR("pcd_init failed\n");
1501 dwc_otg_device->pcd = NULL;
1505 #ifndef DWC_DEVICE_ONLY
1507 * Initialize the HCD
1509 retval = otg20_hcd_init(_dev);
1511 DWC_ERROR("hcd_init failed\n");
1512 dwc_otg_device->hcd = NULL;
1517 * Enable the global interrupt after all the interrupt
1518 * handlers are installed if there is no ADP support else
1519 * perform initial actions required for Internal ADP logic.
1521 if (!dwc_otg_get_param_adp_enable(dwc_otg_device->core_if)) {
1522 if (pldata->phy_status == USB_PHY_ENABLED) {
1523 pldata->phy_suspend(pldata, USB_PHY_SUSPEND);
1525 pldata->clock_enable(pldata, 0);
1527 /* dwc_otg_enable_global_interrupts(dwc_otg_device->core_if); */
1529 dwc_otg_adp_start(dwc_otg_device->core_if,
1530 dwc_otg_is_host_mode(dwc_otg_device->
1536 otg20_driver_remove(_dev);
1539 if (pldata->clock_enable)
1540 pldata->clock_enable(pldata, 0);
1546 static int dwc_otg_pm_suspend(struct device *dev)
1548 dwc_otg_device_t *dwc_otg_device;
1549 struct dwc_otg_platform_data *pdata_otg;
1551 dwc_otg_device = dev_get_platdata(dev);
1553 dev_dbg(dev, "dwc_otg PM suspend\n");
1555 if (dwc_otg_device->core_if->op_state == B_PERIPHERAL)
1558 pdata_otg = dwc_otg_device->pldata;
1559 pdata_otg->phy_suspend(pdata_otg, USB_PHY_SUSPEND);
1564 static int dwc_otg_pm_resume(struct device *dev)
1566 dwc_otg_device_t *dwc_otg_device;
1567 struct dwc_otg_platform_data *pdata_otg;
1569 dwc_otg_device = dev_get_platdata(dev);
1571 dev_dbg(dev, "dwc_otg PM resume\n");
1573 if (dwc_otg_device->core_if->op_state == B_PERIPHERAL)
1576 pdata_otg = dwc_otg_device->pldata;
1577 pdata_otg->phy_suspend(pdata_otg, USB_PHY_ENABLED);
1582 #define dwc_otg_pm_suspend NULL
1583 #define dwc_otg_pm_resume NULL
1586 static const struct dev_pm_ops dwc_otg_dev_pm_ops = {
1587 .suspend = dwc_otg_pm_suspend,
1588 .resume = dwc_otg_pm_resume,
1591 static struct platform_driver dwc_otg_driver = {
1593 .name = (char *)dwc_otg20_driver_name,
1594 .of_match_table = of_match_ptr(usb20_otg_of_match),
1596 .pm = &dwc_otg_dev_pm_ops,
1599 .probe = otg20_driver_probe,
1600 .remove = otg20_driver_remove,
1601 .suspend = dwc_otg_driver_suspend,
1602 .resume = dwc_otg_driver_resume,
1603 .shutdown = dwc_otg_driver_shutdown,
1607 void rk_usb_power_up(void)
1609 struct dwc_otg_platform_data *pldata_otg;
1610 struct dwc_otg_platform_data *pldata_host;
1611 struct rkehci_platform_data *pldata_ehci;
1612 if (cpu_is_rk312x()) {
1613 pldata_otg = &usb20otg_pdata_rk3126;
1614 if (usb_to_uart_status)
1615 pldata_otg->dwc_otg_uart_mode(pldata_otg, PHY_UART_MODE);
1617 if (cpu_is_rk3288()) {
1618 #ifdef CONFIG_RK_USB_UART
1619 /* enable USB bypass UART function */
1620 writel_relaxed(0x00c00000 | usb_to_uart_status,
1621 RK_GRF_VIRT + RK3288_GRF_UOC0_CON3);
1624 /* unset siddq,the analog blocks are powered up */
1625 #ifdef CONFIG_USB20_OTG
1626 pldata_otg = &usb20otg_pdata_rk3288;
1628 if (pldata_otg->phy_status == USB_PHY_SUSPEND)
1629 writel_relaxed((0x01 << 13) << 16,
1631 RK3288_GRF_UOC0_CON0);
1634 #ifdef CONFIG_USB20_HOST
1635 pldata_host = &usb20host_pdata_rk3288;
1637 if (pldata_host->phy_status == USB_PHY_SUSPEND)
1638 writel_relaxed((0x01 << 13) << 16,
1640 RK3288_GRF_UOC2_CON0);
1643 #ifdef CONFIG_USB_EHCI_RK
1644 pldata_ehci = &rkehci_pdata_rk3288;
1646 if (pldata_ehci->phy_status == USB_PHY_SUSPEND)
1647 writel_relaxed((0x01 << 13) << 16,
1649 RK3288_GRF_UOC1_CON0);
1656 void rk_usb_power_down(void)
1658 struct dwc_otg_platform_data *pldata_otg;
1659 struct dwc_otg_platform_data *pldata_host;
1660 struct rkehci_platform_data *pldata_ehci;
1662 if (cpu_is_rk312x()) {
1663 pldata_otg = &usb20otg_pdata_rk3126;
1664 usb_to_uart_status = pldata_otg->get_status(USB_STATUS_UARTMODE);
1665 pldata_otg->dwc_otg_uart_mode(pldata_otg, PHY_USB_MODE);
1667 if (cpu_is_rk3288()) {
1668 #ifdef CONFIG_RK_USB_UART
1669 /* disable USB bypass UART function */
1670 usb_to_uart_status =
1671 readl_relaxed(RK_GRF_VIRT + RK3288_GRF_UOC0_CON3);
1672 writel_relaxed(0x00c00000, RK_GRF_VIRT + RK3288_GRF_UOC0_CON3);
1674 /* set siddq,the analog blocks are powered down
1676 * 1. Before asserting SIDDQ, ensure that VDATSRCENB0,
1677 * VDATDETENB0, DCDENB0, BYPASSSEL0, ADPPRBENB0,
1678 * and TESTBURNIN are set to 1'b0.
1679 * 2. Before asserting SIDDQ, ensure that phy enter suspend.*/
1680 #ifdef CONFIG_USB20_OTG
1681 pldata_otg = &usb20otg_pdata_rk3288;
1683 if (pldata_otg->phy_status == USB_PHY_SUSPEND)
1684 writel_relaxed((0x01 << 13) |
1685 ((0x01 << 13) << 16),
1687 RK3288_GRF_UOC0_CON0);
1690 #ifdef CONFIG_USB20_HOST
1691 pldata_host = &usb20host_pdata_rk3288;
1693 if (pldata_host->phy_status == USB_PHY_SUSPEND)
1694 writel_relaxed((0x01 << 13) |
1695 ((0x01 << 13) << 16),
1697 RK3288_GRF_UOC2_CON0);
1700 #ifdef CONFIG_USB_EHCI_RK
1701 pldata_ehci = &rkehci_pdata_rk3288;
1703 if (pldata_ehci->phy_status == USB_PHY_SUSPEND)
1704 writel_relaxed((0x01 << 13) |
1705 ((0x01 << 13) << 16),
1707 RK3288_GRF_UOC1_CON0);
1713 EXPORT_SYMBOL(rk_usb_power_up);
1714 EXPORT_SYMBOL(rk_usb_power_down);
1716 * This function is called when the dwc_otg_driver is installed with the
1717 * insmod command. It registers the dwc_otg_driver structure with the
1718 * appropriate bus driver. This will cause the dwc_otg_driver_probe function
1719 * to be called. In addition, the bus driver will automatically expose
1720 * attributes defined for the device and driver in the special sysfs file
1725 static int __init dwc_otg_driver_init(void)
1730 #ifdef CONFIG_USB20_OTG
1731 /* register otg20 */
1732 printk(KERN_INFO "%s: version %s\n", dwc_otg20_driver_name,
1733 DWC_DRIVER_VERSION);
1735 retval = platform_driver_register(&dwc_otg_driver);
1737 printk(KERN_ERR "%s retval=%d\n", __func__, retval);
1742 driver_create_file(&dwc_otg_driver.driver, &driver_attr_version);
1744 driver_create_file(&dwc_otg_driver.driver, &driver_attr_debuglevel);
1746 driver_create_file(&dwc_otg_driver.driver,
1747 &driver_attr_dwc_otg_conn_en);
1749 driver_create_file(&dwc_otg_driver.driver,
1750 &driver_attr_vbus_status);
1752 driver_create_file(&dwc_otg_driver.driver,
1753 &driver_attr_force_usb_mode);
1755 driver_create_file(&dwc_otg_driver.driver,
1756 &driver_attr_op_state);
1760 /* register host20 */
1761 #ifdef CONFIG_USB20_HOST
1762 printk(KERN_INFO "%s: version %s\n", dwc_host20_driver_name,
1763 DWC_DRIVER_VERSION);
1765 retval = platform_driver_register(&dwc_host_driver);
1767 printk(KERN_ERR "%s retval=%d\n", __func__, retval);
1772 driver_create_file(&dwc_host_driver.driver, &driver_attr_version);
1774 driver_create_file(&dwc_host_driver.driver,
1775 &driver_attr_debuglevel);
1780 module_init(dwc_otg_driver_init);
1783 * This function is called when the driver is removed from the kernel
1784 * with the rmmod command. The driver unregisters itself with its bus
1788 static void __exit dwc_otg_driver_cleanup(void)
1790 printk(KERN_DEBUG "dwc_otg_driver_cleanup()\n");
1792 #ifdef CONFIG_USB20_HOST
1794 driver_remove_file(&dwc_host_driver.driver, &driver_attr_debuglevel);
1795 driver_remove_file(&dwc_host_driver.driver, &driver_attr_version);
1796 platform_driver_unregister(&dwc_host_driver);
1797 printk(KERN_INFO "%s module removed\n", dwc_host20_driver_name);
1800 #ifdef CONFIG_USB20_OTG
1802 driver_remove_file(&dwc_otg_driver.driver,
1803 &driver_attr_dwc_otg_conn_en);
1804 driver_remove_file(&dwc_otg_driver.driver, &driver_attr_debuglevel);
1805 driver_remove_file(&dwc_otg_driver.driver, &driver_attr_version);
1806 driver_remove_file(&dwc_otg_driver.driver, &driver_attr_vbus_status);
1807 driver_remove_file(&dwc_otg_driver.driver, &driver_attr_force_usb_mode);
1808 driver_remove_file(&dwc_otg_driver.driver, &driver_attr_op_state);
1809 platform_driver_unregister(&dwc_otg_driver);
1810 printk(KERN_INFO "%s module removed\n", dwc_otg20_driver_name);
1814 module_exit(dwc_otg_driver_cleanup);
1816 MODULE_DESCRIPTION(DWC_DRIVER_DESC);
1817 MODULE_AUTHOR("Synopsys Inc.");
1818 MODULE_LICENSE("GPL");
1820 module_param_named(otg_cap, dwc_otg_module_params.otg_cap, int, 0444);
1821 MODULE_PARM_DESC(otg_cap, "OTG Capabilities 0=HNP&SRP 1=SRP Only 2=None");
1822 module_param_named(opt, dwc_otg_module_params.opt, int, 0444);
1823 MODULE_PARM_DESC(opt, "OPT Mode");
1824 module_param_named(dma_enable, dwc_otg_module_params.dma_enable, int, 0444);
1825 MODULE_PARM_DESC(dma_enable, "DMA Mode 0=Slave 1=DMA enabled");
1827 module_param_named(dma_desc_enable, dwc_otg_module_params.dma_desc_enable, int,
1829 MODULE_PARM_DESC(dma_desc_enable,
1830 "DMA Desc Mode 0=Address DMA 1=DMA Descriptor enabled");
1832 module_param_named(dma_burst_size, dwc_otg_module_params.dma_burst_size, int,
1834 MODULE_PARM_DESC(dma_burst_size,
1835 "DMA Burst Size 1, 4, 8, 16, 32, 64, 128, 256");
1836 module_param_named(speed, dwc_otg_module_params.speed, int, 0444);
1837 MODULE_PARM_DESC(speed, "Speed 0=High Speed 1=Full Speed");
1838 module_param_named(host_support_fs_ls_low_power,
1839 dwc_otg_module_params.host_support_fs_ls_low_power, int,
1841 MODULE_PARM_DESC(host_support_fs_ls_low_power,
1842 "Support Low Power w/FS or LS 0=Support 1=Don't Support");
1843 module_param_named(host_ls_low_power_phy_clk,
1844 dwc_otg_module_params.host_ls_low_power_phy_clk, int, 0444);
1845 MODULE_PARM_DESC(host_ls_low_power_phy_clk,
1846 "Low Speed Low Power Clock 0=48Mhz 1=6Mhz");
1847 module_param_named(enable_dynamic_fifo,
1848 dwc_otg_module_params.enable_dynamic_fifo, int, 0444);
1849 MODULE_PARM_DESC(enable_dynamic_fifo, "0=cC Setting 1=Allow Dynamic Sizing");
1850 module_param_named(data_fifo_size, dwc_otg_module_params.data_fifo_size, int,
1852 MODULE_PARM_DESC(data_fifo_size,
1853 "Total number of words in the data FIFO memory 32-32768");
1854 module_param_named(dev_rx_fifo_size, dwc_otg_module_params.dev_rx_fifo_size,
1856 MODULE_PARM_DESC(dev_rx_fifo_size, "Number of words in the Rx FIFO 16-32768");
1857 module_param_named(dev_nperio_tx_fifo_size,
1858 dwc_otg_module_params.dev_nperio_tx_fifo_size, int, 0444);
1859 MODULE_PARM_DESC(dev_nperio_tx_fifo_size,
1860 "Number of words in the non-periodic Tx FIFO 16-32768");
1861 module_param_named(dev_perio_tx_fifo_size_1,
1862 dwc_otg_module_params.dev_perio_tx_fifo_size[0], int, 0444);
1863 MODULE_PARM_DESC(dev_perio_tx_fifo_size_1,
1864 "Number of words in the periodic Tx FIFO 4-768");
1865 module_param_named(dev_perio_tx_fifo_size_2,
1866 dwc_otg_module_params.dev_perio_tx_fifo_size[1], int, 0444);
1867 MODULE_PARM_DESC(dev_perio_tx_fifo_size_2,
1868 "Number of words in the periodic Tx FIFO 4-768");
1869 module_param_named(dev_perio_tx_fifo_size_3,
1870 dwc_otg_module_params.dev_perio_tx_fifo_size[2], int, 0444);
1871 MODULE_PARM_DESC(dev_perio_tx_fifo_size_3,
1872 "Number of words in the periodic Tx FIFO 4-768");
1873 module_param_named(dev_perio_tx_fifo_size_4,
1874 dwc_otg_module_params.dev_perio_tx_fifo_size[3], int, 0444);
1875 MODULE_PARM_DESC(dev_perio_tx_fifo_size_4,
1876 "Number of words in the periodic Tx FIFO 4-768");
1877 module_param_named(dev_perio_tx_fifo_size_5,
1878 dwc_otg_module_params.dev_perio_tx_fifo_size[4], int, 0444);
1879 MODULE_PARM_DESC(dev_perio_tx_fifo_size_5,
1880 "Number of words in the periodic Tx FIFO 4-768");
1881 module_param_named(dev_perio_tx_fifo_size_6,
1882 dwc_otg_module_params.dev_perio_tx_fifo_size[5], int, 0444);
1883 MODULE_PARM_DESC(dev_perio_tx_fifo_size_6,
1884 "Number of words in the periodic Tx FIFO 4-768");
1885 module_param_named(dev_perio_tx_fifo_size_7,
1886 dwc_otg_module_params.dev_perio_tx_fifo_size[6], int, 0444);
1887 MODULE_PARM_DESC(dev_perio_tx_fifo_size_7,
1888 "Number of words in the periodic Tx FIFO 4-768");
1889 module_param_named(dev_perio_tx_fifo_size_8,
1890 dwc_otg_module_params.dev_perio_tx_fifo_size[7], int, 0444);
1891 MODULE_PARM_DESC(dev_perio_tx_fifo_size_8,
1892 "Number of words in the periodic Tx FIFO 4-768");
1893 module_param_named(dev_perio_tx_fifo_size_9,
1894 dwc_otg_module_params.dev_perio_tx_fifo_size[8], int, 0444);
1895 MODULE_PARM_DESC(dev_perio_tx_fifo_size_9,
1896 "Number of words in the periodic Tx FIFO 4-768");
1897 module_param_named(dev_perio_tx_fifo_size_10,
1898 dwc_otg_module_params.dev_perio_tx_fifo_size[9], int, 0444);
1899 MODULE_PARM_DESC(dev_perio_tx_fifo_size_10,
1900 "Number of words in the periodic Tx FIFO 4-768");
1901 module_param_named(dev_perio_tx_fifo_size_11,
1902 dwc_otg_module_params.dev_perio_tx_fifo_size[10], int, 0444);
1903 MODULE_PARM_DESC(dev_perio_tx_fifo_size_11,
1904 "Number of words in the periodic Tx FIFO 4-768");
1905 module_param_named(dev_perio_tx_fifo_size_12,
1906 dwc_otg_module_params.dev_perio_tx_fifo_size[11], int, 0444);
1907 MODULE_PARM_DESC(dev_perio_tx_fifo_size_12,
1908 "Number of words in the periodic Tx FIFO 4-768");
1909 module_param_named(dev_perio_tx_fifo_size_13,
1910 dwc_otg_module_params.dev_perio_tx_fifo_size[12], int, 0444);
1911 MODULE_PARM_DESC(dev_perio_tx_fifo_size_13,
1912 "Number of words in the periodic Tx FIFO 4-768");
1913 module_param_named(dev_perio_tx_fifo_size_14,
1914 dwc_otg_module_params.dev_perio_tx_fifo_size[13], int, 0444);
1915 MODULE_PARM_DESC(dev_perio_tx_fifo_size_14,
1916 "Number of words in the periodic Tx FIFO 4-768");
1917 module_param_named(dev_perio_tx_fifo_size_15,
1918 dwc_otg_module_params.dev_perio_tx_fifo_size[14], int, 0444);
1919 MODULE_PARM_DESC(dev_perio_tx_fifo_size_15,
1920 "Number of words in the periodic Tx FIFO 4-768");
1921 module_param_named(host_rx_fifo_size, dwc_otg_module_params.host_rx_fifo_size,
1923 MODULE_PARM_DESC(host_rx_fifo_size, "Number of words in the Rx FIFO 16-32768");
1924 module_param_named(host_nperio_tx_fifo_size,
1925 dwc_otg_module_params.host_nperio_tx_fifo_size, int, 0444);
1926 MODULE_PARM_DESC(host_nperio_tx_fifo_size,
1927 "Number of words in the non-periodic Tx FIFO 16-32768");
1928 module_param_named(host_perio_tx_fifo_size,
1929 dwc_otg_module_params.host_perio_tx_fifo_size, int, 0444);
1930 MODULE_PARM_DESC(host_perio_tx_fifo_size,
1931 "Number of words in the host periodic Tx FIFO 16-32768");
1932 module_param_named(max_transfer_size, dwc_otg_module_params.max_transfer_size,
1934 /** @todo Set the max to 512K, modify checks */
1935 MODULE_PARM_DESC(max_transfer_size,
1936 "The maximum transfer size supported in bytes 2047-65535");
1937 module_param_named(max_packet_count, dwc_otg_module_params.max_packet_count,
1939 MODULE_PARM_DESC(max_packet_count,
1940 "The maximum number of packets in a transfer 15-511");
1941 module_param_named(host_channels, dwc_otg_module_params.host_channels, int,
1943 MODULE_PARM_DESC(host_channels,
1944 "The number of host channel registers to use 1-16");
1945 module_param_named(dev_endpoints, dwc_otg_module_params.dev_endpoints, int,
1947 MODULE_PARM_DESC(dev_endpoints,
1948 "The number of endpoints in addition to EP0 available for device mode 1-15");
1949 module_param_named(phy_type, dwc_otg_module_params.phy_type, int, 0444);
1950 MODULE_PARM_DESC(phy_type, "0=Reserved 1=UTMI+ 2=ULPI");
1951 module_param_named(phy_utmi_width, dwc_otg_module_params.phy_utmi_width, int,
1953 MODULE_PARM_DESC(phy_utmi_width, "Specifies the UTMI+ Data Width 8 or 16 bits");
1954 module_param_named(phy_ulpi_ddr, dwc_otg_module_params.phy_ulpi_ddr, int, 0444);
1955 MODULE_PARM_DESC(phy_ulpi_ddr,
1956 "ULPI at double or single data rate 0=Single 1=Double");
1957 module_param_named(phy_ulpi_ext_vbus, dwc_otg_module_params.phy_ulpi_ext_vbus,
1959 MODULE_PARM_DESC(phy_ulpi_ext_vbus,
1960 "ULPI PHY using internal or external vbus 0=Internal");
1961 module_param_named(i2c_enable, dwc_otg_module_params.i2c_enable, int, 0444);
1962 MODULE_PARM_DESC(i2c_enable, "FS PHY Interface");
1963 module_param_named(ulpi_fs_ls, dwc_otg_module_params.ulpi_fs_ls, int, 0444);
1964 MODULE_PARM_DESC(ulpi_fs_ls, "ULPI PHY FS/LS mode only");
1965 module_param_named(ts_dline, dwc_otg_module_params.ts_dline, int, 0444);
1966 MODULE_PARM_DESC(ts_dline, "Term select Dline pulsing for all PHYs");
1967 module_param_named(debug, g_dbg_lvl, int, 0444);
1968 MODULE_PARM_DESC(debug, "");
1970 module_param_named(en_multiple_tx_fifo,
1971 dwc_otg_module_params.en_multiple_tx_fifo, int, 0444);
1972 MODULE_PARM_DESC(en_multiple_tx_fifo,
1973 "Dedicated Non Periodic Tx FIFOs 0=disabled 1=enabled");
1974 module_param_named(dev_tx_fifo_size_1,
1975 dwc_otg_module_params.dev_tx_fifo_size[0], int, 0444);
1976 MODULE_PARM_DESC(dev_tx_fifo_size_1, "Number of words in the Tx FIFO 4-768");
1977 module_param_named(dev_tx_fifo_size_2,
1978 dwc_otg_module_params.dev_tx_fifo_size[1], int, 0444);
1979 MODULE_PARM_DESC(dev_tx_fifo_size_2, "Number of words in the Tx FIFO 4-768");
1980 module_param_named(dev_tx_fifo_size_3,
1981 dwc_otg_module_params.dev_tx_fifo_size[2], int, 0444);
1982 MODULE_PARM_DESC(dev_tx_fifo_size_3, "Number of words in the Tx FIFO 4-768");
1983 module_param_named(dev_tx_fifo_size_4,
1984 dwc_otg_module_params.dev_tx_fifo_size[3], int, 0444);
1985 MODULE_PARM_DESC(dev_tx_fifo_size_4, "Number of words in the Tx FIFO 4-768");
1986 module_param_named(dev_tx_fifo_size_5,
1987 dwc_otg_module_params.dev_tx_fifo_size[4], int, 0444);
1988 MODULE_PARM_DESC(dev_tx_fifo_size_5, "Number of words in the Tx FIFO 4-768");
1989 module_param_named(dev_tx_fifo_size_6,
1990 dwc_otg_module_params.dev_tx_fifo_size[5], int, 0444);
1991 MODULE_PARM_DESC(dev_tx_fifo_size_6, "Number of words in the Tx FIFO 4-768");
1992 module_param_named(dev_tx_fifo_size_7,
1993 dwc_otg_module_params.dev_tx_fifo_size[6], int, 0444);
1994 MODULE_PARM_DESC(dev_tx_fifo_size_7, "Number of words in the Tx FIFO 4-768");
1995 module_param_named(dev_tx_fifo_size_8,
1996 dwc_otg_module_params.dev_tx_fifo_size[7], int, 0444);
1997 MODULE_PARM_DESC(dev_tx_fifo_size_8, "Number of words in the Tx FIFO 4-768");
1998 module_param_named(dev_tx_fifo_size_9,
1999 dwc_otg_module_params.dev_tx_fifo_size[8], int, 0444);
2000 MODULE_PARM_DESC(dev_tx_fifo_size_9, "Number of words in the Tx FIFO 4-768");
2001 module_param_named(dev_tx_fifo_size_10,
2002 dwc_otg_module_params.dev_tx_fifo_size[9], int, 0444);
2003 MODULE_PARM_DESC(dev_tx_fifo_size_10, "Number of words in the Tx FIFO 4-768");
2004 module_param_named(dev_tx_fifo_size_11,
2005 dwc_otg_module_params.dev_tx_fifo_size[10], int, 0444);
2006 MODULE_PARM_DESC(dev_tx_fifo_size_11, "Number of words in the Tx FIFO 4-768");
2007 module_param_named(dev_tx_fifo_size_12,
2008 dwc_otg_module_params.dev_tx_fifo_size[11], int, 0444);
2009 MODULE_PARM_DESC(dev_tx_fifo_size_12, "Number of words in the Tx FIFO 4-768");
2010 module_param_named(dev_tx_fifo_size_13,
2011 dwc_otg_module_params.dev_tx_fifo_size[12], int, 0444);
2012 MODULE_PARM_DESC(dev_tx_fifo_size_13, "Number of words in the Tx FIFO 4-768");
2013 module_param_named(dev_tx_fifo_size_14,
2014 dwc_otg_module_params.dev_tx_fifo_size[13], int, 0444);
2015 MODULE_PARM_DESC(dev_tx_fifo_size_14, "Number of words in the Tx FIFO 4-768");
2016 module_param_named(dev_tx_fifo_size_15,
2017 dwc_otg_module_params.dev_tx_fifo_size[14], int, 0444);
2018 MODULE_PARM_DESC(dev_tx_fifo_size_15, "Number of words in the Tx FIFO 4-768");
2020 module_param_named(thr_ctl, dwc_otg_module_params.thr_ctl, int, 0444);
2021 MODULE_PARM_DESC(thr_ctl,
2022 "Thresholding enable flag bit 0 - non ISO Tx thr., 1 - ISO Tx thr., 2 - Rx thr.- bit 0=disabled 1=enabled");
2023 module_param_named(tx_thr_length, dwc_otg_module_params.tx_thr_length, int,
2025 MODULE_PARM_DESC(tx_thr_length, "Tx Threshold length in 32 bit DWORDs");
2026 module_param_named(rx_thr_length, dwc_otg_module_params.rx_thr_length, int,
2028 MODULE_PARM_DESC(rx_thr_length, "Rx Threshold length in 32 bit DWORDs");
2030 module_param_named(pti_enable, dwc_otg_module_params.pti_enable, int, 0444);
2031 module_param_named(mpi_enable, dwc_otg_module_params.mpi_enable, int, 0444);
2032 module_param_named(lpm_enable, dwc_otg_module_params.lpm_enable, int, 0444);
2033 MODULE_PARM_DESC(lpm_enable, "LPM Enable 0=LPM Disabled 1=LPM Enabled");
2035 module_param_named(besl_enable, dwc_otg_module_params.besl_enable, int, 0444);
2036 MODULE_PARM_DESC(besl_enable, "BESL Enable 0=BESL Disabled 1=BESL Enabled");
2037 module_param_named(baseline_besl, dwc_otg_module_params.baseline_besl, int,
2039 MODULE_PARM_DESC(baseline_besl, "Set the baseline besl value");
2040 module_param_named(deep_besl, dwc_otg_module_params.deep_besl, int, 0444);
2041 MODULE_PARM_DESC(deep_besl, "Set the deep besl value");
2043 module_param_named(ic_usb_cap, dwc_otg_module_params.ic_usb_cap, int, 0444);
2044 MODULE_PARM_DESC(ic_usb_cap,
2045 "IC_USB Capability 0=IC_USB Disabled 1=IC_USB Enabled");
2046 module_param_named(ahb_thr_ratio, dwc_otg_module_params.ahb_thr_ratio, int,
2048 MODULE_PARM_DESC(ahb_thr_ratio, "AHB Threshold Ratio");
2049 module_param_named(power_down, dwc_otg_module_params.power_down, int, 0444);
2050 MODULE_PARM_DESC(power_down, "Power Down Mode");
2051 module_param_named(reload_ctl, dwc_otg_module_params.reload_ctl, int, 0444);
2052 MODULE_PARM_DESC(reload_ctl, "HFIR Reload Control");
2053 module_param_named(dev_out_nak, dwc_otg_module_params.dev_out_nak, int, 0444);
2054 MODULE_PARM_DESC(dev_out_nak, "Enable Device OUT NAK");
2055 module_param_named(cont_on_bna, dwc_otg_module_params.cont_on_bna, int, 0444);
2056 MODULE_PARM_DESC(cont_on_bna, "Enable Enable Continue on BNA");
2057 module_param_named(ahb_single, dwc_otg_module_params.ahb_single, int, 0444);
2058 MODULE_PARM_DESC(ahb_single, "Enable AHB Single Support");
2059 module_param_named(adp_enable, dwc_otg_module_params.adp_enable, int, 0444);
2060 MODULE_PARM_DESC(adp_enable, "ADP Enable 0=ADP Disabled 1=ADP Enabled");
2061 module_param_named(otg_ver, dwc_otg_module_params.otg_ver, int, 0444);
2062 MODULE_PARM_DESC(otg_ver, "OTG revision supported 0=OTG 1.3 1=OTG 2.0");
2064 /** @page "Module Parameters"
2066 * The following parameters may be specified when starting the module.
2067 * These parameters define how the DWC_otg controller should be
2068 * configured. Parameter values are passed to the CIL initialization
2069 * function dwc_otg_cil_init
2071 * Example: <code>modprobe dwc_otg speed=1 otg_cap=1</code>
2075 <tr><td>Parameter Name</td><td>Meaning</td></tr>
2079 <td>Specifies the OTG capabilities. The driver will automatically detect the
2080 value for this parameter if none is specified.
2081 - 0: HNP and SRP capable (default, if available)
2082 - 1: SRP Only capable
2083 - 2: No HNP/SRP capable
2088 <td>Specifies whether to use slave or DMA mode for accessing the data FIFOs.
2089 The driver will automatically detect the value for this parameter if none is
2092 - 1: DMA (default, if available)
2096 <td>dma_burst_size</td>
2097 <td>The DMA Burst size (applicable only for External DMA Mode).
2098 - Values: 1, 4, 8 16, 32, 64, 128, 256 (default 32)
2103 <td>Specifies the maximum speed of operation in host and device mode. The
2104 actual speed depends on the speed of the attached device and the value of
2106 - 0: High Speed (default)
2111 <td>host_support_fs_ls_low_power</td>
2112 <td>Specifies whether low power mode is supported when attached to a Full
2113 Speed or Low Speed device in host mode.
2114 - 0: Don't support low power mode (default)
2115 - 1: Support low power mode
2119 <td>host_ls_low_power_phy_clk</td>
2120 <td>Specifies the PHY clock rate in low power mode when connected to a Low
2121 Speed device in host mode. This parameter is applicable only if
2122 HOST_SUPPORT_FS_LS_LOW_POWER is enabled.
2123 - 0: 48 MHz (default)
2128 <td>enable_dynamic_fifo</td>
2129 <td> Specifies whether FIFOs may be resized by the driver software.
2130 - 0: Use cC FIFO size parameters
2131 - 1: Allow dynamic FIFO sizing (default)
2135 <td>data_fifo_size</td>
2136 <td>Total number of 4-byte words in the data FIFO memory. This memory
2137 includes the Rx FIFO, non-periodic Tx FIFO, and periodic Tx FIFOs.
2138 - Values: 32 to 32768 (default 8192)
2140 Note: The total FIFO memory depth in the FPGA configuration is 8192.
2144 <td>dev_rx_fifo_size</td>
2145 <td>Number of 4-byte words in the Rx FIFO in device mode when dynamic
2146 FIFO sizing is enabled.
2147 - Values: 16 to 32768 (default 1064)
2151 <td>dev_nperio_tx_fifo_size</td>
2152 <td>Number of 4-byte words in the non-periodic Tx FIFO in device mode when
2153 dynamic FIFO sizing is enabled.
2154 - Values: 16 to 32768 (default 1024)
2158 <td>dev_perio_tx_fifo_size_n (n = 1 to 15)</td>
2159 <td>Number of 4-byte words in each of the periodic Tx FIFOs in device mode
2160 when dynamic FIFO sizing is enabled.
2161 - Values: 4 to 768 (default 256)
2165 <td>host_rx_fifo_size</td>
2166 <td>Number of 4-byte words in the Rx FIFO in host mode when dynamic FIFO
2168 - Values: 16 to 32768 (default 1024)
2172 <td>host_nperio_tx_fifo_size</td>
2173 <td>Number of 4-byte words in the non-periodic Tx FIFO in host mode when
2174 dynamic FIFO sizing is enabled in the core.
2175 - Values: 16 to 32768 (default 1024)
2179 <td>host_perio_tx_fifo_size</td>
2180 <td>Number of 4-byte words in the host periodic Tx FIFO when dynamic FIFO
2182 - Values: 16 to 32768 (default 1024)
2186 <td>max_transfer_size</td>
2187 <td>The maximum transfer size supported in bytes.
2188 - Values: 2047 to 65,535 (default 65,535)
2192 <td>max_packet_count</td>
2193 <td>The maximum number of packets in a transfer.
2194 - Values: 15 to 511 (default 511)
2198 <td>host_channels</td>
2199 <td>The number of host channel registers to use.
2200 - Values: 1 to 16 (default 12)
2202 Note: The FPGA configuration supports a maximum of 12 host channels.
2206 <td>dev_endpoints</td>
2207 <td>The number of endpoints in addition to EP0 available for device mode
2209 - Values: 1 to 15 (default 6 IN and OUT)
2211 Note: The FPGA configuration supports a maximum of 6 IN and OUT endpoints in
2217 <td>Specifies the type of PHY interface to use. By default, the driver will
2218 automatically detect the phy_type.
2220 - 1: UTMI+ (default, if available)
2225 <td>phy_utmi_width</td>
2226 <td>Specifies the UTMI+ Data Width. This parameter is applicable for a
2227 phy_type of UTMI+. Also, this parameter is applicable only if the
2228 OTG_HSPHY_WIDTH cC parameter was set to "8 and 16 bits", meaning that the
2229 core has been configured to work at either data path width.
2230 - Values: 8 or 16 bits (default 16)
2234 <td>phy_ulpi_ddr</td>
2235 <td>Specifies whether the ULPI operates at double or single data rate. This
2236 parameter is only applicable if phy_type is ULPI.
2237 - 0: single data rate ULPI interface with 8 bit wide data bus (default)
2238 - 1: double data rate ULPI interface with 4 bit wide data bus
2243 <td>Specifies whether to use the I2C interface for full speed PHY. This
2244 parameter is only applicable if PHY_TYPE is FS.
2245 - 0: Disabled (default)
2251 <td>Specifies whether to use ULPI FS/LS mode only.
2252 - 0: Disabled (default)
2258 <td>Specifies whether term select D-Line pulsing for all PHYs is enabled.
2259 - 0: Disabled (default)
2264 <td>en_multiple_tx_fifo</td>
2265 <td>Specifies whether dedicatedto tx fifos are enabled for non periodic IN EPs.
2266 The driver will automatically detect the value for this parameter if none is
2269 - 1: Enabled (default, if available)
2273 <td>dev_tx_fifo_size_n (n = 1 to 15)</td>
2274 <td>Number of 4-byte words in each of the Tx FIFOs in device mode
2275 when dynamic FIFO sizing is enabled.
2276 - Values: 4 to 768 (default 256)
2280 <td>tx_thr_length</td>
2281 <td>Transmit Threshold length in 32 bit double words
2282 - Values: 8 to 128 (default 64)
2286 <td>rx_thr_length</td>
2287 <td>Receive Threshold length in 32 bit double words
2288 - Values: 8 to 128 (default 64)
2293 <td>Specifies whether to enable Thresholding for Device mode. Bits 0, 1, 2 of
2294 this parmater specifies if thresholding is enabled for non-Iso Tx, Iso Tx and
2295 Rx transfers accordingly.
2296 The driver will automatically detect the value for this parameter if none is
2298 - Values: 0 to 7 (default 0)
2299 Bit values indicate:
2300 - 0: Thresholding disabled
2301 - 1: Thresholding enabled
2305 <td>dma_desc_enable</td>
2306 <td>Specifies whether to enable Descriptor DMA mode.
2307 The driver will automatically detect the value for this parameter if none is
2309 - 0: Descriptor DMA disabled
2310 - 1: Descriptor DMA (default, if available)
2315 <td>Specifies whether to enable MPI enhancement mode.
2316 The driver will automatically detect the value for this parameter if none is
2318 - 0: MPI disabled (default)
2324 <td>Specifies whether to enable PTI enhancement support.
2325 The driver will automatically detect the value for this parameter if none is
2327 - 0: PTI disabled (default)
2333 <td>Specifies whether to enable LPM support.
2334 The driver will automatically detect the value for this parameter if none is
2337 - 1: LPM enable (default, if available)
2341 <td>besl_enable</td>
2342 <td>Specifies whether to enable LPM Errata support.
2343 The driver will automatically detect the value for this parameter if none is
2345 - 0: LPM Errata disabled (default)
2346 - 1: LPM Errata enable
2350 <td>baseline_besl</td>
2351 <td>Specifies the baseline besl value.
2352 - Values: 0 to 15 (default 0)
2357 <td>Specifies the deep besl value.
2358 - Values: 0 to 15 (default 15)
2363 <td>Specifies whether to enable IC_USB capability.
2364 The driver will automatically detect the value for this parameter if none is
2366 - 0: IC_USB disabled (default, if available)
2371 <td>ahb_thr_ratio</td>
2372 <td>Specifies AHB Threshold ratio.
2373 - Values: 0 to 3 (default 0)
2378 <td>Specifies Power Down(Hibernation) Mode.
2379 The driver will automatically detect the value for this parameter if none is
2381 - 0: Power Down disabled (default)
2382 - 2: Power Down enabled
2387 <td>Specifies whether dynamic reloading of the HFIR register is allowed during
2388 run time. The driver will automatically detect the value for this parameter if
2389 none is specified. In case the HFIR value is reloaded when HFIR.RldCtrl == 1'b0
2390 the core might misbehave.
2391 - 0: Reload Control disabled (default)
2392 - 1: Reload Control enabled
2396 <td>dev_out_nak</td>
2397 <td>Specifies whether Device OUT NAK enhancement enabled or no.
2398 The driver will automatically detect the value for this parameter if
2399 none is specified. This parameter is valid only when OTG_EN_DESC_DMA == 1
\92b1.
2400 - 0: The core does not set NAK after Bulk OUT transfer complete (default)
2401 - 1: The core sets NAK after Bulk OUT transfer complete
2405 <td>cont_on_bna</td>
2406 <td>Specifies whether Enable Continue on BNA enabled or no.
2407 After receiving BNA interrupt the core disables the endpoint,when the
2408 endpoint is re-enabled by the application the
2409 - 0: Core starts processing from the DOEPDMA descriptor (default)
2410 - 1: Core starts processing from the descriptor which received the BNA.
2411 This parameter is valid only when OTG_EN_DESC_DMA == 1
\92b1.
2416 <td>This bit when programmed supports SINGLE transfers for remainder data
2417 in a transfer for DMA mode of operation.
2418 - 0: The remainder data will be sent using INCR burst size (default)
2419 - 1: The remainder data will be sent using SINGLE burst size.
2424 <td>Specifies whether ADP feature is enabled.
2425 The driver will automatically detect the value for this parameter if none is
2427 - 0: ADP feature disabled (default)
2428 - 1: ADP feature enabled
2433 <td>Specifies whether OTG is performing as USB OTG Revision 2.0 or Revision 1.3
2435 - 0: OTG 2.0 support disabled (default)
2436 - 1: OTG 2.0 support enabled