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

最新推荐文章于 2023-07-25 09:21:38 发布
原创 最新推荐文章于 2023-07-25 09:21:38 发布 · 393 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#FL2440 #platform 按键驱动 制作 #Makefile #plat_button.c驱动内容 #led_button.c按键驱动测试代码

在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
  7 clean:
  8      rm *.o *.ko *.mod.c
  9 
 10  .PHONY:clean

plat_button.c驱动内容

#include "s3c_driver.h"


#define DRV_AUTHOR                "Guo Wenxue <guowenxue@gmail.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 plaotform 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,//这边要改的和.c文件名一样
    .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_kbd", 
        .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");

vim plat_ioctl.h 头文件

 
 17 #ifndef __PLAT_IOCTL_H
 18 #define __PLAT_IOCTL_H
 19 
 20 #include <asm/ioctl.h>
 21 
 22 /*===========================================================================
 23  *                Common ioctl command definition 
 24  *===========================================================================*/
 25 
 26 #define PLATDRV_MAGIC           0x60
 27 
 28 /*===========================================================================
 29  *                 ioctl command for all the drivers 0x01~0x0F
 30  *===========================================================================*/
 31 
 32 /*args is enable or disable*/
 33 #define SET_DRV_DEBUG               _IO (PLATDRV_MAGIC, 0x01)
  1 /*********************************************************************************
  2  *  Copyright(c)  2011, Guo Wenxue <guowenxue@gmail.com>
  3  *  All ringhts reserved.
  4  *
  5  *     Filename:  s3c_ioctl.h
  6  *  Description:  ioctl() cmd argument definition here
  7  *
  8  *     ChangLog:
  9  *      1,   Version: 1.0.0
 10  *              Date: 2011-08-10
 11  *            Author: guowenxue <guowenxue@gmail.com>
 12  *       Descrtipion: Initial first version
 13  *
 14  *
 15  ********************************************************************************/
 16 
 17 #ifndef __PLAT_IOCTL_H
 18 #define __PLAT_IOCTL_H
 19 
 20 #include <asm/ioctl.h>
 21 
 22 /*===========================================================================
 23  *                Common ioctl command definition 
 24  *===========================================================================*/
 25 
 26 #define PLATDRV_MAGIC           0x60
 27 
 28 /*===========================================================================
 29  *                 ioctl command for all the drivers 0x01~0x0F
 30  *===========================================================================*/
 31 
 32 /*args is enable or disable*/
 33 #define SET_DRV_DEBUG               _IO (PLATDRV_MAGIC, 0x01)
 plat_ioctl.h                                                                                                                       
 34 #define GET_DRV_VER                 _IO (PLATDRV_MAGIC, 0x02)
 35 
 36 /*===========================================================================
 37  *                 ioctl command for few ioctl() cmd driver 0x10~0x2F
 38  *===========================================================================*/
 39 
 40 /* LED driver */
 41 #define LED_OFF                     _IO (PLATDRV_MAGIC, 0x18)
 42 #define LED_ON                      _IO (PLATDRV_MAGIC, 0x19)
 43 #define LED_BLINK                   _IO (PLATDRV_MAGIC, 0x1A)
 44 #define ADC_SET_CHANNEL             _IO (PLATDRV_MAGIC, 0x1B)
 45 
 46 /*===========================================================================
 47  *                   ioctl command for GPRS driver 0x30~0x4F
 48  *===========================================================================*/
 49 #define GPRS_POWERDOWN              _IO (PLATDRV_MAGIC, 0x30)
 50 #define GPRS_POWERON                _IO (PLATDRV_MAGIC, 0x31)
 51 #define GPRS_RESET                  _IO (PLATDRV_MAGIC, 0x32)
 52 #define GPRS_POWERMON               _IO (PLATDRV_MAGIC, 0x33)
 53 #define GPRS_CHK_SIMDOOR            _IO (PLATDRV_MAGIC, 0x36)
 54 #define GPRS_SET_DTR                _IO (PLATDRV_MAGIC, 0x37)
 55 #define GPRS_SET_RTS                _IO (PLATDRV_MAGIC, 0x38)
 56 #define GPRS_GET_RING               _IO (PLATDRV_MAGIC, 0x39)
 57 #define SET_PWUP_TIME               _IO (PLATDRV_MAGIC, 0x3A)
 58 #define SET_PWDOWN_TIME             _IO (PLATDRV_MAGIC, 0x3B)
 59 #define SET_RESET_TIME              _IO (PLATDRV_MAGIC, 0x3C)
 60 #define GPRS_CHK_MODEL              _IO (PLATDRV_MAGIC, 0x3E) 
 61 
 62 /*===========================================================================
 63  *                   ioctl command for EEPROM driver 0x50~0x5F
 64  *===========================================================================*/
 65 #define LL_POWEROFF                 _IO (PLATDRV_MAGIC, 0x50)
 66 #define LL_POWERON                  _IO (PLATDRV_MAGIC, 0x51)
 67 #define LL_STOP                     _IO (PLATDRV_MAGIC, 0x52)
 68 #define LL_START                    _IO (PLATDRV_MAGIC, 0x53)
 69 #define LL_READ                     _IO (PLATDRV_MAGIC, 0x54)
 70 #define LL_WRITE                    _IO (PLATDRV_MAGIC, 0x55)
 71 #define LL_DATALOW                  _IO (PLATDRV_MAGIC, 0x56)
 72 #define LL_ACKNAK                   _IO (PLATDRV_MAGIC, 0x57)
 73 
 74 
 75 #endif                          /* __PLAT_IOCTL_H */

s3c_driver.h

#ifndef __S3C_DRIVER_H
#define __S3C_DRIVER_H


#include <linux/version.h>
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/kref.h>
#include <linux/spinlock.h>
#include <asm/uaccess.h>
#include <linux/mutex.h>
#include <linux/delay.h>
#include <linux/fs.h>
#include <linux/device.h>
#include <linux/i2c.h>
#include <linux/string.h>
#include <linux/bcd.h>
#include <linux/miscdevice.h>
#include <linux/poll.h>
#include <linux/irq.h>
#include <linux/interrupt.h>
#include <linux/sysfs.h>
#include <linux/proc_fs.h>
#include <linux/rtc.h>
#include <linux/spinlock.h>
#include <linux/usb.h>
#include <asm/uaccess.h>
#include <asm/delay.h>
#include <linux/syscalls.h>  /* For sys_access*/
#include <linux/platform_device.h>
#include <linux/unistd.h>
#include <linux/tty.h>
#include <linux/tty_flip.h>
#include <linux/serial.h>
#include <linux/serial_core.h>
#include <linux/irq.h>
#include <mach/regs-gpio.h>
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,32)
#include <mach/hardware.h>
#include <mach/gpio.h>
#include <asm/irq.h>
#else 
#include <asm-arm/irq.h>
#include <asm/arch/gpio.h>
#include <asm/arch/hardware.h>
#endif
#include "plat_ioctl.h"


/* ===========================================================================
 *         S3C24XX device driver common macro definition 
 *===========================================================================*/


#define ENPULLUP                    1
#define DISPULLUP                   0


#define HIGHLEVEL                   1
#define LOWLEVEL                    0


#define INPUT                       1
#define OUTPUT                      0


#define OFF                         0
#define ON                          1


#define ENABLE                      1
#define DISABLE                     0


#define TRUE                        1
#define FALSE                       0


/* ===========================================================================
 *         S3C24XX device driver name and Major number define 
 *===========================================================================*/




#define DEV_LED_NAME                "led"
#define DEV_LED_MAJOR               203


#define DEV_BUTTON_NAME             "button"
#define DEV_BUTTON_MAJOR            "211"


#define DEV_ADC_NAME                "adc"
#define DEV_ADC_MAJOR               "212"


/*  ***** Bit Operate Define *****/
#define SET_BIT(data, i)   ((data) |=  (1 << (i)))    /*   Set the bit "i" in "data" to 1  */
#define CLR_BIT(data, i)   ((data) &= ~(1 << (i)))    /*   Clear the bit "i" in "data" to 0 */
#define NOT_BIT(data, i)   ((data) ^=  (1 << (i)))    /*   Inverse the bit "i" in "data"  */
#define GET_BIT(data, i)   ((data) >> (i) & 1)        /*   Get the value of bit "i"  in "data" */
#define L_SHIFT(data, i)   ((data) << (i))            /*   Shift "data" left for "i" bit  */
#define R_SHIFT(data, i)   ((data) >> (i))            /*   Shift "data" Right for "i" bit  */




/* ===========================================================================
 *         S3C24XX device driver common function definition 
 *===========================================================================*/


#define SLEEP(x)    {DECLARE_WAIT_QUEUE_HEAD (stSleep); if (10 > x) mdelay ((x * 1000)); \
                        else wait_event_interruptible_timeout (stSleep, 0, (x / 10));}


#define VERSION_CODE(a,b,c)       ( ((a)<<16) + ((b)<<8) + (c))
#define DRV_VERSION               VERSION_CODE(DRV_MAJOR_VER, DRV_MINOR_VER, DRV_REVER_VER)
#define MAJOR_VER(a)              ((a)>>16&0xFF)
#define MINOR_VER(a)              ((a)>>8&0xFF)
#define REVER_VER(a)              ((a)&0xFF)


#define dbg_print(format,args...) if(DISABLE!=debug) \
        {printk("[kernel] ");printk(format, ##args);}    


static inline void print_version(int version)
{
#ifdef __KERNEL__
        printk("%d.%d.%d\n", MAJOR_VER(version), MINOR_VER(version), REVER_VER(version));
#else
        printf("%d.%d.%d\n", MAJOR_VER(version), MINOR_VER(version), REVER_VER(version));
#endif
}




#endif /* __S3C_DRIVER_H */

把Makefile,s3c_button.c,plat_ioctl.h,s3c_driver.h放在同一个文件夹中编译

make之后产生s3c_button.然后传到开发板，接下来再做按键驱动测试程序。

led_button.c(按键驱动测试代码)

#include <stdio.h>
#include <stdlib.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <unistd.h>
#include <linux/fb.h>
#include <sys/mman.h>


#define KEY1 0x01
#define KEY2 0x02
#define KEY3 0x04
#define KEY4 0x08
#define PLATDRV_MAGIC   0x60
#define OFF _IO (PLATDRV_MAGIC,0x18)
#define ON _IO (PLATDRV_MAGIC,0X19)
#if 0
int  fork_1()
{    
     int pid = 0;
     pid = fork();      
     if(pid < 0)
     {
         printf("failed to fork!\n");
         return 1;
     }
     if(pid > 0)
     {
         wait(NULL);
     }

     else
     {
         execl("/bin/cp", "cp", "dev/fb0", "qwe", NULL);
     }
     return 0;
}

int fork_2()
{
    int pid = 0;
    pid = fork();
    if(pid < 0)
    {
         printf("failed to fork!\n");
         return 1;
    }

    if(pid > 0)
    {
         wait(NULL);
    }

    else
    {
         execl("/bin/tftp","tftp", "-p", "-r", "qwe", "192.168.1.8", NULL);
    }
    return 0;   
}
#endif

int main (int argc, char **argv)
{
    int button_fd;
    int led_fd;
    int ret_button;
    int current_button;
	int i=1;
	int j=1;
	int x=1;
	int y=1;
       

    button_fd = open("/dev/button", 0);
    
    

    if (button_fd < 0)
    {
        printf("open button failed.\n");
        exit(1);
    }
	
	while (1)
    {
        ret_button = read(button_fd, ¤t_button, sizeof(4));
        if (ret_button != sizeof(current_button))
        {
            printf("Read() button failed.\n");
        }
		
		else
		{
		    if (current_button == KEY1)
			{ 
                led_fd = open("/dev/led0",O_RDWR,755);
		        
                
                switch (i%2)
                {
                     case 0:
                          ioctl(led_fd, OFF, 0);
                          i++;
                          printf("Turn led0 OFF.\n");
                          break;

                     case 1:
                          ioctl(led_fd, ON, 0);
                          i++;
                          printf("Turn led0 ON.\n"); 
                          break;
				}
				
			}
			
			else if (current_button == KEY2)
			{
                   
                led_fd = open("/dev/led1",O_RDWR,755);
			    switch (j%2)
                {
                     case 0:
                          ioctl(led_fd, OFF, 1);
                          j++;
                          printf("Turn led1 OFF.\n");
                          break;
                     case 1:
                          ioctl(led_fd, ON, 1);
                          j++;
                          printf("Turn led1 ON.\n");
                          break;
				}
			}
			
			else if (current_button == KEY3)
			{
                led_fd = open("/dev/led2",O_RDWR,755);
			    switch (x%2)
                {
                     case 0:
                          ioctl(led_fd, OFF, 2);
                          x++;
                          printf("Turn led2 OFF.\n");
                          break;
                     case 1:
                          ioctl(led_fd, ON, 2);
                          x++;
                          printf("Turn led2 ON.\n");
                          break;
				}
				
			}
		    
		    else if (current_button == KEY4)
			{
                led_fd = open("/dev/led3",O_RDWR,755);
			    switch (y%2)
                {
                     case 0:
                          ioctl(led_fd, OFF, 3);
                          y++;
                          printf("Turn led3 OFF.\n");
                          break;
                     case 1:
                          ioctl(led_fd, ON, 3);
                          y++;
                          printf("Turn led3 ON.\n");
                          break;
				}
				
			}
	    }	
	
		
	
	}
	ioctl(led_fd,OFF);
    close(led_fd);
    close(button_fd);
	return 0;
}
运用交叉编译器执行armgcc led_button.c -o   led_button(其中armgcc是我定义的变量)

将生成的led_button可执行文件也传到开发板板上


按按键观看led的变化  测试就做完了！

luliteng
关注
platform总线按键驱动分析（精华版）
樊茂林的博客
08-28 2358
驱动做了三个多星期了，从helloworld到LED再到PlatformLED，现在终于到了按键驱动，对于驱动的理解深刻了不少，从完全看不懂到现在能够独立分析，进步很大，今天完成了按键驱动，做一个总结性的分享，给后面的自己看！加油！按键驱动：与之前不同，这次将按
STM32MP157驱动开发——按键驱动（定时器）
NRWHF的博客
07-25 1128
定时器涉及函数参考内核源码：include\linux\timer.h：主要是初始化 timer_list 结构体，设置其中的函数、参数。
详细注释FL2440按键中断驱动（含poll机制），测试成功
bbs598598的专栏
07-12 2164
平台：FL2440   内核版本linux 2.6.28 效果：没有按键时，程序进入休眠，每5秒打印超时信息。按键时响应中断，并输出是按下还是松开。 转载注明：http://blog.csdn.net/bbs598598/article/details/7742052 #include  /*模块有关的*/ #include /*内核有关的*/ #include /*文件系统有关的*/
linux驱动开发fl2440开发板按键驱动
1、测试博主技术知识分享 2、pos行业知识技术分享 3、java后端技术知识分享 4、嵌入式技术知识分享 5、运维部署相关知识分享
07-30 1164
linux驱动开发fl2440开发板按键驱动 [leiyuxing@centos6 input_kbd]$ ls kbd_device.c kbd_driver.c event_button.c kbd_driver.h Makefile 驱动相关头文件kbd_driver.h: /************************************************
FL2440 ADS实验手册
03-26
飞凌公司销售的基于S3C2440内核的ARM开发板FL2440的ADS实验手册。
Linux下基于fl2440开发板platform按键驱动详解（一）
qicheng777的博客
04-18 571
=============================================== 操作系统：center os 64位 平台：fl2440 内核版本：Linux 3.0.54 交叉编译器版本：2012.08 =============================================== #include "s3c_driver.h"
FL2440——RT3070 softAP模式 实现无线路由器功能
萬象森羅，能者獨秀！
05-27 1604
FL2440实现无线路由器功能RT3070无线网卡有两种工作模式STA模式和softAP模式，分别由STA驱动和softAP驱动来实现，STA驱动支持无线网卡工作在STA模式下，可以连接到网络实现上网功能。而SoftAP的驱动支持无线网卡工作在softAP模式下，可以作为一个软的接入点，实现无线路由器功能。在前面一篇博客总结了STA模式的驱动移植，使得我们的开发板能够连接到互联网实现上网功能。这里对
【mini2440 Linux 按键驱动】-【鹏哥教学】系列资料.pdf
02-25
根据提供的文件信息，本文将对“mini2440 Linux按键驱动”进行深入解析，并结合“鹏哥教学”系列资料中的相关内容，详细阐述S3C2440平台下的Linux按键驱动开发流程。 ### S3C2440平台介绍 S3C2440是一款基于ARM...
字符驱动、输入子系统、platform总线、LCD驱动、USB驱动
赶紧十八丶
10-09 3309
大部分ARM9的CPU内部都集成有一个SRAM，SRAM是英文Static RAM的缩写，它是一种具有静止存取功能的内存，不需要刷新电路即能保存它内部存储的数据。这样他不需要初始化就能够直接使用。这与我们在外部扩展的大容量的SDRAM是不一样的，外部大容量的SDRAM是需要初始化后才能使用的，这点大家务必要搞清楚。这点在我做过移植的处理器：s3c2410(arm920t),s3c2440(arm920t),at91rm9200(arm920t),at91sam9260(arm926t)上都是这样的。在s3c
STM32MP157驱动开发——按键驱动（阻塞与非阻塞）
NRWHF的博客
07-25 1320
非阻塞如何让 read 函数既能工作于阻塞方式，也可以工作于非阻塞方式？APP 调用 open 函数时，传入 O_NONBLOCK，就表示要使用非阻塞方式；默认是阻塞方式。在 open 之后，也可以通过 fcntl 函数修改为阻塞或非阻塞。对于字符设备文件，O_NONBLOCK 起作用的注意：在应用程序中设置标记位后，在驱动程序中可以知道该标记位，因为当 APP 打开某个驱动时，在内核中会有一个结构体对应这个驱动【该结构体是虚拟文件系统创建的】，这个结构体中有f_flags，保存所打开文件时的标记位；
2440裸机程序——AD转换实验
ZhuXiaoLong‘Blog
05-10 1230
工程当中需要添加 S3C2440A.s ；2440lib.c；main.c；adc.c 这四个程序。 主程序： /********************************************************************************************* * File name： main.c * Author: ZXL
Linux设备驱动之button按键驱动学习与小结
04-18 7848
button按键驱动，相对于前面的LED驱动来说。增加了中断服务程序以及等待队列等新知识点。 先上学习的驱动代码。 /********************************************************************************* * Copyright: (C) 2011 Guo Wenxue *
linux驱动篇-LCD
中年润的博客
03-31 1845
前言 在嵌入式行业，有很多从业者。我们工作的主旋律是拿开源代码，拿厂家代码，完成产品的功能，提升产品的性能，进而解决各种各样的问题。或者是维护一个模块或方向，一搞就是好几年。 时间长了，中年润发现我们对从零开始编写驱动、应用、算法、系统、协议、文件系统等缺乏经验。没有该有的广度和深度。中年润也是这样，工作了很多年，都是针对某个问题点修修补补或者某个模块的局部删删改改。很少有机会去独自从零开始编...
fl2440内核自带按键驱动移植及hexdump命令
樊茂林的博客
04-29 1131
主机操作系统：Centos 6.7 交叉编译器版本：buildroot-2012.08  开发板平台： FL2440  Linux内核版本： linux-3.0  开发模块： linux内核自带按键驱动移植 1、修改arch/arm/mach-s3c2440/mach-smdk2440.c添加button驱动 添加头文件 #include #inclu
Mini2440 裸机实验之LED程序、按键、中断
行者
05-28 2131
测试平台：Mini2440 Win7 64 ADS开发环境测试   此程序主要考虑按键、LED点亮、中断模式（IRQ）之间的联系 以下为main.c代码部分，其他请参考三星提供的2440用例代码 #define GLOBAL_CLK 1 #include #include #include"def.h" #include"option.h" #include"2440addr.h" #i
一起学mini2440裸机开发(十二)--mini2440的串口中断实验
王文松的博客
05-27 2963
这一节实现利用中断实现串口的中断功能，关于串口的原理我就不再讲述了，如果不明白，就请查看我的另一篇博客    http://blog.csdn.net/mybelief321/article/details/8931064    下面我还是贴出自己的实验代码，我上传到了网站，可以自行下载，下载后，打开工程文档，直接编译后，利用Flash/Dowmload功能下载到nor flash，关于下载到
驱动学习回顾——按键(Button)驱动的理解和总结
C_Aya的博客
08-24 2175
当时在学习按键驱动时，便觉得其中有几个点是比较难理解的，在整体上自己感到并没有很好地掌握。现在经过了一段时间地学习，再将按键驱动里的疑难点加以理解之后，总结记录一下。 关于驱动代码之前已经给出，点击：这里，但只是关于代码语句的注释，下面将从功能块上着重分析这个驱动。一、中断也许现在提起中断，都可以联想到这个图： 中断，本质上就是一种特殊的信号，由某个设备发个CPU，CPU接到这个信号后，操作
蜂鸣器控制实验
wethty的专栏
02-22 3748
实验名称： 蜂鸣器控制实验实验目的： 熟悉ADS使用，熟悉c编程实验原理：      ARM的GPB0控制蜂鸣器，当输出高电平时，三极管导通，蜂鸣器工作。输出低电平时，三极管未工作，蜂鸣器停止。实验步骤：先初始化指针sp，用不着中断，就不必设置了。文件Init.s,代码如下：       AREA DATA, CODE, READONLY    ENTRY 
ACM-ICPC/CCPC/XCPC算法竞赛资料kmeans聚类
最新发布
12-18
ACM-ICPC/CCPC/XCPC算法竞赛资料kmeans聚类
FL2440开发板按键驱动实现与源码分析
标签“输入子系统 按键驱动”说明了该源代码与Linux内核中的输入子系统和按键驱动相关联，强调了代码的应用领域和功能。 ### 压缩包子文件的文件名称列表知识点说明 1. **but-input**： 压缩包文件的名称是“but-...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值