AXI DMA linux驱动

最新推荐文章于 2024-07-27 11:55:31 发布
最新推荐文章于 2024-07-27 11:55:31 发布
阅读量1.7k 收藏 7
点赞数
原文链接：https://blog.csdn.net/shichaog/article/details/51771247
版权


1.PL端设计：

PL端设计包括四个AXI DMA IP，它们分别和zynq处理IP的HP口相连接。

这个设计是基于Avnet-Digilent-ZedBoard-v2016.1-final.bsp，由于其它的ip都是xilinx开发环境开发环境就有，所以这里就不详细每一步设计过程了。

这些IP包括AXI interconnect， system reset，axi dma，concat。

注意concat是用来将AXI DMA的中断传递给zynq之用的，这是必须有的，否则在hdf导入时，会出现如下错误：

2 接下来是创建module和app了


这两个命令执行后，会分配在components/apps和components/modules目录下生成dmaBench和ds_axidma两个文件夹，该文件下的两个文件内容使用如下的文件替换。


 
 
  1. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     《dmaBench.c》
    
    
    
   
   
  2. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     #include <stdio.h>
    
    
    
   
   
  3. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     #include <fcntl.h>
    
    
    
   
   
  4. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     #include <string.h>
    
    
    
   
   
  5. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     #include <stdlib.h>
    
    
    
   
   
  6. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     #include <sys/time.h>
    
    
    
   
   
  7. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  8. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     unsigned 
     
     long tStart, tEnd;
    
    
    
   
   
  9. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     unsigned 
     
     long data;
    
    
    
   
   
  10. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  11. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     unsigned long getTime(){
    
    
    
   
   
  12. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     struct timeval temp;
    
    
    
   
   
  13. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  14. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	gettimeofday(&temp, 
     
     NULL);
    
    
    
   
   
  15. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  16. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     return temp.tv_sec * 
     
     1000 * 
     
     1000 + temp.tv_usec;
    
    
    
   
   
  17. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     }
    
    
    
   
   
  18. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  19. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     void report(char *msg, unsigned long data, unsigned long time, unsigned long dmaUsed){
    
    
    
   
   
  20. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     printf(
     
     "%s\t%ld\t%ld\t%f\t%d\n", msg, data, time, data * 
     
     1.0 / time, dmaUsed);
    
    
    
   
   
  21. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	FILE *f = fopen(
     
     "report.dat", 
     
     "a");
    
    
    
   
   
  22. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     fprintf(f, 
     
     "%s\t%ld\t%ld\t%f\t%d\n", msg, data, time, data * 
     
     1.0 / time, dmaUsed);
    
    
    
   
   
  23. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	fclose(f);
    
    
    
   
   
  24. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     }
    
    
    
   
   
  25. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  26. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     #define REPORT(f, timeStart, timeEnd, dataPtr, msg, dmaUsed) *timeStart = getTime(); *dataPtr = f; *timeEnd = getTime(); report(msg, *dataPtr, *timeEnd - *timeStart, dmaUsed);
    
    
    
   
   
  27. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  28. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     void checkData(char *bufferIn, char *bufferOut, unsigned int elems){
    
    
    
   
   
  29. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     int i;
    
    
    
   
   
  30. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  31. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     if(!
     
     memcmp(bufferIn, bufferOut, elems*
     
     sizeof(
     
     char))){
    
    
    
   
   
  32. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    		
     
     printf(
     
     "DMA Ok!\n");
    
    
    
   
   
  33. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	}
    
    
    
   
   
  34. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     else{
    
    
    
   
   
  35. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    		
     
     for(i=
     
     0;i<elems;i++)
    
    
    
   
   
  36. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    			
     
     printf(
     
     "%d\t%d\t%d\t%d\n", i, bufferIn[i], bufferOut[i], (i==
     
     0 ? 
     
     0 : bufferOut[i] - bufferOut[i
     
     -1]));
    
    
    
   
   
  37. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	}
    
    
    
   
   
  38. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     }
    
    
    
   
   
  39. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  40. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     unsigned long memCpy_ARM(char *bufferIn, char *bufferOut, unsigned long elems, size_t size){
    
    
    
   
   
  41. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     int i;
    
    
    
   
   
  42. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  43. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     for(i=
     
     0; i<elems; i++)
    
    
    
   
   
  44. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     		bufferOut[i] = bufferIn[i];
    
    
    
   
   
  45. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  46. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     return elems * size;
    
    
    
   
   
  47. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     }
    
    
    
   
   
  48. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  49. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     unsigned long memCpy_DMA(char *bufferIn, char *bufferOut, unsigned long elems, size_t size, int dmaToUse){
    
    
    
   
   
  50. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  51. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     #define FIFO_LEN 4000
    
    
    
   
   
  52. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     #define DMA_NUM 4
    
    
    
   
   
  53. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  54. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     int fd[DMA_NUM];
    
    
    
   
   
  55. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  56. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	fd[
     
     0] = open(
     
     "/dev/axi_dma_0", O_RDWR);
    
    
    
   
   
  57. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	fd[
     
     1] = open(
     
     "/dev/axi_dma_1", O_RDWR);
    
    
    
   
   
  58. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	fd[
     
     2] = open(
     
     "/dev/axi_dma_2", O_RDWR);
    
    
    
   
   
  59. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	fd[
     
     3] = open(
     
     "/dev/axi_dma_3", O_RDWR);
    
    
    
   
   
  60. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  61. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     unsigned 
     
     long byteMoved = 
     
     0;
    
    
    
   
   
  62. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     unsigned 
     
     long byteToMove = 
     
     0;
    
    
    
   
   
  63. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  64. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     int i;
    
    
    
   
   
  65. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  66. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     while(byteMoved!=size * elems){
    
    
    
   
   
  67. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     		byteToMove = size * elems - byteMoved > FIFO_LEN ? FIFO_LEN : size * elems - byteMoved;
    
    
    
   
   
  68. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  69. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    		
     
     for(i=
     
     0; i<dmaToUse; i++){
    
    
    
   
   
  70. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     			write(fd[i], &bufferIn[byteMoved], byteToMove);
    
    
    
   
   
  71. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     		}
    
    
    
   
   
  72. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  73. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    		
     
     for(i=
     
     0; i<dmaToUse; i++)
    
    
    
   
   
  74. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     			read(fd[i], &bufferOut[byteMoved], byteToMove);
    
    
    
   
   
  75. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  76. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     		byteMoved += byteToMove;
    
    
    
   
   
  77. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	}
    
    
    
   
   
  78. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  79. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	close(fd[
     
     0]);
    
    
    
   
   
  80. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	close(fd[
     
     1]);
    
    
    
   
   
  81. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	close(fd[
     
     2]);
    
    
    
   
   
  82. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	close(fd[
     
     3]);
    
    
    
   
   
  83. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  84. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     return elems * size * dmaToUse;
    
    
    
   
   
  85. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     }
    
    
    
   
   
  86. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  87. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     int main(int argc, char **argv)
    
    
    
   
   
  88. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     {
    
    
    
   
   
  89. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
     
     char *bufferIn, *bufferOut_ARM, *bufferOut_DMA;
    
    
    
   
   
  90. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  91. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
     
     if(argc!=
     
     3){
    
    
    
   
   
  92. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        	
     
     printf(
     
     "Usage: ./dmaBench DATA DMA_TO_USE\n");
    
    
    
   
   
  93. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        	
     
     exit(
     
     0);
    
    
    
   
   
  94. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         }
    
    
    
   
   
  95. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  96. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
     
     unsigned 
     
     long DATA = atoi(argv[
     
     1]);
    
    
    
   
   
  97. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
     
     unsigned 
     
     int DMA_TO_USE = atoi(argv[
     
     2]);
    
    
    
   
   
  98. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  99. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         bufferIn = (
     
     char *) 
     
     malloc(
     
     sizeof(
     
     char) * DATA);
    
    
    
   
   
  100. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         bufferOut_ARM = (
     
     char *) 
     
     malloc(
     
     sizeof(
     
     char) * DATA);
    
    
    
   
   
  101. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         bufferOut_DMA = (
     
     char *) 
     
     malloc(
     
     sizeof(
     
     char) * DATA);
    
    
    
   
   
  102. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  103. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
     
     int i;
    
    
    
   
   
  104. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  105. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
     
     for(i=
     
     0; i<DATA; i++){
    
    
    
   
   
  106. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         	bufferIn[i] = i;
    
    
    
   
   
  107. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         }
    
    
    
   
   
  108. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  109. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
     
     memset(bufferOut_ARM, 
     
     0, 
     
     sizeof(
     
     char) * DATA);
    
    
    
   
   
  110. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
     
     memset(bufferOut_DMA, 
     
     0, 
     
     sizeof(
     
     char) * DATA);
    
    
    
   
   
  111. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  112. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         REPORT(memCpy_ARM(bufferIn, bufferOut_ARM, DATA, 
     
     sizeof(
     
     char)), &tStart, &tEnd, &data, 
     
     "ARM", 
     
     0);
    
    
    
   
   
  113. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
     
     for(i=
     
     0; i<DMA_TO_USE; i++){
    
    
    
   
   
  114. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         	REPORT(memCpy_DMA(bufferIn, bufferOut_DMA, DATA/(i+
     
     1), 
     
     sizeof(
     
     char), (i+
     
     1)), &tStart, &tEnd, &data, 
     
     "DMA", (i+
     
     1));
    
    
    
   
   
  115. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         }
    
    
    
   
   
  116. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  117. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         checkData(bufferIn, bufferOut_ARM, DATA);
    
    
    
   
   
  118. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         checkData(bufferIn, bufferOut_DMA, DATA);
    
    
    
   
   
  119. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  120. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
     
     return 
     
     0;
    
    
    
   
   
  121. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     }
和<ds_axidma> 


 
 
  1. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     /*
    
    
    
   
   
  2. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
      * Xilinx AXI DMA Driver
    
    
    
   
   
  3. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
      *
    
    
    
   
   
  4. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
      * Authors: 
    
    
    
   
   
  5. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
      *    Fabrizio Spada - fabrizio.spada@mail.polimi.it
    
    
    
   
   
  6. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
      *    Gianluca Durelli - durelli@elet.polimi.it
    
    
    
   
   
  7. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
      *    Politecnico di Milano
    
    
    
   
   
  8. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
      *
    
    
    
   
   
  9. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
      * This is free software; you can redistribute it and/or modify
    
    
    
   
   
  10. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
      * it under the terms of the GNU General Public License as published by
    
    
    
   
   
  11. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
      * the Free Software Foundation; either version 2 of the License, or
    
    
    
   
   
  12. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
      * (at your option) any later version.
    
    
    
   
   
  13. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
      */
    
    
    
   
   
  14. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  15. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     #include <linux/module.h>
    
    
    
   
   
  16. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     #include <linux/version.h>
    
    
    
   
   
  17. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     #include <linux/kernel.h>
    
    
    
   
   
  18. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     #include <linux/types.h>
    
    
    
   
   
  19. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     #include <linux/kdev_t.h>
    
    
    
   
   
  20. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     #include <linux/fs.h>
    
    
    
   
   
  21. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     #include <linux/list.h>
    
    
    
   
   
  22. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     #include <linux/device.h>
    
    
    
   
   
  23. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     #include <linux/cdev.h>
    
    
    
   
   
  24. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     #include <linux/dma-mapping.h>
    
    
    
   
   
  25. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     #include <linux/pm_runtime.h>
    
    
    
   
   
  26. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     #include <linux/slab.h>
    
    
    
   
   
  27. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     #include <linux/of.h>
    
    
    
   
   
  28. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     #include <linux/of_platform.h>
    
    
    
   
   
  29. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     #include <linux/of_address.h>
    
    
    
   
   
  30. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     #include <linux/mm.h>
    
    
    
   
   
  31. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     #include <asm/io.h>
    
    
    
   
   
  32. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  33. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     #define MM2S_DMACR	0x00
    
    
    
   
   
  34. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     #define MM2S_DMASR	0x04
    
    
    
   
   
  35. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     #define MM2S_SA	0x18
    
    
    
   
   
  36. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     #define MM2S_LENGTH	0x28
    
    
    
   
   
  37. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  38. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     #define S2MM_DMACR	0x30
    
    
    
   
   
  39. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     #define S2MM_DMASR	0x34
    
    
    
   
   
  40. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     #define S2MM_DA	0x48
    
    
    
   
   
  41. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     #define S2MM_LENGTH	0x58
    
    
    
   
   
  42. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  43. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     #define DRIVER_NAME "ds_axidma_pdrv"
    
    
    
   
   
  44. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     #define MODULE_NAME "ds_axidma"
    
    
    
   
   
  45. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  46. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     #define DMA_LENGTH	(32*1024)
    
    
    
   
   
  47. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  48. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     static 
     
     struct class *cl;	
     
     // Global variable for the device class 
    
    
    
   
   
  49. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  50. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     struct ds_axidma_device
    
    
    
   
   
  51. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     {
    
    
    
   
   
  52. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     phys_addr_t bus_addr;
    
    
    
   
   
  53. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     unsigned 
     
     long bus_size;
    
    
    
   
   
  54. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     char *virt_bus_addr;
    
    
    
   
   
  55. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     dev_t dev_num;
    
    
    
   
   
  56. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     const 
     
     char *dev_name;
    
    
    
   
   
  57. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     struct cdev c_dev;
    
    
    
   
   
  58. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     char *ds_axidma_addr;
    
    
    
   
   
  59. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     dma_addr_t ds_axidma_handle;
    
    
    
   
   
  60. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  61. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     struct list_head dev_list;
    
    
    
   
   
  62. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     };
    
    
    
   
   
  63. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     LIST_HEAD( full_dev_list );
    
    
    
   
   
  64. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  65. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     static struct ds_axidma_device *get_elem_from_list_by_inode(struct inode *i)
    
    
    
   
   
  66. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     {
    
    
    
   
   
  67. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     struct list_head *pos;
    
    
    
   
   
  68. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     struct ds_axidma_device *obj_dev = NULL;
    
    
    
   
   
  69. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	list_for_each( pos, &full_dev_list ) {
    
    
    
   
   
  70. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    		
     
     struct ds_axidma_device *tmp;
    
    
    
   
   
  71. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         	tmp = list_entry( pos, struct ds_axidma_device, dev_list );
    
    
    
   
   
  72. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        	
     
     if (tmp->dev_num == i->i_rdev)
    
    
    
   
   
  73. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         	{
    
    
    
   
   
  74. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         		obj_dev = tmp;
    
    
    
   
   
  75. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        		
     
     break;
    
    
    
   
   
  76. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         	}
    
    
    
   
   
  77. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
       	}
    
    
    
   
   
  78. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
      	
     
     return obj_dev;	
    
    
    
   
   
  79. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     }
    
    
    
   
   
  80. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     // static void dmaHalt(void){
    
    
    
   
   
  81. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     // 	unsigned long mm2s_halt = ioread32(virt_bus_addr + MM2S_DMASR) & 0x1;
    
    
    
   
   
  82. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     // 	unsigned long s2mm_halt = ioread32(virt_bus_addr + S2MM_DMASR) & 0x1;
    
    
    
   
   
  83. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     // 	int count = 0;
    
    
    
   
   
  84. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     // 	printk(KERN_INFO "Halting...\n");
    
    
    
   
   
  85. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     // 	iowrite32(0, virt_bus_addr + S2MM_DMACR);
    
    
    
   
   
  86. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     // 	iowrite32(0, virt_bus_addr + MM2S_DMACR);
    
    
    
   
   
  87. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     // 	while( !mm2s_halt || !s2mm_halt){
    
    
    
   
   
  88. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     // 		// mm2s_halt = ioread32(virt_bus_addr + MM2S_DMASR) & 0x1;
    
    
    
   
   
  89. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     // 		mm2s_halt = virt_bus_addr[MM2S_DMASR] & 0x1;
    
    
    
   
   
  90. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     // 		//s2mm_halt = ioread32(virt_bus_addr + S2MM_DMASR) & 0x1;
    
    
    
   
   
  91. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     // 		s2mm_halt = virt_bus_addr[S2MM_DMASR] & 0x1;
    
    
    
   
   
  92. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     // 		count++;
    
    
    
   
   
  93. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     // 		if (count>100 )
    
    
    
   
   
  94. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     // 		{
    
    
    
   
   
  95. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     // 			break;
    
    
    
   
   
  96. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     // 		}
    
    
    
   
   
  97. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     // 	}
    
    
    
   
   
  98. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  99. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     // 	printk(KERN_INFO "DMA Halted!\n");
    
    
    
   
   
  100. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     // }
    
    
    
   
   
  101. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  102. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     static int my_strcmp(const char *str1, const char *str2)
    
    
    
   
   
  103. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     {
    
    
    
   
   
  104. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
      
     
     int i;
    
    
    
   
   
  105. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
       i = 
     
     0;
    
    
    
   
   
  106. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
      
     
     while (str1[i] || str2[i])
    
    
    
   
   
  107. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         {
    
    
    
   
   
  108. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
          
     
     if (str1[i] != str2[i])
    
    
    
   
   
  109. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
            
     
     return (str1[i] - str2[i]);
    
    
    
   
   
  110. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
           i++;
    
    
    
   
   
  111. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         }
    
    
    
   
   
  112. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
      
     
     return (
     
     0);
    
    
    
   
   
  113. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     }
    
    
    
   
   
  114. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  115. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     static int dmaSynchMM2S(struct ds_axidma_device *obj_dev){
    
    
    
   
   
  116. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     //	sleep(6);
    
    
    
   
   
  117. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     //	return;
    
    
    
   
   
  118. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  119. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     unsigned 
     
     int mm2s_status = ioread32(obj_dev->virt_bus_addr + MM2S_DMASR);
    
    
    
   
   
  120. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     while(!(mm2s_status & 
     
     1<<
     
     12) || !(mm2s_status & 
     
     1<<
     
     1) ){
    
    
    
   
   
  121. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     		mm2s_status = ioread32(obj_dev->virt_bus_addr + MM2S_DMASR);
    
    
    
   
   
  122. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  123. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	}
    
    
    
   
   
  124. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     return 
     
     0;
    
    
    
   
   
  125. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     }
    
    
    
   
   
  126. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  127. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     static int dmaSynchS2MM(struct ds_axidma_device *obj_dev){
    
    
    
   
   
  128. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     unsigned 
     
     int s2mm_status = ioread32(obj_dev->virt_bus_addr + S2MM_DMASR);
    
    
    
   
   
  129. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     while(!(s2mm_status & 
     
     1<<
     
     12) || !(s2mm_status & 
     
     1<<
     
     1)){
    
    
    
   
   
  130. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     		s2mm_status = ioread32(obj_dev->virt_bus_addr + S2MM_DMASR);
    
    
    
   
   
  131. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	}
    
    
    
   
   
  132. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     return 
     
     0;
    
    
    
   
   
  133. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     }
    
    
    
   
   
  134. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  135. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     static int ds_axidma_open(struct inode *i, struct file *f)
    
    
    
   
   
  136. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     {
    
    
    
   
   
  137. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     /* printk(KERN_INFO "<%s> file: open()\n", MODULE_NAME); */
    
    
    
   
   
  138. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     struct ds_axidma_device *obj_dev = get_elem_from_list_by_inode(i);
    
    
    
   
   
  139. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     if (!request_mem_region(obj_dev->bus_addr, obj_dev->bus_size, MODULE_NAME))
    
    
    
   
   
  140. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	{
    
    
    
   
   
  141. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    		
     
     return 
     
     -1;
    
    
    
   
   
  142. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	}	
    
    
    
   
   
  143. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	obj_dev->virt_bus_addr = (
     
     char *) ioremap_nocache(obj_dev->bus_addr, obj_dev->bus_size);
    
    
    
   
   
  144. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     return 
     
     0;
    
    
    
   
   
  145. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     }
    
    
    
   
   
  146. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  147. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     static int ds_axidma_close(struct inode *i, struct file *f)
    
    
    
   
   
  148. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     {
    
    
    
   
   
  149. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     /* printk(KERN_INFO "<%s> file: close()\n", MODULE_NAME); */
    
    
    
   
   
  150. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     struct ds_axidma_device *obj_dev = get_elem_from_list_by_inode(i);
    
    
    
   
   
  151. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	iounmap(obj_dev->virt_bus_addr);
    
    
    
   
   
  152. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	release_mem_region(obj_dev->bus_addr, obj_dev->bus_size);
    
    
    
   
   
  153. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     return 
     
     0;
    
    
    
   
   
  154. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     }
    
    
    
   
   
  155. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  156. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     static ssize_t ds_axidma_read(struct file *f, char __user * buf, size_t
    
    
    
   
   
  157. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     			 len, 
     
     loff_t * off)
    
    
    
   
   
  158. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     {
    
    
    
   
   
  159. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     /* printk(KERN_INFO "<%s> file: read()\n", MODULE_NAME); */
    
    
    
   
   
  160. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     struct ds_axidma_device *obj_dev;
    
    
    
   
   
  161. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     if (len >= DMA_LENGTH)
    
    
    
   
   
  162. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	{
    
    
    
   
   
  163. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    		
     
     return 
     
     0;
    
    
    
   
   
  164. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	}
    
    
    
   
   
  165. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	obj_dev = get_elem_from_list_by_inode(f->f_inode);
    
    
    
   
   
  166. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	iowrite32(
     
     1, obj_dev->virt_bus_addr + S2MM_DMACR);
    
    
    
   
   
  167. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	iowrite32(obj_dev->ds_axidma_handle, obj_dev->virt_bus_addr + S2MM_DA);
    
    
    
   
   
  168. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	iowrite32(len, obj_dev->virt_bus_addr + S2MM_LENGTH);
    
    
    
   
   
  169. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	dmaSynchS2MM(obj_dev);
    
    
    
   
   
  170. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     memcpy(buf, obj_dev->ds_axidma_addr, len);
    
    
    
   
   
  171. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     return len;
    
    
    
   
   
  172. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     }
    
    
    
   
   
  173. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  174. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     static ssize_t ds_axidma_write(struct file *f, const char __user * buf,
    
    
    
   
   
  175. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    			  
     
     size_t len, 
     
     loff_t * off)
    
    
    
   
   
  176. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     {
    
    
    
   
   
  177. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     /* printk(KERN_INFO "<%s> file: write()\n", MODULE_NAME); */
    
    
    
   
   
  178. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  179. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     struct ds_axidma_device *obj_dev;
    
    
    
   
   
  180. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     if (len >= DMA_LENGTH)
    
    
    
   
   
  181. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	{
    
    
    
   
   
  182. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    		
     
     return 
     
     0;
    
    
    
   
   
  183. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	}
    
    
    
   
   
  184. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  185. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	obj_dev = get_elem_from_list_by_inode(f->f_inode);
    
    
    
   
   
  186. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     memcpy(obj_dev->ds_axidma_addr, buf, len);
    
    
    
   
   
  187. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  188. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     // printk(KERN_INFO "%X\n", ioread32(virt_bus_addr + MM2S_DMASR));
    
    
    
   
   
  189. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     // printk(KERN_INFO "%X\n", ioread32(virt_bus_addr + MM2S_DMACR));
    
    
    
   
   
  190. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     // printk(KERN_INFO "%X\n", ioread32(virt_bus_addr + S2MM_DMASR));
    
    
    
   
   
  191. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     // printk(KERN_INFO "%X\n", ioread32(virt_bus_addr + S2MM_DMACR));
    
    
    
   
   
  192. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  193. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	iowrite32(
     
     1, obj_dev->virt_bus_addr + MM2S_DMACR);
    
    
    
   
   
  194. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	iowrite32(obj_dev->ds_axidma_handle, obj_dev->virt_bus_addr + MM2S_SA);
    
    
    
   
   
  195. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	iowrite32(len, obj_dev->virt_bus_addr + MM2S_LENGTH);
    
    
    
   
   
  196. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  197. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     // dmaSynchMM2S(obj_dev);
    
    
    
   
   
  198. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  199. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     // printk(KERN_INFO "%X\n", ioread32(virt_bus_addr + MM2S_DMASR));
    
    
    
   
   
  200. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     // printk(KERN_INFO "%X\n", ioread32(virt_bus_addr + MM2S_DMACR));
    
    
    
   
   
  201. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     // printk(KERN_INFO "%X\n", ioread32(virt_bus_addr + S2MM_DMASR));
    
    
    
   
   
  202. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     // printk(KERN_INFO "%X\n", ioread32(virt_bus_addr + S2MM_DMACR));	
    
    
    
   
   
  203. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     // printk(KERN_INFO "%X\n", bus_addr);
    
    
    
   
   
  204. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     // printk(KERN_INFO "%lu\n", bus_size);
    
    
    
   
   
  205. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  206. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     return len;
    
    
    
   
   
  207. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     }
    
    
    
   
   
  208. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  209. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     static 
     
     struct file_operations fops = {
    
    
    
   
   
  210. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	.owner = THIS_MODULE,
    
    
    
   
   
  211. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	.open = ds_axidma_open,
    
    
    
   
   
  212. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	.release = ds_axidma_close,
    
    
    
   
   
  213. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	.read = ds_axidma_read,
    
    
    
   
   
  214. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	.write = ds_axidma_write,
    
    
    
   
   
  215. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     /* .mmap = ds_axidma_mmap, */
    
    
    
   
   
  216. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     /* .unlocked_ioctl = ds_axidma_ioctl, */
    
    
    
   
   
  217. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     };
    
    
    
   
   
  218. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  219. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     static int ds_axidma_pdrv_probe(struct platform_device *pdev)
    
    
    
   
   
  220. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     {
    
    
    
   
   
  221. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     /* device constructor */
    
    
    
   
   
  222. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     struct ds_axidma_device *obj_dev = (struct ds_axidma_device *)
    
    
    
   
   
  223. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
                
     
     kmalloc( 
     
     sizeof(
     
     struct 
     
     ds_axidma_device), 
     
     GFP_KERNEL );
    
    
    
   
   
  224. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         obj_dev->bus_addr = pdev->resource[
     
     0].start;
    
    
    
   
   
  225. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         obj_dev->bus_size = pdev->resource[
     
     0].end - pdev->resource[
     
     0].start + 
     
     1;
    
    
    
   
   
  226. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	obj_dev->dev_name = pdev->name + 
     
     9;
    
    
    
   
   
  227. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
    
    
    
   
   
  228. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	printk(KERN_INFO 
     
     "<%s> init: registered\n", obj_dev->dev_name);
    
    
    
   
   
  229. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     if (alloc_chrdev_region(&(obj_dev->dev_num), 
     
     0, 
     
     1, obj_dev->dev_name) < 
     
     0) {
    
    
    
   
   
  230. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    		
     
     return 
     
     -1;
    
    
    
   
   
  231. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	}
    
    
    
   
   
  232. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     if (cl == 
     
     NULL && (cl = class_create(THIS_MODULE, 
     
     "chardrv")) == 
     
     NULL) {
    
    
    
   
   
  233. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     		unregister_chrdev_region(obj_dev->dev_num, 
     
     1);
    
    
    
   
   
  234. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    		
     
     return 
     
     -1;
    
    
    
   
   
  235. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	}
    
    
    
   
   
  236. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     if (device_create(cl, 
     
     NULL, obj_dev->dev_num, 
     
     NULL, obj_dev->dev_name) == 
     
     NULL) {
    
    
    
   
   
  237. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     		class_destroy(cl);
    
    
    
   
   
  238. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     		unregister_chrdev_region(obj_dev->dev_num, 
     
     1);
    
    
    
   
   
  239. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    		
     
     return 
     
     -1;
    
    
    
   
   
  240. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	}
    
    
    
   
   
  241. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	cdev_init(&(obj_dev->c_dev), &fops);
    
    
    
   
   
  242. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     if (cdev_add(&(obj_dev->c_dev), obj_dev->dev_num, 
     
     1) == 
     
     -1) {
    
    
    
   
   
  243. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     		device_destroy(cl, obj_dev->dev_num);
    
    
    
   
   
  244. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     		class_destroy(cl);
    
    
    
   
   
  245. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     		unregister_chrdev_region(obj_dev->dev_num, 
     
     1);
    
    
    
   
   
  246. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    		
     
     return 
     
     -1;
    
    
    
   
   
  247. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	}
    
    
    
   
   
  248. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  249. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	printk(KERN_INFO 
     
     "DMA_LENGTH = %u \n", DMA_LENGTH);
    
    
    
   
   
  250. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     /* allocate mmap area */
    
    
    
   
   
  251. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	obj_dev->ds_axidma_addr =
    
    
    
   
   
  252. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	    dma_zalloc_coherent(
     
     NULL, DMA_LENGTH, &(obj_dev->ds_axidma_handle), GFP_KERNEL);
    
    
    
   
   
  253. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	list_add( &obj_dev->dev_list, &full_dev_list );
    
    
    
   
   
  254. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     return 
     
     0;
    
    
    
   
   
  255. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     }
    
    
    
   
   
  256. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  257. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     static int ds_axidma_pdrv_remove(struct platform_device *pdev)
    
    
    
   
   
  258. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     {
    
    
    
   
   
  259. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     /* device destructor */
    
    
    
   
   
  260. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     struct list_head *pos, *q;
    
    
    
   
   
  261. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	list_for_each_safe( pos, q, &full_dev_list ) {
    
    
    
   
   
  262. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    		
     
     struct ds_axidma_device *obj_dev;
    
    
    
   
   
  263. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         	obj_dev = list_entry( pos, struct ds_axidma_device, dev_list );
    
    
    
   
   
  264. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        	
     
     if (!my_strcmp(obj_dev->dev_name, pdev->name + 
     
     9))
    
    
    
   
   
  265. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         	{
    
    
    
   
   
  266. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         		list_del( pos );
    
    
    
   
   
  267. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         		cdev_del(&(obj_dev->c_dev));
    
    
    
   
   
  268. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         		device_destroy(cl, obj_dev->dev_num);
    
    
    
   
   
  269. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         		unregister_chrdev_region(obj_dev->dev_num, 
     
     1);
    
    
    
   
   
  270. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        		
     
     /* free mmap area */
    
    
    
   
   
  271. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    			
     
     if (obj_dev->ds_axidma_addr) {
    
    
    
   
   
  272. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     				dma_free_coherent(
     
     NULL, DMA_LENGTH, obj_dev->ds_axidma_addr, obj_dev->ds_axidma_handle);
    
    
    
   
   
  273. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     			}
    
    
    
   
   
  274. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         		kfree(obj_dev);
    
    
    
   
   
  275. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        		
     
     break;
    
    
    
   
   
  276. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         	}
    
    
    
   
   
  277. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
       	}
    
    
    
   
   
  278. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
      	
     
     if (list_empty(&full_dev_list))
    
    
    
   
   
  279. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
       	{
    
    
    
   
   
  280. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
       		class_destroy(cl);
    
    
    
   
   
  281. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
       	}
    
    
    
   
   
  282. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	printk(KERN_INFO 
     
     "<%s> exit: unregistered\n", MODULE_NAME);
    
    
    
   
   
  283. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     return 
     
     0;
    
    
    
   
   
  284. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     }
    
    
    
   
   
  285. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  286. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     static int ds_axidma_pdrv_runtime_nop(struct device *dev)
    
    
    
   
   
  287. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     {
    
    
    
   
   
  288. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     /* Runtime PM callback shared between ->runtime_suspend()
    
    
    
   
   
  289. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	 * and ->runtime_resume(). Simply returns success.
    
    
    
   
   
  290. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	 *
    
    
    
   
   
  291. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	 * In this driver pm_runtime_get_sync() and pm_runtime_put_sync()
    
    
    
   
   
  292. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	 * are used at open() and release() time. This allows the
    
    
    
   
   
  293. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	 * Runtime PM code to turn off power to the device while the
    
    
    
   
   
  294. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	 * device is unused, ie before open() and after release().
    
    
    
   
   
  295. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	 *
    
    
    
   
   
  296. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	 * This Runtime PM callback does not need to save or restore
    
    
    
   
   
  297. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	 * any registers since user space is responsbile for hardware
    
    
    
   
   
  298. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	 * register reinitialization after open().
    
    
    
   
   
  299. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	 */
    
    
    
   
   
  300. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     return 
     
     0;
    
    
    
   
   
  301. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     }
    
    
    
   
   
  302. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  303. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     static 
     
     const 
     
     struct dev_pm_ops ds_axidma_pdrv_dev_pm_ops = {
    
    
    
   
   
  304. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	.runtime_suspend = ds_axidma_pdrv_runtime_nop,
    
    
    
   
   
  305. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	.runtime_resume = ds_axidma_pdrv_runtime_nop,
    
    
    
   
   
  306. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     };
    
    
    
   
   
  307. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  308. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     static 
     
     struct of_device_id ds_axidma_of_match[] = {
    
    
    
   
   
  309. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	{ .compatible = 
     
     "ds_axidma", },
    
    
    
   
   
  310. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	{ 
     
     /* This is filled with module_parm */ },
    
    
    
   
   
  311. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	{ 
     
     /* Sentinel */ },
    
    
    
   
   
  312. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     };
    
    
    
   
   
  313. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     MODULE_DEVICE_TABLE(of, ds_axidma_of_match);
    
    
    
   
   
  314. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     module_param_string(of_id, ds_axidma_of_match[
     
     1].compatible, 
     
     128, 
     
     0);
    
    
    
   
   
  315. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     MODULE_PARM_DESC(of_id, 
     
     "Openfirmware id of the device to be handled by uio");
    
    
    
   
   
  316. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  317. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     static 
     
     struct platform_driver ds_axidma_pdrv = {
    
    
    
   
   
  318. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	.probe = ds_axidma_pdrv_probe,
    
    
    
   
   
  319. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	.remove = ds_axidma_pdrv_remove,
    
    
    
   
   
  320. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	.driver = {
    
    
    
   
   
  321. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     		.name = DRIVER_NAME,
    
    
    
   
   
  322. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     		.owner = THIS_MODULE,
    
    
    
   
   
  323. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     		.pm = &ds_axidma_pdrv_dev_pm_ops,
    
    
    
   
   
  324. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     		.of_match_table = of_match_ptr(ds_axidma_of_match),
    
    
    
   
   
  325. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	},
    
    
    
   
   
  326. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     };
    
    
    
   
   
  327. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  328. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     module_platform_driver(ds_axidma_pdrv);
    
    
    
   
   
  329. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  330. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     MODULE_AUTHOR(
     
     "Fabrizio Spada, Gianluca Durelli");
    
    
    
   
   
  331. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     MODULE_DESCRIPTION(
     
     "AXI DMA driver");
    
    
    
   
   
  332. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     MODULE_LICENSE(
     
     "GPL v2");

3.编译，生成BOOT.BIN文件


images/linux/目录下将生成的BOOT.BIN和image.ub文件拷贝到SD卡，插上SD卡。启动串口敲入用户名和密码(均root)：


这里可以看到ds_axidma.ko这个内核module。同时可以看到apps


测试方法如下：


至此，DMA的简单实例就完成了，PS侧的DMA可以参考Audio侧，另外，如果有一些文件挂载分区，则如下：

AE_小良
关注
ZYNQ异常与中断（二）
Derek Qu的博客
10-23 1065
ZYNQ异常与中断（三）1.前言2.中断的嵌入式程序实现2.1 底层寄存器的编写2.2 项目模块3.petalinux系统下的中断实现 1.前言 上一节讲了ZYNQ的异常中断原理，不是特别详细，但也总算把大概的知识体系过了一遍,有了大概的知识体系，就可以开始异常中断的使用了。 这里是以ZYNQ7000为例，进行总结。 2.中断的嵌入式程序实现 ZYNQ7000是一款SOC，所以他的嵌入式开发流程和大部分单片机的开发流程是一样的，总结一下就是以下步骤： 在做某一个完整的嵌入式项目时，应该先结合数据手册
zynq-axis:Zynq AXI DMA接口的硬件，Linux驱动程序和库
04-30
Zynq AXIS：完整的DMA系统 此存储库包含使用Xilinx的Zynq FPGA建立基于DMA的项目所需的所有组件。 首先，有一个称为AXIS的硬件模块，可连接到高性能AXI接口端口。 其次，有一个Linux UIO驱动程序，可将低级AXIS控制硬件公开给Linux用户空间。 第三是一个用户空间库，该库具有低级驱动程序界面，并为用户提供了更易于应用的界面。 最后，有一些示例应用程序来演示上述组件的用法。 硬件 HDL代码与Xilinx Vivado项目目录分开保存在hdl目录中，从而使在项目之间共享代码以及根据需要升级Xilinx工具版本变得更加容易。 要合成比特流文件，必须安装并获取Vivado工具，然后只需从此回购根目录运行“ syn-proj”脚本。 ./syn-proj 如果syn目录中有多个Xilinx项目，则将项目名称作为参数传递到syn-proj脚本中进行选择。
AXI总线
最新发布
小瑞同学的博客
07-27 1214
摘要:AXI总线学习笔记
ZYNQ跑系统 系列（四） AXI-DMA的linux下运行
热门推荐
long_fly的博客
05-30 3万+
AXI-DMA的linux驱动 一、搭建硬件环境 vivado版本2017.4，芯片为7010，不过不管什么版本和芯片大致步骤是一样的 硬件平台PL的搭建同ZYNQ基础系列（六） DMA基本用法，在这个工程的基础上添加SD卡（根据自己的开发板硬件选择相应的引脚） 然后直接生成bit文件，然后记得要导出硬件（包含bit文件）进SDK 二、生成设备树 1.解压设备树工具文件夹到一个地方...
ZedBoard的AXI DMA收发独立双线程linux应用程序
06-02
ZedBoard的AXI DMA收发独立双线程linux应用程序！有别于之前官方或者其它提供的单次发单次收。该代码包含速度测试，实测传输速率可以达到274MB/s。
xilinx axi dma linux 快速搭建框架
HongDaYu的搬砖之路
01-14 619
kernel axi dma 驱动 也是更具数据手册来的, 先把业务简单跑起来,然后在做到内核里,熟悉 dma engine 框架
AXI DMA在Linux下的使用问题：petalinux方式编译 QSPI方式启动
weixin_42278284的博客
09-23 1539
AXI DMA在Linux下的使用问题
zynq 使用AXI_dma 传输==pl到ps，linux驱动开发，应用层处理DMA数据（一）
ZYH10140的博客
10-30 5135
zynq axi_dma pl到ps数据传输 axi_dma驱动 linux应用层使用dma
xilinx-axidma 驱动模块 petalinux2020
10-19
这个过程中，你需要理解Linux驱动模型，了解如何编写和注册设备驱动，以及如何与内核交互。驱动的移植通常涉及以下步骤： 1. **配置内核**: 在`.config`文件中启用AXIDMA模块。 2. **构建驱动**: 编写或修改驱动...
基于zynq的AXI-DMA驱动
02-01
文件"**xilinx-axidma**"很可能包含了实现上述功能的源代码，包括头文件、驱动初始化、主驱动结构体定义、中断处理函数、传输回调函数等。通过分析这些代码，开发者可以深入理解Zynq SoC上的AXI-DMA驱动是如何工作的...
xilinx_axidma-master.rar_ZYNQ7000_axidma_chrdev_axidma测试_xilinx
07-15
axidma_chrdev是AXI DMA的字符设备驱动，它实现了用户空间应用程序与内核驱动之间的通信接口。开发者需要编写驱动代码，注册设备节点，设置中断处理程序，并处理用户空间的读写请求。 1. 设备注册：驱动程序需要在...
XILINX axidma的BD工程以及对应的linux设备树
11-08
axidma的BD工程，亲测可以利用此工程在myir的开发板上进行AXIDMA测试，本资源主要是axidma的sg模式回环测试
dma:用于AXI DMALinux UIO驱动程序
04-29
UDMA 背景 我们习惯于通过UIO驱动程序来控制自定义的AXI4-Full / Lite IP，而不是AXI4-Stream IP。 由于AXI4-Stream IP具有不同的体系结构（customStreamIP.jpg），因此不会创建UIO设备节点。 而是出现DMA控制器，而UIO驱动程序无法适应这种情况。 结果，我们决定对UIO驱动程序进行一些修改，并在devicetree文件中进行一些棘手的设置。 修改后，我们可以通过UIO驱动程序控制我们的自定义AXI4-Stream IP。 用法 在设备树中指定要为哪些dmaengine兼容的DMA通道创建用户空间可访问的设备文件： udma0 { compatible = "generic-uio"; dmas = <&loopback_dma 0 &loopback_dma 1>; dma-names = "lo
集合的axidma驱动，测试使用
06-25
总之，axidma驱动是连接Linux系统与Xilinx FPGA平台AXI DMA控制器的关键组件，它的正确运行对于实现高效的数据传输至关重要。测试axidma驱动需要全面覆盖其功能、性能、稳定性和异常处理能力，以确保在实际应用中...
linux系统移植及AXI DMA配置
box_xidian的博客
04-11 2303
第35行改为 KBUILD_DIR = /home/he/LabPan/SLAM/petalinux/ALINX-ZYNQ/build/tmp/work/zynq_generic-xilinx-linux-gnueabi/linux-xlnx/5.10+gitAUTOINC+568989d441-r0/linux-zynq_generic-standard-build。一定要注意&axi_dma_0和后面的{之间是有一个空格的，网上有一个教程漏了这个空格，不会报语法错误，但是修改不生效。
【ZYNQ搭建系统】第4篇：linux系统层实现AXI DMA数据传输
黑猫奥利奥的博客
07-12 1439
本文依据个人工作经验整理而成，如有错误请留言。 文章为个人辛苦整理，付费内容，禁止私自转载。 文章专栏：《黑猫的FPGA知识合集》 1 前言 1.1 工程环境 软件 windows上装的vivado 2018.1 windows上装的SDK 2018.1 ubuntu 工程项目 axi dma loop实验 硬件 zedboard开发板（ZYNQ 7020） SD卡：通过sd卡启动开发板 1.2 背景概述 我使用的是ZYNQ芯片的zedboard开发板，在开发板中跑Linux系统，之所以跑linux系
ZYNQ AXI-DMA Linux Cache 一致
qq_15031263的博客
09-02 3032
AXI-DMA Cache 一致性 应用层驱动
ZYNQ开发（2）在Linux系统层上PL-PS通过AXI-DMA传输数据详细步骤及注意事项
aizaiyueye的专栏
05-29 2157
参考的网络资料 https://github.com/bperez77/xilinx_axidma/tree/master https://gitlab.gnome.org/HosseinBeheshti/UlteraZed7EV/-/tree/master/petalinux/xilinx_axidma https://www.icode9.com/content-3-925319.html https://blog.csdn.net/weixin_38218267/article/details/1
2021-08-16Zynq linux系统下的AXI DMA驱动与应用程序简单Demo实现
天生不会
08-16 1521
在参考网友（天使之猜）的例程（https://blog.csdn.net/hello_jinjin/article/details/102058119）中遇到了一些问题，导致内核崩溃。 在英勇无比的网友（兜兜里么糖√º）帮助下，成功解决了这一问题。 现将解决方法整理如下： 1.天使之猜网友的DMA驱动源码中第126行有误，应修改为static void dma_exit(void)并将“return 0”注释掉，注意第84行函数的声明也应一起修改。 2.第179行应改为copy_from_user(axid
axi_dma linux驱动
07-15
在 Linux 中，AXI DMA IP 核的驱动程序由 Xilinx 提供，并包含在 Xilinx 的 Linux 内核中。以下是在 Linux 中使用 AXI DMA 驱动程序的基本步骤： 1. 安装 Linux 内核：首先，你需要安装 Xilinx 提供的适用于你的 Zynq SoC 的 Linux 内核。这个内核版本应该包含 AXI DMA 驱动程序。 2. 配置设备树（Device Tree）：设备树是一种描述硬件配置的数据结构，在 Linux 中使用设备树来配置 AXI DMA IP 核。你需要编辑设备树文件（.dts 或 .dtsi），添加 AXI DMA IP 核的节点，并设置相应的属性，如基地址、中断号等。 3. 编译设备树：将设备树文件编译成二进制格式（.dtb），并将其放置在适当的位置，以使 Linux 内核能够加载它。 4. 加载驱动程序：在启动 Linux 内核时，你需要加载 AXI DMA 驱动程序模块。可以通过修改启动脚本或使用 `modprobe` 命令加载驱动程序模块。 5. 使用 AXI DMA 驱动程序：一旦驱动程序加载成功，你可以通过使用相应的设备节点（例如 `/dev/xdevcfg`）来控制和配置 AXI DMA IP 核。你可以使用标准的文件操作系统调用（如 `open`、`read`、`write` 等）来与驱动程序进行交互。 需要注意的是，AXI DMA 驱动程序的具体使用方法可能会因不同的平台和内核版本而有所差异。你可以查阅 Xilinx 的文档和示例代码，以便更详细地了解在 Linux 中使用 AXI DMA 驱动程序的具体步骤和配置方法。希望对你有所帮助！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值