microblaze访问LMB和AXI BRAM Controller

joe

BD图如下：

1. #include "xparameters.h"
   
2. #include "xbram.h"
   
3. #include <stdio.h>
   
4. 
   
5. /************************** Constant Definitions *****************************/
   
6. 
   
7. /*
   
8. * The following constants map to the XPAR parameters created in the
   
9. * xparameters.h file. They are defined here such that a user can easily
   
10. * change all the needed parameters in one place.
    
11. */
    
12. #define BRAM_DEVICE_ID                XPAR_BRAM_0_DEVICE_ID
    
13. #define LMB_DEVICE_ID                XPAR_LMB_BRAM_IF_CNTLR_0_DEVICE_ID
    
14. 
    
15. /************************** Function Prototypes ******************************/
    
16. 
    
17. int BramExample(u16 DeviceId);
    
18. static void InitializeECC(XBram_Config *ConfigPtr, u32 EffectiveAddr);
    
19. 
    
20. 
    
21. /************************** Variable Definitions *****************************/
    
22. 
    
23. /*
    
24. * The following are declared globally so they are zeroed and so they are
    
25. * easily accessible from a debugger
    
26. */
    
27. XBram Bram;        /* The Instance of the BRAM Driver */
    
28. XBram lmbBram;
    
29. 
    
30. /****************************************************************************/
    
31. /**
    
32. *
    
33. * This function is the main function of the BRAM example.
    
34. *
    
35. * @param        None.
    
36. *
    
37. * @return
    
38. *                - XST_SUCCESS to indicate success.
    
39. *                - XST_FAILURE to indicate failure.
    
40. *
    
41. * @note                None.
    
42. *
    
43. *****************************************************************************/
    
44. #ifndef TESTAPP_GEN
    
45. int main(void)
    
46. {
    
47.         int Status;
    
48. 
    
49.         Status = BramExample(BRAM_DEVICE_ID);
    
50.         if (Status != XST_SUCCESS ) {
    
51.                 xil_printf("Bram Example Failed\r\n");
    
52.                 return XST_FAILURE;
    
53.         }
    
54. 
    
55.         xil_printf("Successfully ran Bram Example\r\n");
    
56.         return XST_SUCCESS;
    
57. }
    
58. #endif
    
59. 
    
60. /*****************************************************************************/
    
61. /**
    
62. *
    
63. * This is the entry point for the BRAM example.
    
64. *
    
65. * @param        DeviceId is the XPAR_<BRAM_instance>_DEVICE_ID value from
    
66. *                xparameters.h
    
67. *
    
68. * @return
    
69. *                - XST_SUCCESS to indicate success.
    
70. *                - XST_FAILURE to indicate failure.
    
71. *
    
72. * @note                None.
    
73. *
    
74. ******************************************************************************/
    
75. int BramExample(u16 DeviceId)
    
76. {
    
77.         int Status;
    
78.         XBram_Config *ConfigPtr;
    
79. 
    
80.         /*
    
81.          * Initialize the BRAM driver. If an error occurs then exit
    
82.          */
    
83. 
    
84.         /*
    
85.          * Lookup configuration data in the device configuration table.
    
86.          * Use this configuration info down below when initializing this
    
87.          * driver.
    
88.          */
    
89.         ConfigPtr = XBram_LookupConfig(DeviceId);
    
90.         if (ConfigPtr == (XBram_Config *) NULL) {
    
91.                 return XST_FAILURE;
    
92.         }
    
93. 
    
94.         Status = XBram_CfgInitialize(&Bram, ConfigPtr,
    
95.                                      ConfigPtr->CtrlBaseAddress);
    
96.         if (Status != XST_SUCCESS) {
    
97.                 return XST_FAILURE;
    
98.         }
    
99. 
    
100. 
     
101.         InitializeECC(ConfigPtr, ConfigPtr->CtrlBaseAddress);
     
102. 
     
103. 
     
104.         /*
     
105.          * Execute the BRAM driver selftest.
     
106.          */
     
107.         Status = XBram_SelfTest(&Bram, 0);
     
108.         if (Status != XST_SUCCESS) {
     
109.                 return XST_FAILURE;
     
110.         }
     
111.         /********joe code start****************/
     
112.         XBram_Out8(ConfigPtr->MemBaseAddress,(u8)0x36);
     
113.         volatile u8 data = XBram_In8(ConfigPtr->MemBaseAddress);
     
114.         XBram_Out8(ConfigPtr->MemBaseAddress,(u8)0x37);
     
115.         volatile u8 data2 = XBram_In8(ConfigPtr->MemBaseAddress);
     
116. //        if(data != data2)
     
117. //        {
     
118. //                return XST_SUCCESS;
     
119. //        }
     
120. //        else
     
121. //        {
     
122. //                return XST_FAILURE;
     
123. //        }
     
124.         XBram_Config *lmbConfigPtr;
     
125.         lmbConfigPtr = XBram_LookupConfig(LMB_DEVICE_ID);
     
126.                 if (lmbConfigPtr == (XBram_Config *) NULL) {
     
127.                         return XST_FAILURE;
     
128.                 }
     
129. 
     
130.                 Status = XBram_CfgInitialize(&lmbBram, lmbConfigPtr,
     
131.                                 lmbConfigPtr->CtrlBaseAddress);
     
132.                 if (Status != XST_SUCCESS) {
     
133.                         return XST_FAILURE;
     
134.                 }
     
135.                 InitializeECC(lmbConfigPtr, lmbConfigPtr->CtrlBaseAddress);
     
136. //                XBram_Out8(lmbConfigPtr->MemBaseAddress,(u8)0x36);
     
137.                 data2 = XBram_In8(lmbConfigPtr->MemBaseAddress);
     
138.                 XBram_Out8(lmbConfigPtr->MemBaseAddress,(u8)0x37);
     
139.                 data = XBram_In8(lmbConfigPtr->MemBaseAddress);
     
140.                 if(data != data2)
     
141.                 {
     
142.                         return XST_SUCCESS;
     
143.                 }
     
144.                 else
     
145.                 {
     
146.                         return XST_FAILURE;
     
147.                 }
     
148.         /********joe code end****************/
     
149.         return XST_SUCCESS;
     
150. }
     
151. 
     
152. 
     
153. /****************************************************************************/
     
154. /**
     
155. *
     
156. * This function ensures that ECC in the BRAM is initialized if no hardware
     
157. * initialization is available. The ECC bits are initialized by reading and
     
158. * writing data in the memory. This code is not optimized to only read data
     
159. * in initialized sections of the BRAM.
     
160. *
     
161. * @param        ConfigPtr is a reference to a structure containing information
     
162. *                about a specific BRAM device.
     
163. * @param         EffectiveAddr is the device base address in the virtual memory
     
164. *                address space.
     
165. *
     
166. * @return
     
167. *                None
     
168. *
     
169. * @note                None.
     
170. *
     
171. *****************************************************************************/
     
172. void InitializeECC(XBram_Config *ConfigPtr, u32 EffectiveAddr)
     
173. {
     
174.         u32 Addr;
     
175.         volatile u32 Data;
     
176. 
     
177.         if (ConfigPtr->EccPresent &&
     
178.             ConfigPtr->EccOnOffRegister &&
     
179.             ConfigPtr->EccOnOffResetValue == 0 &&
     
180.             ConfigPtr->WriteAccess != 0) {
     
181.                 for (Addr = ConfigPtr->MemBaseAddress;
     
182.                      Addr < ConfigPtr->MemHighAddress; Addr+=4) {
     
183.                         Data = XBram_In32(Addr);
     
184.                         XBram_Out32(Addr, Data);
     
185.                 }
     
186.                 XBram_WriteReg(EffectiveAddr, XBRAM_ECC_ON_OFF_OFFSET, 1);
     
187.         }
     
188. }

复制代码

LMB和axi bram controller都可以访问到各自对应的BRAM中的数据，实验成功。