DSP与ARM通信的奇怪问题

wwfdzh2012

项目要求DSP不跑操作系统，arm核上linux3.3，在做双核通信的linux设备驱动时候遇到了一个诡异的问题，只要DSP通过CHIPSIG_INT0触发ARM中断，ARM中的linux内核的其他很多驱动都停止了工作，连自己的led控制驱动都失去了响应，流水灯也失去了闪烁，LCD显示也停止了刷新，但是运行GUI还是可以显示界面，就是界面不能刷新，触摸屏也不懂了。好像是其他驱动都阻塞了！！！！

我的linux设备驱动是这样实现的：使用Tasklet实现软中断，只要DSP的数据一准备好就通过CHIPSIG_INT0触发ARM中断，这时候驱动的tasklet顶半部会立刻响应中断去读取数据，然后调度tasklet的底半部，这样的流程一般是没问题才对，但是现象就是只要顶半部被触发了，其他驱动就异常了，linux也没有任何提示，而且无法恢复，触发重启内核，但是唯独这个驱动完全正常运行，数据照样读取也不丢帧，还有一个现象是DSP触发一次CHIPSIG_INT0中断，ARM核会响应两次，也就是顶半部会触发两次调用！！我的驱动实现如下，麻烦帮忙看下。

1. //头文件省略
   
2. 
   
3. //引入其他模块函数和变量
   7 v: R, |* E. s. f5 F- }
4. extern Ping_Pong_Buffer res_buff;
     t* t; t7 [7 |4 y
5. 
   
6. extern char k_linkQueue_create(linkQueue *queue, unsigned int dataType, unsigned int blockNumber, unsigned int blockSize);//创建链队列
   
7. extern void k_linkQueue_release(linkQueue *queue);//释放链队列
   
8. extern unsigned int k_linkQueue_insertData(linkQueue *queue, void *data, int force);//链队列插入数据
   
9. extern unsigned int k_linkQueue_getData(linkQueue *queue, void *r_buff);//获取队列的数据
   
10. 
    & Y) A" o0 d, K: `; H  a; P2 b
11. extern void SHM_ARM_Init(unsigned char* const mem_base);//共享内存初始化
    
12. 
    
13. static int read_quest = 0;//如果有读取数据请求且链队列无数据可读，则置1
    & N7 K- N- k, A9 ?) m  @* c
14. //设置主从设备号
    
15. #define PROTOCOL_MAJOR      1
    $ j8 U7 R6 S+ v! o3 ^8 K7 a* A
16. #define PROTOCOL_MINOR      0
    
17. 
    
18. 
    4 I( Z4 O& m% Z- j9 O; f$ d; ~
19. 
    
20. //定义设备驱动的名字或设备节点的名字
    
21. #define     DEVICE_NAME         "protocol_driver"
    
22. 
    5 S# t$ u0 I/ x4 v% L
23. 
    
24. //定义全局的循环队列作为数据缓冲区
    ' {* H, B' t- r, }
25. k_linkQueue queue;
    : o$ [1 Q0 t. ?( W" L  h, o1 n! E
26. 
    0 R# D- l7 }3 R% T. L2 |
27. //寄存器地址映射全局变量
    6 \4 v% T4 b9 w' S' Q6 |9 [( p) k! [  f
28. unsigned int *R_CHIPSIG = NULL;//CHIPSIG寄存器
    4 P8 \5 G+ y# Y* F/ f  f
29. unsigned int *R_CHIPSIG_CLR = NULL;//CHIPSIG_CLR寄存器
    " h/ O/ y; y; A: \9 i1 h
30. 
    
31. //物理内存映射全局变量
    
32. volatile void *mem_base = NULL;
    ! ~0 ]1 @6 J+ G7 e
33. volatile unsigned char *cur_buf_ptr = NULL;
    
34. volatile unsigned char *data_ready_ptr = NULL;
    3 F9 h( Z' k! N: A3 L' f
35. 
    9 u& I6 a0 w: o+ t  i
36. 
    5 \0 p, H: H  ]# O6 o
37. 
    , @. e6 h; h* n  I+ f. e
38. //定义读数据等待队列头，IO阻塞
    
39. DECLARE_WAIT_QUEUE_HEAD(wait_queue_head);
    
40. 
    7 _3 o5 a5 e3 F
41. //定义原子变量
    ) ]+ ^8 F  N* P  T0 D/ M
42. static atomic_t dev_available = ATOMIC_INIT(1);//原子变量的值为1,即只能一个进程打开此设备
    
43. 
    
44. 
    
45. //定义设备类
    0 S' C( B0 C! F: ^! h4 }
46. static struct class *protocol_class;
    $ ?  n+ `8 s, f; f+ o+ P- [6 x
47. struct cdev *protocol_cdev;
    
48. dev_t protocol_dev_no;
    2 y. p. V' L0 ^+ }3 {, P
49. 
    
50. /*定义tasklet和声明底半部函数并关联*/
    
51. void read_data_tasklet(unsigned long);
    3 z5 p* n* h4 z( u; ^" f) y
52. 
    7 U0 [3 q8 p+ A6 R
53. DECLARE_TASKLET(CHIPINT0_tasklet,read_data,0);
    
54. //将CHIPINT0_tasklet与read_data绑定，传入参数0
    
55. 
    
56. /*中断处理底半部, 拷贝内存*/
    
57. void read_data(unsigned long a)
    - |1 U5 r8 u2 ~5 E+ S/ d6 s
58. {
    
59.     if(read_quest == 1)//如果进程调用了此驱动的read函数且链队列没有数据可读，read_quest将会被赋值为1
    
60.     {
    
61.         read_quest = 0;
    
62.         wake_up_interruptible(&wait_queue_head);//唤醒读等待队列
    
63.     }
    
64. 
    
65. }
    
66. 
    / v; C$ M: C8 H  N7 R
67. /*中断处理顶半部*/
    
68. irqreturn_t CHIPINT0_interrupt(int irq,void *dev_id)
    
69. {
    
70.     //只要一触发进入这个程序，其他驱动会出问题，即使这个程序什么都不做也会这样
    % Y/ G3 r- B& S0 x/ O& |" }
71.     volatile Buffer_Type *next_read;
    
72.     //如果DSP数据已经ready
    1 P. ?! \* ]! Q% ^5 i1 v5 l& P
73.     if(*(res_buff.cur_buffer->data_ready) == 1)
    % d: K6 z% q( n" y. q& L
74.     {
    ! V5 f" U( f: K) K
75.         if(*(res_buff.bufferID_ptr) == BUFF_ID_PING)//切换读buffer
    
76.         {
    , u& `+ h( O3 g! M
77.             next_read = &res_buff.pong_buffer;//下一次中断读pong buffer
    
78.             //printk(KERN_ALERT"read ping\n");
    
79.         }
    
80.         else
    
81.         {
    $ ^6 c4 Y% H" L0 F+ U6 R* v8 }
82.             next_read = &res_buff.ping_buffer;//下一次中断读ping buffer
    1 r7 X  s" C0 F' _+ }+ S
83.             //printk(KERN_ALERT"read pong\n");
    
84.         }
    " d" B0 e5 m( E) f9 e2 `: a. A- X5 c! T
85.         *(res_buff.bufferID_ptr) ^= BUFF_ID_PING;//切换DSP写另一个buffer
    4 n; B' t/ v' B* _$ ?
86.         //将数据插入链队列
    0 m; @: g$ c8 B  Q
87.         k_linkQueue_insertData(&queue, res_buff.cur_buffer->buf_ptr, 0);
    ( h. t$ ?9 S; F' O" q1 y
88.         //标识位都重置
    
89.         *(res_buff.cur_buffer->data_ready) = 0;
    2 M; s& f8 v. ]
90.         *(res_buff.cur_buffer->data_size) = 0;
    
91.         res_buff.cur_buffer = next_read;
    
92.     }
    8 d# K3 R/ d1 s: v" U; B% P& o3 J" a
93.     //清楚中断标识
    
94.     *R_CHIPSIG_CLR = 1 << 0;//clear chipint0 status
    3 r- T5 n2 g8 R) d; y9 o  n
95.     tasklet_schedule(&CHIPINT0_tasklet);//调度底半部     
    ; H3 c; n% s0 Z5 p" s
96. 
    3 q9 Z  N- m  I& R/ G! p0 U
97. 
    
98.     return IRQ_HANDLED;
    
99. 
    
100. }
     
101. 
     
102. //文件打开函数
     , }+ T& u9 R# d5 o
103. static int protocol_open(struct inode *inode, struct file *file)
     
104. {
     
105.     int result = 0;
     
106.     if(!atomic_dec_and_test(&dev_available))
     
107.     {
     
108.         atomic_inc(&dev_available);
     + Z/ E# A% ^# ~3 j+ t
109.         return -EBUSY;//设备已经被打开
     
110.     }
     
111.     printk (KERN_ALERT "\nprotrol driver open\n");
     
112.     return 0;
     
113. }
     & M5 w" a; p  _# n+ d4 E) r! m0 {2 D
114. 
     
115. //文件释放函数
     
116. static int protocol_release(struct inode *inode, struct file *filp)
     
117. {
     - b7 r2 I, T6 B/ b
118.     atomic_inc(&dev_available);//释放设备，原子变量加1
     3 p$ f1 i' K/ f, U. Q3 u
119.     printk (KERN_ALERT "device released\n");
     1 N* O9 }7 Z7 E8 t6 c
120.     return 0;
     ( R& i& R9 ?- A; o' W
121. }
     
122. 
     ; @' i) z4 J$ r2 j5 j
123. //文件读函数
     
124. static int protocol_read(struct file *filp, char *dst, size_t size, loff_t*offset)
     , `$ Z3 L0 U9 l4 m( @! ?& |6 d) X
125. {
     : G: q. y, \/ j- y0 B- Q7 S
126.     int ret = 0;
     , d: O' ^8 C5 W$ F  R9 a! U9 c
127.     //定义等待队列
     
128.     DECLARE_WAITQUEUE(wait_queue, current);//定义等待队列
     2 X: U) \( f  r5 k! _
129.     add_wait_queue(&wait_queue_head, &wait_queue);//添加等待队列
     4 Q" }' j" O) s6 a) n: f4 a% O  F
130.     if(queue.remainNumber == queue.blockNumber)//当前buffer没数据
     " t# A9 K: @' C+ f5 ^
131.     {
     # j* W9 ~+ A2 M+ f0 l- K
132.         //printk(KERN_ALERT"\nbuffer no data\n");
     
133.         //如果是非阻塞方式读取，则直接跳出
     
134.         if(filp->f_flags & O_NONBLOCK)
     
135.         {
     
136.             ret = -EAGAIN;
     & N8 ?$ P7 m2 ]# n
137.             goto out;
     
138.         }
     9 I" x; O, i  h" r6 l$ a
139.         //阻塞当前进程，放弃cpu资源
     & h2 V7 N  C# K# Q
140.         read_quest = 1;
     # c/ E! n, I7 T9 \) c, h
141.         __set_current_state(TASK_INTERRUPTIBLE);//改变进程状态为睡眠
     7 Q5 N# T1 [& U
142.         schedule();//调度其他进程运行
     # W* G; |) \! k+ `
143.         if(signal_pending(current))
     * ]8 r' N; a; J, W7 N2 m5 y/ E7 m
144.         {
     " ^/ }# `' T! h8 q+ B* G
145.             //如果是因为信号被唤醒，则返回到系统调用之前的地方
     
146.             ret = -ERESTARTSYS;
     
147.             goto out;
     
148.         }
     
149.     }
     
150.     //将数据拷贝到用户空间
     8 r/ [& X2 {' E6 W
151.     ret = k_linkQueue_getData(&queue, dst);
     ! q5 H! F" q7 R7 d$ I& |3 G
152.     if(ret == 0)
     
153.     {
       |( ?# P% s/ N9 N/ s
154.         //printk(KERN_ALERT"\ncopy data to user space failed :%d\n", ret);
       n0 I; }# K0 ]
155.     }
     
156. out:
     
157.     remove_wait_queue(&wait_queue_head, &wait_queue);//移除等待队列
     , \/ L# V; ]' P; h# a$ K7 P
158.     set_current_state(TASK_RUNNING);//设置当前进程为运行状态
     # a0 X: Y# ?5 p
159.     return ret;
     ) D6 ^' ]1 v2 @& Y& |3 n
160. }
     
161. 
     ! t, S: g' G- d3 [# e% U
162. 
     
163. static long protocol_ioctl(struct file *file, unsigned int cmd, unsigned long value)
       {) I  C+ J  ?4 o! ^9 [5 m, ]
164. {
     ' U7 d! o3 ?' M* p0 m$ |: n0 k7 U' z
165.     return 0;
     
166. }
     
167. /*驱动文件操作结构体，file_operations结构体中的成员函数会在应用程序进行
     8 |+ m2 o9 _' ~  B
168. open()、release()、ioctl()协同调用时被调用*/
     
169. static const struct file_operations protocol_fops =
     
170. {
     
171.   .owner    = THIS_MODULE,
     
172.   .open     = protocol_open,
     
173.   .release  = protocol_release,
     
174.   .read     = protocol_read,
     
175. //  .write  = protocol_write,
     + r3 z( Z: [8 Q! v( g$ {
176.   .unlocked_ioctl=protocol_ioctl,
     3 p5 x; h! y( y5 F- J; M0 C8 `
177. };
     
178. 
     
179. /*设备驱动模块加载函数*/
     9 f% a% q1 Y! F1 c1 Y
180. int __init protocol_init(void)
     
181. {
     / K% A7 n9 F9 q1 b* t$ V) C
182.     int ret = 0;
     
183.     int result = 0;
     
184.     //申请注册设备号（动态）
     4 z3 a) u; ~; f1 ^9 S/ N1 ]0 M" D
185.     ret=alloc_chrdev_region(&protocol_dev_no, PROTOCOL_MINOR, 1, DEVICE_NAME);
     ! \: r2 z5 J& m9 r% L8 `
186.     if(ret < 0)
     ; c1 }7 Z& ~3 w) p" d
187.     {
       D* i5 [# J# O2 V3 L
188.             printk(KERN_EMERG "alloc_chrdev_region failed\n");
     5 W/ ~' i+ H0 N, v
189.             return 0;
     ; o9 V" F! N# ?! }
190.     }
     * |, l0 s3 Y& J2 @# K
191.     //分配cdev
     - f  ^( Y, T, e5 |
192.     protocol_cdev = cdev_alloc();
     0 `; l. {4 E1 ^7 ]9 s
193.     if(protocol_cdev == NULL)
     
194.     {
     
195.             printk(KERN_EMERG "Cannot alloc cdev\n");
     4 |) f& r& n+ [. N% r
196.             return 0;
     
197.     }
     6 ?2 |# ]* n2 j2 B7 h; T( X/ x
198.     //初始化cdev
     
199.     cdev_init(protocol_cdev,&protocol_fops);
     4 I& Z# J  ^( N
200.     protocol_cdev->owner=THIS_MODULE;
       F' I% I3 F( i' h
201.     //注册cdev
     
202.     cdev_add(protocol_cdev, protocol_dev_no, 1);
     - P+ A3 P  X/ d; i
203.     //创建一个类
     ) X' }4 u5 T5 X0 [/ \/ w7 J4 b7 g
204.     protocol_class = class_create(THIS_MODULE, DEVICE_NAME);
     
205.     //创建设备节点
     7 w" y" o# T- @. [( L9 o; J
206.     device_create(protocol_class, NULL, protocol_dev_no, NULL, DEVICE_NAME);
     " G1 }9 n1 X/ h3 _3 K( L/ q
207.    
     
208.    
     ( t( S. P9 I6 _+ t/ V& M0 Q6 n
209.     //申请链式循环队列作为缓冲区DSP数据帧的缓冲区
     ' W' i. B- Q  q" j" S4 U
210.     k_linkQueue_create(&queue, sizeof(double), 1000, DATA_BLOCK_SIZE);//申请1000个blocksize的队列空间作为帧缓冲区
     + W7 A7 L: r* K' T8 A* f3 Z' s
211. 
     % i6 h: \6 \6 ?$ t
212. //映射ARM的核间通讯寄存器
     ( s7 S; ?0 B- R" ~. X" R: M# U
213.     R_CHIPSIG = ioremap(SOC_SYSCFG_0_REGS + SYSCFG0_CHIPSIG, 4);
     
214.     R_CHIPSIG_CLR = ioremap(SOC_SYSCFG_0_REGS + SYSCFG0_CHIPSIG_CLR, 4);
     
215.     //将物理地址映射到内核空间
     & Z) a0 m; Z8 Y4 P7 A1 N. b
216.     mem_base = ioremap(SHARED_BUFFER_ADDR, SHARED_BUFFER_SIZE);
     
217.     //共享内存初始化
     0 N+ s! X1 K1 V9 K+ Q
218.     SHM_ARM_Init((unsigned char *)mem_base);
       g+ m( f7 m: o9 I7 s
219.     /*申请中断*/
     
220. 
     
221.     result = request_irq(IRQ_DA8XX_CHIPINT0, CHIPINT0_interrupt,IRQF_SHARED,"DSP Signal",&protocol_cdev);
     
222.     if(result != 0)
     
223.     {
     ; y. I9 `( ?; M; p3 R
224.         if(result == -EINVAL)
     # \" R( z' S4 X: Z9 X! R+ a
225.         {
     
226.             printk(KERN_ALERT "irq request err:-EINVAL\n");
     
227.         }
     
228.         else if(result == -EBUSY)
     . b0 {6 f8 X6 e1 ~2 y. Y
229.         {
     
230.             printk(KERN_ALERT "irq request err:--EBUSY\n");
     2 n; d' x8 b: z* P
231.         }
     + Z5 f! Q) N8 _
232.         else
     
233.         {
     
234.             printk(KERN_ALERT "irq request err: unknown\n");
     : X, f' C# b9 g* F- f9 f
235.         }
     # s( q$ l; c* M; D- R
236.         return result;
     ) y9 h# Z) {7 @/ g
237.     }
     
238.     return 0;
     
239. }
     + ?* Y! z" ?: D4 I
240. 
     
241. /*设备驱动模块卸载函数*/
     7 m4 c, e% V8 P! o2 ~/ }! d# e! F1 m
242. void __exit protocol_exit(void)
     . z! s" g7 H9 _& F- J6 h
243. {
     
244.         /*释放中断*/
     5 T/ F' L  s# p/ b1 U
245.     free_irq(IRQ_DA8XX_CHIPINT0, NULL);
     
246.     //释放帧缓冲的内存
     ! t& I2 M5 U( R* P- V
247.     k_linkQueue_release(&queue);
     8 y6 N- c" h& P1 J( _2 j7 J& @
248.     //释放寄存器映射
     
249.     iounmap(R_CHIPSIG);
     
250.     iounmap(R_CHIPSIG_CLR);
     $ p/ `$ R0 Z  b& {- i  m! p. t: e
251.     cdev_del(protocol_cdev);                            //删除cdev
     
252.     unregister_chrdev_region(protocol_dev_no, 1);   //注销设备号
     , m( _% _8 T, z5 C7 z
253.     device_destroy(protocol_class, protocol_dev_no);            //销毁设备节点
     , [  \& _, J* I: U) ^! ]; ]. o
254.     class_destroy(protocol_class);                      //销毁设备类
     # O  N) I/ D4 S% Z
255.     printk(KERN_ALERT "exit success\n");
     
256. 
     
257. }
     
258. //驱动其他部分省略

复制代码

4 E# Q* _' _; J
- o$ b) X3 J. U8 Z

wwfdzh2012

没有人遇到这个问题吗

human

可以参考一下TL_IPC双核通信例程。
TL_IPC是广州创龙独立开发的一种双核通讯协议。ARM核上运行Linux程序，DSP核上运行裸机或SYS/BIOS程序。基于TL_IPC的开发是指在两个处理间采用以直接触发中断进行异步事件通知，以直接读写共享内存进行数据交换，并结合创龙提供的c674x_irq_events内核模块（用于ARM端程序捕获由DSP触发的中断）实现双核通信的一种双核开发方式。

wwfdzh2012

human 发表于 2017-4-16 18:19
可以参考一下TL_IPC双核通信例程。
TL_IPC是广州创龙独立开发的一种双核通讯协议。ARM核上运行Linux程序，D ...

@human 您好，请问有c674x_irq_events模块的源码吗，光盘没有附带，只提供模块，这个模块还不能满足我的需求，但是我想参考他的中断实现。谢谢

wwfdzh2012

human 发表于 2017-4-16 18:19
$ X9 |/ i5 e0 z( c$ S6 O可以参考一下TL_IPC双核通信例程。
TL_IPC是广州创龙独立开发的一种双核通讯协议。ARM核上运行Linux程序，D ...

$ F4 V, ^) L# \) _2 c" m! e( Q8 q请问有c674x_irq_events模块的源码吗

wwfdzh2012

问题已解决，驱动没有任何问题，而是DSP端调用了DelayTimerSetup()这个函数导致定时器的状态被改变，从而导致arm端的定时器驱动无法正常工作，而依赖此定时器的其他驱动也就无法正常工作了，这也是双核的弊端吧，两个核共用一些资源，如果一个核在没有告知其他核的情况下改变了一些资源的寄存器就会导致出问题。

wwfdzh2012

至于DSP触发ARM中断两次的问题，这是由于linux的中断机制导致的，可以参考https://e2e.ti.com/support/embedded/linux/f/354/t/234510
解决方法：在dsp端触发后立即将clr标志位置1清除中断线，即可解决触发两次的问题

human

加陈工的QQ2942385389获取资料