buttons_drv.c

FPGA中的设计全过程

/*
 * Simple - REALLY simple memory mapping demonstration. 
 */

#include <linux/config.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/init.h>

#include <linux/kernel.h>   /* printk() */
#include <linux/slab.h>   /* kmalloc() */
#include <linux/fs.h>       /* everything... */
#include <linux/errno.h>    /* error codes */
#include <linux/types.h>    /* size_t */
#include <linux/mm.h>
#include <linux/kdev_t.h>
#include <linux/cdev.h>

#include <linux/interrupt.h>
#include <linux/ioport.h>
#include <asm/hardware.h>
#include <asm/irq.h>

#include <asm/arch/regs-gpio.h>

#include <linux/device.h>
#include <asm/io.h>
#include <asm/uaccess.h>
#include <asm/arch-s3c2410/regs-gpio.h>

static int simple_major = 0;
module_param(simple_major, int, 0);
MODULE_AUTHOR("Jonathan Corbet");
MODULE_LICENSE("Dual BSD/GPL");

//char *mybuff;
#define BUFF_SIZE 100
static DECLARE_WAIT_QUEUE_HEAD(wq);
static int flag = 0;

/*
 * Open the device; in fact, there's nothing to do here.
 */
int simple_open (struct inode *inode, struct file *filp)
{
	return 0;
}

ssize_t simple_read(struct file *file, char __user *buff, size_t count, loff_t *offp)
{
	return 0;
}

ssize_t simple_write(struct file *file, const char __user *buff, size_t count, loff_t *offp)
{
/*	
	int i;
	if(count < BUFF_SIZE){
		if (copy_from_user(mybuff, buff, count))
			return -EFAULT;
	}
	return count;
*/
	return 0;
}
static int simple_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
{
	switch ( cmd ) {
	case 1:
	{
		//add ur function here;
		break;
	}
	case 2:
	{
		//add ur function here;
		break;
	}
	default:
	{
		break;
	}
	}
	return 0;
}

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

/*
 * Set up the cdev structure for a device.
 */
static void simple_setup_cdev(struct cdev *dev, int minor,
		struct file_operations *fops)
{
	int err, devno = MKDEV(simple_major, minor);
    
	cdev_init(dev, fops);
	dev->owner = THIS_MODULE;
	dev->ops = fops;
	err = cdev_add (dev, devno, 1);
	/* Fail gracefully if need be */
	if (err)
		printk (KERN_NOTICE "Error %d adding simple%d", err, minor);
}


/*
 * Our various sub-devices.
 */
/* Device 0 uses remap_pfn_range */
static struct file_operations simple_remap_ops = {
	.owner   = THIS_MODULE,
	.open    = simple_open,
	.release = simple_release,
	.read    = simple_read,
	.write   = simple_write,
	.ioctl   = simple_ioctl,	
};

static irqreturn_t s3c2410but_keyevent(int irq, void *dev_id, struct pt_regs *regs)
{
	clearpending(BIT_EINT0);

	printk("in keyboard isr\n");
	return IRQ_HANDLED;
}

void clearpending(unsigned long bits)
{
	unsigned long mask;
	
	mask = __raw_readl(S3C2410_SRCPND);
	mask |= bits;
	__raw_writel(mask, S3C2410_SRCPND);
	
	mask = __raw_readl(S3C2410_INTPND);
	mask |= bits;
	__raw_writel(mask, S3C2410_INTPND);
	
	mask = __raw_readl(S3C2410_INTPND);
	
}

void button_gpio_init()
{
	s3c2410_gpio_cfgpin(S3C2410_GPF0, S3C2410_GPF0_EINT0);
	set_irq_type(S3C2410_GPF0_EINT0, IRQT_FALLING);
	clearpending(BIT_EINT0|BIT_EINT2|BIT_EINT8_23);	
}

/*
 * We export two simple devices.  There's no need for us to maintain any
 * special housekeeping info, so we just deal with raw cdevs.
 */
static struct cdev SimpleDevs;

/*
 * Module housekeeping.
 */
static int simple_init(void)
{
	int result;
	dev_t dev = MKDEV(simple_major, 0);

	/* Figure out our device number. */
	if (simple_major)
		result = register_chrdev_region(dev, 1, "simple");
	else {
		result = alloc_chrdev_region(&dev, 0, 1, "simple");
		simple_major = MAJOR(dev);
	}
	if (result < 0) {
		printk(KERN_WARNING "simple: unable to get major %d\n", simple_major);
		return result;
	}
	if (simple_major == 0)
		simple_major = result;

	/* Now set up two cdevs. */
	simple_setup_cdev(&SimpleDevs, 0, &simple_remap_ops);	
	printk("simple device installed, with major %d\n", simple_major);

	button_gpio_init();	
	result = request_irq (S3C2410_GPF0_EINT0, s3c2410but_keyevent,\
				SA_SAMPLE_RANDOM, "button1", NULL);	
	if (result) {
		printk(KERN_INFO "button: can't get assigned irq\n");
	}
	return 0;
}


static void simple_cleanup(void)
{
	cdev_del(&SimpleDevs);
	unregister_chrdev_region(MKDEV(simple_major, 0), 2);
	printk("simple device uninstalled\n");
	disable_irq(S3C2410_GPF0_EINT0);
	free_irq(S3C2410_GPF0_EINT0,NULL);
}

module_init(simple_init);
module_exit(simple_cleanup);