generic.c~

sample code for interrupt on arm processor

#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/version.h>
#include <linux/wait.h>
#include <linux/irq.h>
#include <linux/delay.h>
#include <linux/sched.h>
#include <linux/mm.h>
#include <linux/slab.h>
#include <linux/completion.h>
#include <linux/platform_device.h>
#include <linux/videodev.h>
#include <linux/clk.h>
#include <linux/interrupt.h>
#include <linux/dma-mapping.h>
#include <linux/miscdevice.h>

#include <asm/io.h>
#include <asm/hardware.h>
#include <asm/semaphore.h>
#include <asm/uaccess.h>
#include <asm/arch/gpio.h>
#include <asm/arch/regs-gpioj.h>
#include <asm/dma.h>
#include <asm-arm/poll.h>
#include <linux/poll.h>
#include <linux/string.h>
#include <asm/arch/regs-irq.h>

MODULE_LICENSE("Dual BSD/GPL");
#define DEVICE_NAME "INT3"
#define NR_DEVICE 27
#define IRQ_NO IRQ_EINT3



#define DEBUG
#ifdef DEBUG
#define DPRINTK(x...) printk(x)
#else
#define DPRINTK(x...) /* !!!! */
#endif

#define res_size(_r) (((_r)->end - (_r)->start) + 1)

#define GPJBASE	0x560000d0
#define GPJCON  0x00
#define GPJDAT  0x04
#define GPJUP   0x08

#define INTERRUPT_BASE 0x4A000000
#define INTERRUPT_MODE 0x04

struct generic_data_t
{
	int valoare;
	void __iomem* addr;
};


struct generic_data_cfg_t
{
	struct generic_data_t* dev;
};

static struct generic_data_cfg_t generic_data_cfg;
static void __iomem* base_addr, *base_interrupt;
static int valoare;


static int generic_open(struct inode *inode, struct file *file)
{
	file->private_data = generic_data_cfg.dev;
	return 0;
}

static int generic_close(struct inode *inode, struct file *file)
{
   	return 0;
}



static ssize_t generic_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
{
	struct generic_data_t *dev = (struct generic_data_t *)(file->private_data);

	DPRINTK("READ 1 \n");

	valoare = readl(base_addr + GPJDAT);
	//valoare = readb(base_addr + GPJDAT);

	if(copy_to_user(buf, (void *)&valoare, count))	//can copy 0 byte
		return -EFAULT;

	return 1;

	
}

static unsigned int generic_poll(struct file *file, struct poll_table_struct *wait)
{
	return POLLIN | POLLOUT;
}

static struct file_operations generic_fops = {
     .owner          = THIS_MODULE,
     .open           = generic_open,
     .release        = generic_close,
     .read           = generic_read,
     .poll           = generic_poll,
     //.ioctl          = /*v4l_cam_ioctl,*/video_ioctl2, /* V4L2 ioctl handler */
     //.mmap           = v4l_cam_mmap,
     //.llseek         = no_llseek,
};

//------------------------------------------------------------------------------
static struct miscdevice generic_miscdev = {
    NR_DEVICE, DEVICE_NAME, &generic_fops
};
//------------------------------------------------------------------------------



// run in irq disabled state
static irqreturn_t dmacam_isr(int irq, void *dev_id, struct pt_regs *regs)
{
	//cam_data_t *dev = (cam_data_t *)dev_id;
	//volatile unsigned int val;
	DPRINTK("INTERRUPT!!\n");

  	return IRQ_HANDLED;

}

static void init_gpio()
{
	//interrupt
	set_gpio_ctrl(S3C2410_GPF3,GPIO_PULLUP_EN,GPIO_MODE_ALT0);
}



int __init generic_init(void)
{
	int ret=0;
	struct generic_data_t* dev;
	dev= (struct generic_data_t*)kmalloc(sizeof(struct generic_data_t),GFP_KERNEL);
 
	base_addr = ioremap(GPJBASE, 0x20);
	base_interrupt=ioremap(INTERRUPT_BASE, 0x20);

	if(base_addr == NULL) {
		printk(KERN_ERR "failed to ioremap address reg\n");
	   	ret = -EINVAL; goto release;
        }
	generic_data_cfg.dev=dev;

	if(base_interrupt == NULL) {
		printk(KERN_ERR "failed to ioremap interrupt address reg\n");
	   	ret = -EINVAL; goto release;
        }


	init_gpio();

	set_irq_type(IRQ_NO, IRQT_RISING);
	//interrupt alloc request...
	if ((ret = request_irq(IRQ_NO, dmacam_isr, SA_INTERRUPT, "EXT3", dev))) {
		free_irq(IRQ_NO, dev);
		printk("request_irq(%x) failed.\n", IRQ_NO);
		goto release;
	}
	DPRINTK("%s() 2:\n", __FUNCTION__);

	__raw_writel(1 << 3, S3C2410_INTMOD);


  	misc_register(&generic_miscdev);
	return 0;

release:
	if (dev) kfree(dev);
	return ret;
}

void __exit generic_cleanup(void)
{
	struct device_data_t* dev=generic_data_cfg.dev;

	free_irq(IRQ_NO, dev);

	if (dev)
		kfree(dev);
	misc_deregister(&generic_miscdev);
}


module_init(generic_init);
module_exit(generic_cleanup);

MODULE_LICENSE("GPL");