驱动的分离分层设计——按键点灯

源码附带注释：

key_dev.c

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/irq.h>
#include <asm/irq.h>
#include <asm/io.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/interrupt.h>
#include <linux/input.h>
#include <linux/bitmap.h>
#include <asm/gpio.h>
#include <linux/platform_device.h>

/*记录硬件相关资源*/
static struct resource key_rsrc[] = {  
    [0] = {      /*内存空间*/
        .start = 0x56000050,
        .end   = 0x56000050 + 8 -1,
        .flags = IORESOURCE_MEM
    },
    [1] = {
         /*GPF4,5,6*/
        .start = 4,    
        .end   = 6,
        .flags = IORESOURCE_IO   //flag随便取个什么，按照自己的想法来就行了
    }
};

static struct platform_device key_dev = {
    .name           = "key_led",
    .num_resources  = ARRAY_SIZE(key_rsrc),
    .resource       = key_rsrc
};

/*之所以要平台设备要注册进内核，是因为待会平台设备要根据平台name找到相应的设备
*然后获得硬件相关的资源
*/
static int key_dev_init(void)
{
   /*注册*/
   platform_device_register(&key_dev);
   return 0;
}

static void key_dev_exit(void)
{
    platform_device_unregister(&key_dev);
}

module_init(key_dev_init);
module_exit(key_dev_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("1653699780@qq.com");

key_drv.c

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/irq.h>
#include <asm/irq.h>
#include <asm/io.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/interrupt.h>
#include <linux/input.h>
#include <linux/bitmap.h>
#include <asm/gpio.h>
#include <linux/platform_device.h>

static volatile unsigned long *gpfcon;
static volatile unsigned long *gpfdat;

static struct timer_list key_time;

static struct class *key_class;

struct input_inode {
            char *name;
            unsigned int irq_type;
            unsigned int pin;
            unsigned int key_num;
};

static struct input_inode *irq_pd;
static struct resource *key_resource;
static struct resource *pin_resource;

static struct input_inode key[] = {
                 [0] = {
                         "EINT0",
                         IRQ_EINT0,
                         S3C2410_GPF(0),
                         0},
                 [1] = {
                        "EINT2",
                         IRQ_EINT2,
                         S3C2410_GPF(2),
                         1},
                 [2] = {
                        "EINT11",
                        IRQ_EINT11,
                        S3C2410_GPG(3),
                        2},
};

static irqreturn_t key_irq(int irq, void *dev_id)
{
     irq_pd = (struct input_inode *)dev_id;
     mod_timer(&key_time,jiffies + HZ/100); //延迟10ms,延迟过程中断仍然可以被触发
      
      return IRQ_HANDLED;
}

static void key_time_function(unsigned long data)
{
     unsigned int key_val;
     unsigned int pin_num;
     
     if(!irq_pd)
         return;

     key_val = s3c2410_gpio_getpin(irq_pd->pin);
     pin_num = pin_resource->start + irq_pd->key_num;
     
     if(key_val){
         
        (*gpfdat) |= (1<<pin_num);
        
     }else{
     
        (*gpfdat) &= ~(1<<pin_num);
        
     }
}

int key_open(struct inode *inode, struct file *file)
{
    int i;
    int pin_num;
    pin_num = pin_resource->end - pin_resource->start + 1;
    /*配置输出引脚*/
    for(i = 0; i < pin_num; i++){
        *gpfcon &= ~(3<<((pin_resource->start + i)* 2));
        *gpfcon |= (1<<((pin_resource->start + i)* 2));
    }
    
    return 0;
}

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

static int major;

static struct file_operations key_fops = {
           .owner   = THIS_MODULE,
           .open    = key_open,
           .release = key_release,
};
           
//驱动分离适合用probe函数
static int key_probe(struct platform_device *pdev) //需要枚举找到设备里面同名的pdev
{
    int i;
    int error;
     /*获得设备里面的硬件资源*/
    major = register_chrdev(0,"led_key",&key_fops); //cat /proc/devices 出现led_key
    key_class = class_create(THIS_MODULE,"key");
    device_create(key_class,NULL,MKDEV(major,0),NULL,"key0_led"); //次设备号0，/dev/key0_led
    
    key_resource = platform_get_resource(pdev, IORESOURCE_MEM,0);
    gpfcon = ioremap(key_resource->start,key_resource->end-key_resource->start + 1);
    gpfdat = gpfcon +1;

    pin_resource = platform_get_resource(pdev, IORESOURCE_IO,0);
    
    for(i = 0; i < 3; i++){
        error = request_irq(key[i].irq_type,key_irq,IRQ_TYPE_EDGE_BOTH,key[i].name,&key[i]);
        if(error){
          printk("couldn't get irq!
");
          return -1;
        }
    }

    init_timer(&key_time);
    key_time.function = key_time_function;
    add_timer(&key_time);

    return 0;
}

static int __devexit key_remove(struct platform_device *pdev)
{
    int i;
    del_timer(&key_time);
    for(i = 0; i < 3; i++){
      free_irq(key[i].irq_type,&key[i]);
    }
    unregister_chrdev(major,"led_key");
    class_destroy(key_class);
    device_destroy(key_class, MKDEV(major,0));
    return 0;
}

static struct platform_driver key_driver = {
    .driver = {
        .name    = "key_led",
        .owner    = THIS_MODULE,
    },
    .probe    = key_probe,
    .remove    = __devexit_p(key_remove),
};

static int key_drv_init(void)
{
    /*注册*/
    platform_driver_register(&key_driver);
    return 0;
}

static void key_drv_exit(void)
{
    platform_driver_unregister(&key_driver);
}

module_init(key_drv_init);
module_exit(key_drv_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("1653699780@qq.com");