请教at91rm9200读写SRAM（由FPGA定制生成）的问题

cth2008

一块16KB的SRAM，由FPGA定制产生，挂载在数据总线BANk2。
SRAM主要用于存放临时大量待处理的数据，物理地址从0x30000000开始。
在网上找了些资料看了，说是用ioremap先把实际物理内存映射到内核空间，
再用mmap从内核空间映射到用户空间， 在用户空间对SRAM进行读写，提高处理速度。
驱动代码如下：

1. 
   
2. #include <linux/module.h>
   
3. #include <linux/kernel.h>
   
4. #include <linux/errno.h>
   
5. #include <linux/mm.h>
   
6. #include <linux/wrapper.h>  /* for mem_map_(un)reserve */
   
7. #include <asm/io.h>          /* for virt_to_phys */
   
8. #include <linux/slab.h>   /* for kmalloc and kfree */
   
9. #include <linux/init.h>   /* __init __exit */
   
10. #include <linux/ioport.h>   
    
11. #include <asm/uaccess.h> /*copy_from_user */
    
12. 
    
13. #define SRAM_STARTADD  ((volatile unsigned long*)0x30000000L)
    
14. #define SRAM_SIZE  (0x400<<4) //16kB
    
15. 
    
16. volatile  unsigned short * reserve_virt_addr16;
    
17. static struct resource *iomap_wdt_mem=NULL;
    
18. static int major=242;
    
19. 
    
20. int mmapdrv_open(struct inode *inode, struct file *file);
    
21. int mmapdrv_release(struct inode *inode, struct file *file);
    
22. int mmapdrv_mmap(struct file *file, struct vm_area_struct *vma);
    
23. int mmapdrv_ioctl(struct inode *inode, struct file *file,unsigned int cmd, unsigned long arg) ;
    
24. 
    
25. static struct file_operations mmapdrv_fops =
    
26. {
    
27.   owner:   THIS_MODULE,
    
28.   mmap:    mmapdrv_mmap,
    
29.   ioctl:      mmapdrv_ioctl,  
    
30.   open:    mmapdrv_open,
    
31.   release:   mmapdrv_release,
    
32. };
    
33. static int __init mmapdrv_init_module(void)
    
34. {
    
35. int ret;
    
36.   if ( ( register_chrdev(major, "mmapdrv", &mmapdrv_fops) ) < 0 )
    
37.     {
    
38.       printk("mmapdrv: unable to register character device\n");
    
39.       return (-EIO);
    
40.     }
    
41.   //printk("mmap device major = %d\n",major );
    
42.   //printk( "high memory physical address %ldM\n",virt_to_phys(high_memory)/1024/1024 );
    
43. 
    
44.     if(0 == check_mem_region(SRAM_STARTADD,SRAM_SIZE))  
    
45.     {  
    
46.                     printk("check_region oK\n");
    
47.                         if((iomap_wdt_mem=request_mem_region(SRAM_STARTADD,SRAM_SIZE,"mmapdrv"))==NULL)
    
48.                 {
    
49.                         printk("failed to reserve memory region\n");
    
50.                         ret = -ENOENT;
    
51.                         goto err_nomap;
    
52.                 }
    
53.                 else
    
54.                         printk("request_region oK\n");
    
55.                
    
56.                                
    
57.     }  
    
58.    else  
    
59.    {  
    
60.                 printk("iomap from 0x%x num %d busy\n",SRAM_STARTADD,SRAM_SIZE);  
    
61.                 return -1;  
    
62.     }  
    
63. 
    
64.   reserve_virt_addr16 = (short *)ioremap( SRAM_STARTADD,SRAM_SIZE);
    
65. 
    
66.   if ( reserve_virt_addr )
    
67.   {
    
68.   }
    
69.   else
    
70.     {
    
71.       unregister_chrdev( major, "mmapdrv" );
    
72.        printk("ioremap failed\n");  
    
73.         ret = -EINVAL;
    
74.         goto err_nomap;
    
75.     }
    
76. 
    
77.   return 0;
    
78. err_nomap:
    
79.   if(iomap_wdt_mem)
    
80.         release_resource(iomap_wdt_mem);
    
81. err_nores:
    
82.         return ret;
    
83.   
    
84. }
    
85. /* remove the module */
    
86. static void __exit mmapdrv_cleanup_module(void)
    
87. {
    
88.   if ( reserve_virt_addr )
    
89.     iounmap( (void *)reserve_virt_addr );
    
90.   if(iomap_wdt_mem)
    
91.         release_resource(iomap_wdt_mem);
    
92.   unregister_chrdev( major, "mmapdrv" );
    
93.   return;
    
94. }
    
95. int mmapdrv_open(struct inode *inode, struct file *file)
    
96. {
    
97.   MOD_INC_USE_COUNT;
    
98.   return(0);
    
99. }
    
100.   
     
101. int mmapdrv_release(struct inode *inode, struct file *file)
     
102. {
     
103.   MOD_DEC_USE_COUNT;
     
104.   return(0);
     
105. }
     
106. 
     
107. 
     
108. #define IOMAP_WRITE1 1
     
109. #define IOMAP_WRITE2 2
     
110. #define IOMAP_READ1  3
     
111. #define IOMAP_READ2  4
     
112. int mmapdrv_ioctl(struct inode *inode, struct file *file,unsigned int cmd, unsigned long arg)
     
113. {
     
114.         static int i=0;
     
115.         switch(cmd)
     
116.         {
     
117.                 case IOMAP_WRITE1:
     
118.                         {
     
119.                                 for(i=0;i<10;i++)
     
120.                                 {
     
121.                                 *(reserve_virt_addr16+i)=0x55+i;
     
122. 
     
123.                                 }
     
124.                         }
     
125.                         break;
     
126.                 case IOMAP_WRITE2:
     
127.                         {
     
128.                                 short buf[10];
     
129.                                 for(i=0;i<10;i++)
     
130.                                 {
     
131.                                 buf[i]=0x55+i;
     
132.                                 }
     
133.                                 memcpy(reserve_virt_addr16,buf,10*sizeof(short));
     
134.                         }
     
135.                         break;
     
136.                 case IOMAP_READ1:
     
137.                                   {
     
138.                                       int i,j;
     
139.                                       for ( i=0;i<10;i++)
     
140.                                       {
     
141.                                            //printk("[%d]:%d\n",i,reserve_virt_addr16[i]);
     
142.                                            j=*(unsigned short *)(reserve_virt_addr16+i);
     
143.                                           
     
144.                                       }
     
145.                                  }
     
146.                           break;
     
147.                 case IOMAP_READ2:
     
148.                                 {
     
149.                                       short buf[10];
     
150.                                       memcpy(buf,reserve_virt_addr16,10*sizeof(short));
     
151.                                        
     
152.                                 }
     
153.                         break;
     
154.                 default:
     
155.                         printk("default:%d\n",cmd);
     
156.                         break;
     
157.                
     
158.         }
     
159.         return 0;
     
160.        
     
161. }
     
162. 
     
163. int mmapdrv_mmap(struct file *file, struct vm_area_struct *vma)
     
164. {
     
165.   unsigned long offset = vma->vm_pgoff<<PAGE_SHIFT;
     
166.   unsigned long size = vma->vm_end - vma->vm_start;
     
167. 
     
168.   if ( size > SRAM_SIZE )
     
169.     {
     
170.       printk("size too big\n");
     
171.       return(-ENXIO);
     
172.     }
     
173.    
     
174. if (offset >= __pa(high_memory)||file->f_flags & O_SYNC)
     
175. {
     
176.         vma->vm_flags |= VM_IO;//设置vm_flags标记为VM_IO，将VMA标记为一个内存映射的I/O区域
     
177. }
     
178. 
     
179. vma->vm_flags |= VM_RESERVED;//VM_RESERVED标记内存区域不能被换出
     
180.        
     
181. //vma->vm_flags |= VM_LOCKED;
     
182.   offset = offset + SRAM_STARTADD;
     
183.   /* we do not want to have this area swapped out, lock it */
     
184.   if ( remap_page_range(vma->vm_start,offset,size,PAGE_SHARED))
     
185.     {
     
186.       printk("remap page range failed\n");
     
187.       return -ENXIO;
     
188.     }
     
189.   
     
190.   return(0);
     
191. }
     
192. 
     
193. MODULE_PARM(SRAM_STARTADD,"i");
     
194. MODULE_PARM(SRAM_SIZE,"i");
     
195. module_init(mmapdrv_init_module);  
     
196. module_exit(mmapdrv_cleanup_module);  
     
197. 
     
198. MODULE_AUTHOR ("");  
     
199. MODULE_DESCRIPTION ("");  
     
200. MODULE_LICENSE("GPL");  
     
201. //-----------------------------------------------------------------
     
202. 测试代码：
     
203. #include <stdio.h>
     
204. #include <fcntl.h>
     
205. #include <sys/mman.h>
     
206. 
     
207. #define DEV_FILE "/dev/mmapdrv"
     
208. 
     
209. #define SRAM_STARTADD 0x30000000
     
210. #define SRAM_SIZE (0x400<<4) //16kB
     
211. #define MMAP_SIZE (1*1024)
     
212. #define IOMAP_WRITE1 1
     
213. #define IOMAP_WRITE2 2
     
214. #define IOMAP_READ1  3
     
215. #define IOMAP_READ2  4
     
216. int test(int fd ,int cmd,int data)
     
217. {
     
218.         if(ioctl(fd,cmd,(void *)&data)<0)
     
219.         {
     
220.                 printf("ioctl failed\n");
     
221.                 return -1;
     
222.         }
     
223.         return 0;
     
224. }
     
225. int main(int argc ,char **argv)
     
226. {
     
227. int fd;
     
228. int i;
     
229. if(argc<2)
     
230. {
     
231.         return -1;
     
232. }
     
233. fd = open(DEV_FILE, O_RDWR);
     
234. if(!strcmp(argv[1], "-W1"))
     
235. {
     
236.         test(fd,IOMAP_WRITE1,0);
     
237. }
     
238. else if(!strcmp(argv[1], "-W2"))
     
239. {
     
240.         test(fd,IOMAP_WRITE2,0);
     
241. }
     
242. else if(!strcmp(argv[1], "-R1"))
     
243. {
     
244.         test(fd,IOMAP_READ1,0);
     
245. }
     
246. else if(!strcmp(argv[1], "-R2"))
     
247. {
     
248.         test(fd,IOMAP_READ2,0);
     
249. }
     
250. else if(!strcmp(argv[1], "-MMAP"))
     
251. {
     
252.         unsigned short* vadr=NULL;
     
253.         vadr = (short*)mmap(NULL, MMAP_SIZE, PROT_READ|PROT_WRITE , MAP_SHARED, fd, 0);
     
254.         if (vadr == MAP_FAILED)
     
255.         {
     
256.         perror("mmap");
     
257.         exit(-1);
     
258.         }
     
259.         for(i=0;i<10;i++)
     
260.         {
     
261.         *(unsigned short *)(vadr+i)=0xAA+i;
     
262.         }
     
263.         printf("\n");
     
264.        
     
265.         for(i=0;i<10;i++)
     
266.         {
     
267.         printf("[0x%x]",*(unsigned short *)(vadr+i));
     
268.         }
     
269.         printf("\n");
     
270.         munmap(vadr, MMAP_SIZE);
     
271. }
     
272. else
     
273. {
     
274.         printf("error\n");
     
275. }
     
276. 
     
277. close(fd);
     
278. return 0;
     
279. }
     

复制代码

//-----------------------
其中的SRAM是由FPGA定制生成的。
上面对SRAM物理地址的ioremap映射的过程是正确的，
在/proc/iomem中可以查看到映射的物理地址段。
借助FPGA软件可以查看到在内核空间一次写一个字节写数据的时候，片选，地址，写信号线都是正确的，
但是当每次写许多个字节数据的时候，时而出现写信号不对的情况。对SRAM读操作的，不管一次读一个数据还是一次读多个数据信号线都是错误的。
如：
reserve_virt_addr16 = ioremap( SRAM_STARTADD,SRAM_SIZE);
在内核空间写数据操作：
1)这种方式写：分析软件参看正常
int i;
for(i=0;i<10;i++)
*(reserve_virt_addr16+i) =(short)i;
2）这种方式写：分析软件参看出现信号不对
short buf[100];
int i;
for(i=0;i<10;i++)
buf=(short)i;
memcpy(reserve_virt_addr,buf,100*sizeof(char));
在内核空间读数据操作
3)一次读一个：
short c;
int i;
for(i=0;i<10;i++)
c=*(reserve_virt_addr16+i);
4）一次读多个数据：
memcpy(buf,reserve_virt_addr16,100);

5）把SRAM从内核空间用mmap()映射到应用层进行写操作，采用1）或2）方式的写操作，还是3）或4）方式的读操作，软件分析查看都是错误的
请大家帮帮忙啊，为什么会出现上述的不同情况？
6）上面采用不同方式的读写造成时序的变化，是否跟EBI_SMC2_CSR寄存器配置有关，又如何配置该寄存器值？

[ 本帖最后由 cth2008 于 2009-6-12 15:38 编辑 ]

cth2008

help help

star316

太多了,看花眼了, 你先不要MMAP 看看读写数据对不对, 然后再使用MMAP

cth2008

我在内核先对物理地址映射后的虚拟地址进行读写测试，发现用内核提供的读写函数：
unsigned readb(address);
unsigned readw(address);
unsigned readl(address);
void writeb(unsigned value, address);
void writew(unsigned value, address);
void writel(unsigned value, address);
操作，读写正常。
那为什么不能用下面的读写方法呢？
好像只有1）可以
reserve_virt_addr16 = ioremap( SRAM_STARTADD,SRAM_SIZE);
1)这种方式写：分析软件参看正常
int i;
for(i=0;i<10;i++)
*(reserve_virt_addr16+i) =(short)i;
2）这种方式写：分析软件参看出现信号不对
short buf[100];
int i;
for(i=0;i<10;i++)
buf=(short)i;
memcpy(reserve_virt_addr,buf,100*sizeof(char));
在内核空间读数据操作
3)一次读一个：
short c;
int i;
for(i=0;i<10;i++)
c=*(reserve_virt_addr16+i);
4）一次读多个数据：
memcpy(buf,reserve_virt_addr16,100);

cth2008

用2）3）4）方式的读写操作，数据流时而有，时而无，没有规律

cth2008

somebody help ?

ciaobb

学习了~~~~~~~~