led_flash.c

使用jupiter外部中断4的驱动和测试程序

#include <linux/types.h>
#include <linux/module.h>
#include <linux/sched.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/delay.h>
#include <linux/fs.h>
#include <linux/poll.h>
#include <linux/string.h>

#include <linux/devfs_fs_kernel.h>

#include <asm/uaccess.h>
#include <asm/hardware.h>
#include <asm/irq.h>

#define JUPITER_LED_FLASH_NAME "jpledflash"
#define JUPITER_LED_FLASH_MAJOR 230

static devfs_handle_t devfs_handle, devfs_led_flash_dir;
static char *dev_idledflash = JUPITER_LED_FLASH_NAME;
int led_state, timer_state;

static ssize_t jupiter_led_flash_read(struct file *filp, char *buf, size_t count, loff_t *l)
{
	return 0;
}

static ssize_t jupiter_led_flash_write(struct file *filp, const char *buf, size_t count, loff_t *l)
{
	return 0;
}
/*
static void jupiter_led_flash_timer(int irq, void *dev_idledflash, struct pt_regs *regs)
{
	disable_irq(IRQ_TIMER1);
	disable_irq(IRQ_KEYSCAN);
	if(led_state==0){
		*PIOLDAT1=0x00000000;//led on
		led_state=1;
	}else if(led_state==1){
		*PIOLDAT1=0x02000000;//led off
		led_state=0;
	}
	enable_irq(IRQ_KEYSCAN);
	enable_irq(IRQ_TIMER1);
}
*/
static void jupiter_led_flash_irq4(int irq, void *dev_idledflash, struct pt_regs *regs)
{
	disable_irq(IRQ_EXTIRQ4);
//	disable_irq(IRQ_KEYSCAN);
	if(led_state==0){

		printk("led on\n");
		*PIOLDAT1=0x00000000;//led on
		led_state=1;
	}else if(led_state==1){

		printk("led off\n");
		*PIOLDAT1=0x02000000;//led off
		led_state=0;
	}
	mdelay(10);
//	enable_irq(IRQ_KEYSCAN);
	enable_irq(IRQ_EXTIRQ4);
}
/*
static void jupiter_led_flash_keypad(int irq, void *dev_idledflash, struct pt_regs *regs)
{

	disable_irq(IRQ_KEYSCAN);
	disable_irq(IRQ_EXTIRQ4);
	if(timer_state==0){
//		*TIMCON1=0x0000C703;//TIMER1 run
		timer_state=1;
		if(led_state=1) *PIOLDAT1=0x02000000;
	}else if (timer_state==1){
//		*TIMCON1=0x0000C702;//TIMER1 STOP
		timer_state=0;
		if(led_state=1) *PIOLDAT1=0x02000000;
	}
	enable_irq(IRQ_EXTIRQ4);
	enable_irq(IRQ_KEYSCAN);
	
}
*/

static int jupiter_led_flash_open(struct inode *inode, struct file *filp)
{
	int ret;

/*	if ((ret = request_irq(IRQ_KEYSCAN, jupiter_led_flash_keypad,
				       SA_INTERRUPT, JUPITER_LED_FLASH_NAME, dev_idledflash)))
	{
		printk("jupiter_led_flash_keypad_init: failed to register IRQ_KEYSCAN\n");
		free_irq(IRQ_KEYSCAN, dev_idledflash);
		return ret;
	}
*/
	if((ret=request_irq(IRQ_EXTIRQ4,jupiter_led_flash_irq4,
					SA_INTERRUPT,JUPITER_LED_FLASH_NAME, dev_idledflash)))
	{
		printk("jupiter_led_flash_irq4_init: failed to register IRQ_TIMER1\n");
		free_irq(IRQ_EXTIRQ4, dev_idledflash);
		return ret;
	}

	*INTMOD = 0x1000; //falling edge trigger 
	//*TIMCNT1=0x0000C34F;
	//*TIMCON1=0x0000C703;/*TIMER1 run*/

	
	timer_state=1;
	
	return 0;
}

static int jupiter_led_flash_release(struct inode *inode, struct file *filp)
{
	*PIOLDAT1=0x02000000; /*led off*/
	led_state=0;
	MOD_DEC_USE_COUNT;
	return 0;
}


static struct file_operations jupiter_led_flash_fops = {
	read:	jupiter_led_flash_read,
	write:	jupiter_led_flash_write,
	ioctl:	NULL,
	open:	jupiter_led_flash_open,
	release:	jupiter_led_flash_release,
};


int __init jupiter_led_flash_init(void)
{
	int ret;

	if ((ret=devfs_register_chrdev(JUPITER_LED_FLASH_MAJOR, JUPITER_LED_FLASH_NAME, &jupiter_led_flash_fops))!=0)
	{
		printk("registering of " JUPITER_LED_FLASH_NAME " is failed\n");
		return ret;
	}
	devfs_led_flash_dir = devfs_mk_dir(NULL, "ledflash", NULL);
	devfs_handle = devfs_register(devfs_led_flash_dir, "ledflash",
			DEVFS_FL_DEFAULT,
			JUPITER_LED_FLASH_MAJOR, 0, S_IFCHR | S_IRUSR | S_IWUSR,
			&jupiter_led_flash_fops, NULL);
		
	printk("jupiter led_flash driver initialized\n");
	*PIOMOD1=0x00000000;
	*PIOLDAT1=0x02000000;
	led_state=0;
	return 0;
}




void __exit jupiter_led_flash_cleanup(void)
{
	free_irq(IRQ_KEYSCAN, dev_idledflash);

	devfs_unregister_chrdev(JUPITER_LED_FLASH_MAJOR, JUPITER_LED_FLASH_NAME);
	printk("Jupiter led_flash driver removed\n");
}

module_init(jupiter_led_flash_init);
module_exit(jupiter_led_flash_cleanup);