DSP与ARM通信的奇怪问题 - 嵌入式开发者社区

//头文件省略
' U/ m# S0 q8 m
5 f X( s% l. f# W" ^* B$ K
//引入其他模块函数和变量9 Z; Z2 f- B3 }, |$ E
extern Ping_Pong_Buffer res_buff;7 s+ N* E5 z I! W6 q
: d# a- R" c$ ]) f
extern char k_linkQueue_create(linkQueue *queue, unsigned int dataType, unsigned int blockNumber, unsigned int blockSize);//创建链队列( I P& j) c9 N, a8 A f4 R2 d
extern void k_linkQueue_release(linkQueue *queue);//释放链队列! M: d) k( A9 b% O' e! T
extern unsigned int k_linkQueue_insertData(linkQueue *queue, void *data, int force);//链队列插入数据! a! [6 F5 P D9 f: G
extern unsigned int k_linkQueue_getData(linkQueue *queue, void *r_buff);//获取队列的数据
, H+ ~3 K, y. k
. `# x$ K% y/ F7 B1 A
extern void SHM_ARM_Init(unsigned char* const mem_base);//共享内存初始化" ]# a: Y( [( \* N7 P+ d; }; f$ U
2 ]1 v8 I) L9 R9 a* I
static int read_quest = 0;//如果有读取数据请求且链队列无数据可读，则置12 W- r% Q7 h0 t) ]% c* K
//设置主从设备号
9 m! b( a5 o" t: X2 m
#define PROTOCOL_MAJOR 1
2 ^& W& T) C- j8 y4 J* S
#define PROTOCOL_MINOR 04 S, x1 Y. h# U6 k6 T
) Q% p( h: R: q- I, b
, _: l' X* G) n* H$ F2 Q
" N. \- K8 }+ h$ T
//定义设备驱动的名字或设备节点的名字
, Q) |4 o& t* q3 d: K& k2 @- q
#define DEVICE_NAME "protocol_driver": ^) N2 W a! G9 |
, U8 o* x. u6 W2 }
; k7 M% p; n6 j I( g# I
//定义全局的循环队列作为数据缓冲区
6 X4 M) V# _' _& e
k_linkQueue queue;' M) b7 C5 I4 ?& f% q7 D
; m. J2 @% |4 p9 n1 r6 j5 I) A; |
//寄存器地址映射全局变量
5 S$ k; ~5 ?% \ o4 ^
unsigned int *R_CHIPSIG = NULL;//CHIPSIG寄存器7 n6 z% H/ |8 F4 V$ c5 ?+ x+ U9 s
unsigned int *R_CHIPSIG_CLR = NULL;//CHIPSIG_CLR寄存器
9 L0 J' Z% \* L7 ~$ ~% O) v% ?
% A s) h( s9 n. j( c
//物理内存映射全局变量" {& a7 Q C8 X' T, _6 W7 o% q8 D
volatile void *mem_base = NULL;! j/ m' N2 @' k, V
volatile unsigned char *cur_buf_ptr = NULL;; S1 Y2 Q& g$ [0 \3 X
volatile unsigned char *data_ready_ptr = NULL;
" x$ p# W6 F2 }
$ j1 t' a' n0 y! s8 y
5 L5 @. ^7 u/ A" a; r* u2 x {
~3 j6 Q/ ^. t5 K2 A
//定义读数据等待队列头，IO阻塞
: U1 |. }: r& `" Q$ Z; L
DECLARE_WAIT_QUEUE_HEAD(wait_queue_head);' h0 Q9 j. w1 g. g8 t' M+ O
* p B0 \# p7 m+ f" Y
//定义原子变量8 H3 D% Z) Z" V% Z6 ~7 G! z4 R5 Z% a4 K
static atomic_t dev_available = ATOMIC_INIT(1);//原子变量的值为1,即只能一个进程打开此设备
8 }# l* Q8 Z5 m2 t0 U0 d _- S; b
# ` L) e3 ~ u; i } Q% [, ?
# @& P; y6 W( q' d& Y/ r. U
//定义设备类
& i$ W: A6 w- Y5 ]; S
static struct class *protocol_class;
8 Y, x; ^3 P- _ o1 s
struct cdev *protocol_cdev;
# J) G; x6 Q! [, `1 N
dev_t protocol_dev_no;
& ?7 `/ j% D$ M; X3 z; k6 ~
) i8 O9 T5 t; Q
/*定义tasklet和声明底半部函数并关联*/& M' {! N7 s9 @1 p3 z4 D# k& a
void read_data_tasklet(unsigned long);0 L( v8 @4 B" {0 V) y7 M
4 Y2 P4 A8 m( Z! c; a/ Z6 i
DECLARE_TASKLET(CHIPINT0_tasklet,read_data,0);
$ A4 f: c0 _3 h0 {
//将CHIPINT0_tasklet与read_data绑定，传入参数0, q# K" S1 r {
2 O# w% j" D+ R- U) n! ^ v
/*中断处理底半部, 拷贝内存*/ M' D" U8 L+ b' m7 U
void read_data(unsigned long a)
: h6 Z: W! G, g! I6 t* M
{' L/ c$ F( ?9 o( W) d8 H% O
if(read_quest == 1)//如果进程调用了此驱动的read函数且链队列没有数据可读，read_quest将会被赋值为1 _0 ~% n3 h! y+ G' y3 y
{
) S5 j; x" i3 M
read_quest = 0;
) b+ B- S: Y/ X. w/ k, b% E! ]
wake_up_interruptible(&wait_queue_head);//唤醒读等待队列
, ^6 @+ R; D! ~
}
2 C% H% n$ y0 r! y0 m* I$ v
' ]% Q$ ?9 ]' Q5 _
}9 z2 `2 X% a5 E) e" W% Z! V V
s$ z" e+ I+ |2 K- ~, F* P4 |3 B; b
/*中断处理顶半部*/; n" N, u6 S$ ^" Q5 [- S
irqreturn_t CHIPINT0_interrupt(int irq,void *dev_id)
) p: `+ ] c, _/ `7 h7 b. a
{( S0 I* z6 ?# S7 n; d) }- N
//只要一触发进入这个程序，其他驱动会出问题，即使这个程序什么都不做也会这样
0 ~# L) [) m" {( X9 r p
volatile Buffer_Type *next_read;0 o, ]6 Z2 x+ w4 \
//如果DSP数据已经ready$ a! `8 R7 y/ @
if(*(res_buff.cur_buffer->data_ready) == 1)
, w$ ^+ \8 U% W3 C1 h( k% Y
{
6 h' q" E; D( ~* ^! h7 e! P- d( T
if(*(res_buff.bufferID_ptr) == BUFF_ID_PING)//切换读buffer
+ n1 M8 w5 \7 z7 @& e& |1 P$ H- @
{' t. L0 M* U# J0 J5 [" m8 C; p
next_read = &res_buff.pong_buffer;//下一次中断读pong buffer6 O% q( P3 }# X' q3 ^6 d9 f q' B+ W
//printk(KERN_ALERT"read ping\n");* J+ p: i* m. f; S8 E
}7 E+ x" a7 b* u7 u& z0 `
else
2 G" s$ j! u; Q5 K6 ?; R% x, v
{
+ S3 Q5 M u& S- d4 ^6 v
next_read = &res_buff.ping_buffer;//下一次中断读ping buffer& D0 ]6 ?; z6 O% J3 v* V
//printk(KERN_ALERT"read pong\n");1 B" L8 E C. Q: V; B1 W; s
}
$ o0 `9 n& }9 J3 \) P
*(res_buff.bufferID_ptr) ^= BUFF_ID_PING;//切换DSP写另一个buffer
) @" Q) J/ } A- k- S2 }: g. [* \
//将数据插入链队列- t, u6 Y1 ^8 k& u, v% b+ n
k_linkQueue_insertData(&queue, res_buff.cur_buffer->buf_ptr, 0);& a* @; `: m/ h S, j
//标识位都重置, ^. O, Y, m5 D
*(res_buff.cur_buffer->data_ready) = 0;
, Q4 [- m: b9 O1 Y9 \* \
*(res_buff.cur_buffer->data_size) = 0;" l2 K; S U/ H1 W& B# _
res_buff.cur_buffer = next_read;% ?' X( W- [# x9 L' C
}
4 `4 l& e+ i9 d# k$ p9 j, A3 i
//清楚中断标识
# P6 t" J/ L6 M* A& r+ t
*R_CHIPSIG_CLR = 1 << 0;//clear chipint0 status) o4 _% q7 N8 U
tasklet_schedule(&CHIPINT0_tasklet);//调度底半部
- r& @7 ?1 f2 z8 ` b9 V
, L- Z/ K. V+ b7 w6 K
v& N9 \. q' b1 W- S) i; X
return IRQ_HANDLED;
% h" k) W* e- v& d) d- f
- X0 v2 A3 R0 x8 F: k \
}7 g8 h" v- w% Y6 r6 C8 Z( t
- L/ V/ v+ ^; m) @/ ^0 x& D5 X
//文件打开函数3 g2 X" q4 r- F3 F9 S% Z) k
static int protocol_open(struct inode *inode, struct file *file)' q! F8 F! f/ e4 U3 i. b" N
{& {* @( f7 F; U: T% z; V6 M
int result = 0;" \7 R! J ?% D
if(!atomic_dec_and_test(&dev_available))4 Y" q% G( g1 ~5 i6 ~2 y
{" ?3 J9 T# b& a) u
atomic_inc(&dev_available);
# D _ {$ w/ t4 P
return -EBUSY;//设备已经被打开; }9 V7 }( z' @# k& y8 F
}
\; ]7 L2 O7 r2 f/ g
printk (KERN_ALERT "\nprotrol driver open\n");
8 ?. s+ Y0 `* A# A; j! d" o% c
return 0;
7 L1 `3 v! k' H* {. r$ W
}# g& s2 W3 |0 W# s, S* T
; ^) }, @* K% q- q
//文件释放函数9 c# f: o' o0 |1 g4 ]1 |5 O
static int protocol_release(struct inode *inode, struct file *filp)
) R% O* G; d/ X5 K* c k
{' e* v. f( f9 W8 H' x7 C
atomic_inc(&dev_available);//释放设备，原子变量加1
# R6 w% j0 g+ ~1 S5 F& r6 |
printk (KERN_ALERT "device released\n");
3 Q- Z* G9 }( s$ N8 `
return 0;9 l& `$ X/ D& a+ N' \! E
}
/ N& i4 z% o3 R; \' G
: P% d' g# G; v% r1 ]; }& T
//文件读函数
8 c" B6 | O. D
static int protocol_read(struct file *filp, char *dst, size_t size, loff_t*offset)7 T# G4 ^+ p7 t* V5 A
{6 Y8 Z4 q! j. x9 [9 i
int ret = 0;
]7 T8 \* M% w! Y7 @
//定义等待队列6 J" O1 }, A+ g' B# A& E/ @- X x/ j+ c8 p
DECLARE_WAITQUEUE(wait_queue, current);//定义等待队列
4 o3 N3 c/ W/ N/ I8 k1 C- f
add_wait_queue(&wait_queue_head, &wait_queue);//添加等待队列( `3 W* Z: a: u% N3 N8 n
if(queue.remainNumber == queue.blockNumber)//当前buffer没数据$ W' x. N4 w2 L h/ l& h
{
2 D- ]" _9 I- M; H9 ?
//printk(KERN_ALERT"\nbuffer no data\n");
: m) s0 ^$ J1 A4 o
//如果是非阻塞方式读取，则直接跳出/ h) l" \* n0 U5 m
if(filp->f_flags & O_NONBLOCK)( ?- m8 u; T$ |) Y0 M( R
{: @9 e$ f! P# n" P! g1 g+ J
ret = -EAGAIN;
- C3 U8 ^$ I2 G' Q
goto out;! W: k6 B; }6 V) g
}
) z) o! O! {8 M6 F8 m8 A
//阻塞当前进程，放弃cpu资源6 Q' C! @( g4 j
read_quest = 1;
: B5 b; b" i; x$ e V: Q7 |
__set_current_state(TASK_INTERRUPTIBLE);//改变进程状态为睡眠. g% F/ }& o: D
schedule();//调度其他进程运行% Z6 s0 k, l& m( {" u& b! r) P
if(signal_pending(current))7 f! w# X" q6 @/ n! X8 \' ], Y' d
{
1 B! y/ v( R/ T# l) ~
//如果是因为信号被唤醒，则返回到系统调用之前的地方
0 u& n" w/ H) l
ret = -ERESTARTSYS;
) a3 p6 ~1 e7 T" ~# A$ j
goto out;
5 B! `: N, b" R% {
}
+ ^' Q4 x( O" R) P: D
}
( {/ }9 E% l' o5 Q2 \
//将数据拷贝到用户空间
6 z% g0 M6 ^4 m* y! ?; T5 E5 |
ret = k_linkQueue_getData(&queue, dst);: n4 i; Z- N& ^: W
if(ret == 0)' M( ]: i+ M+ [
{) h0 k/ I& u) Z# G
//printk(KERN_ALERT"\ncopy data to user space failed :%d\n", ret);
1 y$ M% a% y) v! j8 Q' D
}, P# d, {+ Z$ f2 U4 A
out:) L4 ^5 r5 W5 O" D1 S$ E- j
remove_wait_queue(&wait_queue_head, &wait_queue);//移除等待队列
+ o t. b$ ~$ S! U1 P) f
set_current_state(TASK_RUNNING);//设置当前进程为运行状态
) `$ ?; o5 t: T+ ^
return ret;" l4 E" c4 M5 E1 S# k ^" O
}; T6 C& B% b; a4 m" M) e! {
/ \( s* r" q' i2 K0 Y
: C+ ]; n, }, g- V2 S
static long protocol_ioctl(struct file *file, unsigned int cmd, unsigned long value)
$ ]! l/ U' I) h+ a' _5 d {) T
{% v) T, X: \/ t3 h. K$ o$ Y8 F4 w
return 0;
1 G6 L6 S; k; {4 X: o f3 s
}; J T% C: l) W- g
/*驱动文件操作结构体，file_operations结构体中的成员函数会在应用程序进行& ~* t# f: S, Q1 {
open()、release()、ioctl()协同调用时被调用*/- D c' j) n5 B3 L; y9 C
static const struct file_operations protocol_fops =3 z7 [: p( e4 ]6 p& F
{
2 G: x) H2 j+ f6 z, d6 X: J
.owner = THIS_MODULE,$ y( w; ]) ^4 r
.open = protocol_open,! w9 f) u( n" R9 @
.release = protocol_release,
R* o- w& D6 J R0 H% Y a9 C
.read = protocol_read,- I$ Y" t7 v1 a4 W$ u6 O$ e
// .write = protocol_write,
& i) ~0 x7 z0 n- o5 J
.unlocked_ioctl=protocol_ioctl,
; v, X2 c) K( m) y) c9 ?& g) H' w
};
% ]" L$ P K1 f$ |, Z
1 W, v) z( ]4 Z; U
/*设备驱动模块加载函数*/
( t% F& K+ m3 w4 j" Z& X0 R
int __init protocol_init(void). \: ~; ]# l* g2 Z( Y: T
{% J& z4 }- b% i; E0 O8 }
int ret = 0;8 Z* v9 W/ U/ J: z& F% X3 \2 K2 M0 }" `
int result = 0;- C3 O. G/ j% `4 r
//申请注册设备号（动态）/ R2 M1 |: R; f
ret=alloc_chrdev_region(&protocol_dev_no, PROTOCOL_MINOR, 1, DEVICE_NAME); % v ^6 s- E* _3 e7 C; I
if(ret < 0)' y; o- N* j6 Y* R
{+ z+ ^9 l( a9 _8 ]' G0 }! U
printk(KERN_EMERG "alloc_chrdev_region failed\n");
return 0;% q8 d# T2 z- C. q: ~
}
, [, x1 K/ U; K* l$ j6 v
//分配cdev3 W! B: f6 h6 v, K& F7 b
protocol_cdev = cdev_alloc();4 R Y) p5 c& o- q' \
if(protocol_cdev == NULL)8 U6 {& }8 P% K# Y9 ~5 K1 C: k
{& b# E) {" t' R* Y7 ~( S" t+ S* j/ H
printk(KERN_EMERG "Cannot alloc cdev\n");: ^# B/ Z- l! O! ~8 D2 O& d$ O
return 0;" U8 C o( N" {1 q' u" V
}- p4 M+ ^# M8 S# t
//初始化cdev4 l3 }- T3 E( t+ l, Y. P
cdev_init(protocol_cdev,&protocol_fops);
6 u# ^! h- D" | F {
protocol_cdev->owner=THIS_MODULE;# f4 j( r- N- k7 G
//注册cdev
2 W. n/ x- |# x& o t
cdev_add(protocol_cdev, protocol_dev_no, 1); 7 ]/ C1 t/ r4 A7 S% T
//创建一个类& C1 s W' ~. J6 |2 V8 N
protocol_class = class_create(THIS_MODULE, DEVICE_NAME);
: T/ C* B6 ~* d- X( {
//创建设备节点
. U- S7 t5 N9 V' \
device_create(protocol_class, NULL, protocol_dev_no, NULL, DEVICE_NAME);
* b( p. |6 L. r2 S0 f; C
: D, J8 L) b; \1 y( h- K& _
* ^: B. ^. V2 Z! M* J
//申请链式循环队列作为缓冲区DSP数据帧的缓冲区
' h. B0 y9 _7 `6 Z, a) j' z% F" w
k_linkQueue_create(&queue, sizeof(double), 1000, DATA_BLOCK_SIZE);//申请1000个blocksize的队列空间作为帧缓冲区. G3 O6 O4 {" z! U+ \- t. K
$ C) N& V8 F8 h
//映射ARM的核间通讯寄存器; @9 w3 V# g& s: A9 x: n
R_CHIPSIG = ioremap(SOC_SYSCFG_0_REGS + SYSCFG0_CHIPSIG, 4);" U8 u0 A% ~4 `
R_CHIPSIG_CLR = ioremap(SOC_SYSCFG_0_REGS + SYSCFG0_CHIPSIG_CLR, 4);. T" y3 p! b; D4 J! r
//将物理地址映射到内核空间: g# V$ c) i& u- X8 y
mem_base = ioremap(SHARED_BUFFER_ADDR, SHARED_BUFFER_SIZE);" x7 Y B* T' q7 C
//共享内存初始化5 N$ o( [- P( p; W2 U
SHM_ARM_Init((unsigned char *)mem_base);
6 O9 K1 p* T- q0 A' L
/*申请中断*/
% p# R- ^4 d7 v" P5 M" Q
0 f3 ?- \* G8 L
result = request_irq(IRQ_DA8XX_CHIPINT0, CHIPINT0_interrupt,IRQF_SHARED,"DSP Signal",&protocol_cdev);
' A0 ?) k# N7 ]5 e
if(result != 0)" G E+ A3 V+ O( D, U
{ Z; Q) d( ~: n! }0 T
if(result == -EINVAL)" q6 b/ N; e/ `5 |' j
{
' m# C' x7 E4 C$ {) N
printk(KERN_ALERT "irq request err:-EINVAL\n");/ w1 `7 ]" F% @- s
}
6 m, G& e7 v3 c$ q. w' l
else if(result == -EBUSY)2 H( i" r, Z2 l: D4 y+ ?7 G" M
{
# G: C" K I; u5 ?% g
printk(KERN_ALERT "irq request err:--EBUSY\n");) P7 L% R$ G( H9 M! i" a7 s# f
}
0 P. E* q5 [: K6 V/ ~% p
else- X& b. u5 U2 v2 c1 G2 k
{( f A% M. W* j5 y+ [
printk(KERN_ALERT "irq request err: unknown\n");+ P" ]" u3 A' A V: G$ y7 T
}/ E# V% @# e6 U1 z- _
return result;
2 J! y/ w% X; M, l9 l
}) I! l( ]2 U% b3 o) ~
return 0;$ d7 k8 O8 V1 `1 {! W
}0 |4 J0 L e8 B6 K! j
* M5 p9 ~+ U8 `+ y8 U
/*设备驱动模块卸载函数*/6 P. F' B4 D0 Z- o- k! G8 e/ W; p
void __exit protocol_exit(void)
( I& e6 G9 ]% h
{
- L' Z! e. B, ?' C% I0 i: q
/*释放中断*/" t; x! K" O- ]! g: M* z
free_irq(IRQ_DA8XX_CHIPINT0, NULL);1 v6 ]1 }6 | G+ h k4 w! d$ j
//释放帧缓冲的内存
7 }; J9 O- L- A( i
k_linkQueue_release(&queue);
7 i- \2 a" n6 c v1 \
//释放寄存器映射* l; ~! x% g$ B2 ~" ~# U
iounmap(R_CHIPSIG);
+ Q: V! v( H% U5 _3 I" X
iounmap(R_CHIPSIG_CLR);+ R z$ \ a+ s9 R6 w7 [
cdev_del(protocol_cdev); //删除cdev2 r+ G5 E$ R6 @
unregister_chrdev_region(protocol_dev_no, 1); //注销设备号
8 h/ E( `! q" U+ B* w
device_destroy(protocol_class, protocol_dev_no); //销毁设备节点
0 N9 g0 j, h" T! I }0 u, s% a
class_destroy(protocol_class); //销毁设备类
$ J+ F" V5 ?, c. R
printk(KERN_ALERT "exit success\n");2 u8 v- t' X/ F$ F* O2 I1 E
. `9 Q( a5 X$ c$ l/ l
}
% j. R! K% [; a( V+ Y
//驱动其他部分省略

复制代码