UART 发送字节成功，但是不能 执行 发送成功 对应的中断服务函数

Question

学写驱动程序，是在虚拟机中运行的， Kernel 2.4.26 ，请大家看一下代码，帮忙分析一下为什么会出现这样的问题，是不是 request IRQ 以后，还需要作什么处理才能在 中断产生的时候，运行 中断服务函数。

---------------------------------- series_uart.c ------------------------

2. #include <linux/init.h>
3. #include <linux/module.h>
4. #include <linux/kernel.h>
5. #include <linux/ioport.h>
6. #include <linux/fs.h>
7. #include <linux/types.h>
8. #include <linux/ioport.h>
9. #include <linux/wait.h>
10. #include <linux/list.h>
11. //#include <asm/spinlock.h>
12. #include <asm/system.h>
13. #include <asm/io.h>
14. #include <asm/uaccess.h>
15. #include <asm/irq.h>
16. #include <asm/semaphore.h>
18. #include "series_uart.h"
21. static unsigned int series_uart_major = 254 ; /* 240 -- 254 reserved */
23. static const char series_uart_dev_name[] = "series_uart_dev";
24. static const char series_uart_io_name[]  = "series_uart_io";
25. static const char series_uart_irq_name[] = "series_uart_irq";
27. static unsigned long series_uart_io_base = 0x3f8;
28. static unsigned long series_uart_io_size = 8; /* 9 bytes  0x3f8 -- 0x3ff */
30. static int series_uart_dev_reg = -1 ;
31. static int series_uart_io_reg  = -1 ;
32. static int series_uart_irq_reg = -1 ;
34. static size_t  series_uart_rx_buf_head = 0;
35. static size_t  series_uart_rx_buf_tail = 0;
36. static char    series_uart_rx_buf[ SERIES_UART_RX_BUF_SIZE ];
38. static size_t  series_uart_tx_buf_head = 0;
39. static size_t  series_uart_tx_buf_tail = 0;
40. static char    series_uart_tx_buf[ SERIES_UART_TX_BUF_SIZE ];
42. static wait_queue_head_t series_uart_rx_wait_queue_head;
43. static wait_queue_head_t series_uart_tx_wait_queue_head;
45. static struct semaphore series_uart_rx_sem;
46. static struct semaphore series_uart_tx_sem;
48. static spinlock_t series_uart_rx_lock;
49. static spinlock_t series_uart_tx_lock;
54. static ssize_t series_uart_read( struct file *file, char *buf, size_t size, loff_t *loff )
55. {
56.         size_t count;
58.         if( down_interruptible( &series_uart_rx_sem ) ){
59.                 return -ERESTARTSYS;
60.         }
62.         while( size ){
63.                 count = SERIES_UART_RX_BUF_SIZE - series_uart_rx_buf_head ;
64.                 if( size < count ){
65.                         count = size;
66.                 }
68.                 while( series_uart_rx_buf_tail - series_uart_rx_buf_head < count ){
69.                         interruptible_sleep_on( &series_uart_rx_wait_queue_head  );
70.                 }
71.                
72.                 /* <asm/uaccess.h>
73.                  * unsigned long copy_to_user( void * to, const void * from, unsigned long count )
74.                  */
75.                 copy_to_user( buf, series_uart_rx_buf + series_uart_rx_buf_head, count );
76.                
77.                 series_uart_rx_buf_head += count;
78.                
79.                 spin_lock_irq( &series_uart_rx_lock );
80.                 if( series_uart_rx_buf_head == series_uart_rx_buf_tail ){
81.                         series_uart_rx_buf_head = series_uart_rx_buf_tail = 0;
82.                 }
83.                 spin_unlock_irq( &series_uart_rx_lock );
85.                 buf  += count;
86.                 size -= count;
87.         }
88.         
89.         up( &series_uart_rx_sem );
91.         return size;
92. }
94. static ssize_t series_uart_write( struct file *file, const char *buf, size_t size, loff_t *loff )
95. {
96.         size_t count;
97.         
98.         if( down_interruptible( &series_uart_tx_sem ) ){
99.                 return -ERESTARTSYS;
100.         }
102.         while( size ){
103.                 count = SERIES_UART_TX_BUF_SIZE - series_uart_tx_buf_tail;
104.                 if( size < count ){
105.                         count = size;
106.                 }
108.                 /* <asm/uaccess.h>
109.                  * unsigned long copy_from_user( void * to, const void * from, unsigned long count )
110.                  */
111.                 copy_from_user( series_uart_tx_buf + series_uart_tx_buf_tail, buf, count );
112.                
113.                 series_uart_tx_buf_tail += count;
114.                 size -= count;
115.                 buf  += count;
117.                 outb( series_uart_tx_buf[ series_uart_tx_buf_head ], SERIES_UART_IO_DATA );
118.                
119.                 while( series_uart_tx_buf_tail != series_uart_tx_buf_head ){
120.                         interruptible_sleep_on( &series_uart_tx_wait_queue_head  );
121.                 }
123.                 series_uart_tx_buf_tail = series_uart_tx_buf_head = 0;
125.         }
126.         
127.         up( &series_uart_tx_sem );
129.         return size;
130. }
132. static struct file_operations series_uart_fops = {
133.         read  : series_uart_read,
134.         write : series_uart_write,
135. };
138. static void series_uart_irq_hdlr_data_revieved( void )
139. {
140.         if( series_uart_rx_buf_tail < SERIES_UART_RX_BUF_SIZE ){
141.                 series_uart_rx_buf[ series_uart_rx_buf_tail ] = inb( SERIES_UART_IO_DATA );
142.                 series_uart_rx_buf_tail ++ ;
143.                 wake_up_interruptible( &series_uart_rx_wait_queue_head );
144.         }
145. }
147. static void series_uart_irq_hdlr_sent_holding( void )
148. {
149.         if( series_uart_tx_buf_head < series_uart_tx_buf_tail ){
150.                 outb( series_uart_tx_buf[ series_uart_tx_buf_head ], SERIES_UART_IO_DATA );
151.                 series_uart_tx_buf_head ++ ;
152.                 wake_up_interruptible( &series_uart_tx_wait_queue_head );
153.         }
154. }
156. static void series_uart_irq_hdlr( int irq, void *dev_id, struct pt_regs *reg )
157. {
158.         unsigned char data;
160.         /* <asm/io.h>
161.          * unsigned inb( unsigned port )
162.          * void outb( unsigned char byte, unsigned port )
163.          */
164.         data = inb( SERIES_UART_IO_IRQ_HOLD );
165.         
166.         /* recieve error */
167.         if( data == 0x06 ){
168.         }
169.         /* data recieved */
170.         else if( data == 0x04 ){
171.                 series_uart_irq_hdlr_data_revieved();
172.         }
173.         /* sent holding  */
174.         else if( data == 0x02 ){
175.                 series_uart_irq_hdlr_sent_holding();
176.         }
177.         /* modem         */
178.         else if( data == 0x00 ){
179.         }
181.         outb( ( data | 0x01 ), SERIES_UART_IO_IRQ_HOLD );
182. }
185. static void series_uart_exit( void )
186. {
187.         /*
188.          * int unregister_chrdev( unsigned int major, const char *name )
189.          */
190.         if( series_uart_dev_reg >= 0 ){
191.                 unregister_chrdev( series_uart_major, series_uart_dev_name );
192.         }
194.         /* <linux/ioport.h>
195.          * void release_region( unsigned long start, unsigned long len )
196.          */
197.         if( series_uart_io_reg >= 0 ){
198.                 release_region( series_uart_io_base, series_uart_io_size );
199.         }
201.         /* <asm/irq.h>
202.          * void free_irq( unsigned int irq, void *dev_id )
203.          */
204.         if( series_uart_irq_reg >= 0 ){
205.                 free_irq( IRQ4, NULL );
206.         }
208. }
210. static int series_uart_init( void )
211. {
212.         /*
213.          * int register_chrdev( unsigned int major, const char *name, struct file_operations * fops )
214.          */
215.         series_uart_dev_reg = register_chrdev( series_uart_major, series_uart_dev_name, &series_uart_fops );
216.         if( series_uart_dev_reg < 0 ){
217.                 goto exit;
218.         }
221.         /* <linux/ioport.h>
222.          * int check_region( unsigned long start, unsigned long len )
223.          * struct resource * request_region( unsigned long start, unsigned long len, char *name )
224.          */
225.         series_uart_io_reg = check_region( series_uart_io_base, series_uart_io_size );
226.         if( series_uart_io_reg < 0 ){
227.                 goto exit;
228.         }
229.         request_region( series_uart_io_base, series_uart_io_size, series_uart_io_name );
231.         /* initial the wait queue head */
232.         init_waitqueue_head( &series_uart_rx_wait_queue_head );
233.         init_waitqueue_head( &series_uart_tx_wait_queue_head );
234.       
235.         /* initial the semaphore */
236.         sema_init( &series_uart_rx_sem, 1 );
237.         sema_init( &series_uart_tx_sem, 1 );
238.       
239.         /* initial the lock */
240.         spin_lock_init( &series_uart_rx_lock );
241.         spin_lock_init( &series_uart_tx_lock );
243.         /* <asm/irq.h>
244.          * int request_irq(
245.          *      unsigned int irq,
246.          *      void (*handler)(int, void *, struct pt_regs *),
247.          *      unsigned long flags,
248.          *      const char *dev_name,
249.          *      void *dev_id )
250.          * void enable_irq( int irq );
251.          */
252.         series_uart_irq_reg = request_irq( IRQ4, series_uart_irq_hdlr, SA_INTERRUPT, series_uart_irq_name, NULL );
253.         if( series_uart_irq_reg < 0 ){
254.                 goto exit;
255.         }
257.         inb( SERIES_UART_IO_DATA );
258.         inb( SERIES_UART_IO_IRQ_SET );
259.         inb( SERIES_UART_IO_IRQ_HOLD );
260.         inb( SERIES_UART_IO_READ_LINE_STS );
261.         inb( SERIES_UART_IO_READ_MODEM_STS );
262.         
263.         /* set the default bit rate  19200 */
264.         outb( 0x80, SERIES_UART_IO_WRITE_LINE_CTRL );
265.         outb( 0x06, SERIES_UART_IO_RATE_LSB );
266.         outb( 0x00, SERIES_UART_IO_RATE_MSB );
268.         /* set 1 stop bit, 8bit data, no parity */
269.         outb( 0x07, SERIES_UART_IO_WRITE_LINE_CTRL );
271.         /* disable modem control register */
272.         outb( 0x00, SERIES_UART_IO_WRITE_MODEM_CTRL );
274.         /* set interrupt enable and interrupt trigger */
275.         outb( 0x03, SERIES_UART_IO_IRQ_SET );
277.         inb( SERIES_UART_IO_DATA );
278.         inb( SERIES_UART_IO_IRQ_SET );
279.         inb( SERIES_UART_IO_IRQ_HOLD );
280.         inb( SERIES_UART_IO_READ_LINE_STS );
281.         inb( SERIES_UART_IO_READ_MODEM_STS );
283.         return 0;
286. exit:
287.         series_uart_exit();
288.         return -1;
289. }
295. module_init( series_uart_init );
296. module_exit( series_uart_exit );
298. MODULE_LICENSE("GPL");

复制代码

---------------------------------- series_uart.h ------------------------

2. #ifndef __SERIES_UART_H__
3. #define __SERIES_UART_H__
5. #define SERIES_UART_IO_BASE             0x3F8
6. #define SERIES_UART_IO_DATA             ( SERIES_UART_IO_BASE )
7. #define SERIES_UART_IO_RATE_LSB         ( SERIES_UART_IO_BASE )
8. #define SERIES_UART_IO_RATE_MSB         ( SERIES_UART_IO_BASE + 1 )
9. #define SERIES_UART_IO_IRQ_SET          ( SERIES_UART_IO_BASE + 1 )
10. #define SERIES_UART_IO_IRQ_HOLD         ( SERIES_UART_IO_BASE + 2 )
11. #define SERIES_UART_IO_WRITE_LINE_CTRL  ( SERIES_UART_IO_BASE + 3 )
12. #define SERIES_UART_IO_WRITE_MODEM_CTRL ( SERIES_UART_IO_BASE + 4 )
13. #define SERIES_UART_IO_READ_LINE_STS    ( SERIES_UART_IO_BASE + 5 )
14. #define SERIES_UART_IO_READ_MODEM_STS   ( SERIES_UART_IO_BASE + 6 )
16. #define IRQ4 4
18. #define SERIES_UART_RX_BUF_SIZE 2048
19. #define SERIES_UART_TX_BUF_SIZE 2048
21. #endif

复制代码
[ 本帖最后由 platinum 于 2006-7-4 18:23 编辑 ]