usb_regs.h

arm(str710)usb功能的实现

#define _GetTxStallStatus(bEpNum) (_GetEPTxStatus(bEpNum) \
													 == EP_TX_STALL)
#define _GetRxStallStatus(bEpNum) (_GetEPRxStatus(bEpNum) \
													 == EP_RX_STALL)
/*----------------------------------------------------------------*/
/* SetEP_KIND / ClearEP_KIND */
/* IN : bEpNum  = endpoint number */
/* OUT: none */
/*----------------------------------------------------------------*/
void SetEP_KIND(BYTE /*bEpNum*/);
void ClearEP_KIND(BYTE /*bEpNum*/);

#define _SetEP_KIND(bEpNum)	   (_SetENDPOINT(bEpNum, \
					    (_GetENDPOINT(bEpNum) | EP_KIND) & EPREG_MASK))
#define _ClearEP_KIND(bEpNum)  (_SetENDPOINT(bEpNum, \
						         (_GetENDPOINT(bEpNum) & EPKIND_MASK)))
/*----------------------------------------------------------------*/
/* Set_Status_Out / Clear_Status_Out */
/* sets/clears directly STATUS_OUT bit in the endpoint register */
/* to be used only during control transfers */
/* IN : bEpNum = endpoint number */
/* OUT: none */
/*----------------------------------------------------------------*/
void Set_Status_Out(BYTE /*bEpNum*/);
void Clear_Status_Out(BYTE /*bEpNum*/);

#define _Set_Status_Out(bEpNum)	   _SetEP_KIND(bEpNum)
#define _Clear_Status_Out(bEpNum)  _ClearEP_KIND(bEpNum)

/*----------------------------------------------------------------*/
/* SetEPDoubleBuff / ClearEPDoubleBuff */
/* sets/clears directly EP_KIND bit in the endpoint register */
/* IN : bEpNum = endpoint number */
/* OUT: none */
/*----------------------------------------------------------------*/
void SetEPDoubleBuff(BYTE /*bEpNum*/);
void ClearEPDoubleBuff(BYTE /*bEpNum*/);

#define _SetEPDoubleBuff(bEpNum)   _SetEP_KIND(bEpNum)
#define _ClearEPDoubleBuff(bEpNum) _ClearEP_KIND(bEpNum)

/*----------------------------------------------------------------*/
/* ClearEP_CTR_RX / ClearEP_CTR_TX */
/* clears bit CTR_RX / CTR_RX in the endpoint register */
/* IN : bEpNum = endpoint number */
/* OUT: none */
/*----------------------------------------------------------------*/
void ClearEP_CTR_RX(BYTE /*bEpNum*/);
void ClearEP_CTR_TX(BYTE /*bEpNum*/);

#define _ClearEP_CTR_RX(bEpNum)   (_SetENDPOINT(bEpNum,\
						   _GetENDPOINT(bEpNum) & 0x7FFF & EPREG_MASK))
#define _ClearEP_CTR_TX(bEpNum)   (_SetENDPOINT(bEpNum,\
						   _GetENDPOINT(bEpNum) & 0xFF7F & EPREG_MASK))
/*----------------------------------------------------------------*/
/* ToggleDTOG_RX / ToggleDTOG_TX */
/* toggles DTOG_RX / DTOG_TX bit in the endpoint register */
/* IN : bEpNum  = endpoint number */
/* OUT: none */
/*----------------------------------------------------------------*/
void ToggleDTOG_RX(BYTE /*bEpNum*/);
void ToggleDTOG_TX(BYTE /*bEpNum*/);

#define _ToggleDTOG_RX(bEpNum)    (_SetENDPOINT(bEpNum, \
					   EP_DTOG_RX | _GetENDPOINT(bEpNum) & EPREG_MASK))
#define _ToggleDTOG_TX(bEpNum)    (_SetENDPOINT(bEpNum, \
					   EP_DTOG_TX | _GetENDPOINT(bEpNum) & EPREG_MASK))

/*----------------------------------------------------------------*/
/* ClearDTOG_RX / ClearDTOG_TX */
/* IN : bEpNum  = endpoint number */
/* OUT: none */
/*----------------------------------------------------------------*/
void ClearDTOG_RX(BYTE /*bEpNum*/);
void ClearDTOG_TX(BYTE /*bEpNum*/);

#define _ClearDTOG_RX(bEpNum)  if((_GetENDPOINT(bEpNum) & EP_DTOG_RX) != 0)\
			 							_ToggleDTOG_RX(bEpNum)
#define _ClearDTOG_TX(bEpNum)  if((_GetENDPOINT(bEpNum) & EP_DTOG_TX) != 0)\
			 							_ToggleDTOG_TX(bEpNum)
/*----------------------------------------------------------------*/
/* SetEPAddress */
/* sets address in an endpoint register */
/* IN : bEpNum  = endpoint number */
/* 		bAddr   = address */
/* OUT: none */
/*----------------------------------------------------------------*/
void SetEPAddress(BYTE /*bEpNum*/,BYTE /*bAddr*/);
#define _SetEPAddress(bEpNum,bAddr) _SetENDPOINT(bEpNum,\
						_GetENDPOINT(bEpNum) & EPREG_MASK | bAddr)
/*----------------------------------------------------------------*/
/* GetEPAddress */
/* IN : bEpNum  = endpoint number */
/* OUT: none */
/*----------------------------------------------------------------*/
BYTE GetEPAddress(BYTE /*bEpNum*/);
#define _GetEPAddress(bEpNum) ((BYTE)(_GetENDPOINT(bEpNum) & EPADDR_FIELD))

/*----------------------------------------------------------------*/
#define _pEPTxAddr(bEpNum)	((DWORD *)((_GetBTABLE()+bEpNum*8  )*2 + PMAAddr))
#define _pEPTxCount(bEpNum)	((DWORD *)((_GetBTABLE()+bEpNum*8+2)*2 + PMAAddr))
#define _pEPRxAddr(bEpNum)	((DWORD *)((_GetBTABLE()+bEpNum*8+4)*2 + PMAAddr))
#define _pEPRxCount(bEpNum)	((DWORD *)((_GetBTABLE()+bEpNum*8+6)*2 + PMAAddr))

/*----------------------------------------------------------------*/
/* SetEPTxAddr / SetEPRxAddr */
/* sets address of the tx/rx buffer */
/* IN : bEpNum = endpoint number */
/*      wAddr  = address to be set ( must be word aligned ) */
/* OUT: none */
/*----------------------------------------------------------------*/
void SetEPTxAddr(BYTE /*bEpNum*/,WORD /*wAddr*/);
void SetEPRxAddr(BYTE /*bEpNum*/,WORD /*wAddr*/);

/*#define _SetEPTxAddr(bEpNum,wAddr) (*_pEPTxAddr(bEpNum) = (wAddr & 0xFFFE))*/
/*#define _SetEPRxAddr(bEpNum,wAddr) (*_pEPRxAddr(bEpNum) = (wAddr & 0xFFFE))*/

#define _SetEPTxAddr(bEpNum,wAddr) (*_pEPTxAddr(bEpNum) = ((wAddr >> 1) << 1))
#define _SetEPRxAddr(bEpNum,wAddr) (*_pEPRxAddr(bEpNum) = ((wAddr >> 1) << 1))
/*----------------------------------------------------------------*/
/* GetEPTxAddr / GetEPRxAddr */
/* gets address of the tx/rx buffer */
/* IN : bEpNum = endpoint number */
/* IN : */
/* OUT: address of the buffer */
/*----------------------------------------------------------------*/
WORD GetEPTxAddr(BYTE /*bEpNum*/);
WORD GetEPRxAddr(BYTE /*bEpNum*/);

#define _GetEPTxAddr(bEpNum) ((WORD)*_pEPTxAddr(bEpNum))
#define _GetEPRxAddr(bEpNum) ((WORD)*_pEPRxAddr(bEpNum))

/*----------------------------------------------------------------*/
/* SetEPCountRxReg */
/* sets counter of rx buffer with no. of blocks */
/* IN : pdwReg = pointer to counter */
/*      wCount = counter */
/* OUT: none */
/*----------------------------------------------------------------*/
void SetEPCountRxReg(DWORD * /*pdwReg*/, WORD /*wCount*/);

#define _BlocksOf32(dwReg,wCount,wNBlocks) {\
	 	wNBlocks = wCount >> 5;   	\
	 	if((wCount & 0x1f) == 0)	\
	 			wNBlocks--;  		\
		*pdwReg = (DWORD)((wNBlocks << 10) | 0x8000);\
}/* _BlocksOf32 */

#define _BlocksOf2(dwReg,wCount,wNBlocks) {\
	 	wNBlocks = wCount >> 1;		\
	 	if((wCount & 0x1) != 0)		\
	 			 wNBlocks++;		\
		*pdwReg = (DWORD)(wNBlocks << 10);\
}/* _BlocksOf2 */

#define _SetEPCountRxReg(dwReg,wCount)  {\
 WORD wNBlocks;\
	 if(wCount > 62){_BlocksOf32(dwReg,wCount,wNBlocks);}\
	 else {_BlocksOf2(dwReg,wCount,wNBlocks);}\
}/* _SetEPCountRxReg */


#define _SetEPRxDblBuf0Count(bEpNum,wCount) {\
 DWORD *pdwReg = _pEPTxCount(bEpNum); 		 \
 	 _SetEPCountRxReg(pdwReg, wCount);		 \
}

/*----------------------------------------------------------------*/
/* SetEPTxCount / SetEPRxCount */
/* sets counter for the tx/rx buffer */
/* IN : bEpNum = endpoint number */
/*		wCount = counter value */
/* OUT: none */
/*----------------------------------------------------------------*/
void SetEPTxCount(BYTE /*bEpNum*/,WORD /*wCount*/);
void SetEPRxCount(BYTE /*bEpNum*/,WORD /*wCount*/);

#define _SetEPTxCount(bEpNum,wCount) (*_pEPTxCount(bEpNum) = wCount)

#define _SetEPRxCount(bEpNum,wCount) {\
 DWORD *pdwReg = _pEPRxCount(bEpNum); \
 	 _SetEPCountRxReg(pdwReg, wCount);\
}

/*----------------------------------------------------------------*/
/* GetEPTxCount / GetEPRxCount */
/* gets counter of the tx buffer */
/* IN : bEpNum = endpoint number */
/* OUT: counter value */
/*----------------------------------------------------------------*/
WORD GetEPTxCount(BYTE /*bEpNum*/);
WORD GetEPRxCount(BYTE /*bEpNum*/);

#define _GetEPTxCount(bEpNum)((WORD)(*_pEPTxCount(bEpNum)) & 0x3ff)
#define _GetEPRxCount(bEpNum)((WORD)(*_pEPRxCount(bEpNum)) & 0x3ff)

/*----------------------------------------------------------------*/
/*----------------------------------------------------------------*/
/* SetEPDblBuf0Addr / SetEPDblBuf1Addr */
/* sets buffer 0/1 address in a double buffer endpoint */
/* IN : bEpNum = endpoint number */
/*      wBuf0Addr = buffer 0 address */
/* OUT: none */
/*----------------------------------------------------------------*/
void SetEPDblBuf0Addr(BYTE /*bEpNum*/,WORD /*wBuf0Addr*/);
void SetEPDblBuf1Addr(BYTE /*bEpNum*/,WORD /*wBuf1Addr*/);

#define _SetEPDblBuf0Addr(bEpNum,wBuf0Addr) (_SetEPTxAddr(bEpNum, wBuf0Addr))
#define _SetEPDblBuf1Addr(bEpNum,wBuf1Addr) (_SetEPRxAddr(bEpNum, wBuf1Addr))
/*----------------------------------------------------------------*/
/* SetEPDblBuffAddr */
/* sets addresses in a double buffer endpoint */
/* IN : bEpNum = endpoint number */
/*      wBuf0Addr = buffer 0 address */
/*      wBuf1Addr = buffer 1 address */
/* OUT: none */
/*----------------------------------------------------------------*/
void SetEPDblBuffAddr(BYTE /*bEpNum*/,WORD /*wBuf0Addr*/,WORD /*wBuf1Addr*/);

#define _SetEPDblBuffAddr(bEpNum,wBuf0Addr,wBuf1Addr) { 		\
					_SetEPDblBuf0Addr(bEpNum, wBuf0Addr);	\
					_SetEPDblBuf1Addr(bEpNum, wBuf1Addr);	\
} /* _SetEPDblBuffAddr */
/*----------------------------------------------------------------*/
/* GetEPDblBuf0Addr / GetEPDblBuf1Addr */
/* gets buffer 0/1 address of a double buffer endpoint */
/* IN : bEpNum = endpoint number */
/* OUT: none */
/*----------------------------------------------------------------*/
WORD GetEPDblBuf0Addr(BYTE /*bEpNum*/);
WORD GetEPDblBuf1Addr(BYTE /*bEpNum*/);

#define _GetEPDblBuf0Addr(bEpNum) (_GetEPTxAddr(bEpNum))
#define _GetEPDblBuf1Addr(bEpNum) (_GetEPRxAddr(bEpNum))
/*----------------------------------------------------------------*/
/* SetEPDblBuffCount / SetEPDblBuf0Count / SetEPDblBuf1Count */
/* sets both buffers or buff0 or buff1 counter for double buffering */
/* IN : bEpNum  = endpoint number */
/*		bDir    = endpoint dir  EP_DBUF_OUT = OUT */
/*								EP_DBUF_IN  = IN */
/*		wCount  = counter value     */
/* OUT: none */
/*----------------------------------------------------------------*/
void SetEPDblBuffCount(BYTE /*bEpNum*/, BYTE /*bDir*/, WORD /*wCount*/);
void SetEPDblBuf0Count(BYTE /*bEpNum*/, BYTE /*bDir*/, WORD /*wCount*/);
void SetEPDblBuf1Count(BYTE /*bEpNum*/, BYTE /*bDir*/, WORD /*wCount*/);

#define _SetEPDblBuf0Count(bEpNum, bDir, wCount)  { \
		 if(bDir == EP_DBUF_OUT)					\
		     /* OUT endpoint */						\
		     {_SetEPRxDblBuf0Count(bEpNum,wCount);} \
		 else if(bDir == EP_DBUF_IN)				\
		     /* IN endpoint */						\
			 *_pEPTxCount(bEpNum) = (DWORD)wCount;  \
} /* SetEPDblBuf0Count*/

#define _SetEPDblBuf1Count(bEpNum, bDir, wCount)  { \
		 if(bDir == EP_DBUF_OUT)   					\
		     /* OUT endpoint */						\
		     {_SetEPRxCount(bEpNum,wCount);	}		\
		 else if(bDir == EP_DBUF_IN)				\
		     /* IN endpoint */						\
			 *_pEPRxCount(bEpNum) = (DWORD)wCount;  \
} /* SetEPDblBuf1Count */

#define _SetEPDblBuffCount(bEpNum, bDir, wCount) {\
			_SetEPDblBuf0Count(bEpNum, bDir, wCount); \
	 		_SetEPDblBuf1Count(bEpNum, bDir, wCount); \
} /* _SetEPDblBuffCount	 */

/*----------------------------------------------------------------*/
/* GetEPDblBuf0Count / GetEPDblBuf1Count */
/* gets buffer 0/1 rx/tx counter for double buffering */
/* IN : bEpNum  = endpoint number */
/* OUT: none */
/*----------------------------------------------------------------*/
WORD GetEPDblBuf0Count(BYTE /*bEpNum*/);
WORD GetEPDblBuf1Count(BYTE /*bEpNum*/);

#define _GetEPDblBuf0Count(bEpNum) (_GetEPTxCount(bEpNum)) /* rigth version  */
/*#define _GetEPDblBuf0Count(bEpNum)	 (_GetEPRxCount(bEpNum))*/

#define _GetEPDblBuf1Count(bEpNum) (_GetEPRxCount(bEpNum)) /* rigth version  */
/*#define _GetEPDblBuf1Count(bEpNum)	 (_GetEPTxCount(bEpNum))*/

/*----------------------------------------------------------------*/
/* GetEPDblBufDir */
/* gets direction of the double buffered endpoint */
/* IN : bEpNum  = endpoint number */
/* OUT: EP_DBUF_OUT, EP_DBUF_IN, */
/*      EP_DBUF_ERR if the endpoint counter not yet programmed */
/*----------------------------------------------------------------*/
EP_DBUF_DIR GetEPDblBufDir(BYTE /*bEpNum*/);

/*----------------------------------------------------------------*/
/* FreeUserBuffer */
/* free buffer used from the application realising it to the line */
/* toggles bit SW_BUF in the double buffered endpoint register */
/* IN : bEpNum = endpoint number */
/* OUT: none */
/*----------------------------------------------------------------*/
void FreeUserBuffer(BYTE /*bEpNum*/);

/*----------------------------------------------------------------*/
WORD ToWord(BYTE,BYTE);
/*----------------------------------------------------------------*/
WORD ByteSwap(WORD);