fl2440开发板platform_button驱动

驱动程序如下：

此处省略了头文件。

/* Driver version*/

#define DRV_MAJOR_VER             1
#define DRV_MINOR_VER             0
#define DRV_REVER_VER             0


#define DEV_NAME                  DEV_BUTTON_NAME //设备名


//#define DEV_MAJOR               DEV_BUTTON_MAJOR
#ifndef DEV_MAJOR
#define DEV_MAJOR                 0 /* dynamic major by default */
#endif


#define BUTTON_UP                 0 /* Button status is up */ //按键状态定义
#define BUTTON_DOWN               1 /* Button status is pushed down */
#define BUTTON_UNCERTAIN          2 /* Button status uncerntain */


#define TIMER_DELAY_DOWN          (HZ/50)   /*Remove button push down dithering timer delay 20ms  */ //延时时间
#define TIMER_DELAY_UP            (HZ/10)   /*Remove button up dithering timer delay 100ms  */


static int debug = DISABLE;
static int dev_major = DEV_MAJOR;
static int dev_minor = 0;




/*============================ Platform Device part ===============================*/
/* Button hardware informtation structure*/
struct s3c_button_info //定义按键信息结构体
{
    unsigned char           num;       /*Button nubmer  */
    char *                  name;      /*Button nubmer  */
    int                     nIRQ;      /*Button IRQ number*/
    unsigned int            setting;   /*Button IRQ Pin Setting*/
    unsigned int            gpio;      /*Button GPIO port */
};


/* The button plaotform device private data structure */
struct s3c_button_platform_data //定义platform结构体
{
    struct s3c_button_info *buttons;
    int                     nbuttons;
};


/* Button hardware informtation data*/
static struct s3c_button_info  s3c_buttons[] = { //按键信息
    [0] = {
        .num = 1,
        .name = "KEY1",
        .nIRQ = IRQ_EINT0, //中断号
        .gpio = S3C2410_GPF(0), //对应管脚
        .setting = S3C2410_GPF0_EINT0, //对应管脚设置中断
    },
    [1] = {
        .num = 2,
        .name = "KEY2",
        .nIRQ = IRQ_EINT2,
        .gpio = S3C2410_GPF(2),
        .setting = S3C2410_GPF2_EINT2,
    },
    [2] = {
        .num = 3,
        .name = "KEY3",
        .nIRQ = IRQ_EINT3,
        .gpio = S3C2410_GPF(3),
        .setting = S3C2410_GPF3_EINT3,
    },
    [3] = {
        .num = 4,
        .name = "KEY4",
        .nIRQ = IRQ_EINT4,
        .gpio = S3C2410_GPF(4),
        .setting = S3C2410_GPF4_EINT4,
    },
};


/* The button platform device private data */
static struct s3c_button_platform_data s3c_button_data = { //定义按键结构体信息
    .buttons = s3c_buttons,
    .nbuttons = ARRAY_SIZE(s3c_buttons),
};


struct button_device //定义按键设备结构体
{
    unsigned char                      *status;      /* The buttons Push down or up status */
    struct s3c_button_platform_data    *data;        /* The buttons hardware information data */


    struct timer_list                  *timers;      /* The buttons remove dithering timers */
    wait_queue_head_t                  waitq;           /* Wait queue for poll()  */
    volatile int                       ev_press;     /* Button pressed event */


    struct cdev                        cdev;           
    struct class                       *dev_class; 
} button_device;


static void platform_button_release(struct device * dev) //定义驱动返回函数
{
    return; 
}


static struct platform_device s3c_button_device = { //定义按键设备信息
    .name    = "s3c_button",
    .id      = 1,
    .dev     = 
    {
        .platform_data = &s3c_button_data, 
        .release = platform_button_release,
    },
};


static irqreturn_t s3c_button_intterupt(int irq,void *de_id) //定义按键中断
{
    int i;
    int found = 0;
    struct s3c_button_platform_data *pdata = button_device.data;


    for(i=0; i<pdata->nbuttons; i++) //寻找发生中断的按键
    {
        if(irq == pdata->buttons[i].nIRQ) //成功找到，found=1
        {
            found = 1; 
            break;
        }
    }


    if(!found) /* An ERROR interrupt  */
        return IRQ_NONE;


    /* Only when button is up then we will handle this event */
    if(BUTTON_UP  == button_device.status[i]) //当发生中端时按键未使用，会产生未知状态
    {
       button_device.status[i] = BUTTON_UNCERTAIN;
       mod_timer(&(button_device.timers[i]), jiffies+TIMER_DELAY_DOWN);
    }


    return IRQ_HANDLED;
}




static void button_timer_handler(unsigned long data)  //实现按键状态
{
    struct s3c_button_platform_data *pdata = button_device.data;
    int num =(int)data;
    int status = s3c2410_gpio_getpin( pdata->buttons[num].gpio );


    if(LOWLEVEL == status) //当按键是低电平状态
    {
        if(BUTTON_UNCERTAIN == button_device.status[num]) /* Come from interrupt */ //如果按键为低电平查看之前是否为未知状态
        { //如果之前为未知现在为低电平，就是按下键
   
            button_device.status[num] = BUTTON_DOWN; //按键设置为按下


            printk("%s pressed.\n", pdata->buttons[num].name);


            /* Wake up the wait queue for read()/poll() */
            button_device.ev_press = 1;
            wake_up_interruptible(&(button_device.waitq)); //唤醒中断的程序
        }


        /* Cancel the dithering  */
        mod_timer(&(button_device.timers[num]), jiffies+TIMER_DELAY_UP); //检测按键是否工作，如果按键正在工作，会循环检测到按键不工作为止
    }
    else
    {
        
        button_device.status[num] = BUTTON_UP; //设置按键往上
  
    }


    return ;
}




/*===================== Button device driver part ===========================*/


static int button_open(struct inode *inode, struct file *file) //按键打开函数
{ 
    struct button_device *pdev ;
    struct s3c_button_platform_data *pdata;
    int i, result;


    pdev = container_of(inode->i_cdev,struct button_device, cdev); //container_of作用通过inobe找到结构体中的cdev
    pdata = pdev->data;
    file->private_data = pdev;


    /* Malloc for all the buttons remove dithering timer */
    pdev->timers = (struct timer_list *) kmalloc(pdata->nbuttons*sizeof(struct timer_list), GFP_KERNEL); //kmalloc在Linux内核中使用
    if(NULL == pdev->timers) //cdev中的timer分配内存
    {
        printk("Alloc %s driver for timers failure.\n", DEV_NAME);
        return -ENOMEM; //分配失败则返回
    }
    memset(pdev->timers, 0, pdata->nbuttons*sizeof(struct timer_list)); //初始化


    /* Malloc for all the buttons status buffer */
    pdev->status = (unsigned char *)kmalloc(pdata->nbuttons*sizeof(unsigned char), GFP_KERNEL); //按键状态分配空间
    if(NULL == pdev->status) //分配失败打印出错信息
    {
        printk("Alloc %s driver for status failure.\n", DEV_NAME);
        result = -ENOMEM; 
        goto  ERROR;
    }
    memset(pdev->status, 0, pdata->nbuttons*sizeof(unsigned char)); //初始化


    init_waitqueue_head(&(pdev->waitq)); //等待


    for(i=0; i<pdata->nbuttons; i++)  //初始化按键信息
    {
        /* Initialize all the buttons status to UP  */
        pdev->status[i] = BUTTON_UP;  //按键向上为未按状态


        /* Initialize all the buttons' remove dithering timer */
        setup_timer(&(pdev->timers[i]), button_timer_handler, i);


        /* Set all the buttons GPIO to EDGE_FALLING interrupt mode */
        s3c2410_gpio_cfgpin(pdata->buttons[i].gpio, pdata->buttons[i].setting); //设置管脚为中断模式
        irq_set_irq_type(pdata->buttons[i].nIRQ, IRQ_TYPE_EDGE_FALLING); //设置中断为下降沿中断


        /* Request for button GPIO pin interrupt  */
        result = request_irq(pdata->buttons[i].nIRQ, s3c_button_intterupt, IRQF_DISABLED, DEV_NAME, (void *)i); //中断请求的配置
        if( result )
        {
            result = -EBUSY;
            goto ERROR1; //出错打印信息
        }
    }


    return 0;


ERROR1:
     kfree((unsigned char *)pdev->status);
     while(--i) 
     { 
         disable_irq(pdata->buttons[i].nIRQ); 
         free_irq(pdata->buttons[i].nIRQ, (void *)i); 
     }


ERROR:
     kfree(pdev->timers);


     return result;
}


static int button_read(struct file *file, char __user *buf, size_t count, loff_t *ppos) //读取按键信息
{ 
    struct button_device *pdev = file->private_data;
    struct s3c_button_platform_data *pdata;
    int   i, ret;
    unsigned int status = 0;


    pdata = pdev->data;


    dbg_print("ev_press: %d\n", pdev->ev_press);
    if(!pdev->ev_press)
    { //读取按键在之前是为未按下状态，执行检测是否阻塞；否则报错加入等待
         if(file->f_flags & O_NONBLOCK)
         {
             dbg_print("read() without block mode.\n");
             return -EAGAIN;
         }
         else
         {
             /* Read() will be blocked here */
             dbg_print("read() blocked here now.\n");
             wait_event_interruptible(pdev->waitq, pdev->ev_press);
         }
    }


    pdev->ev_press = 0;

//如果按键已按下，设置为0。执行下面程序
    for(i=0; i<pdata->nbuttons; i++) //读取按键按下的状态信息保存到status中
    {
        dbg_print("button[%d] status=%d\n", i, pdev->status[i]);
        status |= (pdev->status[i]<<i); 
    }


    ret = copy_to_user(buf, (void *)&status, min(sizeof(status), count)); //把按键信息发送给用户


    return ret ? -EFAULT : min(sizeof(status), count);
}


static unsigned int button_poll(struct file *file, poll_table * wait) //按键监视函数
{ 
    struct button_device *pdev = file->private_data;
    unsigned int mask = 0;


    poll_wait(file, &(pdev->waitq), wait);
    if(pdev->ev_press)
    {
        mask |= POLLIN | POLLRDNORM; /* The data aviable */    //按下键设置mask的值
    }


    return mask; //返回mask，设置为0
}


static int button_release(struct inode *inode, struct file *file) //按键撤销函数
{ 
    int i;
    struct button_device *pdev = file->private_data;
    struct s3c_button_platform_data *pdata;
    pdata = pdev->data;


    for(i=0; i<pdata->nbuttons; i++) 
    {
        disable_irq(pdata->buttons[i].nIRQ);
        free_irq(pdata->buttons[i].nIRQ, (void *)i);
        del_timer(&(pdev->timers[i]));
    }

//释放定时器和状态信息的内存
    kfree(pdev->timers);
    kfree((unsigned char *)pdev->status);


    return 0;
}




static struct file_operations button_fops = {  //fopsh函数
    .owner = THIS_MODULE,
    .open = button_open, 
    .read = button_read,
    .poll = button_poll, 
    .release = button_release, 
};




static int s3c_button_probe(struct platform_device *dev) //注册主次设备号
{
    int result = 0;
    dev_t devno;




    /* Alloc the device for driver  */ 
    if (0 != dev_major) 
    { 
        devno = MKDEV(dev_major, dev_minor); 
        result = register_chrdev_region(devno, 1, DEV_NAME); 
    } 
    else 
    { 
        result = alloc_chrdev_region(&devno, dev_minor, 1, DEV_NAME); 
        dev_major = MAJOR(devno); 
    }


    /* Alloc for device major failure */
    if (result < 0) 
    { 
        printk("%s driver can't get major %d\n", DEV_NAME, dev_major); 
        return result; 
    }


    /*  Initialize button_device structure and register cdev*/
     memset(&button_device, 0, sizeof(button_device)); //结构体初始化

     button_device.data = dev->dev.platform_data;

     cdev_init (&(button_device.cdev), &button_fops); //cdev初始化
     button_device.cdev.owner  = THIS_MODULE;

     result = cdev_add (&(button_device.cdev), devno , 1);  //设备注册
     if (result) 
     { 
         printk (KERN_NOTICE "error %d add %s device", result, DEV_NAME); 
         goto ERROR; 
     }


     button_device.dev_class = class_create(THIS_MODULE, DEV_NAME);  //添加配置信息
     if(IS_ERR(button_device.dev_class)) 
     { 
         printk("%s driver create class failture\n",DEV_NAME); 
         result =  -ENOMEM; 
         goto ERROR; 
     }


#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)     
     device_create(button_device.dev_class, NULL, devno, NULL, DEV_NAME);
#else
     device_create (button_device.dev_class, NULL, devno, DEV_NAME);
#endif


     printk("S3C %s driver version %d.%d.%d initiliazed.\n", DEV_NAME, DRV_MAJOR_VER, DRV_MINOR_VER, DRV_REVER_VER);


     return 0;


ERROR: 
     printk("S3C %s driver version %d.%d.%d install failure.\n", DEV_NAME, DRV_MAJOR_VER, DRV_MINOR_VER, DRV_REVER_VER);
     cdev_del(&(button_device.cdev)); 
     unregister_chrdev_region(devno, 1);
     return result;
}




static int s3c_button_remove(struct platform_device *dev) //释放主次设备号给内存
{
    dev_t devno = MKDEV(dev_major, dev_minor);


    cdev_del(&(button_device.cdev));
    device_destroy(button_device.dev_class, devno);
    class_destroy(button_device.dev_class);


    unregister_chrdev_region(devno, 1); 
    printk("S3C %s driver removed\n", DEV_NAME);


    return 0;
}




/*===================== Platform Device and driver regist part ===========================*/


static struct platform_driver s3c_button_driver = {  //设备驱动结构体
    .probe      = s3c_button_probe, 
    .remove     = s3c_button_remove, 
    .driver     = { 
        .name       = "s3c_button", 
        .owner      = THIS_MODULE, 
    },
};




static int __init s3c_button_init(void) //按键初始函数
{
   int       ret = 0;


   ret = platform_device_register(&s3c_button_device); //加载按键设备，出错退出
   if(ret)
   {
        printk(KERN_ERR "%s: Can't register platform device %d\n", __FUNCTION__, ret); 
        goto fail_reg_plat_dev;
   }
   dbg_print("Regist S3C %s Device successfully.\n", DEV_NAME);


   ret = platform_driver_register(&s3c_button_driver); //加载按键驱动，出错退出
   if(ret)
   {
        printk(KERN_ERR "%s: Can't register platform driver %d\n", __FUNCTION__, ret); 
        goto fail_reg_plat_drv;
   }
   dbg_print("Regist S3C %s Driver successfully.\n", DEV_NAME);


   return 0;


fail_reg_plat_drv:
   platform_driver_unregister(&s3c_button_driver);
fail_reg_plat_dev:
   return ret;
}




static void s3c_button_exit(void) //按键退出函数
{
    platform_driver_unregister(&s3c_button_driver);
    dbg_print("S3C %s platform device removed.\n", DEV_NAME);


    platform_device_unregister(&s3c_button_device);
    dbg_print("S3C %s platform driver removed.\n", DEV_NAME);
}


module_init(s3c_button_init);
module_exit(s3c_button_exit);


module_param(debug, int, S_IRUGO);
module_param(dev_major, int, S_IRUGO);
module_param(dev_minor, int, S_IRUGO);


MODULE_AUTHOR(DRV_AUTHOR);
MODULE_DESCRIPTION(DRV_DESC);
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:S3C24XX_button");