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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > DSP编程 > 查看源码
DSP281x_Mcbsp.h
资源名称：TMS320F2812-EVM.rar　[点击查看]
上传用户：qingfan3
上传日期：2014-10-27
资源大小：31439k
文件大小：35k
源码类别：

DSP编程

开发平台：

C/C++

DSP281x_Mcbsp.h：源码内容
  1. //###########################################################################
  2. //
  3. // FILE:   DSP281x_Mcbsp.h
  4. //
  5. // TITLE:  DSP281x Device McBSP Register Definitions.
  6. //
  7. //###########################################################################
  8. //
  9. //  Ver | dd mmm yyyy | Who  | Description of changes
  10. // =====|=============|======|===============================================
  11. //  1.00| 11 Sep 2003 | L.H. | Changes since previous version (v.58 Alpha)
  12. //      |             |      | Changed the name of PCR1 register to PCR
  13. //      |             |      | Fixed name of GSYNC bit (was GYSNC)
  14. //      |             |      | Changed bit 14 of SRGR2 to reserved
  15. //      |             |      | RFULL bit in SPCR1 was mislabled (was REMPTY)
  16. //      |             |      | XCERA register bits changed from XCEAn to XCERAn   
  17. //      |             |      | XCERB register bits changed from XCEBn to XCERBn
  18. //      |             |      | XCERC register bits changed from XCECn to XCERCn
  19. //      |             |      | XCERD register bits changed from XCEDn to XCERDn
  20. //      |             |      | XCERE register bits changed from XCEEn to XCEREn
  21. //      |             |      | XCERF register bits changed from XCEFn to XCERFn
  22. //      |             |      | XCERG register bits changed from XCEGn to XCERGn
  23. //      |             |      | MFFTX register bits change to align with user's guide
  24. //      |             |      | MFFRX register bits change to align with user's guide
  25. //###########################################################################
  27. #ifndef DSP281x_MCBSP_H
  28. #define DSP281x_MCBSP_H
  30. #ifdef __cplusplus
  31. extern "C" {
  32. #endif
  35. //---------------------------------------------------------------------------
  36. // McBSP Individual Register Bit Definitions:
  37. //
  38. // McBSP DRR2 register bit definitions:
  39. struct  DRR2_BITS {       // bit   description
  40.    Uint16     HWLB:8;     // 16:23 High word low byte
  41.    Uint16     HWHB:8;     // 24:31 High word high byte
  42. };                                                                 
  44. union DRR2_REG {
  45.    Uint16            all;
  46.    struct DRR2_BITS  bit;
  47. };
  49. // McBSP DRR1 register bit definitions:
  50. struct  DRR1_BITS {       // bit   description
  51.    Uint16     LWLB:8;     // 16:23 Low word low byte
  52.    Uint16     LWHB:8;     // 24:31 low word high byte
  53. };
  55. union DRR1_REG {
  56.    Uint16            all;
  57.    struct DRR1_BITS  bit;
  58. };
  60. // McBSP DXR2 register bit definitions:
  61. struct  DXR2_BITS {       // bit   description
  62.    Uint16     HWLB:8;     // 16:23 High word low byte
  63.    Uint16     HWHB:8;     // 24:31 High word high byte
  64. };
  66. union DXR2_REG {
  67.    Uint16            all;
  68.    struct DXR2_BITS  bit;
  69. };
  71. // McBSP DXR1 register bit definitions:
  72. struct  DXR1_BITS {       // bit   description
  73.    Uint16     LWLB:8;     // 16:23 Low word low byte
  74.    Uint16     LWHB:8;     // 24:31 low word high byte
  75. };               
  77. union DXR1_REG {
  78.    Uint16              all;
  79.    struct DXR1_BITS  bit;
  80. };
  82. // SPCR2 control register bit definitions:
  83. struct  SPCR2_BITS {       // bit   description
  84.    Uint16     XRST:1;      // 0     transmit reset
  85.    Uint16     XRDY:1;      // 1     transmit ready
  86.    Uint16     XEMPTY:1;    // 2     Transmit empty    
  87.    Uint16     XSYNCERR:1;  // 3     Transmit syn errorINT flag
  88.    Uint16     XINTM:2;     // 5:4   Transmit interrupt types
  89.    Uint16     GRST:1;      // 6     CLKG reset     
  90.    Uint16     FRST:1;      // 7     Frame sync reset
  91.    Uint16     SOFT:1;      // 8     SOFT bit
  92.    Uint16     FREE:1;      // 9     FREE bit
  93.    Uint16     rsvd:6;      // 15:10 reserved
  94. }; 
  96. union SPCR2_REG {
  97.    Uint16               all;
  98.    struct SPCR2_BITS  bit;
  99. };
  100.          
  101. // SPCR1 control register bit definitions:
  102. struct  SPCR1_BITS {       // bit   description
  103.    Uint16     RRST:1;      // 0     Receive reset
  104.    Uint16     RRDY:1;      // 1     Receive  ready
  105.    Uint16     RFULL:1;     // 2     Receive  full    
  106.    Uint16     RSYNCERR:1;  // 7     Receive  syn error
  107.    Uint16     RINTM:2;     // 5:4   Receive  interrupt types
  108.    Uint16     ABIS:1;      // 6     ABIS mode select     
  109.    Uint16     DXENA:1;     // 7     DX hi-z enable     
  110.    Uint16     rsvd:3;      // 10:8  reserved  
  111.    Uint16     CLKSTP:2;    // 12:11 CLKSTOP mode bit
  112.    Uint16     RJUST:2;     // 13:14 Right justified
  113.    Uint16     DLB:1;       // 15    Digital loop back
  114. }; 
  116. union SPCR1_REG {
  117.    Uint16              all;
  118.    struct SPCR1_BITS bit;
  119. };                                                               
  121. // RCR2 control register bit definitions:
  122. struct  RCR2_BITS {         // bit    description
  123.    Uint16     RDATDLY:2;    // 1:0    Receive data delay
  124.    Uint16     RFIG:1;       // 2      Receive  frame sync ignore
  125.    Uint16     RCOMPAND:2;   // 4:3    Receive  Companding Mode selects
  126.    Uint16     RWDLEN2:3;    // 7:5    Receive  word length   
  127.    Uint16     RFRLEN2:7;    // 14:8   Receive  Frame sync
  128.    Uint16     RPHASE:1;     // 15     Receive Phase
  129. }; 
  131. union RCR2_REG {
  132.    Uint16           all;
  133.    struct RCR2_BITS bit;
  134. };
  135.      
  136. // RCR1 control register bit definitions:
  137. struct  RCR1_BITS {         // bit   description
  138.    Uint16     rsvd1:5;      // 4:0   reserved  
  139.    Uint16     RWDLEN1:3;    // 7:5   Receive word length   
  140.    Uint16     RFRLEN1:7;    // 14:8  Receive frame length    
  141.    Uint16     rsvd2:1;      // 15    reserved  
  142. }; 
  144. union RCR1_REG {
  145.    Uint16           all;
  146.    struct RCR1_BITS bit;
  147. };    
  149. // XCR2 control register bit definitions:
  151. struct  XCR2_BITS {         // bit    description
  152.    Uint16     XDATDLY:2;    // 1:0    Transmit data delay
  153.    Uint16     XFIG:1;       // 2      Transmit frame sync ignore
  154.    Uint16     XCOMPAND:2;   // 4:3    Transmit Companding Mode selects
  155.    Uint16     XWDLEN2:3;    // 7:5    Transmit  word length   
  156.    Uint16     XFRLEN2:7;    // 14:8   Transmit  Frame sync
  157.    Uint16     XPHASE:1;     // 15     Transmit Phase
  158. }; 
  160. union XCR2_REG {
  161.    Uint16           all;
  162.    struct XCR2_BITS bit;
  163. };
  164.      
  165. // XCR1 control register bit definitions:
  166. struct  XCR1_BITS {         // bit   description
  167.    Uint16     rsvd1:5;      // 4:0   reserved      
  168.    Uint16     XWDLEN1:3;    // 7:5   Transmit word length    
  169.    Uint16     XFRLEN1:7;    // 14:8  Transmit frame length    
  170.    Uint16     rsvd2:1;      // 15    reserved  
  171. }; 
  173. union XCR1_REG {
  174.    Uint16             all;
  175.    struct XCR1_BITS bit;
  176. };         
  178. // SRGR2 Sample rate generator control register bit definitions:
  179. struct  SRGR2_BITS {        // bit  description
  180.    Uint16     FPER:12;      // 11:0 Frame period
  181.    Uint16     FSGM:1;       // 12   Frame sync generator mode 
  182.    Uint16     CLKSM:1;      // 13   Sample rate generator mode
  183.    Uint16     rsvd:1;       // 14   reserved 
  184.    Uint16     GSYNC:1;      // 15   CLKG sync   
  185. }; 
  187. union  SRGR2_REG {
  188.    Uint16              all;
  189.    struct  SRGR2_BITS  bit;
  190. };
  192. // SRGR1 control register bit definitions:
  193. struct  SRGR1_BITS {        // bit   description
  194.    Uint16     CLKGDV:8;     // 7:0   CLKG divider 
  195.    Uint16     FWID:8;       // 15:8  Frame width
  196. }; 
  198. union  SRGR1_REG {
  199.    Uint16              all;
  200.    struct  SRGR1_BITS  bit;
  201. };
  203. // MCR2 Multichannel control register bit definitions:
  204. struct  MCR2_BITS {         // bit   description
  205.    Uint16     XMCM:2;       // 1:0   Transmit multichannel mode      
  206.    Uint16     XCBLK:3;      // 2:4   Transmit current block    
  207.    Uint16     XPABLK:2;     // 5:6   Transmit partition A Block 
  208.    Uint16     XPBBLK:2;     // 7:8   Transmit partition B Block 
  209.    Uint16     XMCME:1;      // 9     Transmit multi-channel enhance mode 
  210.    Uint16     rsvd:6;       // 15:10 reserved  
  211. }; 
  213. union  MCR2_REG {
  214.    Uint16             all;
  215.    struct  MCR2_BITS  bit;
  216. };
  217.       
  218. // MCR1 Multichannel control register bit definitions:
  219. struct  MCR1_BITS {         // bit   description
  220.    Uint16     RMCM:1;       // 0     Receive multichannel mode  
  221.    Uint16     rsvd:1;       // 1     reserved     
  222.    Uint16     RCBLK:3;      // 4:2   Receive current block    
  223.    Uint16     RPABLK:2;     // 6:5   Receive partition A Block 
  224.    Uint16     RPBBLK:2;     // 7:8   Receive partition B Block 
  225.    Uint16     RMCME:1;      // 9     Receive multi-channel enhance mode 
  226.    Uint16     rsvd1:6;      // 15:10 reserved   
  227. }; 
  229. union  MCR1_REG {
  230.    Uint16             all;
  231.    struct  MCR1_BITS  bit;
  232. };
  233.  
  234. // RCERA control register bit definitions:
  235. struct  RCERA_BITS {         // bit description
  236.    Uint16     RCEA0:1;       // 0   Receive Channel enable bit  
  237.    Uint16     RCEA1:1;       // 1   Receive Channel enable bit  
  238.    Uint16     RCEA2:1;       // 2   Receive Channel enable bit  
  239.    Uint16     RCEA3:1;       // 3   Receive Channel enable bit   
  240.    Uint16     RCEA4:1;       // 4   Receive Channel enable bit  
  241.    Uint16     RCEA5:1;       // 5   Receive Channel enable bit  
  242.    Uint16     RCEA6:1;       // 6   Receive Channel enable bit  
  243.    Uint16     RCEA7:1;       // 7   Receive Channel enable bit 
  244.    Uint16     RCEA8:1;       // 8   Receive Channel enable bit  
  245.    Uint16     RCEA9:1;       // 9   Receive Channel enable bit  
  246.    Uint16     RCEA10:1;      // 10  Receive Channel enable bit  
  247.    Uint16     RCEA11:1;      // 11  Receive Channel enable bit 
  248.    Uint16     RCEA12:1;      // 12  Receive Channel enable bit  
  249.    Uint16     RCEA13:1;      // 13  Receive Channel enable bit  
  250.    Uint16     RCEA14:1;      // 14  Receive Channel enable bit  
  251.    Uint16     RCEA15:1;      // 15  Receive Channel enable bit 
  252. }; 
  254. union RCERA_REG {
  255.    Uint16              all;
  256.    struct  RCERA_BITS  bit;
  257. };  
  259. // RCERB control register bit definitions:
  260. struct  RCERB_BITS {         // bit description
  261.    Uint16     RCEB0:1;       // 0   Receive Channel enable bit  
  262.    Uint16     RCEB1:1;       // 1   Receive Channel enable bit  
  263.    Uint16     RCEB2:1;       // 2   Receive Channel enable bit  
  264.    Uint16     RCEB3:1;       // 3   Receive Channel enable bit   
  265.    Uint16     RCEB4:1;       // 4   Receive Channel enable bit  
  266.    Uint16     RCEB5:1;       // 5   Receive Channel enable bit  
  267.    Uint16     RCEB6:1;       // 6   Receive Channel enable bit  
  268.    Uint16     RCEB7:1;       // 7   Receive Channel enable bit 
  269.    Uint16     RCEB8:1;       // 8   Receive Channel enable bit  
  270.    Uint16     RCEB9:1;       // 9   Receive Channel enable bit  
  271.    Uint16     RCEB10:1;      // 10  Receive Channel enable bit  
  272.    Uint16     RCEB11:1;      // 11  Receive Channel enable bit 
  273.    Uint16     RCEB12:1;      // 12  Receive Channel enable bit  
  274.    Uint16     RCEB13:1;      // 13  Receive Channel enable bit  
  275.    Uint16     RCEB14:1;      // 14  Receive Channel enable bit  
  276.    Uint16     RCEB15:1;      // 15  Receive Channel enable bit   
  277. }; 
  279. union RCERB_REG {
  280.    Uint16              all;
  281.    struct  RCERB_BITS  bit;
  282. };
  284. // XCERA control register bit definitions:
  285. struct  XCERA_BITS {         // bit description
  286.    Uint16     XCERA0:1;       // 0   Receive Channel enable bit  
  287.    Uint16     XCERA1:1;       // 1   Receive Channel enable bit  
  288.    Uint16     XCERA2:1;       // 2   Receive Channel enable bit  
  289.    Uint16     XCERA3:1;       // 3   Receive Channel enable bit   
  290.    Uint16     XCERA4:1;       // 4   Receive Channel enable bit  
  291.    Uint16     XCERA5:1;       // 5   Receive Channel enable bit  
  292.    Uint16     XCERA6:1;       // 6   Receive Channel enable bit  
  293.    Uint16     XCERA7:1;       // 7   Receive Channel enable bit 
  294.    Uint16     XCERA8:1;       // 8   Receive Channel enable bit  
  295.    Uint16     XCERA9:1;       // 9   Receive Channel enable bit  
  296.    Uint16     XCERA10:1;      // 10  Receive Channel enable bit  
  297.    Uint16     XCERA11:1;      // 11  Receive Channel enable bit 
  298.    Uint16     XCERA12:1;      // 12  Receive Channel enable bit  
  299.    Uint16     XCERA13:1;      // 13  Receive Channel enable bit  
  300.    Uint16     XCERA14:1;      // 14  Receive Channel enable bit  
  301.    Uint16     XCERA15:1;      // 15  Receive Channel enable bit 
  302. }; 
  304. union XCERA_REG {
  305.    Uint16              all;
  306.    struct  XCERA_BITS  bit;
  307. };  
  309. // XCERB control register bit definitions:
  310. struct  XCERB_BITS {         // bit description
  311.    Uint16     XCERB0:1;       // 0   Receive Channel enable bit  
  312.    Uint16     XCERB1:1;       // 1   Receive Channel enable bit  
  313.    Uint16     XCERB2:1;       // 2   Receive Channel enable bit  
  314.    Uint16     XCERB3:1;       // 3   Receive Channel enable bit   
  315.    Uint16     XCERB4:1;       // 4   Receive Channel enable bit  
  316.    Uint16     XCERB5:1;       // 5   Receive Channel enable bit  
  317.    Uint16     XCERB6:1;       // 6   Receive Channel enable bit  
  318.    Uint16     XCERB7:1;       // 7   Receive Channel enable bit 
  319.    Uint16     XCERB8:1;       // 8   Receive Channel enable bit  
  320.    Uint16     XCERB9:1;       // 9   Receive Channel enable bit  
  321.    Uint16     XCERB10:1;      // 10  Receive Channel enable bit  
  322.    Uint16     XCERB11:1;      // 11  Receive Channel enable bit 
  323.    Uint16     XCERB12:1;      // 12  Receive Channel enable bit  
  324.    Uint16     XCERB13:1;      // 13  Receive Channel enable bit  
  325.    Uint16     XCERB14:1;      // 14  Receive Channel enable bit  
  326.    Uint16     XCERB15:1;      // 15  Receive Channel enable bit 
  327. }; 
  329. union XCERB_REG {
  330.    Uint16              all;
  331.    struct  XCERB_BITS  bit;
  332. };
  333.   
  334. // PCR control register bit definitions:
  335. struct  PCR_BITS {          // bit description
  336.    Uint16     CLKRP:1;       // 0   Receive Clock polarity
  337.    Uint16     CLKXP:1;       // 1   Transmit clock polarity  
  338.    Uint16     FSRP:1;        // 2   Receive Frame synchronization polarity  
  339.    Uint16     FSXP:1;        // 3   Transmit Frame synchronization polarity   
  340.    Uint16     DR_STAT:1;     // 4   DR pin status - reserved for this McBSP  
  341.    Uint16     DX_STAT:1;     // 5   DX pin status - reserved for this McBSP  
  342.    Uint16     CLKS_STAT:1;   // 6   CLKS pin status - reserved for 28x -McBSP  
  343.    Uint16     SCLKME:1;      // 7   Enhanced sample clock mode selection bit.
  344.    Uint16     CLKRM:1;       // 8   Receiver Clock Mode 
  345.    Uint16     CLKXM:1;       // 9   Transmitter Clock Mode.  
  346.    Uint16     FSRM:1;        // 10  Receive Frame Synchronization Mode  
  347.    Uint16     FSXM:1;        // 11  Transmit Frame Synchronization Mode
  348.    Uint16     RIOEN:1;       // 12  General Purpose I/O Mode - reserved in this 28x-McBSP    
  349.    Uint16     XIOEN:1;       // 13  General Purpose I/O Mode - reserved in this 28x-McBSP
  350.    Uint16     IDEL_EN:1;     // 14  reserved in this 28x-McBSP
  351.    Uint16     rsvd:1  ;      // 15  reserved
  352. }; 
  354. union PCR_REG {
  355.    Uint16            all;
  356.    struct  PCR_BITS  bit;
  357. };
  358.   
  359. // RCERC control register bit definitions:
  360. struct  RCERC_BITS {         // bit description
  361.    Uint16     RCEC0:1;       // 0   Receive Channel enable bit  
  362.    Uint16     RCEC1:1;       // 1   Receive Channel enable bit  
  363.    Uint16     RCEC2:1;       // 2   Receive Channel enable bit  
  364.    Uint16     RCEC3:1;       // 3   Receive Channel enable bit   
  365.    Uint16     RCEC4:1;       // 4   Receive Channel enable bit  
  366.    Uint16     RCEC5:1;       // 5   Receive Channel enable bit  
  367.    Uint16     RCEC6:1;       // 6   Receive Channel enable bit  
  368.    Uint16     RCEC7:1;       // 7   Receive Channel enable bit 
  369.    Uint16     RCEC8:1;       // 8   Receive Channel enable bit  
  370.    Uint16     RCEC9:1;       // 9   Receive Channel enable bit  
  371.    Uint16     RCEC10:1;      // 10  Receive Channel enable bit  
  372.    Uint16     RCEC11:1;      // 11  Receive Channel enable bit 
  373.    Uint16     RCEC12:1;      // 12  Receive Channel enable bit  
  374.    Uint16     RCEC13:1;      // 13  Receive Channel enable bit  
  375.    Uint16     RCEC14:1;      // 14  Receive Channel enable bit  
  376.    Uint16     RCEC15:1;      // 15  Receive Channel enable bit 
  377. }; 
  379. union RCERC_REG {
  380.    Uint16              all;
  381.    struct  RCERC_BITS  bit;
  382. };  
  384. // RCERD control register bit definitions:
  385. struct  RCERD_BITS {         // bit description
  386.    Uint16     RCED0:1;       // 0   Receive Channel enable bit  
  387.    Uint16     RCED1:1;       // 1   Receive Channel enable bit  
  388.    Uint16     RCED2:1;       // 2   Receive Channel enable bit  
  389.    Uint16     RCED3:1;       // 3   Receive Channel enable bit   
  390.    Uint16     RCED4:1;       // 4   Receive Channel enable bit  
  391.    Uint16     RCED5:1;       // 5   Receive Channel enable bit  
  392.    Uint16     RCED6:1;       // 6   Receive Channel enable bit  
  393.    Uint16     RCED7:1;       // 7   Receive Channel enable bit 
  394.    Uint16     RCED8:1;       // 8   Receive Channel enable bit  
  395.    Uint16     RCED9:1;       // 9   Receive Channel enable bit  
  396.    Uint16     RCED10:1;      // 10  Receive Channel enable bit  
  397.    Uint16     RCED11:1;      // 11  Receive Channel enable bit 
  398.    Uint16     RCED12:1;      // 12  Receive Channel enable bit  
  399.    Uint16     RCED13:1;      // 13  Receive Channel enable bit  
  400.    Uint16     RCED14:1;      // 14  Receive Channel enable bit  
  401.    Uint16     RCED15:1;      // 15  Receive Channel enable bit 
  402. }; 
  404. union RCERD_REG {
  405.    Uint16              all;
  406.    struct  RCERD_BITS  bit;
  407. };
  409. // XCERC control register bit definitions:
  410. struct  XCERC_BITS {         // bit description
  411.    Uint16     XCERC0:1;       // 0   Receive Channel enable bit  
  412.    Uint16     XCERC1:1;       // 1   Receive Channel enable bit  
  413.    Uint16     XCERC2:1;       // 2   Receive Channel enable bit  
  414.    Uint16     XCERC3:1;       // 3   Receive Channel enable bit   
  415.    Uint16     XCERC4:1;       // 4   Receive Channel enable bit  
  416.    Uint16     XCERC5:1;       // 5   Receive Channel enable bit  
  417.    Uint16     XCERC6:1;       // 6   Receive Channel enable bit  
  418.    Uint16     XCERC7:1;       // 7   Receive Channel enable bit 
  419.    Uint16     XCERC8:1;       // 8   Receive Channel enable bit  
  420.    Uint16     XCERC9:1;       // 9   Receive Channel enable bit  
  421.    Uint16     XCERC10:1;      // 10  Receive Channel enable bit  
  422.    Uint16     XCERC11:1;      // 11  Receive Channel enable bit 
  423.    Uint16     XCERC12:1;      // 12  Receive Channel enable bit  
  424.    Uint16     XCERC13:1;      // 13  Receive Channel enable bit  
  425.    Uint16     XCERC14:1;      // 14  Receive Channel enable bit  
  426.    Uint16     XCERC15:1;      // 15  Receive Channel enable bit 
  427. }; 
  429. union XCERC_REG {
  430.    Uint16              all;
  431.    struct  XCERC_BITS  bit;
  432. };  
  434. // XCERD control register bit definitions:
  435. struct  XCERD_BITS {         // bit description
  436.    Uint16     XCERD0:1;       // 0   Receive Channel enable bit  
  437.    Uint16     XCERD1:1;       // 1   Receive Channel enable bit  
  438.    Uint16     XCERD2:1;       // 2   Receive Channel enable bit  
  439.    Uint16     XCERD3:1;       // 3   Receive Channel enable bit   
  440.    Uint16     XCERD4:1;       // 4   Receive Channel enable bit  
  441.    Uint16     XCERD5:1;       // 5   Receive Channel enable bit  
  442.    Uint16     XCERD6:1;       // 6   Receive Channel enable bit  
  443.    Uint16     XCERD7:1;       // 7   Receive Channel enable bit 
  444.    Uint16     XCERD8:1;       // 8   Receive Channel enable bit  
  445.    Uint16     XCERD9:1;       // 9   Receive Channel enable bit  
  446.    Uint16     XCERD10:1;      // 10  Receive Channel enable bit  
  447.    Uint16     XCERD11:1;      // 11  Receive Channel enable bit 
  448.    Uint16     XCERD12:1;      // 12  Receive Channel enable bit  
  449.    Uint16     XCERD13:1;      // 13  Receive Channel enable bit  
  450.    Uint16     XCERD14:1;      // 14  Receive Channel enable bit  
  451.    Uint16     XCERD15:1;      // 15  Receive Channel enable bit 
  452. }; 
  454. union XCERD_REG {
  455.    Uint16              all;
  456.    struct  XCERD_BITS  bit;
  457. };
  458.   
  459. // RCERE control register bit definitions:
  460. struct  RCERE_BITS {         // bit description
  461.    Uint16     RCEE0:1;       // 0   Receive Channel enable bit  
  462.    Uint16     RCEE1:1;       // 1   Receive Channel enable bit  
  463.    Uint16     RCEE2:1;       // 2   Receive Channel enable bit  
  464.    Uint16     RCEE3:1;       // 3   Receive Channel enable bit   
  465.    Uint16     RCEE4:1;       // 4   Receive Channel enable bit  
  466.    Uint16     RCEE5:1;       // 5   Receive Channel enable bit  
  467.    Uint16     RCEE6:1;       // 6   Receive Channel enable bit  
  468.    Uint16     RCEE7:1;       // 7   Receive Channel enable bit 
  469.    Uint16     RCEE8:1;       // 8   Receive Channel enable bit  
  470.    Uint16     RCEE9:1;       // 9   Receive Channel enable bit  
  471.    Uint16     RCEE10:1;      // 10  Receive Channel enable bit  
  472.    Uint16     RCEE11:1;      // 11  Receive Channel enable bit 
  473.    Uint16     RCEE12:1;      // 12  Receive Channel enable bit  
  474.    Uint16     RCEE13:1;      // 13  Receive Channel enable bit  
  475.    Uint16     RCEE14:1;      // 14  Receive Channel enable bit  
  476.    Uint16     RCEE15:1;      // 15  Receive Channel enable bit 
  477. }; 
  479. union RCERE_REG {
  480.    Uint16              all;
  481.    struct  RCERE_BITS  bit;
  482. };  
  484. // RCERF control register bit definitions:
  485. struct  RCERF_BITS {         // bit   description
  486.    Uint16     RCEF0:1;       // 0   Receive Channel enable bit  
  487.    Uint16     RCEF1:1;       // 1   Receive Channel enable bit  
  488.    Uint16     RCEF2:1;       // 2   Receive Channel enable bit  
  489.    Uint16     RCEF3:1;       // 3   Receive Channel enable bit   
  490.    Uint16     RCEF4:1;       // 4   Receive Channel enable bit  
  491.    Uint16     RCEF5:1;       // 5   Receive Channel enable bit  
  492.    Uint16     RCEF6:1;       // 6   Receive Channel enable bit  
  493.    Uint16     RCEF7:1;       // 7   Receive Channel enable bit 
  494.    Uint16     RCEF8:1;       // 8   Receive Channel enable bit  
  495.    Uint16     RCEF9:1;       // 9   Receive Channel enable bit  
  496.    Uint16     RCEF10:1;      // 10  Receive Channel enable bit  
  497.    Uint16     RCEF11:1;      // 11  Receive Channel enable bit 
  498.    Uint16     RCEF12:1;      // 12  Receive Channel enable bit  
  499.    Uint16     RCEF13:1;      // 13  Receive Channel enable bit  
  500.    Uint16     RCEF14:1;      // 14  Receive Channel enable bit  
  501.    Uint16     RCEF15:1;      // 15  Receive Channel enable bit 
  502. }; 
  504. union RCERF_REG {
  505.    Uint16              all;
  506.    struct  RCERF_BITS  bit;
  507. };
  509. // XCERE control register bit definitions:
  510. struct  XCERE_BITS {         // bit description
  511.    Uint16     XCERE0:1;       // 0   Receive Channel enable bit  
  512.    Uint16     XCERE1:1;       // 1   Receive Channel enable bit  
  513.    Uint16     XCERE2:1;       // 2   Receive Channel enable bit  
  514.    Uint16     XCERE3:1;       // 3   Receive Channel enable bit   
  515.    Uint16     XCERE4:1;       // 4   Receive Channel enable bit  
  516.    Uint16     XCERE5:1;       // 5   Receive Channel enable bit  
  517.    Uint16     XCERE6:1;       // 6   Receive Channel enable bit  
  518.    Uint16     XCERE7:1;       // 7   Receive Channel enable bit 
  519.    Uint16     XCERE8:1;       // 8   Receive Channel enable bit  
  520.    Uint16     XCERE9:1;       // 9   Receive Channel enable bit  
  521.    Uint16     XCERE10:1;      // 10  Receive Channel enable bit  
  522.    Uint16     XCERE11:1;      // 11  Receive Channel enable bit 
  523.    Uint16     XCERE12:1;      // 12  Receive Channel enable bit  
  524.    Uint16     XCERE13:1;      // 13  Receive Channel enable bit  
  525.    Uint16     XCERE14:1;      // 14  Receive Channel enable bit  
  526.    Uint16     XCERE15:1;      // 15  Receive Channel enable bit 
  527. }; 
  529. union XCERE_REG {
  530.    Uint16              all;
  531.    struct  XCERE_BITS  bit;
  532. };  
  534. // XCERF control register bit definitions:
  535. struct  XCERF_BITS {         // bit description
  536.    Uint16     XCERF0:1;       // 0   Receive Channel enable bit  
  537.    Uint16     XCERF1:1;       // 1   Receive Channel enable bit  
  538.    Uint16     XCERF2:1;       // 2   Receive Channel enable bit  
  539.    Uint16     XCERF3:1;       // 3   Receive Channel enable bit   
  540.    Uint16     XCERF4:1;       // 4   Receive Channel enable bit  
  541.    Uint16     XCERF5:1;       // 5   Receive Channel enable bit  
  542.    Uint16     XCERF6:1;       // 6   Receive Channel enable bit  
  543.    Uint16     XCERF7:1;       // 7   Receive Channel enable bit 
  544.    Uint16     XCERF8:1;       // 8   Receive Channel enable bit  
  545.    Uint16     XCERF9:1;       // 9   Receive Channel enable bit  
  546.    Uint16     XCERF10:1;      // 10  Receive Channel enable bit  
  547.    Uint16     XCERF11:1;      // 11  Receive Channel enable bit 
  548.    Uint16     XCERF12:1;      // 12  Receive Channel enable bit  
  549.    Uint16     XCERF13:1;      // 13  Receive Channel enable bit  
  550.    Uint16     XCERF14:1;      // 14  Receive Channel enable bit  
  551.    Uint16     XCERF15:1;      // 15  Receive Channel enable bit 
  552. }; 
  554. union XCERF_REG {
  555.    Uint16              all;
  556.    struct  XCERF_BITS  bit;
  557. };                   
  559. // RCERG control register bit definitions:
  560. struct  RCERG_BITS {         // bit description
  561.    Uint16     RCEG0:1;       // 0   Receive Channel enable bit  
  562.    Uint16     RCEG1:1;       // 1   Receive Channel enable bit  
  563.    Uint16     RCEG2:1;       // 2   Receive Channel enable bit  
  564.    Uint16     RCEG3:1;       // 3   Receive Channel enable bit   
  565.    Uint16     RCEG4:1;       // 4   Receive Channel enable bit  
  566.    Uint16     RCEG5:1;       // 5   Receive Channel enable bit  
  567.    Uint16     RCEG6:1;       // 6   Receive Channel enable bit  
  568.    Uint16     RCEG7:1;       // 7   Receive Channel enable bit 
  569.    Uint16     RCEG8:1;       // 8   Receive Channel enable bit  
  570.    Uint16     RCEG9:1;       // 9   Receive Channel enable bit  
  571.    Uint16     RCEG10:1;      // 10  Receive Channel enable bit  
  572.    Uint16     RCEG11:1;      // 11  Receive Channel enable bit 
  573.    Uint16     RCEG12:1;      // 12  Receive Channel enable bit  
  574.    Uint16     RCEG13:1;      // 13  Receive Channel enable bit  
  575.    Uint16     RCEG14:1;      // 14  Receive Channel enable bit  
  576.    Uint16     RCEG15:1;      // 15  Receive Channel enable bit 
  577. }; 
  579. union RCERG_REG {
  580.    Uint16              all;
  581.    struct  RCERG_BITS  bit;
  582. };  
  584. // RCERH control register bit definitions:
  585. struct  RCERH_BITS {         // bit description
  586.    Uint16     RCEH0:1;       // 0   Receive Channel enable bit  
  587.    Uint16     RCEH1:1;       // 1   Receive Channel enable bit  
  588.    Uint16     RCEH2:1;       // 2   Receive Channel enable bit  
  589.    Uint16     RCEH3:1;       // 3   Receive Channel enable bit   
  590.    Uint16     RCEH4:1;       // 4   Receive Channel enable bit  
  591.    Uint16     RCEH5:1;       // 5   Receive Channel enable bit  
  592.    Uint16     RCEH6:1;       // 6   Receive Channel enable bit  
  593.    Uint16     RCEH7:1;       // 7   Receive Channel enable bit 
  594.    Uint16     RCEH8:1;       // 8   Receive Channel enable bit  
  595.    Uint16     RCEH9:1;       // 9   Receive Channel enable bit  
  596.    Uint16     RCEH10:1;      // 10  Receive Channel enable bit  
  597.    Uint16     RCEH11:1;      // 11  Receive Channel enable bit 
  598.    Uint16     RCEH12:1;      // 12  Receive Channel enable bit  
  599.    Uint16     RCEH13:1;      // 13  Receive Channel enable bit  
  600.    Uint16     RCEH14:1;      // 14  Receive Channel enable bit  
  601.    Uint16     RCEH15:1;      // 15  Receive Channel enable bit 
  602. }; 
  604. union RCERH_REG {
  605.    Uint16              all;
  606.    struct  RCERH_BITS  bit;
  607. };
  609. // XCERG control register bit definitions:
  610. struct  XCERG_BITS {         // bit description
  611.    Uint16     XCERG0:1;       // 0   Receive Channel enable bit  
  612.    Uint16     XCERG1:1;       // 1   Receive Channel enable bit  
  613.    Uint16     XCERG2:1;       // 2   Receive Channel enable bit  
  614.    Uint16     XCERG3:1;       // 3   Receive Channel enable bit   
  615.    Uint16     XCERG4:1;       // 4   Receive Channel enable bit  
  616.    Uint16     XCERG5:1;       // 5   Receive Channel enable bit  
  617.    Uint16     XCERG6:1;       // 6   Receive Channel enable bit  
  618.    Uint16     XCERG7:1;       // 7   Receive Channel enable bit 
  619.    Uint16     XCERG8:1;       // 8   Receive Channel enable bit  
  620.    Uint16     XCERG9:1;       // 9   Receive Channel enable bit  
  621.    Uint16     XCERG10:1;      // 10  Receive Channel enable bit  
  622.    Uint16     XCERG11:1;      // 11  Receive Channel enable bit 
  623.    Uint16     XCERG12:1;      // 12  Receive Channel enable bit  
  624.    Uint16     XCERG13:1;      // 13  Receive Channel enable bit  
  625.    Uint16     XCERG14:1;      // 14  Receive Channel enable bit  
  626.    Uint16     XCERG15:1;      // 15  Receive Channel enable bit 
  627. }; 
  629. union XCERG_REG {
  630.    Uint16              all;
  631.    struct  XCERG_BITS  bit;
  632. };  
  634. // XCERH control register bit definitions:
  635. struct  XCERH_BITS {         // bit description
  636.    Uint16     XCEH0:1;       // 0   Receive Channel enable bit  
  637.    Uint16     XCEH1:1;       // 1   Receive Channel enable bit  
  638.    Uint16     XCEH2:1;       // 2   Receive Channel enable bit  
  639.    Uint16     XCEH3:1;       // 3   Receive Channel enable bit   
  640.    Uint16     XCEH4:1;       // 4   Receive Channel enable bit  
  641.    Uint16     XCEH5:1;       // 5   Receive Channel enable bit  
  642.    Uint16     XCEH6:1;       // 6   Receive Channel enable bit  
  643.    Uint16     XCEH7:1;       // 7   Receive Channel enable bit 
  644.    Uint16     XCEH8:1;       // 8   Receive Channel enable bit  
  645.    Uint16     XCEH9:1;       // 9   Receive Channel enable bit  
  646.    Uint16     XCEH10:1;      // 10  Receive Channel enable bit  
  647.    Uint16     XCEH11:1;      // 11  Receive Channel enable bit 
  648.    Uint16     XCEH12:1;      // 12  Receive Channel enable bit  
  649.    Uint16     XCEH13:1;      // 13  Receive Channel enable bit  
  650.    Uint16     XCEH14:1;      // 14  Receive Channel enable bit  
  651.    Uint16     XCEH15:1;      // 15  Receive Channel enable bit 
  652. }; 
  654. union XCERH_REG {
  655.    Uint16              all;
  656.    struct  XCERH_BITS  bit;
  657. };
  659. // McBSP FIFO Transmit register bit definitions:
  660. struct  MFFTX_BITS {            // bit   description
  661.    Uint16     TXFFIL:5;         // 4:0   Interrupt level
  662.    Uint16     TXFFIENA:1;       // 5     Interrupt enable
  663.    Uint16     TXFFINT_CLEAR:1;  // 6     Clear INT flag
  664.    Uint16     TXFFINT_FLAG:1;   // 7     INT flag
  665.    Uint16     TXFFST:5;         // 12:8  FIFO status
  666.    Uint16     TXFIFO_RESET:1;   // 13    FIFO reset
  667.    Uint16     MFFENA:1;         // 14    Enhancement enable
  668.    Uint16     rsvd:1;           // 15    reserved
  669. }; 
  671. union MFFTX_REG {
  672.    Uint16            all;
  673.    struct MFFTX_BITS bit;
  674. };
  676. // McBSP FIFO recieve register bit definitions:
  677. struct  MFFRX_BITS {        // bits  description
  678.    Uint16 RXFFIL:5;         // 4:0   Interrupt level
  679.    Uint16 RXFFIENA:1;       // 5     Interrupt enable
  680.    Uint16 RXFFINT_CLEAR:1;  // 6     Clear INT flag
  681.    Uint16 RXFFINT_FLAG:1;   // 7     INT flag
  682.    Uint16 RXFFST:5;         // 12:8  FIFO status
  683.    Uint16 RXFIFO_RESET:1;   // 13    FIFO reset
  684.    Uint16 RXFFOVF_CLEAR:1;  // 14    Clear overflow
  685.    Uint16 RXFFOVF_FLAG:1;   // 15    FIFO overflow
  686. }; 
  688. union MFFRX_REG {
  689.    Uint16            all;
  690.    struct MFFRX_BITS bit;
  691. };
  693. // McBSP FIFO control register bit definitions:
  694. struct  MFFCT_BITS {        // bits  description
  695.     Uint16 FFTXTXDLY:8;     // 7:0   FIFO transmit delay
  696.     Uint16 rsvd:7;          // 15:7  reserved
  697.     Uint16 IACKM:1;         // 15    is IACK mode enable bit
  698. };
  700. union MFFCT_REG {
  701.    Uint16             all;
  702.    struct MFFCT_BITS  bit;
  703. };
  704.    
  705. // McBSP FIFO INTERRUPT control register bit definitions:
  706. struct  MFFINT_BITS {       // bits description
  707.     Uint16     XINT:1;      // 0    XINT  interrupt enable
  708.     Uint16     XEVTA:1;     // 1    XEVTA interrupt enable
  709.     Uint16     RINT:1;      // 2    RINT  interrupt enable
  710.     Uint16     REVTA:1;     // 3    REVTA interrupt enable
  711.     Uint16     rsvd:12;     // 15:4 reserved
  712. };
  714. union MFFINT_REG {
  715.    Uint16              all;
  716.    struct MFFINT_BITS  bit;
  717. };
  719. // McBSP FIFO INTERRUPT status  register bit definitions:
  720. struct  MFFST_BITS {       // bits description
  721.     Uint16     EOBX:1;     // 0    EOBX flag
  722.     Uint16     FSX:1;      // 1    FSX flag
  723.     Uint16     EOBR:1;     // 2    EOBR flag
  724.     Uint16     FSR:1;      // 3    FSR flag
  725.     Uint16     rsvd:12;    // 15:4 reserved
  726. };
  728. union MFFST_REG {
  729.    Uint16            all;
  730.    struct MFFST_BITS bit;
  731. };
  734. //---------------------------------------------------------------------------
  735. // McBSP Register File:
  736. //
  737. struct  MCBSP_REGS {      
  738.    union DRR2_REG    DRR2;   // 0x7800, MCBSP Data receive register bits 31-16 
  739.    union DRR1_REG    DRR1;   // 0x7801, MCBSP Data receive register bits 15-0 
  740.    union DXR2_REG    DXR2;   // 0x7802, MCBSP Data transmit register bits 31-16 
  741.    union DXR1_REG    DXR1;   // 0x7803, MCBSP Data transmit register bits 15-0 
  742.    union SPCR2_REG   SPCR2;  // 0x7804, MCBSP control register bits 31-16 
  743.    union SPCR1_REG   SPCR1;  // 0x7805, MCBSP control register bits 15-0 
  744.    union RCR2_REG    RCR2;   // 0x7806, MCBSP receive control register bits 31-16 
  745.    union RCR1_REG    RCR1;   // 0x7807, MCBSP receive control register bits 15-0 
  746.    union XCR2_REG    XCR2;   // 0x7808, MCBSP transmit control register bits 31-16 
  747.    union XCR1_REG    XCR1;   // 0x7809, MCBSP transmit control register bits 15-0 
  748.    union SRGR2_REG   SRGR2;  // 0x7810, MCBSP sample rate gen register bits 31-16 
  749.    union SRGR1_REG   SRGR1;  // 0x7811, MCBSP sample rate gen register bits 15-0  
  750.    union MCR2_REG    MCR2;   // 0x7812, MCBSP multichannel register bits 31-16 
  751.    union MCR1_REG    MCR1;   // 0x7813, MCBSP multichannel register bits 15-0    
  752.    union RCERA_REG   RCERA;  // 0x7814, MCBSP Receive channel enable partition A 
  753.    union RCERB_REG   RCERB;  // 0x7815, MCBSP Receive channel enable partition B 
  754.    union XCERA_REG   XCERA;  // 0x7816, MCBSP Transmit channel enable partition A 
  755.    union XCERB_REG   XCERB;  // 0x7817, MCBSP Transmit channel enable partition B            
  756.    union PCR_REG     PCR;    // 0x7818, MCBSP Pin control register bits 15-0  
  757.    union RCERC_REG   RCERC;  // 0x7819, MCBSP Receive channel enable partition C 
  758.    union RCERD_REG   RCERD;  // 0x7820, MCBSP Receive channel enable partition D
  759.    union XCERC_REG   XCERC;  // 0x7821, MCBSP Transmit channel enable partition C 
  760.    union XCERD_REG   XCERD;  // 0x7823, MCBSP Transmit channel enable partition D             
  761.    union RCERE_REG   RCERE;  // 0x7824, MCBSP Receive channel enable partition E 
  762.    union RCERF_REG   RCERF;  // 0x7825, MCBSP Receive channel enable partition F
  763.    union XCERE_REG   XCERE;  // 0x7826, MCBSP Transmit channel enable partition E
  764.    union XCERF_REG   XCERF;  // 0x7827, MCBSP Transmit channel enable partition F            
  765.    union RCERG_REG   RCERG;  // 0x7828, MCBSP Receive channel enable partition G
  766.    union RCERH_REG   RCERH;  // 0x7829, MCBSP Receive channel enable partition H
  767.    union XCERG_REG   XCERG;  // 0x7830, MCBSP Transmit channel enable partition G 
  768.    union XCERH_REG   XCERH;  // 0x7831, MCBSP Transmit channel enable partition H             
  769.    Uint16            rsvd1;  // 0x7832, reserved             
  770.    union MFFTX_REG   MFFTX;  // 0x7833, MCBSP Transmit FIFO register bits  
  771.    union MFFRX_REG   MFFRX;  // 0x7834, MCBSP Receive FIFO register bits
  772.    union MFFCT_REG   MFFCT;  // 0x7835, MCBSP FIFO control register bits    
  773.    union MFFINT_REG  MFFINT; // 0x7836, MCBSP Interrupt register bits  
  774.    union MFFST_REG   MFFST;  // 0x7837, MCBSP Status register bits 
  775. };
  777. //---------------------------------------------------------------------------
  778. // McBSP External References & Function Declarations:
  779. //
  780. extern volatile struct MCBSP_REGS McbspaRegs;
  782. #ifdef __cplusplus
  783. }
  784. #endif /* extern "C" */
  786. #endif  // end of DSP281x_MCBSP_H definition
  788. //===========================================================================
  789. // No more.
  790. //===========================================================================