/*
|
* (C) Copyright 2007-2013
|
* Allwinner Technology Co., Ltd. <www.allwinnertech.com>
|
* Jerry Wang <wangflord@allwinnertech.com>
|
*
|
* See file CREDITS for list of people who contributed to this
|
* project.
|
*
|
* This program is free software; you can redistribute it and/or
|
* modify it under the terms of the GNU General Public License as
|
* published by the Free Software Foundation; either version 2 of
|
* the License, or (at your option) any later version.
|
*
|
* This program is distributed in the hope that it will be useful,
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
* GNU General Public License for more details.
|
*
|
* You should have received a copy of the GNU General Public License
|
* along with this program; if not, write to the Free Software
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
|
* MA 02111-1307 USA
|
*/
|
|
#include "usbc_i.h"
|
|
|
static __u32 usbc_base_address[USBC_MAX_CTL_NUM] = { SUNXI_USBOTG_BASE }; /* usb base address */
|
static __usbc_otg_t usbc_otg_array[USBC_MAX_OPEN_NUM]; /* usbc 内部使用, 用来管理USB端口 */
|
static __fifo_info_t usbc_info_g;
|
|
/*
|
***********************************************************************************
|
* USBC_GetVbusStatus
|
*
|
* Description:
|
* 获得当前vbus的状态
|
*
|
* Arguments:
|
* hUSB : input. USBC_open_otg获得的句柄, 记录了USBC所需要的一些关键数据
|
*
|
* Returns:
|
* 返回当前vbus的状态
|
*
|
* note:
|
* 无
|
*
|
***********************************************************************************
|
*/
|
__u32 USBC_GetVbusStatus(__hdle hUSB)
|
{
|
__usbc_otg_t *usbc_otg = (__usbc_otg_t *)hUSB;
|
__u8 reg_val = 0;
|
|
if(usbc_otg == NULL){
|
return 0;
|
}
|
|
reg_val = USBC_Readb(USBC_REG_DEVCTL(usbc_otg->base_addr));
|
reg_val = reg_val >> USBC_BP_DEVCTL_VBUS;
|
switch(reg_val & 0x03){
|
case 0x00:
|
return USBC_VBUS_STATUS_BELOW_SESSIONEND;
|
//break;
|
|
case 0x01:
|
return USBC_VBUS_STATUS_ABOVE_SESSIONEND_BELOW_AVALID;
|
//break;
|
|
case 0x02:
|
return USBC_VBUS_STATUS_ABOVE_AVALID_BELOW_VBUSVALID;
|
//break;
|
|
case 0x03:
|
return USBC_VBUS_STATUS_ABOVE_VBUSVALID;
|
//break;
|
|
default:
|
return USBC_VBUS_STATUS_BELOW_SESSIONEND;
|
}
|
}
|
|
/*
|
***********************************************************************************
|
* USBC_OTG_SelectMode
|
*
|
* Description:
|
* 选择设备的类型。当前设备是作device, 还是作host
|
*
|
* Arguments:
|
* hUSB : input. USBC_open_otg获得的句柄, 记录了USBC所需要的一些关键数据
|
*
|
* Returns:
|
*
|
*
|
* note:
|
* 无
|
*
|
***********************************************************************************
|
*/
|
void USBC_OTG_SelectMode(__hdle hUSB, __u32 mode)
|
{
|
__usbc_otg_t *usbc_otg = (__usbc_otg_t *)hUSB;
|
|
if(usbc_otg == NULL){
|
return ;
|
}
|
|
if(mode == USBC_OTG_HOST){
|
|
}else{
|
|
}
|
}
|
|
/*
|
***********************************************************************************
|
* USBC_ReadLenFromFifo
|
*
|
* Description:
|
* 本次fifo可以读到的数据长度
|
*
|
* Arguments:
|
* hUSB : input. USBC_open_otg获得的句柄, 记录了USBC所需要的一些关键数据
|
* ep_type : input. ep的类型, rx 或 tx。
|
* Returns:
|
* 返回本次fifo可以读到的数据长度
|
*
|
* note:
|
* 无
|
*
|
***********************************************************************************
|
*/
|
__u32 USBC_ReadLenFromFifo(__hdle hUSB, __u32 ep_type)
|
{
|
__usbc_otg_t *usbc_otg = (__usbc_otg_t *)hUSB;
|
|
if(usbc_otg == NULL){
|
return 0;
|
}
|
|
switch(ep_type){
|
case USBC_EP_TYPE_EP0:
|
return USBC_Readw(USBC_REG_COUNT0(usbc_otg->base_addr));
|
//break;
|
|
case USBC_EP_TYPE_TX:
|
return 0;
|
//break;
|
|
case USBC_EP_TYPE_RX:
|
return USBC_Readw(USBC_REG_RXCOUNT(usbc_otg->base_addr));
|
//break;
|
|
default:
|
return 0;
|
}
|
}
|
|
/*
|
***********************************************************************************
|
* USBC_WritePacket
|
*
|
* Description:
|
* 往fifo里面写数据包
|
*
|
* Arguments:
|
* hUSB : input. USBC_open_otg获得的句柄, 记录了USBC所需要的一些关键数据
|
* fifo : input. fifo地址.
|
* cnt : input. 写数据长度
|
* buff : input. 存放要写的数据
|
*
|
* Returns:
|
* 返回成功写入的长度
|
*
|
* note:
|
* 无
|
*
|
***********************************************************************************
|
*/
|
__u32 USBC_WritePacket(__hdle hUSB, __u32 fifo, __u32 cnt, void *buff)
|
{
|
__usbc_otg_t *usbc_otg = (__usbc_otg_t *)hUSB;
|
__u32 len = 0;
|
__u32 i32 = 0;
|
__u32 i8 = 0;
|
__u8 *buf8 = NULL;
|
__u32 *buf32 = NULL;
|
ulong a64_fifo = (ulong)fifo;
|
|
if(usbc_otg == NULL || buff == NULL){
|
return 0;
|
}
|
|
//--<1>--调整数据
|
buf32 = buff;
|
len = cnt;
|
|
|
i32 = len >> 2;
|
i8 = len & 0x03;
|
|
// when buff is not 4 bytes align ,will data abort ----wangwei
|
if(((u32)buf32)&0x03)
|
{
|
buf8 = (__u8 *)buff;
|
i8 = len;
|
while (i8--){
|
USBC_Writeb(*buf8++, a64_fifo);
|
}
|
return len;
|
}
|
|
//--<2>--处理4字节的部分
|
while (i32--){
|
|
USBC_Writel(*buf32++, a64_fifo);
|
}
|
|
//--<3>--处理非4字节的部分
|
buf8 = (__u8 *)buf32;
|
while (i8--){
|
USBC_Writeb(*buf8++, a64_fifo);
|
}
|
|
return len;
|
}
|
|
/*
|
***********************************************************************************
|
* USBC_ReadPacket
|
*
|
* Description:
|
* 从fifo里面读数据
|
*
|
* Arguments:
|
* hUSB : input. USBC_open_otg获得的句柄, 记录了USBC所需要的一些关键数据
|
* fifo : input. fifo地址.
|
* cnt : input. 写数据长度
|
* buff : input. 存放要读的数据
|
*
|
* Returns:
|
* 返回成功读的长度
|
*
|
* note:
|
* 无
|
*
|
***********************************************************************************
|
*/
|
__u32 USBC_ReadPacket(__hdle hUSB, __u32 fifo, __u32 cnt, void *buff)
|
{
|
__usbc_otg_t *usbc_otg = (__usbc_otg_t *)hUSB;
|
__u32 len = 0;
|
__u32 i32 = 0;
|
__u32 i8 = 0;
|
__u8 *buf8 = NULL;
|
__u32 *buf32 = NULL;
|
ulong a64_fifo = (ulong)fifo;
|
|
if(usbc_otg == NULL || buff == NULL){
|
return 0;
|
}
|
|
//--<1>--调整数据
|
buf32 = (__u32 *)buff;
|
len = cnt;
|
|
i32 = len >> 2;
|
i8 = len & 0x03;
|
|
//--<2>--处理4字节的部分
|
while (i32--){
|
*buf32++ = USBC_Readl(a64_fifo);
|
}
|
|
//--<3>--处理非4字节的部分
|
buf8 = (__u8 *)buf32;
|
while (i8--){
|
*buf8++ = USBC_Readb(a64_fifo);
|
}
|
|
return len;
|
}
|
|
/* 映射SRAM D给usb fifo使用 */
|
void USBC_ConfigFIFO_Base(__hdle hUSB, __u32 sram_base, __u32 fifo_mode)
|
{
|
__usbc_otg_t *usbc_otg = (__usbc_otg_t *)hUSB;
|
__fifo_info_t *usbc_info = &usbc_info_g;
|
__maybe_unused __u32 reg_value = 0;
|
|
if(usbc_otg == NULL){
|
return ;
|
}
|
|
if(usbc_otg->port_num == 0){
|
usbc_info->port0_fifo_addr = 0x00;
|
usbc_info->port0_fifo_size = (8 * 1024); //8k
|
#ifdef CONFIG_ARCH_SUN3IW1P1
|
reg_value = USBC_Readl(SUNXI_SRAM_BASE + 0x04);
|
reg_value |= (1 << 0);
|
USBC_Writel(reg_value, (SUNXI_SRAM_BASE + 0x04));
|
#endif
|
}
|
return ;
|
}
|
|
/* 获得port fifo的起始地址 */
|
__u32 USBC_GetPortFifoStartAddr(__hdle hUSB)
|
{
|
__usbc_otg_t *usbc_otg = (__usbc_otg_t *)hUSB;
|
|
if(usbc_otg == NULL){
|
return 0;
|
}
|
|
if(usbc_otg->port_num == 0){
|
return usbc_info_g.port0_fifo_addr;
|
}else if(usbc_otg->port_num == 1){
|
return usbc_info_g.port1_fifo_addr;
|
}else {
|
return usbc_info_g.port2_fifo_addr;
|
}
|
}
|
|
/* 获得port fifo的大小 */
|
__u32 USBC_GetPortFifoSize(__hdle hUSB)
|
{
|
__usbc_otg_t *usbc_otg = (__usbc_otg_t *)hUSB;
|
|
if(usbc_otg == NULL){
|
return 0;
|
}
|
|
if(usbc_otg->port_num == 0){
|
return usbc_info_g.port0_fifo_size;
|
}else{
|
return usbc_info_g.port1_fifo_size;
|
}
|
}
|
|
|
/*
|
***********************************************************************************
|
* USBC_SelectFIFO
|
*
|
* Description:
|
* 选择设备的类型。当前设备是作device, 还是作host
|
*
|
* Arguments:
|
* hUSB : input. USBC_open_otg获得的句柄, 记录了USBC所需要的一些关键数据
|
* ep_index : input. ep号。用来选择相应的fifo
|
*
|
* Returns:
|
* 返回选中的fifo
|
*
|
* note:
|
* 无
|
*
|
***********************************************************************************
|
*/
|
/*
|
__u32 USBC_SelectFIFO(__hdle hUSB, __u32 ep_index)
|
{
|
__usbc_otg_t *usbc_otg = (__usbc_otg_t *)hUSB;
|
__u32 fifo = 0;
|
|
if(usbc_otg == NULL){
|
return 0;
|
}
|
|
switch(ep_index){
|
case 0:
|
fifo = USBC_REG_EPFIFO0(usbc_otg->base_addr);
|
break;
|
|
case 1:
|
fifo = USBC_REG_EPFIFO1(usbc_otg->base_addr);
|
break;
|
|
case 2:
|
fifo = USBC_REG_EPFIFO2(usbc_otg->base_addr);
|
break;
|
|
case 3:
|
fifo = USBC_REG_EPFIFO3(usbc_otg->base_addr);
|
break;
|
|
case 4:
|
fifo = USBC_REG_EPFIFO4(usbc_otg->base_addr);
|
break;
|
|
case 5:
|
fifo = USBC_REG_EPFIFO5(usbc_otg->base_addr);
|
break;
|
|
default:
|
fifo = 0;
|
}
|
|
return fifo;
|
}
|
*/
|
|
__u32 USBC_SelectFIFO(__hdle hUSB, __u32 ep_index)
|
{
|
__usbc_otg_t *usbc_otg = (__usbc_otg_t *)hUSB;
|
|
if(usbc_otg == NULL){
|
return 0;
|
}
|
|
return USBC_REG_EPFIFOx(usbc_otg->base_addr, ep_index);
|
}
|
|
static void __USBC_ConfigFifo_TxEp_Default(ulong usbc_base_addr)
|
{
|
USBC_Writew(0x00, USBC_REG_TXFIFOAD(usbc_base_addr));
|
USBC_Writeb(0x00, USBC_REG_TXFIFOSZ(usbc_base_addr));
|
}
|
|
/*
|
***********************************************************************************
|
* USBC_ConfigFifo_TxEp
|
*
|
* Description:
|
* 配置tx ep 的fifo地址和大小。
|
*
|
* Arguments:
|
* hUSB : input. USBC_open_otg获得的句柄, 记录了USBC所需要的一些关键数据
|
* is_double_fifo : input. 是否使用硬件双fifo
|
* fifo_size : input. fifo大小 = 2的fifo_size次方
|
* fifo_addr : input. fifo的起始地址 = fifo_addr * 8
|
*
|
* Returns:
|
* 返回成功读的长度
|
*
|
* note:
|
* 无
|
*
|
***********************************************************************************
|
*/
|
void __USBC_ConfigFifo_TxEp(ulong usbc_base_addr, __u32 is_double_fifo, __u32 fifo_size, __u32 fifo_addr)
|
{
|
__u32 temp = 0;
|
__u32 size = 0; //fifo_size = (size + 3)的2次方
|
__u32 addr = 0; //fifo_addr = addr * 8
|
|
//--<1>--换算sz, 不满512，以512对齐
|
temp = fifo_size + 511;
|
temp &= ~511; //把511后面的清零
|
temp >>= 3;
|
temp >>= 1;
|
while(temp){
|
size++;
|
temp >>= 1;
|
}
|
|
//--<2>--换算addr
|
addr = fifo_addr >> 3;
|
|
//--<3>--config fifo addr
|
USBC_Writew(addr, USBC_REG_TXFIFOAD(usbc_base_addr));
|
|
//--<4>--config fifo size
|
USBC_Writeb((size & 0x0f), USBC_REG_TXFIFOSZ(usbc_base_addr));
|
if(is_double_fifo){
|
USBC_REG_set_bit_b(USBC_BP_TXFIFOSZ_DPB, USBC_REG_TXFIFOSZ(usbc_base_addr));
|
}
|
}
|
|
void __USBC_ConfigFifo_RxEp_Default(ulong usbc_base_addr)
|
{
|
USBC_Writew(0x00, USBC_REG_RXFIFOAD(usbc_base_addr));
|
USBC_Writeb(0x00, USBC_REG_RXFIFOSZ(usbc_base_addr));
|
}
|
|
/*
|
***********************************************************************************
|
* USBC_ConfigFifo_RxEp
|
*
|
* Description:
|
* 配置tx ep 的fifo地址和大小。
|
*
|
* Arguments:
|
* hUSB : input. USBC_open_otg获得的句柄, 记录了USBC所需要的一些关键数据
|
* is_double_fifo : input. 是否使用硬件双fifo
|
* fifo_size : input. fifo大小 = 2的fifo_size次方
|
* fifo_addr : input. fifo的起始地址 = fifo_addr * 8
|
*
|
* Returns:
|
* 返回成功读的长度
|
*
|
* note:
|
* 无
|
*
|
***********************************************************************************
|
*/
|
void __USBC_ConfigFifo_RxEp(ulong usbc_base_addr, __u32 is_double_fifo, __u32 fifo_size, __u32 fifo_addr)
|
{
|
__u32 temp = 0;
|
__u32 size = 0; //fifo_size = (size + 3)的2次方
|
__u32 addr = 0; //fifo_addr = addr * 8
|
|
//--<1>--计算sz, 不满512，以512对齐
|
temp = fifo_size + 511;
|
temp &= ~511; //把511后面的清零
|
temp >>= 3;
|
temp >>= 1;
|
while(temp){
|
size++;
|
temp >>= 1;
|
}
|
|
//--<2>--换算addr
|
addr = fifo_addr >> 3;
|
|
//--<3>--config fifo addr
|
USBC_Writew(addr, USBC_REG_RXFIFOAD(usbc_base_addr));
|
|
//--<2>--config fifo size
|
USBC_Writeb((size & 0x0f), USBC_REG_RXFIFOSZ(usbc_base_addr));
|
if(is_double_fifo){
|
USBC_REG_set_bit_b(USBC_BP_RXFIFOSZ_DPB, USBC_REG_RXFIFOSZ(usbc_base_addr));
|
}
|
}
|
|
/*
|
***********************************************************************************
|
* USBC_ConfigFifo_Default
|
*
|
* Description:
|
* 配置ep 的fifo地址和大小。
|
*
|
* Arguments:
|
* hUSB : input. USBC_open_otg获得的句柄, 记录了USBC所需要的一些关键数据
|
* ep_type : input. ep的类型
|
*
|
* Returns:
|
* 返回成功读的长度
|
*
|
* note:
|
* 无
|
*
|
***********************************************************************************
|
*/
|
void USBC_ConfigFifo_Default(__hdle hUSB, __u32 ep_type)
|
{
|
__usbc_otg_t *usbc_otg = (__usbc_otg_t *)hUSB;
|
|
if(usbc_otg == NULL){
|
return ;
|
}
|
|
switch(ep_type){
|
case USBC_EP_TYPE_EP0:
|
//not support
|
break;
|
|
case USBC_EP_TYPE_TX:
|
__USBC_ConfigFifo_TxEp_Default(usbc_otg->base_addr);
|
break;
|
|
case USBC_EP_TYPE_RX:
|
__USBC_ConfigFifo_RxEp_Default(usbc_otg->base_addr);
|
break;
|
|
default:
|
break;
|
}
|
}
|
|
/*
|
***********************************************************************************
|
* USBC_ConfigFifo
|
*
|
* Description:
|
* 配置ep 的fifo地址和大小。
|
*
|
* Arguments:
|
* hUSB : input. USBC_open_otg获得的句柄, 记录了USBC所需要的一些关键数据
|
* ep_type : input. ep的类型
|
* is_double_fifo : input. 是否使用硬件双fifo
|
* fifo_size : input. fifo大小 = 2的fifo_size次方
|
* fifo_addr : input. fifo的起始地址 = fifo_addr * 8
|
*
|
* Returns:
|
* 返回成功读的长度
|
*
|
* note:
|
* 无
|
*
|
***********************************************************************************
|
*/
|
void USBC_ConfigFifo(__hdle hUSB, __u32 ep_type, __u32 is_double_fifo, __u32 fifo_size, __u32 fifo_addr)
|
{
|
__usbc_otg_t *usbc_otg = (__usbc_otg_t *)hUSB;
|
|
if(usbc_otg == NULL){
|
return ;
|
}
|
|
switch(ep_type){
|
case USBC_EP_TYPE_EP0:
|
//not support
|
break;
|
|
case USBC_EP_TYPE_TX:
|
__USBC_ConfigFifo_TxEp(usbc_otg->base_addr, is_double_fifo, fifo_size, fifo_addr);
|
break;
|
|
case USBC_EP_TYPE_RX:
|
__USBC_ConfigFifo_RxEp(usbc_otg->base_addr, is_double_fifo, fifo_size, fifo_addr);
|
break;
|
|
default:
|
break;
|
}
|
}
|
|
/*
|
***********************************************************************************
|
* USBC_GetLastFrameNumber
|
*
|
* Description:
|
* 获得最后一帧的帧号
|
*
|
* Arguments:
|
* hUSB : input. USBC_open_otg获得的句柄, 记录了USBC所需要的一些关键数据
|
*
|
* Returns:
|
*
|
*
|
* note:
|
* 无
|
*
|
***********************************************************************************
|
*/
|
__u32 USBC_GetLastFrameNumber(__hdle hUSB)
|
{
|
__usbc_otg_t *usbc_otg = (__usbc_otg_t *)hUSB;
|
|
if(usbc_otg == NULL){
|
return 0;
|
}
|
|
return USBC_Readl(USBC_REG_FRNUM(usbc_otg->base_addr));
|
}
|
|
/*
|
***********************************************************************************
|
* USBC_GetStatus_Dp
|
*
|
* Description:
|
* 获得dp的状态
|
*
|
* Arguments:
|
* hUSB : input. USBC_open_otg获得的句柄, 记录了USBC所需要的一些关键数据
|
*
|
* Returns:
|
*
|
*
|
* note:
|
* 无
|
*
|
***********************************************************************************
|
*/
|
|
__u32 USBC_GetStatus_Dp(__hdle hUSB)
|
{
|
__usbc_otg_t *usbc_otg = (__usbc_otg_t *)hUSB;
|
__u32 temp = 0;
|
|
if(usbc_otg == NULL){
|
return 0;
|
}
|
|
temp = USBC_Readl(USBC_REG_ISCR(usbc_otg->base_addr));
|
temp = (temp >> USBC_BP_ISCR_EXT_DP_STATUS) & 0x01;
|
|
return temp;
|
}
|
|
|
|
/*
|
***********************************************************************************
|
* USBC_GetStatus_Dm
|
*
|
* Description:
|
* 获得dm的状态
|
*
|
* Arguments:
|
* hUSB : input. USBC_open_otg获得的句柄, 记录了USBC所需要的一些关键数据
|
*
|
* Returns:
|
*
|
*
|
* note:
|
* 无
|
*
|
***********************************************************************************
|
*/
|
__u32 USBC_GetStatus_Dm(__hdle hUSB)
|
{
|
__usbc_otg_t *usbc_otg = (__usbc_otg_t *)hUSB;
|
__u32 temp = 0;
|
|
if(usbc_otg == NULL){
|
return 0;
|
}
|
|
temp = USBC_Readl(USBC_REG_ISCR(usbc_otg->base_addr));
|
temp = (temp >> USBC_BP_ISCR_EXT_DM_STATUS) & 0x01;
|
|
return temp;
|
}
|
|
|
/*
|
***********************************************************************************
|
* USBC_GetStatus_Dp
|
*
|
* Description:
|
* 获得dp的状态
|
*
|
* Arguments:
|
* hUSB : input. USBC_open_otg获得的句柄, 记录了USBC所需要的一些关键数据
|
*
|
* Returns:
|
*
|
*
|
* note:
|
* 无
|
*
|
***********************************************************************************
|
*/
|
|
__u32 USBC_GetStatus_DpDm(__hdle hUSB)
|
{
|
__usbc_otg_t *usbc_otg = (__usbc_otg_t *)hUSB;
|
__u32 temp = 0;
|
__u32 dp = 0;
|
__u32 dm = 0;
|
|
|
if(usbc_otg == NULL){
|
return 0;
|
}
|
|
temp = USBC_Readl(USBC_REG_ISCR(usbc_otg->base_addr));
|
dp = (temp >> USBC_BP_ISCR_EXT_DP_STATUS) & 0x01;
|
dm = (temp >> USBC_BP_ISCR_EXT_DM_STATUS) & 0x01;
|
return ((dp << 1) | dm);
|
|
}
|
|
/*
|
***********************************************************************************
|
* USBC_GetOtgMode_Form_ID
|
*
|
* Description:
|
* 从vendor0 的 id 获得当前OTG的模式
|
*
|
* Arguments:
|
* hUSB : input. USBC_open_otg获得的句柄, 记录了USBC所需要的一些关键数据
|
*
|
* Returns:
|
* USBC_OTG_DEVICE / USBC_OTG_HOST
|
*
|
* note:
|
* 无
|
*
|
***********************************************************************************
|
*/
|
__u32 USBC_GetOtgMode_Form_ID(__hdle hUSB)
|
{
|
__usbc_otg_t *usbc_otg = (__usbc_otg_t *)hUSB;
|
__u32 mode = 0;
|
|
if(usbc_otg == NULL){
|
return USBC_OTG_DEVICE;
|
}
|
|
mode = USBC_REG_test_bit_l(USBC_BP_ISCR_MERGED_ID_STATUS, USBC_REG_ISCR(usbc_otg->base_addr));
|
if(mode){
|
return USBC_OTG_DEVICE;
|
}else{
|
return USBC_OTG_HOST;
|
}
|
}
|
|
/*
|
***********************************************************************************
|
* USBC_GetOtgMode_Form_BDevice
|
*
|
* Description:
|
* 从 OTG Device 的 B-Device 获得当前OTG的模式
|
*
|
* Arguments:
|
* hUSB : input. USBC_open_otg获得的句柄, 记录了USBC所需要的一些关键数据
|
*
|
* Returns:
|
* USBC_OTG_DEVICE / USBC_OTG_HOST
|
*
|
* note:
|
* 无
|
*
|
***********************************************************************************
|
*/
|
__u32 USBC_GetOtgMode_Form_BDevice(__hdle hUSB)
|
{
|
__usbc_otg_t *usbc_otg = (__usbc_otg_t *)hUSB;
|
__u32 mode = 0;
|
|
if(usbc_otg == NULL){
|
return USBC_OTG_DEVICE;
|
}
|
|
mode = USBC_REG_test_bit_b(USBC_BP_DEVCTL_B_DEVICE, USBC_REG_DEVCTL(usbc_otg->base_addr));
|
if(mode){
|
return USBC_OTG_DEVICE;
|
}else{
|
return USBC_OTG_HOST;
|
}
|
}
|
|
/*
|
***********************************************************************************
|
* USBC_SelectBus
|
*
|
* Description:
|
* 选择数据传输的总线方式
|
*
|
* Arguments:
|
* hUSB : input. USBC_open_otg获得的句柄, 记录了USBC所需要的一些关键数据
|
* io_type : input. 总线方式, pio还是dma.
|
* ep_type : input. ep的类型, rx 或 tx。
|
* ep_index : input. ep号
|
*
|
* Returns:
|
*
|
*
|
* note:
|
* 无
|
*
|
***********************************************************************************
|
*/
|
void USBC_SelectBus(__hdle hUSB, __u32 io_type, __u32 ep_type, __u32 ep_index)
|
{
|
__usbc_otg_t *usbc_otg = (__usbc_otg_t *)hUSB;
|
__u32 reg_val = 0;
|
|
if(usbc_otg == NULL){
|
return ;
|
}
|
|
reg_val = USBC_Readb(USBC_REG_VEND0(usbc_otg->base_addr));
|
if(io_type == USBC_IO_TYPE_DMA){
|
if(ep_type == USBC_EP_TYPE_TX){
|
reg_val |= ((ep_index - 0x01) << 1) << USBC_BP_VEND0_DRQ_SEL; //drq_sel
|
reg_val |= 0x1<<USBC_BP_VEND0_BUS_SEL; //io_dma
|
}else{
|
reg_val |= ((ep_index << 1) - 0x01) << USBC_BP_VEND0_DRQ_SEL;
|
reg_val |= 0x1<<USBC_BP_VEND0_BUS_SEL;
|
}
|
}else{
|
//reg_val &= ~(0x1 << USBC_BP_VEND0_DRQ_SEL); //清除drq_sel, 选择pio
|
reg_val &= 0x00; //清除drq_sel, 选择pio
|
}
|
|
USBC_Writeb(reg_val, USBC_REG_VEND0(usbc_otg->base_addr));
|
}
|
|
/* 获得tx ep中断标志位 */
|
static __u32 __USBC_INT_TxPending(ulong usbc_base_addr)
|
{
|
return (USBC_Readw(USBC_REG_INTTx(usbc_base_addr)));
|
}
|
|
/* 清除tx ep中断标志位 */
|
static void __USBC_INT_ClearTxPending(ulong usbc_base_addr, __u8 ep_index)
|
{
|
USBC_Writew((1 << ep_index), USBC_REG_INTTx(usbc_base_addr));
|
}
|
|
/* 清除所有tx ep中断标志位 */
|
static void __USBC_INT_ClearTxPendingAll(ulong usbc_base_addr)
|
{
|
USBC_Writew(0xffff, USBC_REG_INTTx(usbc_base_addr));
|
}
|
|
/* 获得rx ep中断标志位 */
|
static __u32 __USBC_INT_RxPending(ulong usbc_base_addr)
|
{
|
return (USBC_Readw(USBC_REG_INTRx(usbc_base_addr)));
|
}
|
|
/* 清除rx ep中断标志位 */
|
static void __USBC_INT_ClearRxPending(ulong usbc_base_addr, __u8 ep_index)
|
{
|
USBC_Writew((1 << ep_index), USBC_REG_INTRx(usbc_base_addr));
|
}
|
|
/* 清除rx ep中断标志位 */
|
static void __USBC_INT_ClearRxPendingAll(ulong usbc_base_addr)
|
{
|
USBC_Writew(0xffff, USBC_REG_INTRx(usbc_base_addr));
|
}
|
|
/* 开某一个tx ep的中断 */
|
static void __USBC_INT_EnableTxEp(ulong usbc_base_addr, __u8 ep_index)
|
{
|
USBC_REG_set_bit_w(ep_index, USBC_REG_INTTxE(usbc_base_addr));
|
}
|
|
/* 开某一个rx ep的中断 */
|
static void __USBC_INT_EnableRxEp(ulong usbc_base_addr, __u8 ep_index)
|
{
|
USBC_REG_set_bit_w(ep_index, USBC_REG_INTRxE(usbc_base_addr));
|
}
|
|
/* 关某一个tx ep的中断 */
|
static void __USBC_INT_DisableTxEp(ulong usbc_base_addr, __u8 ep_index)
|
{
|
USBC_REG_clear_bit_w(ep_index, USBC_REG_INTTxE(usbc_base_addr));
|
}
|
|
/* 关某一个rx ep的中断 */
|
static void __USBC_INT_DisableRxEp(ulong usbc_base_addr, __u8 ep_index)
|
{
|
USBC_REG_clear_bit_w(ep_index, USBC_REG_INTRxE(usbc_base_addr));
|
}
|
|
/* 关所有的tx ep中断 */
|
static void __USBC_INT_DisableTxAll(ulong usbc_base_addr)
|
{
|
USBC_Writew(0, USBC_REG_INTTxE(usbc_base_addr));
|
}
|
|
/* 关所有的rx ep中断 */
|
static void __USBC_INT_DisableRxAll(ulong usbc_base_addr)
|
{
|
USBC_Writew(0, USBC_REG_INTRxE(usbc_base_addr));
|
}
|
|
/* 获得ep中断标志位 */
|
__u32 USBC_INT_EpPending(__hdle hUSB, __u32 ep_type)
|
{
|
__usbc_otg_t *usbc_otg = (__usbc_otg_t *)hUSB;
|
|
if(usbc_otg == NULL){
|
return 0;
|
}
|
|
switch(ep_type){
|
case USBC_EP_TYPE_EP0:
|
case USBC_EP_TYPE_TX:
|
return __USBC_INT_TxPending(usbc_otg->base_addr);
|
|
case USBC_EP_TYPE_RX:
|
return __USBC_INT_RxPending(usbc_otg->base_addr);
|
|
default:
|
return 0;
|
}
|
}
|
|
/* 清除ep中断标志位 */
|
void USBC_INT_ClearEpPending(__hdle hUSB, __u32 ep_type, __u8 ep_index)
|
{
|
__usbc_otg_t *usbc_otg = (__usbc_otg_t *)hUSB;
|
|
if(usbc_otg == NULL){
|
return ;
|
}
|
|
switch(ep_type){
|
case USBC_EP_TYPE_EP0:
|
case USBC_EP_TYPE_TX:
|
__USBC_INT_ClearTxPending(usbc_otg->base_addr, ep_index);
|
break;
|
|
case USBC_EP_TYPE_RX:
|
__USBC_INT_ClearRxPending(usbc_otg->base_addr, ep_index);
|
break;
|
|
default:
|
break;
|
}
|
|
return ;
|
}
|
|
/* 清除ep中断标志位 */
|
void USBC_INT_ClearEpPendingAll(__hdle hUSB, __u32 ep_type)
|
{
|
__usbc_otg_t *usbc_otg = (__usbc_otg_t *)hUSB;
|
|
if(usbc_otg == NULL){
|
return ;
|
}
|
|
switch(ep_type){
|
case USBC_EP_TYPE_EP0:
|
case USBC_EP_TYPE_TX:
|
__USBC_INT_ClearTxPendingAll(usbc_otg->base_addr);
|
break;
|
|
case USBC_EP_TYPE_RX:
|
__USBC_INT_ClearRxPendingAll(usbc_otg->base_addr);
|
break;
|
|
default:
|
break;
|
}
|
|
return ;
|
}
|
|
/* 获得usb misc中断标志位 */
|
__u32 USBC_INT_MiscPending(__hdle hUSB)
|
{
|
__usbc_otg_t *usbc_otg = (__usbc_otg_t *)hUSB;
|
|
if(usbc_otg == NULL){
|
return 0;
|
}
|
|
return (USBC_Readb(USBC_REG_INTUSB(usbc_otg->base_addr)));
|
}
|
|
/* 清除usb misc中断标志位 */
|
void USBC_INT_ClearMiscPending(__hdle hUSB, __u32 mask)
|
{
|
__usbc_otg_t *usbc_otg = (__usbc_otg_t *)hUSB;
|
|
if(usbc_otg == NULL){
|
return ;
|
}
|
|
USBC_Writeb(mask, USBC_REG_INTUSB(usbc_otg->base_addr));
|
}
|
|
/* 清除所有usb misc中断标志位 */
|
void USBC_INT_ClearMiscPendingAll(__hdle hUSB)
|
{
|
__usbc_otg_t *usbc_otg = (__usbc_otg_t *)hUSB;
|
|
if(usbc_otg == NULL){
|
return ;
|
}
|
|
USBC_Writeb(0xff, USBC_REG_INTUSB(usbc_otg->base_addr));
|
}
|
|
/* 开某一个ep中断 */
|
void USBC_INT_EnableEp(__hdle hUSB, __u32 ep_type, __u8 ep_index)
|
{
|
__usbc_otg_t *usbc_otg = (__usbc_otg_t *)hUSB;
|
|
if(usbc_otg == NULL){
|
return ;
|
}
|
|
switch(ep_type){
|
case USBC_EP_TYPE_TX:
|
__USBC_INT_EnableTxEp(usbc_otg->base_addr, ep_index);
|
break;
|
|
case USBC_EP_TYPE_RX:
|
__USBC_INT_EnableRxEp(usbc_otg->base_addr, ep_index);
|
break;
|
|
default:
|
break;
|
}
|
|
return ;
|
}
|
|
/* 开某一个usb misc中断 */
|
void USBC_INT_EnableUsbMiscUint(__hdle hUSB, __u32 mask)
|
{
|
__usbc_otg_t *usbc_otg = (__usbc_otg_t *)hUSB;
|
__u32 reg_val = 0;
|
|
if(usbc_otg == NULL){
|
return ;
|
}
|
|
reg_val = USBC_Readb(USBC_REG_INTUSBE(usbc_otg->base_addr));
|
reg_val |= mask;
|
USBC_Writeb(reg_val, USBC_REG_INTUSBE(usbc_otg->base_addr));
|
}
|
|
/* 关某tx ep的中断 */
|
void USBC_INT_DisableEp(__hdle hUSB, __u32 ep_type, __u8 ep_index)
|
{
|
__usbc_otg_t *usbc_otg = (__usbc_otg_t *)hUSB;
|
|
if(usbc_otg == NULL){
|
return ;
|
}
|
|
switch(ep_type){
|
case USBC_EP_TYPE_TX:
|
__USBC_INT_DisableTxEp(usbc_otg->base_addr, ep_index);
|
break;
|
|
case USBC_EP_TYPE_RX:
|
__USBC_INT_DisableRxEp(usbc_otg->base_addr, ep_index);
|
break;
|
|
default:
|
break;
|
}
|
|
return;
|
}
|
|
/* 关某一个usb misc中断 */
|
void USBC_INT_DisableUsbMiscUint(__hdle hUSB, __u32 mask)
|
{
|
__usbc_otg_t *usbc_otg = (__usbc_otg_t *)hUSB;
|
__u32 reg_val = 0;
|
|
if(usbc_otg == NULL){
|
return ;
|
}
|
|
reg_val = USBC_Readb(USBC_REG_INTUSBE(usbc_otg->base_addr));
|
reg_val &= ~mask;
|
USBC_Writeb(reg_val, USBC_REG_INTUSBE(usbc_otg->base_addr));
|
}
|
|
/* 关所有的ep中断 */
|
void USBC_INT_DisableEpAll(__hdle hUSB, __u32 ep_type)
|
{
|
__usbc_otg_t *usbc_otg = (__usbc_otg_t *)hUSB;
|
|
if(usbc_otg == NULL){
|
return ;
|
}
|
|
switch(ep_type){
|
case USBC_EP_TYPE_TX:
|
__USBC_INT_DisableTxAll(usbc_otg->base_addr);
|
break;
|
|
case USBC_EP_TYPE_RX:
|
__USBC_INT_DisableRxAll(usbc_otg->base_addr);
|
break;
|
|
default:
|
break;
|
}
|
|
return;
|
}
|
|
/* 关所有的usb misc中断 */
|
void USBC_INT_DisableUsbMiscAll(__hdle hUSB)
|
{
|
__usbc_otg_t *usbc_otg = (__usbc_otg_t *)hUSB;
|
|
if(usbc_otg == NULL){
|
return ;
|
}
|
|
USBC_Writeb(0, USBC_REG_INTUSBE(usbc_otg->base_addr));
|
}
|
|
/* 获得当前活动的ep */
|
__u32 USBC_GetActiveEp(__hdle hUSB)
|
{
|
__usbc_otg_t *usbc_otg = (__usbc_otg_t *)hUSB;
|
|
if(usbc_otg == NULL){
|
return 0;
|
}
|
|
return USBC_Readb(USBC_REG_EPIND(usbc_otg->base_addr));
|
}
|
|
/* 配置当前活动ep */
|
void USBC_SelectActiveEp(__hdle hUSB, __u8 ep_index)
|
{
|
__usbc_otg_t *usbc_otg = (__usbc_otg_t *)hUSB;
|
|
if(usbc_otg == NULL){
|
return ;
|
}
|
|
USBC_Writeb(ep_index, USBC_REG_EPIND(usbc_otg->base_addr));
|
}
|
|
/* 加强usb传输信号 */
|
void USBC_EnhanceSignal(__hdle hUSB)
|
{
|
#if 0
|
__usbc_otg_t *usbc_otg = (__usbc_otg_t *)hUSB;
|
|
if(usbc_otg == NULL){
|
return ;
|
}
|
#endif
|
return;
|
}
|
|
/* 进入 TestPacket 模式 */
|
void USBC_EnterMode_TestPacket(__hdle hUSB)
|
{
|
__usbc_otg_t *usbc_otg = (__usbc_otg_t *)hUSB;
|
|
if(usbc_otg == NULL){
|
return ;
|
}
|
|
USBC_REG_set_bit_b(USBC_BP_TMCTL_TEST_PACKET, USBC_REG_TMCTL(usbc_otg->base_addr));
|
}
|
|
/* 进入 Test_K 模式 */
|
void USBC_EnterMode_Test_K(__hdle hUSB)
|
{
|
__usbc_otg_t *usbc_otg = (__usbc_otg_t *)hUSB;
|
|
if(usbc_otg == NULL){
|
return ;
|
}
|
|
USBC_REG_set_bit_b(USBC_BP_TMCTL_TEST_K, USBC_REG_TMCTL(usbc_otg->base_addr));
|
}
|
|
/* 进入 Test_J 模式 */
|
void USBC_EnterMode_Test_J(__hdle hUSB)
|
{
|
__usbc_otg_t *usbc_otg = (__usbc_otg_t *)hUSB;
|
|
if(usbc_otg == NULL){
|
return ;
|
}
|
|
USBC_REG_set_bit_b(USBC_BP_TMCTL_TEST_J, USBC_REG_TMCTL(usbc_otg->base_addr));
|
}
|
|
/* 进入 Test_SE0_NAK 模式 */
|
void USBC_EnterMode_Test_SE0_NAK(__hdle hUSB)
|
{
|
__usbc_otg_t *usbc_otg = (__usbc_otg_t *)hUSB;
|
|
if(usbc_otg == NULL){
|
return ;
|
}
|
|
USBC_REG_set_bit_b(USBC_BP_TMCTL_TEST_SE0_NAK, USBC_REG_TMCTL(usbc_otg->base_addr));
|
}
|
|
/* 清除所有测试模式 */
|
void USBC_EnterMode_Idle(__hdle hUSB)
|
{
|
__usbc_otg_t *usbc_otg = (__usbc_otg_t *)hUSB;
|
|
if(usbc_otg == NULL){
|
return ;
|
}
|
|
USBC_REG_clear_bit_b(USBC_BP_TMCTL_TEST_PACKET, USBC_REG_TMCTL(usbc_otg->base_addr));
|
USBC_REG_clear_bit_b(USBC_BP_TMCTL_TEST_K, USBC_REG_TMCTL(usbc_otg->base_addr));
|
USBC_REG_clear_bit_b(USBC_BP_TMCTL_TEST_J, USBC_REG_TMCTL(usbc_otg->base_addr));
|
USBC_REG_clear_bit_b(USBC_BP_TMCTL_TEST_SE0_NAK, USBC_REG_TMCTL(usbc_otg->base_addr));
|
}
|
|
/* vbus, id, dpdm变化位是写1清零, 因此我们在操作其他bit的时候清除这些位 */
|
static __u32 __USBC_WakeUp_ClearChangeDetect(__u32 reg_val)
|
{
|
__u32 temp = reg_val;
|
|
temp &= ~(1 << USBC_BP_ISCR_VBUS_CHANGE_DETECT);
|
temp &= ~(1 << USBC_BP_ISCR_ID_CHANGE_DETECT);
|
temp &= ~(1 << USBC_BP_ISCR_DPDM_CHANGE_DETECT);
|
|
return temp;
|
}
|
|
void USBC_SetWakeUp_Default(__hdle hUSB)
|
{
|
|
return;
|
}
|
|
void USBC_EnableIdPullUp(__hdle hUSB)
|
{
|
__usbc_otg_t *usbc_otg = (__usbc_otg_t *)hUSB;
|
__u32 reg_val = 0;
|
|
//vbus, id, dpdm变化位是写1清零, 因此我们在操作其他bit的时候清除这些位
|
reg_val = USBC_Readl(USBC_REG_ISCR(usbc_otg->base_addr));
|
reg_val |= (1 << USBC_BP_ISCR_ID_PULLUP_EN);
|
reg_val = __USBC_WakeUp_ClearChangeDetect(reg_val);
|
USBC_Writel(reg_val, USBC_REG_ISCR(usbc_otg->base_addr));
|
}
|
|
void USBC_DisableIdPullUp(__hdle hUSB)
|
{
|
__usbc_otg_t *usbc_otg = (__usbc_otg_t *)hUSB;
|
__u32 reg_val = 0;
|
|
//vbus, id, dpdm变化位是写1清零, 因此我们在操作其他bit的时候清除这些位
|
reg_val = USBC_Readl(USBC_REG_ISCR(usbc_otg->base_addr));
|
reg_val &= ~(1 << USBC_BP_ISCR_ID_PULLUP_EN);
|
reg_val = __USBC_WakeUp_ClearChangeDetect(reg_val);
|
USBC_Writel(reg_val, USBC_REG_ISCR(usbc_otg->base_addr));
|
}
|
|
void USBC_EnableDpDmPullUp(__hdle hUSB)
|
{
|
__usbc_otg_t *usbc_otg = (__usbc_otg_t *)hUSB;
|
__u32 reg_val = 0;
|
|
//vbus, id, dpdm变化位是写1清零, 因此我们在操作其他bit的时候清除这些位
|
reg_val = USBC_Readl(USBC_REG_ISCR(usbc_otg->base_addr));
|
reg_val |= (1 << USBC_BP_ISCR_DPDM_PULLUP_EN);
|
reg_val = __USBC_WakeUp_ClearChangeDetect(reg_val);
|
USBC_Writel(reg_val, USBC_REG_ISCR(usbc_otg->base_addr));
|
}
|
|
void USBC_DisableDpDmPullUp(__hdle hUSB)
|
{
|
__usbc_otg_t *usbc_otg = (__usbc_otg_t *)hUSB;
|
__u32 reg_val = 0;
|
|
//vbus, id, dpdm变化位是写1清零, 因此我们在操作其他bit的时候清除这些位
|
reg_val = USBC_Readl(USBC_REG_ISCR(usbc_otg->base_addr));
|
reg_val &= ~(1 << USBC_BP_ISCR_DPDM_PULLUP_EN);
|
reg_val = __USBC_WakeUp_ClearChangeDetect(reg_val);
|
USBC_Writel(reg_val, USBC_REG_ISCR(usbc_otg->base_addr));
|
}
|
|
static void __USBC_ForceIdDisable(ulong usbc_base_addr)
|
{
|
__u32 reg_val = 0;
|
|
//vbus, id, dpdm变化位是写1清零, 因此我们在操作其他bit的时候清除这些位
|
reg_val = USBC_Readl(USBC_REG_ISCR(usbc_base_addr));
|
reg_val &= ~(0x03 << USBC_BP_ISCR_FORCE_ID);
|
reg_val = __USBC_WakeUp_ClearChangeDetect(reg_val);
|
USBC_Writel(reg_val, USBC_REG_ISCR(usbc_base_addr));
|
}
|
|
static void __USBC_ForceIdToLow(ulong usbc_base_addr)
|
{
|
__u32 reg_val = 0;
|
|
//先写00，后写10
|
reg_val = USBC_Readl(USBC_REG_ISCR(usbc_base_addr));
|
reg_val &= ~(0x03 << USBC_BP_ISCR_FORCE_ID);
|
reg_val |= (0x02 << USBC_BP_ISCR_FORCE_ID);
|
reg_val = __USBC_WakeUp_ClearChangeDetect(reg_val);
|
USBC_Writel(reg_val, USBC_REG_ISCR(usbc_base_addr));
|
}
|
|
static void __USBC_ForceIdToHigh(ulong usbc_base_addr)
|
{
|
__u32 reg_val = 0;
|
|
//先写00，后写10
|
reg_val = USBC_Readl(USBC_REG_ISCR(usbc_base_addr));
|
//reg_val &= ~(0x03 << USBC_BP_ISCR_FORCE_ID);
|
reg_val |= (0x03 << USBC_BP_ISCR_FORCE_ID);
|
reg_val = __USBC_WakeUp_ClearChangeDetect(reg_val);
|
USBC_Writel(reg_val, USBC_REG_ISCR(usbc_base_addr));
|
}
|
|
/* force id to (id_type) */
|
void USBC_ForceId(__hdle hUSB, __u32 id_type)
|
{
|
__usbc_otg_t *usbc_otg = (__usbc_otg_t *)hUSB;
|
|
switch(id_type){
|
case USBC_ID_TYPE_HOST:
|
__USBC_ForceIdToLow(usbc_otg->base_addr);
|
break;
|
|
case USBC_ID_TYPE_DEVICE:
|
__USBC_ForceIdToHigh(usbc_otg->base_addr);
|
break;
|
|
default:
|
__USBC_ForceIdDisable(usbc_otg->base_addr);
|
}
|
}
|
|
static void __USBC_ForceVbusValidDisable(ulong usbc_base_addr)
|
{
|
__u32 reg_val = 0;
|
|
//先写00，后写10
|
reg_val = USBC_Readl(USBC_REG_ISCR(usbc_base_addr));
|
reg_val &= ~(0x03 << USBC_BP_ISCR_FORCE_VBUS_VALID);
|
reg_val = __USBC_WakeUp_ClearChangeDetect(reg_val);
|
USBC_Writel(reg_val, USBC_REG_ISCR(usbc_base_addr));
|
}
|
|
static void __USBC_ForceVbusValidToLow(ulong usbc_base_addr)
|
{
|
__u32 reg_val = 0;
|
|
//先写00，后写10
|
reg_val = USBC_Readl(USBC_REG_ISCR(usbc_base_addr));
|
reg_val &= ~(0x03 << USBC_BP_ISCR_FORCE_VBUS_VALID);
|
reg_val |= (0x02 << USBC_BP_ISCR_FORCE_VBUS_VALID);
|
reg_val = __USBC_WakeUp_ClearChangeDetect(reg_val);
|
USBC_Writel(reg_val, USBC_REG_ISCR(usbc_base_addr));
|
}
|
|
static void __USBC_ForceVbusValidToHigh(ulong usbc_base_addr)
|
{
|
__u32 reg_val = 0;
|
|
//先写00，后写11
|
reg_val = USBC_Readl(USBC_REG_ISCR(usbc_base_addr));
|
//reg_val &= ~(0x03 << USBC_BP_ISCR_FORCE_VBUS_VALID);
|
reg_val |= (0x03 << USBC_BP_ISCR_FORCE_VBUS_VALID);
|
reg_val = __USBC_WakeUp_ClearChangeDetect(reg_val);
|
USBC_Writel(reg_val, USBC_REG_ISCR(usbc_base_addr));
|
}
|
|
/* force vbus valid to (id_type) */
|
void USBC_ForceVbusValid(__hdle hUSB, __u32 vbus_type)
|
{
|
__usbc_otg_t *usbc_otg = (__usbc_otg_t *)hUSB;
|
|
switch(vbus_type){
|
case USBC_VBUS_TYPE_LOW:
|
__USBC_ForceVbusValidToLow(usbc_otg->base_addr);
|
break;
|
|
case USBC_VBUS_TYPE_HIGH:
|
__USBC_ForceVbusValidToHigh(usbc_otg->base_addr);
|
break;
|
|
default:
|
__USBC_ForceVbusValidDisable(usbc_otg->base_addr);
|
}
|
}
|
|
void USBC_A_valid_InputSelect(__hdle hUSB, __u32 source)
|
{
|
|
return;
|
}
|
|
void USBC_EnableUsbLineStateBypass(__hdle hUSB)
|
{
|
|
return;
|
}
|
|
void USBC_DisableUsbLineStateBypass(__hdle hUSB)
|
{
|
|
return;
|
}
|
|
void USBC_EnableHosc(__hdle hUSB)
|
{
|
__usbc_otg_t *usbc_otg = (__usbc_otg_t *)hUSB;
|
__u32 reg_val = 0;
|
|
reg_val = USBC_Readl(USBC_REG_ISCR(usbc_otg->base_addr));
|
reg_val |= 1 << USBC_BP_ISCR_HOSC_EN;
|
reg_val = __USBC_WakeUp_ClearChangeDetect(reg_val);
|
USBC_Writel(reg_val, USBC_REG_ISCR(usbc_otg->base_addr));
|
}
|
|
/* 禁用Hosc */
|
void USBC_DisableHosc(__hdle hUSB)
|
{
|
__usbc_otg_t *usbc_otg = (__usbc_otg_t *)hUSB;
|
__u32 reg_val = 0;
|
|
reg_val = USBC_Readl(USBC_REG_ISCR(usbc_otg->base_addr));
|
reg_val &= ~(1 << USBC_BP_ISCR_HOSC_EN);
|
reg_val = __USBC_WakeUp_ClearChangeDetect(reg_val);
|
USBC_Writel(reg_val, USBC_REG_ISCR(usbc_otg->base_addr));
|
}
|
|
/* 查询是否产生 vbus 中断 */
|
__u32 USBC_IsVbusChange(__hdle hUSB)
|
{
|
__usbc_otg_t *usbc_otg = (__usbc_otg_t *)hUSB;
|
__u32 reg_val = 0;
|
__u32 temp = 0;
|
|
//读取变化位的同时, 写1清除该位
|
reg_val = USBC_Readl(USBC_REG_ISCR(usbc_otg->base_addr));
|
|
temp = reg_val & (1 << USBC_BP_ISCR_VBUS_CHANGE_DETECT);
|
|
reg_val = __USBC_WakeUp_ClearChangeDetect(reg_val);
|
reg_val |= 1 << USBC_BP_ISCR_VBUS_CHANGE_DETECT;
|
USBC_Writel(reg_val, USBC_REG_ISCR(usbc_otg->base_addr));
|
|
return temp;
|
}
|
|
/* 查询是否产生 id 中断 */
|
__u32 USBC_IsIdChange(__hdle hUSB)
|
{
|
__usbc_otg_t *usbc_otg = (__usbc_otg_t *)hUSB;
|
__u32 reg_val = 0;
|
__u32 temp = 0;
|
|
//读取变化位的同时, 写1清除该位
|
reg_val = USBC_Readl(USBC_REG_ISCR(usbc_otg->base_addr));
|
|
temp = reg_val & (1 << USBC_BP_ISCR_ID_CHANGE_DETECT);
|
|
reg_val = __USBC_WakeUp_ClearChangeDetect(reg_val);
|
reg_val |= 1 << USBC_BP_ISCR_ID_CHANGE_DETECT;
|
USBC_Writel(reg_val, USBC_REG_ISCR(usbc_otg->base_addr));
|
|
return temp;
|
}
|
|
/* 查询是否产生 dpdm 中断 */
|
__u32 USBC_IsDpDmChange(__hdle hUSB)
|
{
|
__usbc_otg_t *usbc_otg = (__usbc_otg_t *)hUSB;
|
__u32 reg_val = 0;
|
__u32 temp = 0;
|
|
//读取变化位的同时, 写1清除该位
|
reg_val = USBC_Readl(USBC_REG_ISCR(usbc_otg->base_addr));
|
|
temp = reg_val & (1 << USBC_BP_ISCR_DPDM_CHANGE_DETECT);
|
|
reg_val = __USBC_WakeUp_ClearChangeDetect(reg_val);
|
reg_val |= 1 << USBC_BP_ISCR_DPDM_CHANGE_DETECT;
|
USBC_Writel(reg_val, USBC_REG_ISCR(usbc_otg->base_addr));
|
|
return temp;
|
}
|
|
/* 禁用 wake 中断 */
|
void USBC_DisableWakeIrq(__hdle hUSB)
|
{
|
__usbc_otg_t *usbc_otg = (__usbc_otg_t *)hUSB;
|
__u32 reg_val = 0;
|
|
reg_val = USBC_Readl(USBC_REG_ISCR(usbc_otg->base_addr));
|
reg_val &= ~(1 << USBC_BP_ISCR_IRQ_ENABLE);
|
reg_val = __USBC_WakeUp_ClearChangeDetect(reg_val);
|
USBC_Writel(reg_val, USBC_REG_ISCR(usbc_otg->base_addr));
|
}
|
|
/* 禁用 vbus 中断 */
|
void USBC_DisableVbusChange(__hdle hUSB)
|
{
|
__usbc_otg_t *usbc_otg = (__usbc_otg_t *)hUSB;
|
__u32 reg_val = 0;
|
|
reg_val = USBC_Readl(USBC_REG_ISCR(usbc_otg->base_addr));
|
reg_val &= ~(1 << USBC_BP_ISCR_VBUS_CHANGE_DETECT_EN);
|
reg_val = __USBC_WakeUp_ClearChangeDetect(reg_val);
|
USBC_Writel(reg_val, USBC_REG_ISCR(usbc_otg->base_addr));
|
}
|
|
/* 禁用 id 中断 */
|
void USBC_DisableIdChange(__hdle hUSB)
|
{
|
__usbc_otg_t *usbc_otg = (__usbc_otg_t *)hUSB;
|
__u32 reg_val = 0;
|
|
reg_val = USBC_Readl(USBC_REG_ISCR(usbc_otg->base_addr));
|
reg_val &= ~(1 << USBC_BP_ISCR_ID_CHANGE_DETECT_EN);
|
reg_val = __USBC_WakeUp_ClearChangeDetect(reg_val);
|
USBC_Writel(reg_val, USBC_REG_ISCR(usbc_otg->base_addr));
|
}
|
|
/* 禁用 dpdm 中断 */
|
void USBC_DisableDpDmChange(__hdle hUSB)
|
{
|
__usbc_otg_t *usbc_otg = (__usbc_otg_t *)hUSB;
|
__u32 reg_val = 0;
|
|
reg_val = USBC_Readl(USBC_REG_ISCR(usbc_otg->base_addr));
|
reg_val &= ~(1 << USBC_BP_ISCR_DPDM_CHANGE_DETECT_EN);
|
reg_val = __USBC_WakeUp_ClearChangeDetect(reg_val);
|
USBC_Writel(reg_val, USBC_REG_ISCR(usbc_otg->base_addr));
|
}
|
|
/* 使能 wake 中断 */
|
void USBC_EnableWakeIrq(__hdle hUSB)
|
{
|
__usbc_otg_t *usbc_otg = (__usbc_otg_t *)hUSB;
|
__u32 reg_val = 0;
|
|
reg_val = USBC_Readl(USBC_REG_ISCR(usbc_otg->base_addr));
|
reg_val |= 1 << USBC_BP_ISCR_IRQ_ENABLE;
|
reg_val = __USBC_WakeUp_ClearChangeDetect(reg_val);
|
USBC_Writel(reg_val, USBC_REG_ISCR(usbc_otg->base_addr));
|
}
|
|
/* 使能 vbus 变化中断 */
|
void USBC_EnableVbusChange(__hdle hUSB)
|
{
|
__usbc_otg_t *usbc_otg = (__usbc_otg_t *)hUSB;
|
__u32 reg_val = 0;
|
|
reg_val = USBC_Readl(USBC_REG_ISCR(usbc_otg->base_addr));
|
reg_val |= 1 << USBC_BP_ISCR_VBUS_CHANGE_DETECT_EN;
|
reg_val = __USBC_WakeUp_ClearChangeDetect(reg_val);
|
USBC_Writel(reg_val, USBC_REG_ISCR(usbc_otg->base_addr));
|
}
|
|
/* 使能id变化中断 */
|
void USBC_EnableIdChange(__hdle hUSB)
|
{
|
__usbc_otg_t *usbc_otg = (__usbc_otg_t *)hUSB;
|
__u32 reg_val = 0;
|
|
reg_val = USBC_Readl(USBC_REG_ISCR(usbc_otg->base_addr));
|
reg_val |= 1 << USBC_BP_ISCR_ID_CHANGE_DETECT_EN;
|
reg_val = __USBC_WakeUp_ClearChangeDetect(reg_val);
|
USBC_Writel(reg_val, USBC_REG_ISCR(usbc_otg->base_addr));
|
}
|
|
/* 使能dmdp变化中断 */
|
void USBC_EnableDpDmChange(__hdle hUSB)
|
{
|
__usbc_otg_t *usbc_otg = (__usbc_otg_t *)hUSB;
|
__u32 reg_val = 0;
|
|
reg_val = USBC_Readl(USBC_REG_ISCR(usbc_otg->base_addr));
|
reg_val |= 1 << USBC_BP_ISCR_DPDM_CHANGE_DETECT_EN;
|
reg_val = __USBC_WakeUp_ClearChangeDetect(reg_val);
|
USBC_Writel(reg_val, USBC_REG_ISCR(usbc_otg->base_addr));
|
}
|
|
/* 测试模式, 获得寄存器的值 */
|
__u32 USBC_TestMode_ReadReg(__hdle hUSB, __u32 offset, __u32 reg_width)
|
{
|
__usbc_otg_t *usbc_otg = (__usbc_otg_t *)hUSB;
|
__u32 reg_val = 0;
|
|
if(usbc_otg == NULL){
|
return reg_val;
|
}
|
|
if(reg_width == 8){
|
reg_val = USBC_Readb(usbc_otg->base_addr + offset);
|
}else if(reg_width == 16){
|
reg_val = USBC_Readw(usbc_otg->base_addr + offset);
|
}else if(reg_width == 32){
|
reg_val = USBC_Readl(usbc_otg->base_addr + offset);
|
}else{
|
reg_val = 0;
|
}
|
|
return reg_val;
|
}
|
|
/*
|
*******************************************************************************
|
* print_usb_reg_by_ep
|
*
|
* Description:
|
* void
|
*
|
* Parameters:
|
* void
|
*
|
* Return value:
|
* void
|
*
|
* note:
|
* void
|
*
|
*******************************************************************************
|
*/
|
static void USBC_PrintEPReg(ulong usbc_base, __s32 ep_index, char *str, USBC_PRINT print)
|
{
|
__u32 old_ep_index = 0;
|
|
print("\n");
|
print("--------------------------ep%d: %s--------------------------\n", ep_index, str);
|
|
if(ep_index >= 0){
|
old_ep_index = USBC_Readw(usbc_base + USBC_REG_o_EPIND);
|
USBC_Writew(ep_index, (usbc_base + USBC_REG_o_EPIND));
|
print("old_ep_index = %d, ep_index = %d\n", old_ep_index, ep_index);
|
}
|
|
print("USBC_REG_o_FADDR = 0x%x\n", USBC_Readb(usbc_base + USBC_REG_o_FADDR));
|
print("USBC_REG_o_PCTL = 0x%x\n", USBC_Readb(usbc_base + USBC_REG_o_PCTL));
|
print("USBC_REG_o_INTTx = 0x%x\n", USBC_Readw(usbc_base + USBC_REG_o_INTTx));
|
print("USBC_REG_o_INTRx = 0x%x\n", USBC_Readw(usbc_base + USBC_REG_o_INTRx));
|
print("USBC_REG_o_INTTxE = 0x%x\n", USBC_Readw(usbc_base + USBC_REG_o_INTTxE));
|
print("USBC_REG_o_INTRxE = 0x%x\n", USBC_Readw(usbc_base + USBC_REG_o_INTRxE));
|
print("USBC_REG_o_INTUSB = 0x%x\n", USBC_Readb(usbc_base + USBC_REG_o_INTUSB));
|
print("USBC_REG_o_INTUSBE = 0x%x\n", USBC_Readb(usbc_base + USBC_REG_o_INTUSBE));
|
print("USBC_REG_o_EPIND = 0x%x\n", USBC_Readw(usbc_base + USBC_REG_o_EPIND));
|
print("USBC_REG_o_TXMAXP = 0x%x\n", USBC_Readw(usbc_base + USBC_REG_o_TXMAXP));
|
print("USBC_REG_o_CSR0 = 0x%x\n", USBC_Readw(usbc_base + USBC_REG_o_CSR0));
|
print("USBC_REG_o_TXCSR = 0x%x\n", USBC_Readw(usbc_base + USBC_REG_o_TXCSR));
|
print("USBC_REG_o_RXMAXP = 0x%x\n", USBC_Readw(usbc_base + USBC_REG_o_RXMAXP));
|
print("USBC_REG_o_RXCSR = 0x%x\n", USBC_Readw(usbc_base + USBC_REG_o_RXCSR));
|
|
print("USBC_REG_o_COUNT0 = 0x%x\n", USBC_Readw(usbc_base + USBC_REG_o_COUNT0));
|
print("USBC_REG_o_RXCOUNT = 0x%x\n", USBC_Readw(usbc_base + USBC_REG_o_RXCOUNT));
|
print("USBC_REG_o_TXTYPE = 0x%x\n", USBC_Readb(usbc_base + USBC_REG_o_TXTYPE));
|
print("USBC_REG_o_NAKLIMIT0 = 0x%x\n", USBC_Readb(usbc_base + USBC_REG_o_NAKLIMIT0));
|
print("USBC_REG_o_TXINTERVAL = 0x%x\n", USBC_Readb(usbc_base + USBC_REG_o_TXINTERVAL));
|
print("USBC_REG_o_RXTYPE = 0x%x\n", USBC_Readb(usbc_base + USBC_REG_o_RXTYPE));
|
print("USBC_REG_o_RXINTERVAL = 0x%x\n", USBC_Readb(usbc_base + USBC_REG_o_RXINTERVAL));
|
print("USBC_REG_o_CONFIGDATA = 0x%x\n", USBC_Readb(usbc_base + USBC_REG_o_CONFIGDATA));
|
|
print("USBC_REG_o_DEVCTL = 0x%x\n", USBC_Readb(usbc_base + USBC_REG_o_DEVCTL));
|
print("USBC_REG_o_TXFIFOSZ = 0x%x\n", USBC_Readb(usbc_base + USBC_REG_o_TXFIFOSZ));
|
print("USBC_REG_o_RXFIFOSZ = 0x%x\n", USBC_Readb(usbc_base + USBC_REG_o_RXFIFOSZ));
|
print("USBC_REG_o_TXFIFOAD = 0x%x\n", USBC_Readw(usbc_base + USBC_REG_o_TXFIFOAD));
|
print("USBC_REG_o_RXFIFOAD = 0x%x\n", USBC_Readw(usbc_base + USBC_REG_o_RXFIFOAD));
|
print("USBC_REG_o_VEND0 = 0x%x\n", USBC_Readb(usbc_base + USBC_REG_o_VEND0));
|
print("USBC_REG_o_VEND1 = 0x%x\n", USBC_Readb(usbc_base + USBC_REG_o_VEND1));
|
|
print("TXFADDRx(%d) = 0x%x\n", ep_index, USBC_Readb(usbc_base + USBC_REG_o_TXFADDRx));
|
print("TXHADDRx(%d = 0x%x\n", ep_index, USBC_Readb(usbc_base + USBC_REG_o_TXHADDRx));
|
print("TXHPORTx(%d) = 0x%x\n", ep_index, USBC_Readb(usbc_base + USBC_REG_o_TXHPORTx));
|
print("RXFADDRx(%d) = 0x%x\n", ep_index, USBC_Readb(usbc_base + USBC_REG_o_RXFADDRx));
|
print("RXHADDRx(%d) = 0x%x\n", ep_index, USBC_Readb(usbc_base + USBC_REG_o_RXHADDRx));
|
print("RXHPORTx(%d) = 0x%x\n", ep_index, USBC_Readb(usbc_base + USBC_REG_o_RXHPORTx));
|
print("RPCOUNTx(%d) = 0x%x\n", ep_index, (u32)USBC_Readw(usbc_base + USBC_REG_o_RPCOUNT));
|
|
print("USBC_REG_o_ISCR = 0x%x\n", (u32)USBC_Readl(usbc_base + USBC_REG_o_ISCR));
|
print("USBC_REG_o_PHYCTL = 0x%x\n", (u32)USBC_Readl(usbc_base + USBC_REG_o_PHYCTL));
|
print("USBC_REG_o_PHYBIST = 0x%x\n", (u32)USBC_Readl(usbc_base + USBC_REG_o_PHYBIST));
|
|
if(ep_index >= 0){
|
USBC_Writew(old_ep_index, (usbc_base + USBC_REG_o_EPIND));
|
}
|
|
print("---------------------------------------------------------------------------\n");
|
print("\n");
|
|
return;
|
}
|
/*
|
*******************************************************************************
|
* print_all_usb_reg
|
*
|
* Description:
|
* void
|
*
|
* Parameters:
|
* void
|
*
|
* Return value:
|
* void
|
*
|
* note:
|
* void
|
*
|
*******************************************************************************
|
*/
|
void USBC_PrintAllReg(ulong usbc_base, __s32 ep_start, __u32 ep_end, char *str, USBC_PRINT print)
|
{
|
__u32 i = 0;
|
__u32 old_ep_index = 0;
|
|
print("\n");
|
print("-------------------print_all_usb_reg: %s----------------\n", str);
|
|
old_ep_index = USBC_Readw(usbc_base + USBC_REG_o_EPIND);
|
|
for(i = ep_start; i <= ep_end; i++){
|
USBC_PrintEPReg(usbc_base, i, str, print);
|
}
|
|
USBC_Writew(old_ep_index, (usbc_base + USBC_REG_o_EPIND));
|
|
print("---------------------------------------------------------------------------\n");
|
print("\n");
|
|
return;
|
}
|
|
/*
|
***********************************************************************************
|
* USBC_open_otg
|
*
|
* Description:
|
* 向bsp申请获得端口号为otg_no的tog使用权
|
*
|
* Arguments:
|
* otg_no : input. 需要使用的TOG端口号, 范围为: 0 ~ USBC_MAX_CTL_NUM
|
*
|
* Returns:
|
* 成功, 返回usbc_otg句柄。失败, 返回NULL
|
*
|
* note:
|
* 无
|
*
|
***********************************************************************************
|
*/
|
#if 0
|
__hdle USBC_open_otg(__u32 otg_no)
|
{
|
__usbc_otg_t *usbc_otg = usbc_otg_array;
|
__u32 i = 0;
|
|
//--<1>--otg_no不能超过所能支持的范围
|
if(otg_no >= USBC_MAX_CTL_NUM){
|
return 0;
|
}
|
|
//--<2>--在管理数组里找一个空位, 最大支持同时打开8次
|
for(i = 0; i < USBC_MAX_OPEN_NUM; i++){
|
if(usbc_otg[i].used == 0){
|
usbc_otg[i].used = 1;
|
usbc_otg[i].no = i;
|
usbc_otg[i].port_num = otg_no;
|
usbc_otg[i].base_addr = usbc_base_address[otg_no];
|
|
return (__hdle)(&(usbc_otg[i]));
|
}
|
}
|
|
return 0;
|
}
|
#else
|
__hdle USBC_open_otg(__u32 otg_no)
|
{
|
__usbc_otg_t *usbc_otg = usbc_otg_array;
|
|
//--<1>--otg_no不能超过所能支持的范围
|
if(otg_no >= USBC_MAX_CTL_NUM){
|
return 0;
|
}
|
|
//--<2>--在管理数组里找一个空位, 最大支持同时打开8次
|
usbc_otg[otg_no].used = 1;
|
usbc_otg[otg_no].no = otg_no;
|
usbc_otg[otg_no].port_num = otg_no;
|
usbc_otg[otg_no].base_addr = usbc_base_address[otg_no];
|
|
return (__hdle)(&(usbc_otg[otg_no]));
|
}
|
|
#endif
|
|
/*
|
***********************************************************************************
|
* USBC_close_otg
|
*
|
* Description:
|
* 释放tog的使用权
|
*
|
* Arguments:
|
* hUSB : input. USBC_open_otg获得的句柄, 记录了USBC所需要的一些关键数据
|
*
|
* Returns:
|
* 0 : 成功
|
* !0 : 失败
|
*
|
* note:
|
* 无
|
*
|
***********************************************************************************
|
*/
|
__s32 USBC_close_otg(__hdle hUSB)
|
{
|
__usbc_otg_t *usbc_otg = (__usbc_otg_t *)hUSB;
|
|
if(usbc_otg == NULL){
|
return -1;
|
}
|
|
memset(usbc_otg, 0, sizeof(__usbc_otg_t));
|
|
return 0;
|
}
|
|
|
/*
|
***********************************************************************************
|
* USBC_init
|
*
|
* Description:
|
*
|
*
|
* Arguments:
|
*
|
*
|
* Returns:
|
* 0 : 成功
|
* !0 : 失败
|
*
|
* note:
|
*
|
*
|
***********************************************************************************
|
*/
|
__s32 USBC_init(bsp_usbc_t *usbc)
|
{
|
// __usbc_otg_t *usbc_otg = usbc_otg_array;
|
// __u32 i = 0;
|
|
// memset(usbc_base_address, 0, sizeof(usbc_base_address));
|
// memset(&usbc_info_g, 0, sizeof(__fifo_info_t));
|
// memset(usbc_otg, 0, (USBC_MAX_OPEN_NUM * sizeof(__usbc_otg_t)));
|
|
/* 保存 driver 传进来的 usb 控制器的基址 */
|
/*
|
for(i = 0; i < USBC_MAX_CTL_NUM; i++){
|
__u32 port_num = 0;
|
|
port_num = usbc->usbc_info[i].num;
|
usbc_base_address[i] = usbc->usbc_info[i].base;
|
}
|
*/
|
/*
|
for(i = 0; i < USBC_MAX_CTL_NUM; i++){
|
__u32 port_num = 0;
|
|
if(usbc->usbc_info[i].base){
|
port_num = usbc->usbc_info[i].num;
|
usbc_base_address[i] = usbc->usbc_info[i].base;
|
}
|
}
|
*/
|
|
return 0;
|
}
|
|
/*
|
***********************************************************************************
|
* USBC_exit
|
*
|
* Description:
|
*
|
*
|
* Arguments:
|
*
|
*
|
* Returns:
|
* 0 : 成功
|
* !0 : 失败
|
*
|
* note:
|
*
|
*
|
***********************************************************************************
|
*/
|
__s32 USBC_exit(bsp_usbc_t *usbc)
|
{
|
__usbc_otg_t *usbc_otg = usbc_otg_array;
|
|
memset(&usbc_info_g, 0, sizeof(__fifo_info_t));
|
memset(usbc_otg, 0, (USBC_MAX_OPEN_NUM * sizeof(__usbc_otg_t)));
|
memset(usbc_base_address, 0, sizeof(usbc_base_address));
|
|
return 0;
|
}
|
|
///* USB传输类型选择, 读写数据等 */
|
//EXPORT_SYMBOL(USBC_OTG_SelectMode);
|
//
|
//EXPORT_SYMBOL(USBC_ReadLenFromFifo);
|
//EXPORT_SYMBOL(USBC_WritePacket);
|
//EXPORT_SYMBOL(USBC_ReadPacket);
|
//
|
//EXPORT_SYMBOL(USBC_ConfigFIFO_Base);
|
//EXPORT_SYMBOL(USBC_GetPortFifoStartAddr);
|
//EXPORT_SYMBOL(USBC_GetPortFifoSize);
|
//EXPORT_SYMBOL(USBC_SelectFIFO);
|
//EXPORT_SYMBOL(USBC_ConfigFifo_Default);
|
//EXPORT_SYMBOL(USBC_ConfigFifo);
|
//
|
//EXPORT_SYMBOL(USBC_SelectBus);
|
//
|
//EXPORT_SYMBOL(USBC_GetActiveEp);
|
//EXPORT_SYMBOL(USBC_SelectActiveEp);
|
//
|
//EXPORT_SYMBOL(USBC_EnhanceSignal);
|
//
|
//EXPORT_SYMBOL(USBC_GetLastFrameNumber);
|
//
|
//
|
///* usb 中断操作部分 */
|
//EXPORT_SYMBOL(USBC_INT_EpPending);
|
//EXPORT_SYMBOL(USBC_INT_MiscPending);
|
//EXPORT_SYMBOL(USBC_INT_ClearEpPending);
|
//EXPORT_SYMBOL(USBC_INT_ClearMiscPending);
|
//EXPORT_SYMBOL(USBC_INT_ClearEpPendingAll);
|
//EXPORT_SYMBOL(USBC_INT_ClearMiscPendingAll);
|
//
|
//EXPORT_SYMBOL(USBC_INT_EnableEp);
|
//EXPORT_SYMBOL(USBC_INT_EnableUsbMiscUint);
|
//
|
//EXPORT_SYMBOL(USBC_INT_DisableEp);
|
//EXPORT_SYMBOL(USBC_INT_DisableUsbMiscUint);
|
//
|
//EXPORT_SYMBOL(USBC_INT_DisableEpAll);
|
//EXPORT_SYMBOL(USBC_INT_DisableUsbMiscAll);
|
//
|
//
|
///* usb 控制操作部分 */
|
//EXPORT_SYMBOL(USBC_GetVbusStatus);
|
//EXPORT_SYMBOL(USBC_GetStatus_Dp);
|
//EXPORT_SYMBOL(USBC_GetStatus_Dm);
|
//EXPORT_SYMBOL(USBC_GetStatus_DpDm);
|
//
|
//EXPORT_SYMBOL(USBC_GetOtgMode_Form_ID);
|
//EXPORT_SYMBOL(USBC_GetOtgMode_Form_BDevice);
|
//
|
//EXPORT_SYMBOL(USBC_SetWakeUp_Default);
|
//
|
//EXPORT_SYMBOL(USBC_EnableIdPullUp);
|
//EXPORT_SYMBOL(USBC_DisableIdPullUp);
|
//EXPORT_SYMBOL(USBC_EnableDpDmPullUp);
|
//EXPORT_SYMBOL(USBC_DisableDpDmPullUp);
|
//
|
//EXPORT_SYMBOL(USBC_ForceId);
|
//EXPORT_SYMBOL(USBC_ForceVbusValid);
|
//
|
//EXPORT_SYMBOL(USBC_A_valid_InputSelect);
|
//
|
//EXPORT_SYMBOL(USBC_EnableUsbLineStateBypass);
|
//EXPORT_SYMBOL(USBC_DisableUsbLineStateBypass);
|
//EXPORT_SYMBOL(USBC_EnableHosc);
|
//EXPORT_SYMBOL(USBC_DisableHosc);
|
//
|
//EXPORT_SYMBOL(USBC_IsVbusChange);
|
//EXPORT_SYMBOL(USBC_IsIdChange);
|
//EXPORT_SYMBOL(USBC_IsDpDmChange);
|
//
|
//EXPORT_SYMBOL(USBC_DisableWakeIrq);
|
//EXPORT_SYMBOL(USBC_DisableVbusChange);
|
//EXPORT_SYMBOL(USBC_DisableIdChange);
|
//EXPORT_SYMBOL(USBC_DisableDpDmChange);
|
//
|
//EXPORT_SYMBOL(USBC_EnableWakeIrq);
|
//EXPORT_SYMBOL(USBC_EnableVbusChange);
|
//EXPORT_SYMBOL(USBC_EnableIdChange);
|
//EXPORT_SYMBOL(USBC_EnableDpDmChange);
|
//
|
///* usb 测试模式 */
|
//EXPORT_SYMBOL(USBC_EnterMode_TestPacket);
|
//EXPORT_SYMBOL(USBC_EnterMode_Test_K);
|
//EXPORT_SYMBOL(USBC_EnterMode_Test_J);
|
//EXPORT_SYMBOL(USBC_EnterMode_Test_SE0_NAK);
|
//EXPORT_SYMBOL(USBC_EnterMode_Idle);
|
//
|
//EXPORT_SYMBOL(USBC_TestMode_ReadReg);
|
//
|
//EXPORT_SYMBOL(USBC_open_otg);
|
//EXPORT_SYMBOL(USBC_close_otg);
|
//EXPORT_SYMBOL(USBC_init);
|
//EXPORT_SYMBOL(USBC_exit);
|
//
|
