ioblock.c

Linux device driver sample code

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <asm/uaccess.h>
#include <linux/interrupt.h>
#include <linux/module.h>
#include <asm/hardware.h>
#include <asm/irq.h>
#include <asm/mach/irq.h>

#define AIC_BASE ((0xFFFFF000 - 0xFFF78000) + AT91_IO_VIRT_BASE)
#define AIC_IRQ30_SMR (volatile unsigned int *) (AIC_BASE + 0x78)
#define AIC_ICCR (volatile unsigned int *) (AIC_BASE + 0x128)



int device_open(struct inode *inode, struct file *file);
int device_release(struct inode *inode, struct file *file);
ssize_t device_read(struct file *filep, char *buffer, size_t length, loff_t *offset);
ssize_t device_write(struct file *filep, char *buffer, size_t len, loff_t *offset);
int flag = 0;

void do_irq30_tasklet(unsigned long param)
{
    printk(KERN_INFO "IRQ30 Tasklet \n");
}


void do_irq30_wq(void *data)
{
    printk(KERN_INFO "workqueue scheduled\n");
}

DECLARE_WORK(wq, do_irq30_wq);

DECLARE_WAIT_QUEUE_HEAD(waitq);

irqreturn_t myIRQ(int irq, void *devid)
{
    printk(KERN_INFO "IRQ test");

//  tasklet_schedule(&irq30_tasklet);
    schedule_work(&wq);
    *AIC_ICCR = (1 << 30);

	flag = 1;
	wake_up_interruptible(&waitq);
	
    return IRQ_HANDLED;
}

struct file_operations fops =
{
	.read = device_read,
	.write = device_write,
	.open = device_open,
	.release = device_release
};

int major_no;
char *msg_ptr;
char msg[20];

int init_module(void)
{
	printk(KERN_INFO "hello \n");

	if((major_no = register_chrdev(0, "Oasis", &fops)) < 0)
	{
		printk(KERN_INFO "Error \n");
	}
	*AIC_IRQ30_SMR = 0x27;
	request_irq(30, myIRQ, 0, "MYIRQ", 0);


	return 0;
}

void cleanup_module(void)
{
	int ret;

	printk(KERN_INFO "bye \n");

	if((ret = unregister_chrdev(major_no, "Oasis")) < 0)
	{
		printk(KERN_INFO "Error\n");
	}
	free_irq(30, 0);
}

int device_open(struct inode *inode, struct file *file)
{
	printk(KERN_INFO "Open called\n");

//	msg_ptr = msg;

	return 0;
}

int device_release(struct inode *inode, struct file *file)
{
	printk(KERN_INFO "Close called\n");

	kfree(msg_ptr);

	return 0;
}

ssize_t device_read(struct file *filep, char *buffer, size_t length, loff_t *offset)
{
	int count = 0;

	printk(KERN_INFO "process going to sleep... \n");

	wait_event_interruptible(waitq, flag != 0);
	flag = 0;
	
	printk(KERN_INFO "process out of sleep... \n");

	if(__copy_to_user(buffer, "heLLO", 5) > 0)
	{
		printk(KERN_INFO "fail\n");
	}

	return count;
}

ssize_t device_write(struct file *filep, char *buffer, size_t len, loff_t *offset)
{
	int err = 0;

	printk(KERN_INFO "write called\n");

	if((msg_ptr = (char *) kmalloc(len, GFP_KERNEL)) == NULL)
	{
		printk(KERN_INFO "kmalloc problem \n");
	}

	err = access_ok(VERIFY_WRITE, buffer, len);
	
	if(err)
	{
#if 1
		if(__copy_from_user(msg_ptr, buffer, len) > 0)
		{
			printk(KERN_INFO "fail\n");
		}
		else
		{
			printk(KERN_INFO "success %s\n", msg_ptr);
		}
#endif
	}
	else
	{
		printk(KERN_INFO "user space pointer not good \n");
	}

	printk(KERN_INFO "write done\n");
	return 0;
}