按键驱动--platform设备的例子

http://blog.csdn.net/sjwangjinbao/archive/2010/12/26/6099210.aspx

下面将之前的按键驱动改写为platform设备。

1、建立文件夹Key+Platform

2、在文件夹Key+Platform下建立设备文件keydevice.c。

#include <linux/device.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/string.h>
#include <linux/platform_device.h>

MODULE_AUTHOR("WJB");
MODULE_LICENSE("Dual BSD/GPL");

static struct platform_device *my_device;

static int __init my_device_init(void)
{
 int ret = 0;
 
 my_device = platform_device_alloc("pf_key_dev", -1);

 ret =  platform_device_add(my_device);

 if(ret)
  platform_device_put(my_device);

 return ret;
}

static void my_device_exit(void)
{
 platform_device_unregister(my_device);
}

module_init(my_device_init);
module_exit(my_device_exit);

3、在文件夹Key+Platform下建立驱动文件keydriver.c。

#include <linux/device.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/string.h>
#include <linux/platform_device.h>
#include <linux/fs.h>
#include <linux/delay.h>
#include <linux/poll.h>
#include <linux/irq.h>
#include <asm/irq.h>
#include <asm/uaccess.h>
#include <mach/regs-gpio.h>
#include <mach/hardware.h>
#include <linux/platform_device.h>
#include <linux/cdev.h>
#include <linux/miscdevice.h>
#include <linux/gpio.h>
#include <linux/interrupt.h>
#include <linux/sched.h>

MODULE_AUTHOR("WJB");
MODULE_LICENSE("Dual BSD/GPL");

#define DEVICE_NAME "pf_key_dev"

struct button_irq_desc{
 int irq;
 int pin;
 int number;
 char *name;
};

static struct button_irq_desc button_irqs[] = {
 {IRQ_EINT8, S3C2410_GPG(0), 0, "KEY0"},
 {IRQ_EINT11, S3C2410_GPG(3), 1, "KEY1"},
 {IRQ_EINT13, S3C2410_GPG(5), 2, "KEY2"},
 {IRQ_EINT14, S3C2410_GPG(6), 3, "KEY3"},
 {IRQ_EINT15, S3C2410_GPG(7), 4, "KEY4"},
 {IRQ_EINT19, S3C2410_GPG(11), 5, "KEY5"},
};

static volatile char key_values[] = {'0', '0', '0', '0', '0', '0'};
static DECLARE_WAIT_QUEUE_HEAD(button_waitq);

static volatile int ev_press = 0;

static irqreturn_t buttons_interrupt(int irq, void* dev_id)
{
 struct button_irq_desc *button_irqs = (struct button_irq_desc*)dev_id;
 int down;
 
 down = !s3c2410_gpio_getpin(button_irqs->pin);

 if(down != (key_values[button_irqs->number] & 1))
 {
  key_values[button_irqs->number] = '0' + down;

  ev_press = 1;

  wake_up_interruptible(&button_waitq);
 }
 
 return IRQ_RETVAL(IRQ_HANDLED);
}

static int s3c24xx_buttons_open(struct inode* inode, struct file* file)
{
 int i;
 int err;
 
 for(i = 0; i < sizeof(button_irqs)/sizeof(button_irqs[0]); i++)
 {
  if(button_irqs[i].irq < 0)
  {
   continue;
  }

  err = request_irq(button_irqs[i].irq, buttons_interrupt, IRQ_TYPE_EDGE_BOTH, button_irqs[i].name, (void *)&button_irqs[i]);
  if(err)
  {
   break;
  }
 }
 if(err)
 {
  i--;
  for(; i >= 0; i--)
  {
   if(button_irqs[i].irq < 0)
   {
    continue;
   }
   disable_irq(button_irqs[i].irq);
   free_irq(button_irqs[i].irq, (void*)&button_irqs[i]);
  }
  return -EBUSY;
 }

 ev_press = 1;

 return 0;
}

static int s3c24xx_buttons_close(struct inode* inode, struct file* file)
{
 int i;
 
 for(i = 0; i < sizeof(button_irqs)/sizeof(button_irqs[0]); i++)
 {
  if(button_irqs[i].irq < 0)
  {
   continue;
  }
  free_irq(button_irqs[i].irq, (void*)&button_irqs[i]);
 }

 return 0;
}

static int s3c24xx_buttons_read(struct file* filp, char __user *buff, size_t count, loff_t *offset)
{
 unsigned long err;
 
 if(!ev_press)
 {
  if(filp->f_flags & O_NONBLOCK)
  {
   return -EAGAIN;
  }
  else
  {
   wait_event_interruptible(button_waitq, ev_press);
  }
 }

 ev_press = 0;

 err = copy_to_user(buff, (const void*)key_values, min(sizeof(key_values), count));
 
 return err ? -EFAULT : min(sizeof(key_values), count);
}

static unsigned int s3c24xx_buttons_poll(struct file* file, struct poll_table_struct *wait)
{
 unsigned int mask = 0;

 poll_wait(file, &button_waitq, wait);
 
 if(ev_press)
 {
  mask |= POLLIN | POLLRDNORM;
  return mask;
 }
}

static struct file_operations dev_fops = {
 .owner = THIS_MODULE,
 .open = s3c24xx_buttons_open,
 .release = s3c24xx_buttons_close,
 .read = s3c24xx_buttons_read,
 .poll = s3c24xx_buttons_poll,
};

static struct miscdevice misc = {
 .minor = MISC_DYNAMIC_MINOR,
 .name = DEVICE_NAME,
 .fops = &dev_fops,
};

static int my_probe(struct device* dev)
{
 int ret;
 ret = misc_register(&misc);
 
 printk("driver found device which my driver can handle!\n");
 return 0;
}

static int my_remove(struct device* dev)
{
 misc_deregister(&misc);
 printk("drvier found device unpluged!\n");
}

static struct platform_driver my_driver = {
 .probe = my_probe,
 .remove = my_remove,
 .driver = {
  .owner = THIS_MODULE,
  .name = "pf_key_dev",
 },
};

static int __init my_driver_init(void)
{
 return platform_driver_register(&my_driver);
}

static void my_driver_exit(void)
{
 platform_driver_unregister(&my_driver);
}

module_init(my_driver_init);
module_exit(my_driver_exit);

 

4、Makefile

ifneq ($(KERNELRELEASE), )

obj-m := keydriver.o keydevice.o

else

KDIR := /usr/src/linux-2.6.32.2

all:
 make -C $(KDIR) M=$(PWD) modules ARCH=arm CROSS_COMPILE=arm-linux-
clean:
 rm -f *.ko *.o *.mod.o *.mod.c *.symvers

endif

5、执行make。

得到keydevice.ko和keydriver.ko。

6、编写应用程序。

其实此时的应用程序和之前的应用程序是一样的，只是修改下设备名字就好了。

7、将生成的应用程序以及keydevice.ko和keydriver.ko拷贝到开发板上的某个目录下。

执行insmod keydevice.ko和insmod keydriver.ko以后，我们发现/dev下已经多了个设备pf_key_dev。同时，在/sys/bus/platform/devices也发现了我们的设备pf_key_dev，在/sys/bus/platform/drivers也发现了我们的设备驱动pf_key_dev。

执行应用程序，效果和之前的一模一样。