Senghoo's Blog

#include <linux/interrupt.h>
int request_irq(unsigned int irq,
		irqreturn_t (*handler)(int, void *,
				 struct pt_regs *),
		unsigned long flags,
		const char *dev_name,
		void *dev_id);
/*函数request_irq函数返回0时表示成功，为负值时表示错误码 返回-EBUSY表示已经有另一个程序占用了中断信号线*/
void free_irq(unsigned int irq, void *dev_id);
int can_request_irq(unsigned int irq, unsigned long flags);
/*can_request_irq用于查询中断线是否可用，注意can_request_irq后request_irq之前可能发生一些事情导致中断线被其他程序占用*/

if (short_irq >= 0) {
	result = request_irq(short_irq, short_interrupt,
				SA_INTERRUPT, "short", NULL);
	if (result) {
		printk(KERN_INFO "short: can't get \
			assigned irq %i\n",short_irq);
		short_irq = -1;
	}else { 
		/* actually enable it -- assume this 
			*is* a parallel port */
		outb(0x10,short_base+2);
	}
}

if (short_irq < 0) /* 未指定信号线根据基地址使用默认值*/
	switch(short_base) {
		case 0x378: short_irq = 7;break;
		case 0x278: short_irq = 2;break;
		case 0x3bc: short_irq = 5;break;
}

#include <linux/interrupt.h>
unsigned long probe_irq_on(void);
/*返回一个未分配中断的掩码，返回值传递给probe_irq_off函数，
此函数执行后驱动程序要安排设备至少产生一次中断*/
int probe_irq_off(unsigned long);
/*请求设备产生中断以后以probe_irq_on的返回值为参数调用。
如果没有中断产生返回0，如果产生了多次中断（产生二义性）返回一个负值。*/

int count = 0;
do {
	unsigned long mask;
	mask = probe_irq_on( );
	outb_p(0x10,short_base+2); /* enable reporting */
	outb_p(0x00,short_base);
	/* clear the bit */
	outb_p(0xFF,short_base);
	/* set the bit: interrupt! */
	outb_p(0x00,short_base+2); /* disable reporting */
	udelay(5); /* give it some time */
	short_irq = probe_irq_off(mask);
	if (short_irq = = 0) { /* none of them? */
	printk(KERN_INFO "short: no irq reported by probe\n");
	short_irq = -1;
	}
	/*
	* if more than one line has been activated, the 
	*result is negative. We should service the interrup
	*(no need for lpt port) and loop over again. Loop 
	*at most five times, then give up
	*/
} while (short_irq < 0 && count++ < 5);
if (short_irq < 0)
	printk("short: probe failed %i times, 
		giving up\n", count);

<pre lang="C">
int trials[ ] = {3, 5, 7, 9, 0};
int tried[ ] = {0, 0, 0, 0, 0};
int i, count = 0;
/*
* install the probing handler for all possible lines.
*Remember the result (0 for success, or -EBUSY) in order
*to only free what has been acquired
*/
for (i = 0; trials[i]; i++)
	tried[i] = request_irq(trials[i], short_probing,
				SA_INTERRUPT, "short probe", NULL);
do {
	short_irq = 0; /* none got, yet */
	outb_p(0x10,short_base+2); /* enable */
	outb_p(0x00,short_base);
	outb_p(0xFF,short_base); /* toggle the bit */
	outb_p(0x00,short_base+2); /* disable */
	udelay(5); /* give it some time */
	/* the value has been set by the handler */
	if (short_irq = = 0) { /* none of them? */
		printk(KERN_INFO "short: no irq reported \
					by probe\n");
	}
	/*
	* If more than one line has been activated, 
	*the result is negative. We should service the
	*interrupt (but the lpt portdoesn't need it) and 
	*loop over again. Do it at most 5 times
	*/
	} while (short_irq <=0 && count++ < 5);
	/* end of loop, uninstall the handler */
	for (i = 0; trials[i]; i++)
		if (tried[i] = = 0)
	free_irq(trials[i], NULL);
	if (short_irq < 0)
		printk("short: probe failed %i times, giving \
				up\n", count);

irqreturn_t short_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
struct timeval tv;
int written;
do_gettimeofday(&tv);
/* Write a 16 byte record. Assume PAGE_SIZE is a multiple of 16 */
written = sprintf((char *)short_head,"%08u.%06u\n",
	(int)(tv.tv_sec % 100000000), (int)(tv.tv_usec));
BUG_ON(written != 16);
short_incr_bp(&short_head, written);
wake_up_interruptible(&short_queue); 
/* awake any reading process */
return IRQ_HANDLED;
}
static inline void short_incr_bp(volatile unsigned long *index, int delta)
{
	unsigned long new = *index + delta;
	barrier( ); /* Don't optimize these two together */
	*index = (new >= (short_buffer + PAGE_SIZE)) ? 		short_buffer : new;
}

irqreturn_t handler(int irq, void * dev_id,
			struct pt_regs *reg)

static irqreturn_t sample_interrupt(int irq, void *dev_id, 		struct pt_regs *regs)
{
	struct sample_dev *dev = dev_id;
	/* now `dev' points to the right hardware item */
	/* .... */
}
static void sample_open(struct inode *inode, struct file
				*filp)
{
	struct sample_dev *dev = hwinfo + MINOR(inode->i_rdev);
	request_irq(dev->irq, sample_interrupt,
		0 /* flags */, "sample", dev /* dev_id */);
	/*....*/
	return 0;
}
 
<h4>启用和禁用中断</h4>
<h5>禁用单个中断</h5>
<pre lang="C">
void disable_irq(int irq);
void disable_irq_nosync(int irq);/*立即返回*/
void enable_irq(int irq);

void local_irq_save(unsigned long flags);
void local_irq_disable(void);
void local_irq_restore(unsigned long flags);
void local_irq_enable(void);

irqreturn_t short_sh_interrupt(int irq, void *dev_id, 
					struct pt_regs *regs)
{
	int value, written;
	struct timeval tv;
	/* If it wasn't short, return immediately */
	value = inb(short_base);
	if (!(value & 0x80))
		return IRQ_NONE;
	/* clear the interrupting bit */
	outb(value & 0x7F, short_base);
	/* the rest is unchanged */
	do_gettimeofday(&tv);
	written = sprintf((char *)short_head,"%08u.%06u\n",
		(int)(tv.tv_sec % 100000000), (int)(tv.tv_usec));
	short_incr_bp(&short_head, written);
	wake_up_interruptible(&short_queue); 
	/* awake any 	reading process */
	return IRQ_HANDLED;
}