Linux下基于fl2440开发板platform按键驱动详解（一）

最新推荐文章于 2019-04-08 17:07:34 发布
置顶 最新推荐文章于 2019-04-08 17:07:34 发布
阅读量533 收藏
点赞数
分类专栏： linux内核驱动 文章标签： platform驱动 fl2440 button驱动 中断
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qicheng777/article/details/70228496
版权

===============================================

操作系统：center os 64位

平台：fl2440

内核版本：Linux 3.0.54

交叉编译器版本：2012.08

===============================================

#include "s3c_driver.h"
#define DRV_AUTHOR                "497049229@qq.com"
#define DRV_DESC                  "S3C24XX button driver"

/* 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 platform device private data structure */
struct s3c_button_platform_data
{
    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; 
            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 */
        {
            //dbg_print("Key pressed!\n");
            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
    {
        //dbg_print("Key Released!\n");
        button_device.status[num] = BUTTON_UP;
     //   enable_irq(pdata->buttons[num].nIRQ);
    }

    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);
    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);
    if(NULL == pdev->timers)
    {
        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;

    for(i=0; i<pdata->nbuttons; i++)
    {
        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 */ 
    }

    return mask;
}

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 = { 
    .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);
     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");


      关于平台以及设备注册，以及设备号的分配与注册等等就不一一介绍了，在之前关于led的platform驱动中以及作过介绍。所以就按键驱动其他几个主要部分再做一些阐述。


一、中断部分：

static irqreturn_t s3c_button_intterupt(int irq,void *de_id)
{
    int i;
    int found = 0;        //通过found的值来判断是否产生了中断
    struct s3c_button_platform_data *pdata = button_device.data;

    for(i=0; i<pdata->nbuttons; i++)
    {
        if(irq == pdata->buttons[i].nIRQ)
        {
            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;
}
      这里的定时器函数 mod_timer()用于去抖动。因为按键按下时可能产生抖动，所以引入定时器概念来忽略这段可能产生抖动的时间。这段时间内转而去执行定时器超时函数。中断函数的注册在open(）函数中进行，待会介绍。

更多中断相关内容请参考：http://blog.csdn.net/qicheng777/article/details/70194695


二、定时器超时函数：

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 */
        {
            //dbg_print("Key pressed!\n");
            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;     //值为1表示事件发生
            wake_up_interruptible(&(button_device.waitq)); //唤醒等待的操作，往下继续执行
        }

        /* Cancel the dithering  */
        mod_timer(&(button_device.timers[num]), jiffies+TIMER_DELAY_UP); 
    }
    else
    {
        //dbg_print("Key Released!\n");
        button_device.status[num] = BUTTON_UP;
     //   enable_irq(pdata->buttons[num].nIRQ);
    }

    return ;
}
       中断发生时，定时器去抖产生超时。超时期间执行本段函数。函数主要用于检测按键是否有效，如果有效，则唤醒等待的队列。此处调用mod_timer()函数延时用于等待按键为电平为止，以便进入if语句唤醒队列。


三、open()函数：

     

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);  //获得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);
    if(NULL == pdev->timers)
    {
        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;
}
     open()函数理解起来其实很简单。无非就是做一些 内存的分配，以及 初始化工作。不过这里多引入了关于中断的注册，以及将中断设置为下降沿触发（ EDGE_FALLING）。


四、read（）函数：

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)   //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;

    
for(i=0; i<pdata->nbuttons; i++)
    {
        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);}



       值得一提的是，如果文件以阻塞的方式打开的话，read()函数如果未读取到数据（按键状态）则会发生阻塞，如果不引入中断概念，则cpu将永远阻塞在此处。此处，read函数调用wait_event_interruptible()将进程挂起，等待中断函数处理完成后唤醒，所以接下来介绍一个函数poll() 用于将一些操作丢进等待队列，待中断唤醒后方可继续执行。


       read（）函数主要是用来读取按键，发生阻塞后等待中断返回唤醒。唤醒后继续执行下面函数：


for(i=0; i<pdata->nbuttons; i++)
    {
        dbg_print("button[%d] status=%d\n", i, pdev->status[i]);
        status |= (pdev->status[i]<<i); 
    }
      并把内核数据传给用户空间，最后返回一个ret的值，ret储存了所有按键对应的status，每个按键对应一个值，所以应用定义按键时，需和此处的对应。分别对应1<<1,1<<2,1<<3,1<<4。





五、poll()函数：



       应用程序调用select（）函数时会调用此函数用于监听函数。将设备信息丢入等待队列，便于唤醒后继续执行。此函数在系统调用select内部被使用，作用是把当前的文件指针挂到设备内部定义的等待，定义在#include
 <poll.h>中。和epoll，select类似可用来查询某个或多个文件描述符的读取或写入是否被阻塞。如果驱动程序将poll的方法定义为NULL，则设备被认为可读也可写，并且不会阻塞。






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 */   //表示可读可写
    }

    return mask;
}



    相关测试程序以及select具体用法请参考第二篇：


http://blog.csdn.net/qicheng777/article/details/70229456





    

















                

        

        

    

  


    

      

        

            

              
                
                  qicheng777
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









                



	

		

			

				
					
Linux设备驱动之button按键驱动学习与小结

				
			

			

				

					
				

				

					04-18
					
					7697
					
				

			

		

		

			
				
button按键驱动，相对于前面的LED驱动来说。增加了中断服务程序以及等待队列等新知识点。
先上学习的驱动代码。


/*********************************************************************************
 *      Copyright:  (C) 2011 Guo Wenxue  
 *

			
		

	



                

            
              



	

		

			

				
					
jz2440开发板实现视频监控

				
			

			

				

					06-13
				

			

		

		

			
				
为了使Linux系统能够在jz2440开发板上运行，还需要构建一个完整的根文件系统。这一过程涉及到安装各种库文件、工具链以及其他应用程序。  #### 四、移植驱动 除了上述步骤外，还需要对特定的硬件设备进行驱动移植，...

			
		

	



              


  
              

                


	

		

			

				
					
linux驱动开发fl2440开发板按键驱动

				
			

			

				

					LYX_WIN
				

				

					07-30
					
					1047
					
				

			

		

		

			
				
linux驱动开发fl2440开发板按键驱动
[leiyuxing@centos6 input_kbd]$ ls
kbd_device.c  kbd_driver.c event_button.c kbd_driver.h Makefile
驱动相关头文件kbd_driver.h:
/************************************************

			
		

	





	

		

			

				
					
fl2440 platform 按键驱动的制作和测试

				
			

			

				

					luliteng的博客
				

				

					05-07
					
					348
					
				

			

		

		

			
				
在led驱动的基础上，继续学习按键驱动
Makefile
  1
  2 obj-m := s3c_button.o
  3 KERNEL_DIR := ~/fl2440/kernel/linux-3.0.54/ 
  4 PWD := $(shell pwd)
  5 all:
  6     make -C $(KERNEL_DIR) SUBDIRS=$(PWD) modules

			
		

	



		

			
		



	

		

			

				
					
mini2440裸机之按键（1）

				
			

			

				

					dfl448866的专栏
				

				

					04-08
					
					312
					
				

			

		

		

			
				
1 了解基本的硬件连接



2 按键进行扫描方式操作

1） 按键gpio输入模式上拉输入

2) 按键进行消抖处理

gpio相关寄存器的功能描述

<1> 端口配置寄存器（GPACON 至GPJCON）
S3C2440A 中，大多数端口为复用引脚。因此要决定每个引脚选择哪项功能。PnCON（引脚控制寄存器）决
定了每个引脚使用哪项功能。如果在掉电模式中PE0 至PE7 用于...

			
		

	





	

		

			

				
					
huaqing_摄像头驱动_linux_4412开发板_按键_

				
			

			

				

					10-03
				

			

		

		

			
				
在本文中，我们将深入探讨如何在基于Samsung Exynos4412处理器的开发板上为摄像头和按键编写驱动程序，以及如何管理相关的硬件资源。  标题中的“huaqing_摄像头驱动_linux_4412开发板_按键_”暗示我们将讨论针对...

			
		

	





	

		

			

				
					
基于jz2440开发板的linux-4.9版本内核移植.zip

					
最新发布

				
			

			

				

					02-11
				

			

		

		

			
				
本教程主要围绕基于JZ2440开发板的Linux-4.9版本内核移植进行详细讲解，旨在帮助开发者理解这一过程，提升在嵌入式Linux系统开发中的实践能力。  JZ2440是一款广泛应用的嵌入式微处理器，由君正公司设计，基于MIPS32...

			
		

	





	

		

			

				
					
FL2440开发板内核移植笔记

				
			

			

				

					04-26
				

			

		

		

			
				
《FL2440开发板内核移植笔记》是一份详尽记录了在FL2440开发板上移植Linux内核的过程和技术要点的文档。FL2440是一款基于Samsung S3C2440处理器的嵌入式开发板，广泛应用于各种嵌入式系统设计。Linux内核移植是将...

			
		

	





	

		

			

				
					
fl2440开发板platform_button驱动

				
			

			

				

					KarinaCristall的博客
				

				

					07-16
					
					408
					
				

			

		

		

			
				
驱动程序如下：
此处省略了头文件。
/* Driver version*/
#define DRV_MAJOR_VER             1
#define DRV_MINOR_VER             0
#define DRV_REVER_VER             0


#define DEV_NAME                  DEV_BUTTON

			
		

	





	

		

			

				
					
TQ2440开发板按键点亮LED驱动开发详解

				
			

			

				

					05-15
				

			

		

		

			
				
### TQ2440开发板按键点亮LED驱动开发详解  #### 一、驱动开发流程概述  本篇文章详细记录了作者在TQ2440开发板上实现按键点亮LED驱动开发的过程，其中包括了硬件原理图分析、软件编程等多个方面。通过本篇文档的...

			
		

	





	

		

			

				
					
platform按键驱动（二）——编程测试实例以及select（）函数详解

				
			

			

				

					qicheng777的博客
				

				

					04-18
					
					3738
					
				

			

		

		

			
				
一、测试程序：
    之前对按键驱动程序原理大概进行了分析，那么现在给出测试程序了。。。


/*********************************************************************************
 *      Copyright:  (C) 2017 qicheng
 *                  All righ

			
		

	





	

		

			

				
					
Linux内核之 中断以及中断处理程序

				
			

			

				

					qicheng777的博客
				

				

					04-16
					
					1636
					
				

			

		

		

			
				
人生若只如初见，何事秋风悲画扇。
                                                                  --------纳兰容若   《木兰花令·拟古决绝词》



一、什么是中断：
       
linux管理所有的硬件设备，要做的第一件事先是通信。然而CPU的处理速度要远快于外围设备，总不能让CPU一直在等待外围设备

			
		

	





	

		

			

				
					
linux下基于S3C2440的PWM蜂鸣器移植以及驱动程序分析

				
			

			

				

					qicheng777的博客
				

				

					04-20
					
					1472
					
				

			

		

		

			
				
==========================================================================

主机操作系统：Centos 6.7 
交叉编译器环境：arm-linux-gcc-4.5.4 （可通过命令/opt/buildroot-2012.08/arm920t/usr/bin/arm-linux-gcc -v查询）
开发板平台： f

			
		

	





	

		

			

				
					
Linux下fl2440之led驱动编写以及测试

				
			

			

				

					qicheng777的博客
				

				

					04-06
					
					1027
					
				

			

		

		

			
				
===============================================
操作系统：center os
平台：fl2440
内核版本：linux 3.0.54
交叉编译器版本：2012.08
===============================================
驱动：
       程序即添加到操作系统中的一小块代码，其中包含有关硬件设

			
		

	





	

		

			

				
					
s3c2440之uda1341声卡驱动以及madplay播放器移植

				
			

			

				

					qicheng777的博客
				

				

					04-19
					
					914
					
				

			

		

		

			
				
===================================================

主机操作系统：Centos 6.7 
交叉编译器环境：arm-linux-gcc-4.5.4 （可通过命令/opt/buildroot-2012.08/arm920t/usr/bin/arm-linux-gcc -v查询）
开发板平台： fl2440 
Linux内核版本： linu

			
		

	





	

		

			

				
					
Linux下基于Platform总线led驱动学习（一）

				
			

			

				

					qicheng777的博客
				

				

					04-07
					
					883
					
				

			

		

		

			
				
===============================================

操作系统：center os 64位

平台：fl2440

内核版本：Linux 3.0.54

交叉编译器版本：2012.08

===============================================
       通常情况下，Linux设备和驱动通常

			
		

	





	

		

			

				
					
Linux下基于Platform的led驱动（二）——测试

				
			

			

				

					qicheng777的博客
				

				

					04-07
					
					831
					
				

			

		

		

			
				
之前，我们熟悉了platform的驱动相关知识，现在我们要对其进行相关测试。
     首先，我们需要写好makefile来生成.ko文件。
 
Makefile如下：      
RCH = s3c2440
KERNEL_VER = linux-3.0.54                                       //内核版本，必须与开发板相同
LINUX_SRC ?

			
		

	





	

		

			

				
					
fl2440——linux内核自带的led驱动添加

				
			

			

				

					qicheng777的博客
				

				

					04-23
					
					747
					
				

			

		

		

			
				
======================================================================================================================  


主机操作系统：Centos 6.7 
交叉编译器环境：arm-linux-gcc-4.5.4 （可通过命令/opt/buildroot-2012.

			
		

	





	

		

			

				
					
fl2440——内核自带按键驱动的移植与测试

				
			

			

				

					qicheng777的博客
				

				

					04-25
					
					639
					
				

			

		

		

			
				
陌上人如玉，公子世无双。雨虽大，但心境不能乱，是时候静下心来好好整理一篇博客了！
一、

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值