开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 微处理器开发 > 查看源码
usb_regs.h
资源名称：str711USB.rar　[点击查看]
上传用户：yyyd609
上传日期：2022-07-18
资源大小：183k
文件大小：26k
源码类别：

微处理器开发

开发平台：

C/C++

usb_regs.h：源码内容
  1. /******************** (C) COPYRIGHT 2003 STMicroelectronics ********************
  2. * File Name          : usb_regs.h
  3. * Author             : MCD Application Team
  4. * Date First Issued  : 27/10/2003
  5. * Description        : Interface functions to USB cell registers
  6. *
  7. ********************************************************************************/
  9. #define RegBase  (0xC0008800L)  /* USB_IP Peripheral Registers base address */
  10. #define PMAAddr  (0xC0008000L)  /* USB_IP Packet Memory Area base address */
  12. /* General registers */
  13. #define GCNTR    ((volatile unsigned *)(RegBase + 0x40)) /* Control register           */
  14. #define GISTR    ((volatile unsigned *)(RegBase + 0x44)) /* Interrupt status register  */
  15. #define GFNR     ((volatile unsigned *)(RegBase + 0x48)) /* Frame number register      */
  16. #define GDADDR   ((volatile unsigned *)(RegBase + 0x4C)) /* Device address register    */
  17. #define GBTABLE  ((volatile unsigned *)(RegBase + 0x50)) /* Buffer Table address register */
  19. /* Endpoint registers */
  20. #define EP0REG  ((volatile unsigned *)(RegBase)) /* endpoint 0 register address */
  21. /* endpoints enumeration */
  22. #define ENDP0  ((BYTE)0)
  23. #define ENDP1  ((BYTE)1)
  24. #define ENDP2  ((BYTE)2)
  25. #define ENDP3  ((BYTE)3)
  26. #define ENDP4  ((BYTE)4)
  27. #define ENDP5  ((BYTE)5)
  28. #define ENDP6  ((BYTE)6)
  29. #define ENDP7  ((BYTE)7)
  30. #define ENDP8  ((BYTE)8)
  31. #define ENDP9  ((BYTE)9)
  32. #define ENDP10  ((BYTE)10)
  33. #define ENDP11  ((BYTE)11)
  34. #define ENDP12  ((BYTE)12)
  35. #define ENDP13  ((BYTE)13)
  36. #define ENDP14  ((BYTE)14)
  37. #define ENDP15  ((BYTE)15)
  39. /*******************************************************************************/
  40. /*  ISTR interrupt events      */
  41. /*******************************************************************************/
  42. #define ISTR_CTR    (0x8000) /* Correct TRansfer         (clear-only bit) */
  43. #define ISTR_DOVR   (0x4000) /* DMA OVeR/underrun (clear-only bit) */
  44. #define ISTR_ERR    (0x2000) /* ERRor (clear-only bit) */
  45. #define ISTR_WKUP   (0x1000) /* WaKe UP (clear-only bit) */
  46. #define ISTR_SUSP   (0x0800) /* SUSPend (clear-only bit) */
  47. #define ISTR_RESET  (0x0400) /* RESET (clear-only bit) */
  48. #define ISTR_SOF    (0x0200) /* Start Of Frame (clear-only bit) */
  49. #define ISTR_ESOF   (0x0100) /* Expected Start Of Frame (clear-only bit) */
  50. #define ISTR_DIR    (0x0010) /* DIRection of transaction (read-only bit)  */
  51. #define ISTR_EP_ID  (0x000F) /* EndPoint IDentifier (read-only bit)  */
  53. #define CLR_CTR    (~ISTR_CTR)  /* clear Correct TRansfer bit */
  54. #define CLR_DOVR   (~ISTR_DOVR) /* clear DMA OVeR/underrun bit*/
  55. #define CLR_ERR    (~ISTR_ERR)  /* clear ERRor bit */
  56. #define CLR_WKUP   (~ISTR_WKUP) /* clear WaKe UP bit    */
  57. #define CLR_SUSP   (~ISTR_SUSP) /* clear SUSPend bit    */
  58. #define CLR_RESET  (~ISTR_RESET)/* clear RESET bit    */
  59. #define CLR_SOF    (~ISTR_SOF)  /* clear Start Of Frame bit   */
  60. #define CLR_ESOF   (~ISTR_ESOF) /* clear Expected Start Of Frame bit */
  62. /*******************************************************************************/
  63. /*  CNTR control register bits definitions    */
  64. /*******************************************************************************/
  65. #define CNTR_CTRM   (0x8000) /* Correct TRansfer Mask */
  66. #define CNTR_DOVRM  (0x4000) /* DMA OVeR/underrun Mask */
  67. #define CNTR_ERRM   (0x2000) /* ERRor Mask */
  68. #define CNTR_WKUPM  (0x1000) /* WaKe UP Mask */
  69. #define CNTR_SUSPM  (0x0800) /* SUSPend Mask */
  70. #define CNTR_RESETM (0x0400) /* RESET Mask   */
  71. #define CNTR_SOFM   (0x0200) /* Start Of Frame Mask */
  72. #define CNTR_ESOFM  (0x0100) /* Expected Start Of Frame Mask */
  73. #define CNTR_RESUME (0x0010) /* RESUME request */
  74. #define CNTR_FSUSP  (0x0008) /* Force SUSPend */
  75. #define CNTR_LPMODE (0x0004) /* Low-power MODE */
  76. #define CNTR_PDWN   (0x0002) /* Power DoWN */
  77. #define CNTR_FRES   (0x0001) /* Force USB RESet */
  79. /*******************************************************************************/
  80. /*  FNR Frame Number Register bit definitions    */
  81. /*******************************************************************************/
  82. #define FNR_RXDP (0x8000) /* status of D+ data line */
  83. #define FNR_RXDM (0x4000) /* status of D- data line */
  84. #define FNR_LCK (0x2000) /* LoCKed */
  85. #define FNR_LSOF (0x1800) /* Lost SOF */
  86. #define FNR_FN (0x07FF) /* Frame Number */
  87. /*******************************************************************************/
  88. /* DADDR Device ADDRess bit definitions    */
  89. /*******************************************************************************/
  90. #define DADDR_EF (0x80)
  91. #define DADDR_ADD (0x7F)
  92. /*===============================================================================*/
  93. /* Endpoint register */
  94. /*===============================================================================*/
  95. /* bit positions */
  96. #define EP_CTR_RX      (0x8000) /* EndPoint Correct TRansfer RX  */
  97. #define EP_DTOG_RX     (0x4000) /* EndPoint Data TOGGLE RX */
  98. #define EPRX_STAT      (0x3000) /* EndPoint RX STATus bit field */
  99. #define EP_SETUP       (0x0800) /* EndPoint SETUP */
  100. #define EP_T_FIELD     (0x0600) /* EndPoint TYPE */
  101. #define EP_KIND        (0x0100) /* EndPoint KIND */
  102. #define EP_CTR_TX      (0x0080) /* EndPoint Correct TRansfer TX */
  103. #define EP_DTOG_TX     (0x0040) /* EndPoint Data TOGGLE TX */
  104. #define EPTX_STAT      (0x0030) /* EndPoint TX STATus bit field */
  105. #define EPADDR_FIELD   (0x000F) /* EndPoint ADDRess FIELD */
  107. /* EndPoint REGister MASK (no toggle fields) */
  108. #define EPREG_MASK     (EP_CTR_RX|EP_SETUP|EP_T_FIELD|EP_KIND|EP_CTR_TX|EPADDR_FIELD)
  110. /* EP_TYPE[1:0] EndPoint TYPE */
  111. #define EP_BULK        (0x0000) /* EndPoint BULK */
  112. #define EP_CONTROL     (0x0200) /* EndPoint CONTROL */
  113. #define EP_ISOCHRONOUS (0x0400) /* EndPoint ISOCHRONOUS */
  114. #define EP_INTERRUPT   (0x0600) /* EndPoint INTERRUPT */
  115. #define EP_T_MASK      (~EP_T_FIELD & EPREG_MASK)
  118. /* EP_KIND EndPoint KIND */
  119. #define EPKIND_MASK    (~EP_KIND & EPREG_MASK)
  121. /* STAT_TX[1:0] STATus for TX transfer */
  122. #define EP_TX_DIS      (0x0000) /* EndPoint TX DISabled */
  123. #define EP_TX_STALL    (0x0010) /* EndPoint TX STALLed */
  124. #define EP_TX_NAK      (0x0020) /* EndPoint TX NAKed */
  125. #define EP_TX_VALID    (0x0030) /* EndPoint TX VALID */
  126. #define EPTX_DTOG1     (0x0010) /* EndPoint TX Data TOGgle bit1 */
  127. #define EPTX_DTOG2     (0x0020) /* EndPoint TX Data TOGgle bit2 */
  128. #define EPTX_DTOGMASK  (EPTX_STAT|EPREG_MASK)
  130. /* STAT_RX[1:0] STATus for RX transfer */
  131. #define EP_RX_DIS      (0x0000) /* EndPoint RX DISabled */
  132. #define EP_RX_STALL    (0x1000) /* EndPoint RX STALLed */
  133. #define EP_RX_NAK      (0x2000) /* EndPoint RX NAKed */
  134. #define EP_RX_VALID    (0x3000) /* EndPoint RX VALID */
  135. #define EPRX_DTOG1     (0x1000) /* EndPoint RX Data TOGgle bit1 */
  136. #define EPRX_DTOG2     (0x2000) /* EndPoint RX Data TOGgle bit1 */
  137. #define EPRX_DTOGMASK  (EPRX_STAT|EPREG_MASK)
  140. typedef enum _EP_DBUF_DIR{ /* double buffered endpoint direction */
  141.  EP_DBUF_ERR,
  142.  EP_DBUF_OUT,
  143.  EP_DBUF_IN
  144. }EP_DBUF_DIR;
  146. enum EP_BUF_NUM{ /* endpoint buffer number */
  147.  EP_NOBUF,
  148.  EP_BUF0 ,
  149.  EP_BUF1
  150. };
  152. /*----------------------------------------------------------------*/
  154. extern volatile WORD wIstr;  /* ISTR register last read value */
  155. /*----------------------------------------------------------------*/
  156. /*    FUNCTION PROTOTYPES   */
  157. /* &   */
  158. /* M A C R O s    */
  159. /*----------------------------------------------------------------*/
  160. /*----------------------------------------------------------------*/
  161. /* SetCNTR */
  162. /*----------------------------------------------------------------*/
  163. void SetCNTR(WORD /*wRegValue*/);
  164. #define _SetCNTR(wRegValue)  (*GCNTR   = (WORD)wRegValue)
  165. /*----------------------------------------------------------------*/
  166. /* SetISTR */
  167. /*----------------------------------------------------------------*/
  168. void SetISTR(WORD /*wRegValue*/);
  169. #define _SetISTR(wRegValue)  (*GISTR   = (WORD)wRegValue)
  170. /*----------------------------------------------------------------*/
  171. /* SetDADDR */
  172. /*----------------------------------------------------------------*/
  173. void SetDADDR(WORD /*wRegValue*/);
  174. #define _SetDADDR(wRegValue) (*GDADDR  = (WORD)wRegValue)
  175. /*----------------------------------------------------------------*/
  176. /* SetBTABLE */
  177. /*----------------------------------------------------------------*/
  178. void SetBTABLE(WORD /*wRegValue*/);
  179. #define _SetBTABLE(wRegValue)(*GBTABLE = (WORD)(wRegValue & 0xFFF8))
  180. /*----------------------------------------------------------------*/
  181. /* GetCNTR */
  182. /*----------------------------------------------------------------*/
  183. WORD GetCNTR(void);
  184. #define _GetCNTR()   ((WORD) *GCNTR)
  185. /*----------------------------------------------------------------*/
  186. /* GetISTR */
  187. /*----------------------------------------------------------------*/
  188. WORD GetISTR(void);
  189. #define _GetISTR()   ((WORD) *GISTR)
  190. /*----------------------------------------------------------------*/
  191. /* GetFNR */
  192. /*----------------------------------------------------------------*/
  193. WORD GetFNR(void);
  194. #define _GetFNR()    ((WORD) *GFNR)
  195. /*----------------------------------------------------------------*/
  196. /* GetDADDR */
  197. /*----------------------------------------------------------------*/
  198. WORD GetDADDR(void);
  199. #define _GetDADDR()  ((WORD) *GDADDR)
  200. /*----------------------------------------------------------------*/
  201. /* GetBTABLE */
  202. /*----------------------------------------------------------------*/
  203. WORD GetBTABLE(void);
  204. #define _GetBTABLE() ((WORD) *GBTABLE)
  205. /*----------------------------------------------------------------*/
  206. /* SetENDPOINT */
  207. /*----------------------------------------------------------------*/
  208. void SetENDPOINT(BYTE /*bEpNum*/,WORD /*wRegValue*/);
  209. #define _SetENDPOINT(bEpNum,wRegValue)  (*(EP0REG + bEpNum)= 
  210.  (WORD)wRegValue)
  211. /*----------------------------------------------------------------*/
  212. /* GetENDPOINT */
  213. /*----------------------------------------------------------------*/
  214. WORD GetENDPOINT(BYTE /*bEpNum*/);
  215. #define _GetENDPOINT(bEpNum)       ((WORD)(*(EP0REG + bEpNum)))
  217. /*----------------------------------------------------------------*/
  218. /* SetEPType */
  219. /* sets the type in the endpoint register(bits EP_TYPE[1:0]) */
  220. /* IN : bEpNum = endpoint number */
  221. /* wType  = type definition */
  222. /* OUT: none */
  223. /*----------------------------------------------------------------*/
  224. void SetEPType(BYTE /*bEpNum*/,WORD /*wType*/);
  225. #define _SetEPType(bEpNum,wType) (_SetENDPOINT(bEpNum,
  226. ((_GetENDPOINT(bEpNum) & EP_T_MASK) | wType)))
  228. /*----------------------------------------------------------------*/
  229. /* GetEPType */
  230. /* gets the type in the endpoint register(bits EP_TYPE[1:0]) */
  231. /* IN : bEpNum  = endpoint number */
  232. /* OUT: type definition */
  233. /*----------------------------------------------------------------*/
  234. WORD GetEPType(BYTE /*bEpNum*/);
  235. #define _GetEPType(bEpNum) (_GetENDPOINT(bEpNum) & EP_T_FIELD)
  237. /*----------------------------------------------------------------*/
  238. /* SetEPTxStatus */
  239. /* sets the status for tx transfer (bits STAT_TX[1:0]) */
  240. /* IN : bEpNum = endpoint number */
  241. /* wState = new state */
  242. /* OUT: none */
  243. /*----------------------------------------------------------------*/
  244. void SetEPTxStatus(BYTE /*bEpNum*/,WORD /*wState*/);
  245. #define _SetEPTxStatus(bEpNum,wState) {
  246.  register WORD _wRegVal;     
  247. _wRegVal = _GetENDPOINT(bEpNum) & EPTX_DTOGMASK;
  248. /* toggle first bit ? */    
  249. if((EPTX_DTOG1 & wState)!= 0)      
  250. _wRegVal ^= EPTX_DTOG1;        
  251. /* toggle second bit ?  */         
  252. if((EPTX_DTOG2 & wState)!= 0)      
  253. _wRegVal ^= EPTX_DTOG2;        
  254. _SetENDPOINT(bEpNum, _wRegVal);    
  255. } /* _SetEPTxStatus */
  257. /*----------------------------------------------------------------*/
  258. /* SetEPRxStatus */
  259. /* sets the status for rx transfer (bits STAT_TX[1:0]) */
  260. /* IN : bEpNum = endpoint number */
  261. /* wState = new state */
  262. /* OUT: none */
  263. /*----------------------------------------------------------------*/
  264. void SetEPRxStatus(BYTE /*bEpNum*/,WORD /*wState*/);
  265. #define _SetEPRxStatus(bEpNum,wState) {
  266.  register WORD _wRegVal;
  268. _wRegVal = _GetENDPOINT(bEpNum) & EPRX_DTOGMASK;
  269. /* toggle first bit ? */
  270. if((EPRX_DTOG1 & wState)!= 0)
  271. _wRegVal ^= EPRX_DTOG1;
  272. /* toggle second bit ? */
  273. if((EPRX_DTOG2 & wState)!= 0)
  274. _wRegVal ^= EPRX_DTOG2;
  275. _SetENDPOINT(bEpNum, _wRegVal);
  276. } /* _SetEPRxStatus */
  278. /*----------------------------------------------------------------*/
  279. /* GetEPTxStatus / GetEPRxStatus */
  280. /* gets the status for tx/rx transfer (bits STAT_TX[1:0]/STAT_RX[1:0]) */
  281. /* IN : bEpNum  = endpoint number */
  282. /* OUT: WORD status  */
  283. /*----------------------------------------------------------------*/
  284. WORD GetEPTxStatus(BYTE /*bEpNum*/);
  285. WORD GetEPRxStatus(BYTE /*bEpNum*/);
  287. #define _GetEPTxStatus(bEpNum) ((WORD)_GetENDPOINT(bEpNum) & EPTX_STAT)
  288. #define _GetEPRxStatus(bEpNum) ((WORD)_GetENDPOINT(bEpNum) & EPRX_STAT)
  290. /*----------------------------------------------------------------*/
  291. /* SetEPTxValid / SetEPRxValid */
  292. /* sets directly the VALID tx/rx-status into the enpoint register */
  293. /* IN : bEpNum = endpoint number */
  294. /* OUT: none */
  295. /*----------------------------------------------------------------*/
  296. void SetEPTxValid(BYTE /*bEpNum*/);
  297. void SetEPRxValid(BYTE /*bEpNum*/);
  299. #define _SetEPTxValid(bEpNum)     (_SetEPTxStatus(bEpNum, EP_TX_VALID))
  300. #define _SetEPRxValid(bEpNum)     (_SetEPRxStatus(bEpNum, EP_RX_VALID))
  302. /*----------------------------------------------------------------*/
  303. /* GetTxStallStatus / GetRxStallStatus */
  304. /* checks stall condition in an endpoint */
  305. /* IN : bEpNum = endpoint number */
  306. /* OUT: TRUE = endpoint in stall condition */
  307. /*----------------------------------------------------------------*/
  308. BOOL GetTxStallStatus(BYTE /*bEpNum*/);
  309. BOOL GetRxStallStatus(BYTE /*bEpNum*/);
  311. #define _GetTxStallStatus(bEpNum) (_GetEPTxStatus(bEpNum) 
  312.  == EP_TX_STALL)
  313. #define _GetRxStallStatus(bEpNum) (_GetEPRxStatus(bEpNum) 
  314.  == EP_RX_STALL)
  315. /*----------------------------------------------------------------*/
  316. /* SetEP_KIND / ClearEP_KIND */
  317. /* IN : bEpNum  = endpoint number */
  318. /* OUT: none */
  319. /*----------------------------------------------------------------*/
  320. void SetEP_KIND(BYTE /*bEpNum*/);
  321. void ClearEP_KIND(BYTE /*bEpNum*/);
  323. #define _SetEP_KIND(bEpNum)    (_SetENDPOINT(bEpNum, 
  324.     (_GetENDPOINT(bEpNum) | EP_KIND) & EPREG_MASK))
  325. #define _ClearEP_KIND(bEpNum)  (_SetENDPOINT(bEpNum, 
  326.          (_GetENDPOINT(bEpNum) & EPKIND_MASK)))
  327. /*----------------------------------------------------------------*/
  328. /* Set_Status_Out / Clear_Status_Out */
  329. /* sets/clears directly STATUS_OUT bit in the endpoint register */
  330. /* to be used only during control transfers */
  331. /* IN : bEpNum = endpoint number */
  332. /* OUT: none */
  333. /*----------------------------------------------------------------*/
  334. void Set_Status_Out(BYTE /*bEpNum*/);
  335. void Clear_Status_Out(BYTE /*bEpNum*/);
  337. #define _Set_Status_Out(bEpNum)    _SetEP_KIND(bEpNum)
  338. #define _Clear_Status_Out(bEpNum)  _ClearEP_KIND(bEpNum)
  340. /*----------------------------------------------------------------*/
  341. /* SetEPDoubleBuff / ClearEPDoubleBuff */
  342. /* sets/clears directly EP_KIND bit in the endpoint register */
  343. /* IN : bEpNum = endpoint number */
  344. /* OUT: none */
  345. /*----------------------------------------------------------------*/
  346. void SetEPDoubleBuff(BYTE /*bEpNum*/);
  347. void ClearEPDoubleBuff(BYTE /*bEpNum*/);
  349. #define _SetEPDoubleBuff(bEpNum)   _SetEP_KIND(bEpNum)
  350. #define _ClearEPDoubleBuff(bEpNum) _ClearEP_KIND(bEpNum)
  352. /*----------------------------------------------------------------*/
  353. /* ClearEP_CTR_RX / ClearEP_CTR_TX */
  354. /* clears bit CTR_RX / CTR_RX in the endpoint register */
  355. /* IN : bEpNum = endpoint number */
  356. /* OUT: none */
  357. /*----------------------------------------------------------------*/
  358. void ClearEP_CTR_RX(BYTE /*bEpNum*/);
  359. void ClearEP_CTR_TX(BYTE /*bEpNum*/);
  361. #define _ClearEP_CTR_RX(bEpNum)   (_SetENDPOINT(bEpNum,
  362.    _GetENDPOINT(bEpNum) & 0x7FFF & EPREG_MASK))
  363. #define _ClearEP_CTR_TX(bEpNum)   (_SetENDPOINT(bEpNum,
  364.    _GetENDPOINT(bEpNum) & 0xFF7F & EPREG_MASK))
  365. /*----------------------------------------------------------------*/
  366. /* ToggleDTOG_RX / ToggleDTOG_TX */
  367. /* toggles DTOG_RX / DTOG_TX bit in the endpoint register */
  368. /* IN : bEpNum  = endpoint number */
  369. /* OUT: none */
  370. /*----------------------------------------------------------------*/
  371. void ToggleDTOG_RX(BYTE /*bEpNum*/);
  372. void ToggleDTOG_TX(BYTE /*bEpNum*/);
  374. #define _ToggleDTOG_RX(bEpNum)    (_SetENDPOINT(bEpNum, 
  375.    EP_DTOG_RX | _GetENDPOINT(bEpNum) & EPREG_MASK))
  376. #define _ToggleDTOG_TX(bEpNum)    (_SetENDPOINT(bEpNum, 
  377.    EP_DTOG_TX | _GetENDPOINT(bEpNum) & EPREG_MASK))
  379. /*----------------------------------------------------------------*/
  380. /* ClearDTOG_RX / ClearDTOG_TX */
  381. /* IN : bEpNum  = endpoint number */
  382. /* OUT: none */
  383. /*----------------------------------------------------------------*/
  384. void ClearDTOG_RX(BYTE /*bEpNum*/);
  385. void ClearDTOG_TX(BYTE /*bEpNum*/);
  387. #define _ClearDTOG_RX(bEpNum)  if((_GetENDPOINT(bEpNum) & EP_DTOG_RX) != 0)
  388.   _ToggleDTOG_RX(bEpNum)
  389. #define _ClearDTOG_TX(bEpNum)  if((_GetENDPOINT(bEpNum) & EP_DTOG_TX) != 0)
  390.   _ToggleDTOG_TX(bEpNum)
  391. /*----------------------------------------------------------------*/
  392. /* SetEPAddress */
  393. /* sets address in an endpoint register */
  394. /* IN : bEpNum  = endpoint number */
  395. /*  bAddr   = address */
  396. /* OUT: none */
  397. /*----------------------------------------------------------------*/
  398. void SetEPAddress(BYTE /*bEpNum*/,BYTE /*bAddr*/);
  399. #define _SetEPAddress(bEpNum,bAddr) _SetENDPOINT(bEpNum,
  400. _GetENDPOINT(bEpNum) & EPREG_MASK | bAddr)
  401. /*----------------------------------------------------------------*/
  402. /* GetEPAddress */
  403. /* IN : bEpNum  = endpoint number */
  404. /* OUT: none */
  405. /*----------------------------------------------------------------*/
  406. BYTE GetEPAddress(BYTE /*bEpNum*/);
  407. #define _GetEPAddress(bEpNum) ((BYTE)(_GetENDPOINT(bEpNum) & EPADDR_FIELD))
  409. /*----------------------------------------------------------------*/
  410. #define _pEPTxAddr(bEpNum) ((DWORD *)((_GetBTABLE()+bEpNum*8  )*2 + PMAAddr))
  411. #define _pEPTxCount(bEpNum) ((DWORD *)((_GetBTABLE()+bEpNum*8+2)*2 + PMAAddr))
  412. #define _pEPRxAddr(bEpNum) ((DWORD *)((_GetBTABLE()+bEpNum*8+4)*2 + PMAAddr))
  413. #define _pEPRxCount(bEpNum) ((DWORD *)((_GetBTABLE()+bEpNum*8+6)*2 + PMAAddr))
  415. /*----------------------------------------------------------------*/
  416. /* SetEPTxAddr / SetEPRxAddr */
  417. /* sets address of the tx/rx buffer */
  418. /* IN : bEpNum = endpoint number */
  419. /*      wAddr  = address to be set ( must be word aligned ) */
  420. /* OUT: none */
  421. /*----------------------------------------------------------------*/
  422. void SetEPTxAddr(BYTE /*bEpNum*/,WORD /*wAddr*/);
  423. void SetEPRxAddr(BYTE /*bEpNum*/,WORD /*wAddr*/);
  425. /*#define _SetEPTxAddr(bEpNum,wAddr) (*_pEPTxAddr(bEpNum) = (wAddr & 0xFFFE))*/
  426. /*#define _SetEPRxAddr(bEpNum,wAddr) (*_pEPRxAddr(bEpNum) = (wAddr & 0xFFFE))*/
  428. #define _SetEPTxAddr(bEpNum,wAddr) (*_pEPTxAddr(bEpNum) = ((wAddr >> 1) << 1))
  429. #define _SetEPRxAddr(bEpNum,wAddr) (*_pEPRxAddr(bEpNum) = ((wAddr >> 1) << 1))
  430. /*----------------------------------------------------------------*/
  431. /* GetEPTxAddr / GetEPRxAddr */
  432. /* gets address of the tx/rx buffer */
  433. /* IN : bEpNum = endpoint number */
  434. /* IN : */
  435. /* OUT: address of the buffer */
  436. /*----------------------------------------------------------------*/
  437. WORD GetEPTxAddr(BYTE /*bEpNum*/);
  438. WORD GetEPRxAddr(BYTE /*bEpNum*/);
  440. #define _GetEPTxAddr(bEpNum) ((WORD)*_pEPTxAddr(bEpNum))
  441. #define _GetEPRxAddr(bEpNum) ((WORD)*_pEPRxAddr(bEpNum))
  443. /*----------------------------------------------------------------*/
  444. /* SetEPCountRxReg */
  445. /* sets counter of rx buffer with no. of blocks */
  446. /* IN : pdwReg = pointer to counter */
  447. /*      wCount = counter */
  448. /* OUT: none */
  449. /*----------------------------------------------------------------*/
  450. void SetEPCountRxReg(DWORD * /*pdwReg*/, WORD /*wCount*/);
  452. #define _BlocksOf32(dwReg,wCount,wNBlocks) {
  453.   wNBlocks = wCount >> 5;   
  454.   if((wCount & 0x1f) == 0)
  455.   wNBlocks--;  
  456. *pdwReg = (DWORD)((wNBlocks << 10) | 0x8000);
  457. }/* _BlocksOf32 */
  459. #define _BlocksOf2(dwReg,wCount,wNBlocks) {
  460.   wNBlocks = wCount >> 1;
  461.   if((wCount & 0x1) != 0)
  462.    wNBlocks++;
  463. *pdwReg = (DWORD)(wNBlocks << 10);
  464. }/* _BlocksOf2 */
  466. #define _SetEPCountRxReg(dwReg,wCount)  {
  467.  WORD wNBlocks;
  468.  if(wCount > 62){_BlocksOf32(dwReg,wCount,wNBlocks);}
  469.  else {_BlocksOf2(dwReg,wCount,wNBlocks);}
  470. }/* _SetEPCountRxReg */
  473. #define _SetEPRxDblBuf0Count(bEpNum,wCount) {
  474.  DWORD *pdwReg = _pEPTxCount(bEpNum);   
  475.    _SetEPCountRxReg(pdwReg, wCount);  
  476. }
  478. /*----------------------------------------------------------------*/
  479. /* SetEPTxCount / SetEPRxCount */
  480. /* sets counter for the tx/rx buffer */
  481. /* IN : bEpNum = endpoint number */
  482. /* wCount = counter value */
  483. /* OUT: none */
  484. /*----------------------------------------------------------------*/
  485. void SetEPTxCount(BYTE /*bEpNum*/,WORD /*wCount*/);
  486. void SetEPRxCount(BYTE /*bEpNum*/,WORD /*wCount*/);
  488. #define _SetEPTxCount(bEpNum,wCount) (*_pEPTxCount(bEpNum) = wCount)
  490. #define _SetEPRxCount(bEpNum,wCount) {
  491.  DWORD *pdwReg = _pEPRxCount(bEpNum); 
  492.    _SetEPCountRxReg(pdwReg, wCount);
  493. }
  495. /*----------------------------------------------------------------*/
  496. /* GetEPTxCount / GetEPRxCount */
  497. /* gets counter of the tx buffer */
  498. /* IN : bEpNum = endpoint number */
  499. /* OUT: counter value */
  500. /*----------------------------------------------------------------*/
  501. WORD GetEPTxCount(BYTE /*bEpNum*/);
  502. WORD GetEPRxCount(BYTE /*bEpNum*/);
  504. #define _GetEPTxCount(bEpNum)((WORD)(*_pEPTxCount(bEpNum)) & 0x3ff)
  505. #define _GetEPRxCount(bEpNum)((WORD)(*_pEPRxCount(bEpNum)) & 0x3ff)
  507. /*----------------------------------------------------------------*/
  508. /*----------------------------------------------------------------*/
  509. /* SetEPDblBuf0Addr / SetEPDblBuf1Addr */
  510. /* sets buffer 0/1 address in a double buffer endpoint */
  511. /* IN : bEpNum = endpoint number */
  512. /*      wBuf0Addr = buffer 0 address */
  513. /* OUT: none */
  514. /*----------------------------------------------------------------*/
  515. void SetEPDblBuf0Addr(BYTE /*bEpNum*/,WORD /*wBuf0Addr*/);
  516. void SetEPDblBuf1Addr(BYTE /*bEpNum*/,WORD /*wBuf1Addr*/);
  518. #define _SetEPDblBuf0Addr(bEpNum,wBuf0Addr) (_SetEPTxAddr(bEpNum, wBuf0Addr))
  519. #define _SetEPDblBuf1Addr(bEpNum,wBuf1Addr) (_SetEPRxAddr(bEpNum, wBuf1Addr))
  520. /*----------------------------------------------------------------*/
  521. /* SetEPDblBuffAddr */
  522. /* sets addresses in a double buffer endpoint */
  523. /* IN : bEpNum = endpoint number */
  524. /*      wBuf0Addr = buffer 0 address */
  525. /*      wBuf1Addr = buffer 1 address */
  526. /* OUT: none */
  527. /*----------------------------------------------------------------*/
  528. void SetEPDblBuffAddr(BYTE /*bEpNum*/,WORD /*wBuf0Addr*/,WORD /*wBuf1Addr*/);
  530. #define _SetEPDblBuffAddr(bEpNum,wBuf0Addr,wBuf1Addr) { 
  531. _SetEPDblBuf0Addr(bEpNum, wBuf0Addr);
  532. _SetEPDblBuf1Addr(bEpNum, wBuf1Addr);
  533. } /* _SetEPDblBuffAddr */
  534. /*----------------------------------------------------------------*/
  535. /* GetEPDblBuf0Addr / GetEPDblBuf1Addr */
  536. /* gets buffer 0/1 address of a double buffer endpoint */
  537. /* IN : bEpNum = endpoint number */
  538. /* OUT: none */
  539. /*----------------------------------------------------------------*/
  540. WORD GetEPDblBuf0Addr(BYTE /*bEpNum*/);
  541. WORD GetEPDblBuf1Addr(BYTE /*bEpNum*/);
  543. #define _GetEPDblBuf0Addr(bEpNum) (_GetEPTxAddr(bEpNum))
  544. #define _GetEPDblBuf1Addr(bEpNum) (_GetEPRxAddr(bEpNum))
  545. /*----------------------------------------------------------------*/
  546. /* SetEPDblBuffCount / SetEPDblBuf0Count / SetEPDblBuf1Count */
  547. /* sets both buffers or buff0 or buff1 counter for double buffering */
  548. /* IN : bEpNum  = endpoint number */
  549. /* bDir    = endpoint dir  EP_DBUF_OUT = OUT */
  550. /* EP_DBUF_IN  = IN */
  551. /* wCount  = counter value     */
  552. /* OUT: none */
  553. /*----------------------------------------------------------------*/
  554. void SetEPDblBuffCount(BYTE /*bEpNum*/, BYTE /*bDir*/, WORD /*wCount*/);
  555. void SetEPDblBuf0Count(BYTE /*bEpNum*/, BYTE /*bDir*/, WORD /*wCount*/);
  556. void SetEPDblBuf1Count(BYTE /*bEpNum*/, BYTE /*bDir*/, WORD /*wCount*/);
  558. #define _SetEPDblBuf0Count(bEpNum, bDir, wCount)  { 
  559.  if(bDir == EP_DBUF_OUT)
  560.      /* OUT endpoint */
  561.      {_SetEPRxDblBuf0Count(bEpNum,wCount);} 
  562.  else if(bDir == EP_DBUF_IN)
  563.      /* IN endpoint */
  564.  *_pEPTxCount(bEpNum) = (DWORD)wCount;  
  565. } /* SetEPDblBuf0Count*/
  567. #define _SetEPDblBuf1Count(bEpNum, bDir, wCount)  { 
  568.  if(bDir == EP_DBUF_OUT)   
  569.      /* OUT endpoint */
  570.      {_SetEPRxCount(bEpNum,wCount); }
  571.  else if(bDir == EP_DBUF_IN)
  572.      /* IN endpoint */
  573.  *_pEPRxCount(bEpNum) = (DWORD)wCount;  
  574. } /* SetEPDblBuf1Count */
  576. #define _SetEPDblBuffCount(bEpNum, bDir, wCount) {
  577. _SetEPDblBuf0Count(bEpNum, bDir, wCount); 
  578.   _SetEPDblBuf1Count(bEpNum, bDir, wCount); 
  579. } /* _SetEPDblBuffCount  */
  581. /*----------------------------------------------------------------*/
  582. /* GetEPDblBuf0Count / GetEPDblBuf1Count */
  583. /* gets buffer 0/1 rx/tx counter for double buffering */
  584. /* IN : bEpNum  = endpoint number */
  585. /* OUT: none */
  586. /*----------------------------------------------------------------*/
  587. WORD GetEPDblBuf0Count(BYTE /*bEpNum*/);
  588. WORD GetEPDblBuf1Count(BYTE /*bEpNum*/);
  590. #define _GetEPDblBuf0Count(bEpNum) (_GetEPTxCount(bEpNum)) /* rigth version  */
  591. /*#define _GetEPDblBuf0Count(bEpNum)  (_GetEPRxCount(bEpNum))*/
  593. #define _GetEPDblBuf1Count(bEpNum) (_GetEPRxCount(bEpNum)) /* rigth version  */
  594. /*#define _GetEPDblBuf1Count(bEpNum)  (_GetEPTxCount(bEpNum))*/
  596. /*----------------------------------------------------------------*/
  597. /* GetEPDblBufDir */
  598. /* gets direction of the double buffered endpoint */
  599. /* IN : bEpNum  = endpoint number */
  600. /* OUT: EP_DBUF_OUT, EP_DBUF_IN, */
  601. /*      EP_DBUF_ERR if the endpoint counter not yet programmed */
  602. /*----------------------------------------------------------------*/
  603. EP_DBUF_DIR GetEPDblBufDir(BYTE /*bEpNum*/);
  605. /*----------------------------------------------------------------*/
  606. /* FreeUserBuffer */
  607. /* free buffer used from the application realising it to the line */
  608. /* toggles bit SW_BUF in the double buffered endpoint register */
  609. /* IN : bEpNum = endpoint number */
  610. /* OUT: none */
  611. /*----------------------------------------------------------------*/
  612. void FreeUserBuffer(BYTE /*bEpNum*/);
  614. /*----------------------------------------------------------------*/
  615. WORD ToWord(BYTE,BYTE);
  616. /*----------------------------------------------------------------*/
  617. WORD ByteSwap(WORD);