tiny6410按键platform（平台）驱动的实现

最新推荐文章于 2019-06-09 21:06:25 发布

SuJFighting

最新推荐文章于 2019-06-09 21:06:25 发布

阅读量2.1k

点赞数

分类专栏：嵌入式文章标签：平台 button module makefile file up

本文链接：https://blog.csdn.net/ahstusujian/article/details/7978850

版权

嵌入式专栏收录该内容

51 篇文章 0 订阅

订阅专栏

tiny6410中的按键驱动没有提供按键的platform驱动，于是闲来无事把/drivers/char/mini6410_buttons.c给移植成platform驱动，下面是整个的移植过程：

1.首先在 /arch/arm/mach-s3c64xx 目录下添加我们的按键device，文件名定为dev-buttons.c，其源码为：

#include <linux/module.h>
#include <linux/types.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/platform_device.h>
#include <linux/interrupt.h>
#include <linux/device.h>
#include <plat/devs.h>//这个是必须添加的，否则会产生错误

/* 平台资源的定义 */
static struct resource tiny6410_buttons_resource[] = {
        [0] = {
                .start = IRQ_EINT(0),
                .end   = IRQ_EINT(0),
                .flags = IORESOURCE_IRQ,
        },
        [1] = {
                .start = IRQ_EINT(1),
                .end   = IRQ_EINT(1),
                .flags = IORESOURCE_IRQ,
        },
        [2] = {
                .start = IRQ_EINT(2),
                .end   = IRQ_EINT(2),
                .flags = IORESOURCE_IRQ,
        },
        [3] = {
                .start = IRQ_EINT(3),
                .end   = IRQ_EINT(3),
                .flags = IORESOURCE_IRQ,
        },
        [4] = {
                .start = IRQ_EINT(4),
                .end   = IRQ_EINT(4),
                .flags = IORESOURCE_IRQ,
        },
        [5] = {
                .start = IRQ_EINT(5),
                .end   = IRQ_EINT(5),
                .flags = IORESOURCE_IRQ,
        },
        [6] = {
                .start = IRQ_EINT(19),
                .end   = IRQ_EINT(19),
                .flags = IORESOURCE_IRQ,
        },
        [7] = {
                .start = IRQ_EINT(20),
                .end   = IRQ_EINT(20),
                .flags = IORESOURCE_IRQ,
        }                                       /* 这里不需要加逗号 */
};

struct platform_device tiny6410_buttons_device =    //此处不要定义为static的，否则会有错误
{
.name = "tiny6410_buttons",
.id = -1,
.num_resources   = ARRAY_SIZE(tiny6410_buttons_resource),
.resource   = tiny6410_buttons_resource,
};

2.需要对/arch/arm/mach-s3c64xx 目录下的Makefile和Kconfig进行修改：

makefile的最后添加这样一行代码：

obj-y += dev-buttons.o

这里-y表示不管在make menuconfig中有没有选择都会强制编译

Kconfig的最后添加：

config BUTTONS_TINY6410
        bool "Buttons_tiny6410"
        help
            Machine support for the Buttons_tiny6410

3.修改/arch/arm/mach-s3c64xx 目录下的 mach-mini6410.c的代码：

在此结构体中 static struct platform_device *mini6410_devices[] __initdata = { 最后一行添加按键设备：

&s3c_device_ts

此结构会被添加到static void __init mini6410_machine_init(platform_add_devices(mini6410_devices, ARRAY_SIZE(mini6410_devices));)中，此函数会在内核启动初始化时被调用，从而将按键device挂载到内核，等待驱动去匹配。（注意：驱动的name要和device的name一样，这样才能进行匹配）

4.我们还有在/arch/arm/plat-samsung/include/plat/文件中声明我们的platform设备：

在其中添加 extern struct platform_device tiny6410_buttons_device;

至此，平台设备这一边已经告一段落了！下面就是按键驱动。

驱动以模块方式添加到内核，下面是驱动的代码，文件名为：plat_btn_drv.c，

#include <linux/module.h>
#include <linux/types.h>
#include <linux/miscdevice.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/platform_device.h>
#include <linux/interrupt.h>
#include <linux/uaccess.h>
#include <linux/io.h>
#include <mach/map.h>
#include <mach/regs-gpio.h>
#include <linux/poll.h>
#include <linux/irq.h>
#include <asm/unistd.h>
#include <linux/device.h>

#include <mach/gpio-bank-n.h>
#include <mach/gpio-bank-l.h>

#define DRIVER_NAME "tiny6410_buttons"
#define DEVICE_NAME "tiny6410_buttons"

/* 定义并初始化等待队列 */
static DECLARE_WAIT_QUEUE_HEAD(button_waitq);

static volatile int ev_press = 0;

/* 记录键值 */
static int key_value;

/* 记录按键中断号 */
typedef struct
{
        int irq;                        /* 中断号，初始化为 0，将在
                                         * probe 获取资源 */
        int num;                        /* 对应的按键编号 */
        char *name;                     /* 中断所属的名字 */
} button_irq_t;

button_irq_t  button_irqs[] =
{
        {0, 0, "KEY0"},
        {0, 1, "KEY1"},
        {0, 2, "KEY2"},
        {0, 3, "KEY3"},
        {0, 4, "KEY4"},
        {0, 5, "KEY5"},
        {0, 6, "KEY6"},
        {0, 7, "KEY7"},
};

/*
* buttons_interrupt
* 使用一个整形变量 key_value 的 0~7 位来记录键值，0~7
* 位分别对应 KEY0～KEY7 的抬起或者按下情况（ 1 表示按下）。
*/
static irqreturn_t buttons_interrupt(int irq,void *dev_id)
{
        /* 定义一个指针，指向所对应的中断号 */
        button_irq_t *button_irqs = (button_irq_t *)dev_id;
        int down;
        int num;
        unsigned tmp;

        num = button_irqs->num;
        switch(num)
        {
                case 0: case 1: case 2: case 3: case 4: case 5:
                        tmp = readl(S3C64XX_GPNDAT);
                        down = !(tmp & (1 << num));
                        break;

                        case 6: case 7:
                        tmp = readl(S3C64XX_GPLDAT);
                        down = !(tmp & (1 << (num + 5)));
                        break;
                default:
                        down = 0;
        }

        if(down == !(key_value & (1 << num)))
        {
                key_value = down ? key_value | (1<<num) : key_value & ~(1 << num);

                ev_press = 1;
                wake_up_interruptible(&button_waitq);
        }

return IRQ_RETVAL(IRQ_HANDLED);
}

/*
* tiny6410_buttons_open
*/
static int tiny6410_buttons_open(struct inode *inode,struct file *file)
{
int i;
int err = 0;

        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;
}

/*
* tiny6410_buttons_close
*/
static int tiny6410_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;
}

/*
* tiny6410_buttons_read
*/
static int tiny6410_buttons_read(struct file *filp,char __user *buff,
size_t count,loff_t *offp)
{
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((void *)buff,(const void *)(&key_value),
min(sizeof(key_value),count));

return err ? -EFAULT : min(sizeof(key_value),count);
}

/*
* poll 实现函数
*/
static unsigned int tiny6410_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;
}

/*
* file_operation
*/
static struct file_operations dev_fops =
{
        .owner  =   THIS_MODULE,
        .open   =   tiny6410_buttons_open,
        .release =   tiny6410_buttons_close,
        .read   =   tiny6410_buttons_read,
        .poll   =   tiny6410_buttons_poll,
};

/*
* 混合设备结构体
*/
static struct miscdevice tiny6410_buttons_misc =
{
        .minor = MISC_DYNAMIC_MINOR,
        .name  = DEVICE_NAME,
        .fops  = &dev_fops,
};

/*
* probe 实现函数
*/
static int tiny6410_buttons_probe(struct platform_device *pdev)
{
        int ret;
        int i;
        struct device *dev;
        static struct resource   *buttons_irq;

        printk("[call %s]\n", __func__);

        /* 获取设备资源 */
        for(i = 0;i < 8;i ++ )
        {
                buttons_irq = platform_get_resource(pdev,IORESOURCE_IRQ,i);
                button_irqs[i].irq = buttons_irq->start;
        }

ret = misc_register(&tiny6410_buttons_misc);

return 0;
}

/*
* remove 实现函数
*/
static int tiny6410_buttons_remove(struct platform_device *dev)
{
misc_deregister(&tiny6410_buttons_misc);
return 0;
}

/* 平台设备驱动结构 */
static struct platform_driver tiny6410_buttons_driver = {
        .probe  = tiny6410_buttons_probe,
        .remove = tiny6410_buttons_remove,
        .driver =
        {
                .owner  = THIS_MODULE,
                .name   = DRIVER_NAME,
        },
};

static int __init buttons_init(void)
{
printk("[Call buttons_init!]\n");

        /* 注册驱动 */
        platform_driver_register(&tiny6410_buttons_driver);
        return 0;
}

static void __exit buttons_exit(void)
{
printk("[Call buttons_exit!]\n");

platform_driver_unregister(&tiny6410_buttons_driver);
}

module_init(buttons_init);
module_exit(buttons_exit);

MODULE_AUTHOR("_Justin");
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Tiny6410 Buttons Driver");

最后我们需要重新编译内核：make zImage

然后将生成的zImage拷贝到开发板上，运行，编写按键驱动的makefile:

ifneq ($(KERNELRELEASE),)
obj-m := plat_btn_drv.o

else
KDIR := /opt/FriendlyARM/mini6410/linux/linux-2.6.38

all:
make -C $(KDIR) M=$(PWD) modules ARCH=arm CROSS_COMPILE=arm-linux-

clean:
rm -f *.ko *.o *.mod.o *.mod.c *.symvers *.order

endif

最后把驱动的plat_btn_drv.ko文件通过拷贝到开发板，通过命令insmod plat_btn_drv.ko插入内核：

此时会在超级终端中打印出下面的话：

[Call buttons_init!]
[call tiny6410_buttons_probe]
表明platform驱动成功加载，

这时候，在/sys/bus/platform/devices下，我们发现我们添加的设备tiny6410_buttons已经存在了。

另外，在/sys/bus/platform/drivers下，我们发现我们添加的驱动tiny6410_buttons也已经存在了。

在/sys/bus/platform/devices/tiny6410_buttons/driver下，有设备tiny6410_buttons,这说明tiny6410_buttons设备和tiny6410_buttons驱动已经联系起来了。

另外，在/sys/bus/platform/drivers/tiny6410_buttons/device下，有驱动tiny6410_buttons,这也说明tiny6410_buttons设备和tiny6410_buttons驱动已经联系起来了。

我们可以写一个测试程序测试一下：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/select.h>
#include <time.h>

#define DEVICE_NAME "/dev/tiny6410_buttons"

static int key_value = 0;

int main(void)
{
        int fd, ret;
        fd_set rfds;
        int last_kval = key_value;

        if(-1 == (fd = open(DEVICE_NAME,O_RDONLY)))
        {
                printf("open %s error\n",DEVICE_NAME);
                _exit(EXIT_FAILURE);
        }

/* 先清空集合 */
FD_ZERO(&rfds);

/* 设置要监控的文件描述符 */
FD_SET(fd,&rfds);

printf("Test for tiny6410_buttons: ...\n");

        while(1)
        {
                if(-1 == (ret = select(fd + 1,&rfds,NULL,NULL,NULL)))
                {
                        printf("select error\n");
                        _exit(EXIT_FAILURE);
                }

                if(FD_ISSET(fd,&rfds))
                {
                        read(fd, &key_value, sizeof(key_value));

                        int i;
                        for(i = 0;i < 8;i ++ )
                        {
                                if((key_value & (1 << i)) != (last_kval & (1 << i)))
                                {
                                        printf("KEY%d: %s (key_value=0x%x)\n", i+1,
                                               (key_value& (1<<i))? "DOWN": "UP", key_value);
                                }
                        }
                        last_kval = key_value;
                }
    }
        _exit(EXIT_SUCCESS);
}

运行测试程序会打印出：

KEY4: DOWN (key_value=0x8)
KEY4: UP (key_value=0x0)
KEY1: DOWN (key_value=0x1)
KEY1: UP (key_value=0x0)
KEY2: DOWN (key_value=0x2)
KEY2: UP (key_value=0x0)
KEY4: DOWN (key_value=0x8)
KEY4: UP (key_value=0x0)
KEY6: DOWN (key_value=0x20)
KEY6: UP (key_value=0x0)
。。。。。。。。。。。