Chinaunix首页 | 论坛 | 博客
  • 博客访问: 337580
  • 博文数量: 92
  • 博客积分: 2500
  • 博客等级: 少校
  • 技术积分: 960
  • 用 户 组: 普通用户
  • 注册时间: 2009-08-21 19:38
文章分类

全部博文(92)

文章存档

2010年(71)

2009年(21)

我的朋友

分类: 嵌入式

2010-04-13 21:06:00

Linux 中断编程

先总结一下硬中断,软中断和信号的区别:

硬中断:外部设备对CPU的中断。

软中断:硬中断服务程序对内核的中断。

信号:内核(或进程)对某个进程的中断。

Linux设备驱动中中断处理相关的首先是申请与释放IRQAPI request_irq()free_irq()request_irq()的原型为:

int request_irq(unsigned int irq,
void (*handler)(int irq, void *dev_id, struct pt_regs *regs),
unsigned long irqflags,
const char * devname,
void *dev_id);

l         Irq         是要申请的硬件中断号;

l         Handler  是向系统登记的中断处理函数,是一个回调函数,中断发生时,系统调用这个函数,dev_id参数将被传递;

l         Irqflags  是中断处理的属性,若设置SA_INTERRUPT,标明中断处理程序是快速处理程序,快速处理程序被调用时屏蔽所有中断,慢速处理程序不屏蔽;若设置SA_SHIRQ则多个设备共享中断,dev_id在中断共享时会用到,一般设置为这个设备的device结构本身或者NULL


  free_irq()的原型为:

void free_irq(unsigned int irq,void *dev_id);


  另外,与Linux中断息息相关的一个重要概念是Linux中断分为两个半部:上半部(tophalf)和下半部(bottom half)。上半部的功能是"登记中断",当一个中断发生时,它进行相应地硬件读写后就把中断例程的下半部挂到该设备的下半部执行队列中去。因此,上半部执行的速度就会很快,可以服务更多的中断请求。但是,仅有"登记中断"是远远不够的,因为中断的事件可能很复杂。因此,Linux引入了一个下半部,来完成中断事件的绝大多数使命。下半部和上半部最大的不同是下半部是可中断的,而上半部是不可中断的,下半部几乎做了中断处理程序所有的事情,而且可以被新的中断打断!下半部则相对来说并不是非常紧急的,通常还是比较耗时的,因此由系统自行安排运行时机,不在中断服务上下文中执行。

  Linux实现下半部的机制主要有tasklet工作队列
tasklet:

  tasklet基于Linux softirq,其使用相当简单,我们只需要定义tasklet及其处理函数并将二者关联:

void my_tasklet_func(unsigned long); //定义一个处理函数:
DECLARE_TASKLET(my_tasklet,my_tasklet_func,data); //
定义一个tasklet结构my_tasklet,与my_tasklet_func(data)函数相关联


  然后,在需要调度tasklet的时候引用一个简单的API就能使系统在适当的时候进行调度运行:

tasklet_schedule(&my_tasklet);


  此外,Linux还提供了另外一些其它的控制tasklet调度与运行的API

DECLARE_TASKLET_DISABLED(name,function,data); //DECLARE_TASKLET类似,但等待tasklet被使能
tasklet_enable(struct tasklet_struct *); //
使能tasklet
tasklet_disble(struct tasklet_struct *); //
禁用
tasklet
tasklet_init(struct tasklet_struct *,void (*func)(unsigned long),unsigned long); //
类似
DECLARE_TASKLET()
tasklet_kill(struct tasklet_struct *); //
清除指定tasklet的可调度位,即不允许调度该tasklet


  我们先来看一个tasklet的运行实例,这个实例没有任何实际意义,仅仅为了演示。它的功能是:在globalvar被写入一次后,就调度一个tasklet,函数中输出"tasklet is executing"

#include

//
定义与绑定tasklet函数

void test_tasklet_action(unsigned long t);
DECLARE_TASKLET(test_tasklet, test_tasklet_action, 0);

void test_tasklet_action(unsigned long t)
{
 printk("tasklet is executing\n");
}



ssize_t globalvar_write(struct file *filp, const char *buf, size_t len, loff_t *off)
{
 

 
if (copy_from_user(&global_var, buf, sizeof(int)))
 
{
  
return - EFAULT;
 
}

 //调度tasklet执行

 tasklet_schedule(&test_tasklet);
 
return sizeof(int);
}


 

工作队列:

 由于中断与真实的硬件息息相关,脱离硬件而空谈中断是毫无意义的,我们还是来举一个简单的例子。这个例子来源于SAMSUNG S3C2410嵌入式系统实例,看看其中实时钟的驱动中与中断相关的部分:

static struct fasync_struct *rtc_async_queue;
static int __init rtc_init(void)
{
 
misc_register(&rtc_dev);
 
create_proc_read_entry("driver/rtc", 0, 0, rtc_read_proc, NULL);

 
#if RTC_IRQ
  
if (rtc_has_irq == 0)
   
goto no_irq2;

  
init_timer(&rtc_irq_timer);
  
rtc_irq_timer.function = rtc_dropped_irq;
  
spin_lock_irq(&rtc_lock);
  
/* Initialize periodic freq. to CMOS reset default, which is 1024Hz */
  
CMOS_WRITE(((CMOS_READ(RTC_FREQ_SELECT) &0xF0) | 0x06), RTC_FREQ_SELECT);
  
spin_unlock_irq(&rtc_lock);
  
rtc_freq = 1024;
  
no_irq2:
 
#endif

 
printk(KERN_INFO "Real Time Clock Driver v" RTC_VERSION "\n");
 
return 0;
}

static void __exit rtc_exit(void)
{
 
remove_proc_entry("driver/rtc", NULL);
 
misc_deregister(&rtc_dev);

 
release_region(RTC_PORT(0), RTC_IO_EXTENT);
 
if (rtc_has_irq)
  
free_irq(RTC_IRQ, NULL);
}
static void rtc_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
 
/*
 
* Can be an alarm interrupt, update complete interrupt,
 
* or a periodic interrupt. We store the status in the
 
* low byte and the number of interrupts received since
 
* the last read in the remainder of rtc_irq_data.
 
*/

 
spin_lock(&rtc_lock);
 
rtc_irq_data += 0x100;
 
rtc_irq_data &= ~0xff;
 
rtc_irq_data |= (CMOS_READ(RTC_INTR_FLAGS) &0xF0);

 
if (rtc_status &RTC_TIMER_ON)
  
mod_timer(&rtc_irq_timer, jiffies + HZ / rtc_freq + 2 * HZ / 100);

 
spin_unlock(&rtc_lock);

 /*
唤醒一个等待队列,也就是说一个阻塞进程被执行 */
 wake_up_interruptible(&rtc_wait);
 kill_fasync(&rtc_async_queue, SIGIO, POLL_IN);
}

static int rtc_fasync (int fd, struct file *filp, int on)
{
 return fasync_helper (fd, filp, on, &rtc_async_queue);
}

static void rtc_dropped_irq(unsigned long data)
{
 
unsigned long freq;

 
spin_lock_irq(&rtc_lock);

 
/* Just in case someone disabled the timer from behind our back... */
 
if (rtc_status &RTC_TIMER_ON)
  
mod_timer(&rtc_irq_timer, jiffies + HZ / rtc_freq + 2 * HZ / 100);

 
rtc_irq_data += ((rtc_freq / HZ) << 8);
 
rtc_irq_data &= ~0xff;
 
rtc_irq_data |= (CMOS_READ(RTC_INTR_FLAGS) &0xF0); /* restart */

 
freq = rtc_freq;

 
spin_unlock_irq(&rtc_lock);
 
printk(KERN_WARNING "rtc: lost some interrupts at %ldHz.\n", freq);

 
/* Now we have new data */
 
wake_up_interruptible(&rtc_wait);
 
kill_fasync(&rtc_async_queue, SIGIO, POLL_IN);
}


 

阅读(1030) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~