【Altera SoC体验之旅】高速数据采集之中断

chenzhufly

【Altera SoC体验之旅】高速数据采集之中断 [复制链接]

 

作者：chenzhufly  QQ：36886052

1、  硬件环境

硬件平台：Embest SoC --LarkBoard

软件平台：开发板-linux-3.10.31

          Quartus 14.0

2、系统概述

     简单点说，就是FPGA准备好数据了，现在需要通知ARM过来取数据。在传统的设计里面可以把FPGA的一个IO挂在ARM的外部中断上，准备好数据了就触发一次中断，大喊一声“HI，我来啦！准备接客”。那么在soc中怎么设计呢，如下图所示：

1）  ADC采集来的数据先进FIFO缓存

2）  在FPGA内部生成IRQ逻辑，并挂在lwhps上

3、系统生成

在qsys中我们要生成如下的硬件系统，整体连接关系如下：

中断号应该是几呢？请看下面分解。

中断的参数设计如下：

地址映射关系如下：

HDL Example如下：

1. lark_pcie u0 (
   
2.         .memory_mem_a                          (<connected-to-memory_mem_a>),                          //                         memory.mem_a
   
3.         .memory_mem_ba                         (<connected-to-memory_mem_ba>),                         //                               .mem_ba
   
4.         .memory_mem_ck                         (<connected-to-memory_mem_ck>),                         //                               .mem_ck
   
5.         .memory_mem_ck_n                       (<connected-to-memory_mem_ck_n>),                       //                               .mem_ck_n
   
6.         .memory_mem_cke                        (<connected-to-memory_mem_cke>),                        //                               .mem_cke
   
7.         .memory_mem_cs_n                       (<connected-to-memory_mem_cs_n>),                       //                               .mem_cs_n
   
8.         .memory_mem_ras_n                      (<connected-to-memory_mem_ras_n>),                      //                               .mem_ras_n
   
9.         .memory_mem_cas_n                      (<connected-to-memory_mem_cas_n>),                      //                               .mem_cas_n
   
10.         .memory_mem_we_n                       (<connected-to-memory_mem_we_n>),                       //                               .mem_we_n
    
11.         .memory_mem_reset_n                    (<connected-to-memory_mem_reset_n>),                    //                               .mem_reset_n
    
12.         .memory_mem_dq                         (<connected-to-memory_mem_dq>),                         //                               .mem_dq
    
13.         .memory_mem_dqs                        (<connected-to-memory_mem_dqs>),                        //                               .mem_dqs
    
14.         .memory_mem_dqs_n                      (<connected-to-memory_mem_dqs_n>),                      //                               .mem_dqs_n
    
15.         .memory_mem_odt                        (<connected-to-memory_mem_odt>),                        //                               .mem_odt
    
16.         .memory_mem_dm                         (<connected-to-memory_mem_dm>),                         //                               .mem_dm
    
17.         .memory_oct_rzqin                      (<connected-to-memory_oct_rzqin>),                      //                               .oct_rzqin
    
18.         .clk_clk                               (<connected-to-clk_clk>),                               //                            clk.clk
    
19.         .reset_reset_n                         (<connected-to-reset_reset_n>),                         //                          reset.reset_n
    
20.         .hps_0_h2f_reset_reset_n               (<connected-to-hps_0_h2f_reset_reset_n>),               //                hps_0_h2f_reset.reset_n
    
21.         .hps_0_f2h_cold_reset_req_reset_n      (<connected-to-hps_0_f2h_cold_reset_req_reset_n>),      //       hps_0_f2h_cold_reset_req.reset_n
    
22.         .hps_0_f2h_debug_reset_req_reset_n     (<connected-to-hps_0_f2h_debug_reset_req_reset_n>),     //      hps_0_f2h_debug_reset_req.reset_n
    
23.         .hps_0_f2h_warm_reset_req_reset_n      (<connected-to-hps_0_f2h_warm_reset_req_reset_n>),      //       hps_0_f2h_warm_reset_req.reset_n
    
24.         .pio_led_external_connection_export    (<connected-to-pio_led_external_connection_export>),    //    pio_led_external_connection.export
    
25.         .pio_button_external_connection_export (<connected-to-pio_button_external_connection_export>)  // pio_button_external_connection.export
    
26.     );

复制代码

做到这里硬件系统就设计完成了！

4、关于中断号

    从上图看到，我们的中断是挂在f2h_irq0上，实际的物理中断是多少呢，需要认真看手册了

总共fpga到arm的有64个中断源，分别分配在f2h_irq0和f2h_irq1上，所以上面的设计对应的物理中断号是77，记住了哦，下面还有用！

5、产生中断源

简单的写了一个计数器，作为中断源，如下：

1. module count_int (                           
   
2.     input clk,                                       
   
3.     input reset,                                                              
   
4.                                                      
   
5.     output avl_irq
   
6. );                                                   
   
7. 
   
8. reg  [31:0] s_cnt;
   
9. 
   
10. always @(posedge clk or negedge reset)
    
11.     begin
    
12.         if (!reset)
    
13.             s_cnt <= 32'd0;
    
14.         else
    
15.             s_cnt <= s_cnt + 1'b1;
    
16.     end  
    
17. 
    
18. assign avl_irq = s_cnt[24];                             
    
19. 
    
20. endmodule   

复制代码

把输出挂在HPS的模块上就可以

1. .pio_button_external_connection_export                  (avl_irq)

复制代码

6、linux驱动

1）首先要告知内核，要挂在这个中断啊，dts中需要添加

1.   altera_pio: gpio@0xff200000{
   
2.                         compatible = "altr,pio-1.0";
   
3.                         reg = <0xff200010 0x10>;
   
4.                         //reg = <0xff200000 0x10>;
   
5.                         interrupts = <0 45 4>;
   
6.                         //interrupts = <0 40 4>;
   
7.                         altr,gpio-bank-width = <32>;
   
8.                         altr,interrupt_type = <2>;                //failing edge
   
9.                         #gpio-cells = <2>;
   
10.                         gpio-controller;
    
11.                         //inter_gpios = < &altera_pio 0 1 >;
    
12.                         #interrupt-cells = <1>;
    
13.                         interrupt-controller;               
    
14.                 };

复制代码

注意：

• reg = <0xff200010 0x10>;和上面的地址分配是对应的
• interrupts = <0 45 4>;，这个45需要加上32，那么和上面的中断号77也是对应的
  

2）挂载自己的驱动程序

还要告知内核，我用了它的哪个中断源，取个名字叫key_int吧

1. <blockquote>key_int {

复制代码

自己写的简单驱动如下：

1. #include <linux/init.h>
   
2. #include <linux/module.h>
   
3. #include <linux/kernel.h>
   
4. #include <linux/device.h>
   
5. #include <linux/platform_device.h>
   
6. #include <linux/leds.h>
   
7. #include <linux/io.h>
   
8. #include <linux/uaccess.h>
   
9. 
   
10. #include <linux/semaphore.h>
    
11. #include <linux/cdev.h>
    
12. 
    
13. #include <linux/types.h>
    
14. #include <linux/fs.h>
    
15. #include <linux/interrupt.h>
    
16. #include <linux/irq.h>
    
17. #include <linux/of.h>
    
18. #include <linux/of_gpio.h>
    
19. #include <linux/of_device.h>
    
20. #include <linux/gpio.h>
    
21. 
    
22. int key_gpio;
    
23. int key_irq;
    
24. /*******************************************/
    
25. //中断处理函数：
    
26. static irqreturn_t key_interrupt (int irq, void *dev_id)
    
27. {
    
28. //       printk("=============key_interrupt=============\n");
    
29.         return 0;
    
30. }
    
31. 
    
32. int button_release(struct platform_device *pdev)
    
33. {
    
34.     return 0;   
    
35. }
    
36. 
    
37. int button_probe(struct platform_device *pdev)
    
38. {
    
39.         int result;
    
40.         struct device_node *node = pdev->dev.of_node;
    
41.         key_gpio = of_get_named_gpio(node,"inter_gpios",0);
    
42.         key_irq = __gpio_to_irq(key_gpio);
    
43.         printk("=============key_irq = %d=============\n",key_irq);        
    
44. 
    
45.         result = request_irq(key_irq, key_interrupt,IRQF_TRIGGER_FALLING, "key_int", NULL);
    
46.   if(result)
    
47.        {
    
48.           printk(KERN_INFO"[FALLED: Cannot register Key  Interrupt!]\n");
    
49.        }
    
50. 
    
51.         return 0;
    
52. }
    
53. 
    
54. static struct of_device_id altera_gpio_of_match[] = {
    
55.         { .compatible = "altr,key-int", },
    
56.         {},
    
57. };
    
58. MODULE_DEVICE_TABLE(of, altera_gpio_of_match);
    
59. 
    
60. static struct platform_driver button_fops = {
    
61.         .driver = {
    
62.                 .name        = "key_int",
    
63.                 .owner        = THIS_MODULE,
    
64.                 .of_match_table = of_match_ptr(altera_gpio_of_match),
    
65.         },
    
66.     .probe = button_probe,
    
67.     .remove = button_release,
    
68. };
    
69. 
    
70. // 模块加载函数
    
71. static int __init button_init(void)
    
72. {
    
73.     printk(KERN_ALERT "key modules is install\n");   
    
74.     return    platform_driver_register(&button_fops);   
    
75.    
    
76. }
    
77. 
    
78. // 模块卸载函数
    
79. static void  __exit button_cleanup(void)
    
80. {
    
81.     printk("Goodbye,chenzhufly!\n");
    
82.     platform_driver_unregister(&button_fops);   
    
83. }
    
84. 
    
85. module_init(button_init);
    
86. module_exit(button_cleanup);
    
87. 
    
88. MODULE_AUTHOR("chenzhufly");
    
89. MODULE_LICENSE("Dual BSD/GPL");

复制代码

7、测试

看到key_int了吗？

8、小结

1）学习的过程总是苦逼的，但结果总是异常的简单明了，纵观下来，其实所涉及的东西并不多，但如何能在一开始就融汇贯通，难度相当的大啊

2）soc中断设计比传统的arm+fpga架构要好使很多，避免很多麻烦的事情，自从调通以后，我就喜欢上了它

3）提醒一下3.10内核的linux版本，不支持arm端的IO中断，有需要的需要自己移植了，不要再在这个上面浪费时间了

lelee007

研究了半天得出的结论就是3.10以上的kernel不支持IO中断了？

chenzhufly

是不支持arm上IO中断

chenzhufly

驱动不支持

chenzhufly

这个是fpga触发arm中断 还是支持的  哈哈

coyoo

请教几个问题：
1、存ADC数据的FIFO是在fpga逻辑中例化的还是在Qsys中例化的，图中并未看到你的fifo挂靠到Qsys之中？
2、你的ADC是另外申请的？记得之前DE1-soc好像带了一个ADC板子

sdcaine

我是楼主吗？？

chenzhufly

coyoo 发表于 2015-4-17 10:06
请教几个问题：
1、存ADC数据的FIFO是在fpga逻辑中例化的还是在Qsys中例化的，图中并未看到你的fifo挂靠到Qsys之中？
2、你的ADC是另外申请的？记得之前DE1-soc好像带了一个ADC板子

1、FIFO是在fpga逻辑中例化的

2、板子是Embest的，自带了ADC

coyoo

chenzhufly 发表于 2015-4-17 11:27
1、FIFO是在fpga逻辑中例化的

2、板子是Embest的，自带了ADC

在逻辑中例化的FIFO，最终数据怎么通过Qsys互联送到ARM呢？

chenzhufly

这个还没做呢 呵呵 等我发文章

不足论

哇哇，好厉害，学习学习。

南盗

厉害，不愧是之前搞嵌入式的，我只是在裸机下弄过fpga到arm的中断，有空真得学习一下。

zuo785843091

这一段是什么意思？

chenzhufly

函数啊
有疑问直接说过

陌路沙砾

楼主，请教一下 ，这个物理中断号是怎么确定的呀？

chenzhufly

这个中断号 是在内核申请的 我没有关心

cqiang

楼主，我想问一下你有没有接触DSP Builder，我对里面的时钟不理解，能不能帮我解释一下。我外部是50MHz的晶振，有没有可能让板子跑的更快？

chenzhufly

那当然可以，外部时钟只不过是提供个时钟源而已，系统的运行时钟还可以通过倍频提高，每个芯片的等级不一样，可以稳定运行的频率也会不同，这个可以查看相关的技术手册得到

陌路沙砾

请教一下， key_gpio = of_get_named_gpio(node,"inter_gpios",0);  这句话里的 “inter_gpios” 是在哪里定义的，是要自己手动在 dts 文件里添加吗？是什么格式的？

1162248857

同问，inter_gpio在哪里定义的啊？还有

key_int {没有贴完啊，就差这点弦没搭接起来，烦请楼主及时答疑解惑。非常感谢！