使用内存映射的好处是可以加快我们应用与内核数据传送的速度,一般的调用需要在应用层申请空间,同时需要在内核申请空间,有内存映射就可以只申请一个空间就可以.
加载函数中申请空间
//分配内存
key_dev->virt_mem = kzalloc(PAGE_SIZE, GFP_KERNEL);
卸载函数中释放空间
kfree(key_dev->virt_mem);
fops中实现mmp函数
int key_drv_mmap(struct file *filp, struct vm_area_struct *vma)
{
unsigned long addr;
addr = virt_to_phys(key_dev->virt_mem);
//将当前内存映射到用户空间
//参数1--描述应用空间的mmap函数的需求(参数)
//参数2--应用空间的起始位置
//参数3--内核空间的内存的物理地址的页地址
//参数4--内存的大小
//参数5--权限
if (io_remap_pfn_range(vma, vma->vm_start, addr >> PAGE_SHIFT,
PAGE_SIZE, vma->vm_page_prot)) {
printk(KERN_ERR "%s: io_remap_pfn_range failed\n",
__func__);
return -EAGAIN;
}
return 0;
}
phys_to_virt是将已经映射的物理内存的地址转换为虚拟地址
PAGE_SHIFT为12 向右移动实际为除以2^12 在内核中一页的地址个数为2^12个实际为4K空间(一个地址对应一个字节)
所以addr 右移动12位实际为其页地址
应用层实现mmp
//演示mmap的使用
//参数1---映射到用户进程空间的起始位置,一般填NULL, 由系统自动分配
//参数2--映射的长度
//参数3--映射之后的内存访问权限
/*
PROT_EXEC Pages may be executed.
PROT_READ Pages may be read.
PROT_WRITE Pages may be written.
PROT_NONE Pages may not be accessed.
*/
//参数4--是否私有或者共享--MAP_SHARED/MAP_PRIVATE
//参数5--文件描述符
//参数6--映射内核中内存的起始的偏移量,一般都是填0
//返回值--映射成功之后的用户空间的起始地址
paddr = (char *)mmap(NULL, PAGE_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
if(MAP_FAILED == paddr)
{
perror("mmap");
exit(1);
}
memcpy(paddr, test_data, strlen(test_data));
//测试是否成功
sleep(1);
memcpy(rbuf, paddr, 128);
printf("rbuf = %s\n", rbuf);
文件io中的ioctl和mmap接口
应用程序如何使用mmap:
#include <sys/mman.h>
//参数1---映射到用户进程空间的起始位置,一般填NULL, 由系统自动分配
//参数2--映射的长度
//参数3--映射之后的内存访问权限
/*
PROT_EXEC Pages may be executed.
PROT_READ Pages may be read.
PROT_WRITE Pages may be written.
PROT_NONE Pages may not be accessed.
*/
//参数4--是否私有或者共享--MAP_SHARED/MAP_PRIVATE
//参数5--文件描述符
//参数6--映射内核中内存的起始的偏移量,一般都是填0
//返回值--映射成功之后的用户空间的起始地址
void *mmap(void *addr, size_t length, int prot, int flags,
int fd, off_t offset);
int munmap(void *addr, size_t length);
-------------------------------------------------------
驱动中需要实现:xxx_mmap
xxx_mmap
{
}
struct vm_area_struct {
unsigned long vm_start; /* Our start address within vm_mm. */
unsigned long vm_end; /* The first byte after our end address
pgprot_t vm_page_prot; /* Access permissions of this VMA. */
unsigned long vm_flags; /* Flags, see mm.h. */
unsigned long vm_pgoff;
}
https://blog.csdn.net/oguro/article/details/53842275 延伸
驱动代码
#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/device.h>
#include <linux/interrupt.h>
#include <linux/gpio.h>
#include <linux/input.h>
#include <linux/wait.h>
#include <linux/sched.h>
#include <linux/poll.h>
#include <linux/slab.h>
#include <linux/mm.h>
#include <asm/uaccess.h>
// 设计一个对象--描述按键产生的数据包
struct key_event{
int code; //什么按键: 左键, 回车键
int value; // 按键的状态: 按下/抬起 (1/0)
};
//设计一个描述按键的对象: 名字, irqno, gpio, 按键值,触发方式
struct key_desc{
char *name;
int irqno;
int gpio;
int code;
int flags;// 触发方式
};
//设计一个对象类型--描述所有的全局的变量
struct s5pv210_key{
__u8 have_data; //用于描述是否有数据
int major ; //记录主设备号
void *virt_mem; //模拟的一块4k内存
struct class *cls; //用于创建 类
struct device *dev; //用来创建设备文件
wait_queue_head_t wq_head; //用于实现阻塞的等待队列头
struct key_event event; //用于存放数据的包
struct work_struct work;//用于实现中断下半部
};
//声明一个对象
struct s5pv210_key *key_dev;
struct key_desc all_keys[] = {
[0] = {
.name = "key1_up_eint0",
.irqno = IRQ_EINT(0),
.gpio = S5PV210_GPH0(0),
.code = KEY_UP,
.flags = IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
},
[1] = {
.name = "key2_down_eint1",
.irqno = IRQ_EINT(1),
.gpio = S5PV210_GPH0(1),
.code = KEY_DOWN,
.flags = IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
},
[2] = {
.name = "key3_left_eint2",
.irqno = IRQ_EINT(2),
.gpio = S5PV210_GPH0(2),
.code = KEY_LEFT,
.flags = IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
},
[3] = {
.name = "key4_right_eint3",
.irqno = IRQ_EINT(3),
.gpio = S5PV210_GPH0(3),
.code = KEY_LEFT,
.flags = IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
},
};
int key_drv_open (struct inode *inode, struct file *filp)
{
printk("--------^_* %s-------\n", __FUNCTION__);
// 通过文件路径可以得到inode
// 通过得到次设备号可以区分不同的设备
//int major = MAJOR(filp->f_path.dentry->d_inode->i_rdev);
int major = imajor(filp->f_path.dentry->d_inode);
int major2 = imajor(inode);
int minor = iminor(filp->f_path.dentry->d_inode);
int minor2 = iminor(inode);
printk("major = %d, minor = %d\n", major, minor);
printk("major2 = %d, minor2 = %d\n", major2, minor2);
memset(&key_dev->event, 0, sizeof(struct key_event));
key_dev->have_data= 0; //为假--一开始都没有按键按下或者抬起
return 0;
}
ssize_t key_drv_read(struct file *filp, char __user *buf, size_t count, loff_t *fpos)
{
int ret;
//区分当前是阻塞还是非阻塞
if((filp->f_flags & O_NONBLOCK) && !key_dev->have_data)
{
return -EAGAIN;
}
// 在资源不可达的时候,进行休眠
// 参数1---当前驱动中的等待队列头
// 参数2--休眠的条件: 假的话就休眠,真就不休眠
wait_event_interruptible(key_dev->wq_head, key_dev->have_data);
ret = copy_to_user(buf, &key_dev->event, count);
if(ret > 0)
{
printk("copy_to_user error\n");
return -EFAULT;
}
//清零,以备下次充值
memset(&key_dev->event, 0, sizeof(struct key_event));
key_dev->have_data = 0; //没有数据了,等待下一次数据
return count;
}
int key_drv_close(struct inode *inode, struct file *filp)
{
printk("--------^_* %s-------\n", __FUNCTION__);
return 0;
}
unsigned int key_drv_poll (struct file *filp, struct poll_table_struct *pts)
{
//返回一个整数: 没有数据的时候返回0, 有数据的时候,返回POLLIN
unsigned int mask = 0;
// 将当前的等待队列头,注册到vfs层, 注意: poll_wait该函数不会导致休眠
//参数1-文件对象--当前file
//参数2--当前的等待队列头
//参数3--当前传递过来的第三个参数
poll_wait(filp, &key_dev->wq_head, pts);
if(key_dev->have_data)
mask |= POLLIN;
return mask;
}
int key_drv_mmap(struct file *filp, struct vm_area_struct *vma)
{
unsigned long addr;
addr = virt_to_phys(key_dev->virt_mem);
//将当前内存映射到用户空间
//参数1--描述应用空间的mmap函数的需求(参数)
//参数2--应用空间的起始位置
//参数3--内核空间的内存的物理地址的页地址
//参数4--内存的大小
//参数5--权限
if (io_remap_pfn_range(vma, vma->vm_start, addr >> PAGE_SHIFT,
PAGE_SIZE, vma->vm_page_prot)) {
printk(KERN_ERR "%s: io_remap_pfn_range failed\n",
__func__);
return -EAGAIN;
}
return 0;
}
// 4, 实现fops
const struct file_operations key_fops = {
.owner = THIS_MODULE,
.open = key_drv_open,
.read = key_drv_read,
.poll = key_drv_poll,
.mmap = key_drv_mmap,
.release =key_drv_close,
};
void work_key_irq(struct work_struct *work)
{
printk("-----------%s-------\n", __FUNCTION__);
key_dev->have_data = 1;//表示有数据了
wake_up_interruptible(&key_dev->wq_head);
}
//中断处理方法
//参数1--当前产生的中断的号码
//参数2--request_irq传递过来的参数
irqreturn_t key_irq_handler(int irqno, void *dev_id)
{
int *p = (int *)dev_id;
//printk("-----------%s-------0x%x-----\n", __FUNCTION__, *p);
//区分当前是哪个按键
struct key_desc *pdesc = (struct key_desc *)dev_id;
//区分按下还是抬起
int value = gpio_get_value(pdesc->gpio);
if(value)
{
//抬起
printk("<kernel>--%s : release\n", pdesc->name);
//填充值
key_dev->event.code = pdesc->code;
key_dev->event.value = 0;
}else
{
//按下
printk("<kernel>--%s : pressed\n", pdesc->name);
key_dev->event.code = pdesc->code;
key_dev->event.value = 1;
}
//在中断上半部,将work加入到内核线程
schedule_work(&key_dev->work);
return IRQ_HANDLED;
}
static int __init key_drv_init(void)
{
int ret;
// 0-为全局设备/数据对象分配空间
//参数2--标志--分配内存方式, GFP_KERNEL(如果当前内存不够的时候会等待)
key_dev = kzalloc(sizeof(struct s5pv210_key), GFP_KERNEL);
if(key_dev == NULL)
{
printk(KERN_ERR"kmalloc error\n");
return -ENOMEM;
}
// 1, 申请主设备号--动态申请主设备号
key_dev->major = register_chrdev(0, "key_dev", &key_fops);
if(key_dev->major < 0)
{
printk(KERN_ERR"register_chrdev error\n");
ret = key_dev->major;
goto err_free;
}
// 2, 创建设备节点
key_dev->cls = class_create(THIS_MODULE, "key_cls");
if(IS_ERR(key_dev->cls))
{
ret = PTR_ERR(key_dev->cls); //自动根据指针转换一个对应的出错码
goto err_unregister;
}
key_dev->dev = device_create(key_dev->cls, NULL, MKDEV(key_dev->major, 0), NULL, "key0");
if(IS_ERR(key_dev->dev))
{
ret = PTR_ERR(key_dev->dev);
goto err_destory_cls;
}
// 3, 硬件初始化-- 映射地址或者中断申请
//参数1--中断号码
//获取中断号码的方法: 1,外部中断IRQ_EINT(x)
// 2, 头文件 #include <mach/irqs.h> #include <plat/irqs.h>
//参数2--中断的处理方法
//参数3--中断触发方式: 高电平,低电平,上升沿,下降沿,双边沿
/*
#define IRQF_TRIGGER_NONE 0x00000000
#define IRQF_TRIGGER_RISING 0x00000001
#define IRQF_TRIGGER_FALLING 0x00000002
#define IRQF_TRIGGER_HIGH 0x00000004
#define IRQF_TRIGGER_LOW 0x00000008
*/
//参数4--中断的描述-自定义字符串
//参数5--传递个参数2的任意数据
//返回值0表示正确
int i;
int irqno;
int flags;
char *name;
for(i=0; i<ARRAY_SIZE(all_keys); i++)
{
name = all_keys[i].name;
irqno = all_keys[i].irqno;
flags = all_keys[i].flags;
ret = request_irq(irqno, key_irq_handler, flags, name, &all_keys[i]);
if(ret != 0)
{
printk("request_irq error\n");
goto err_destroy_dev;
}
}
// 定义一个等待队列头,并且初始化
init_waitqueue_head(&key_dev->wq_head);
//初始化work
INIT_WORK(&key_dev->work, work_key_irq);
//分配内存
key_dev->virt_mem = kzalloc(PAGE_SIZE, GFP_KERNEL);
return 0;
err_destroy_dev:
device_destroy(key_dev->cls, MKDEV(key_dev->major, 0));
err_destory_cls:
class_destroy(key_dev->cls);
err_unregister:
unregister_chrdev(key_dev->major, "key_dev");
err_free:
kfree(key_dev);
return ret;
}
static void __exit key_drv_exit(void)
{
kfree(key_dev->virt_mem);
//移除work
cancel_work_sync(&key_dev->work);
// 释放中断
//参数1--中断号码
//参数5--和request_irq第5个参数保持一致
int i;
int irqno;
for(i=0; i<ARRAY_SIZE(all_keys); i++)
{
irqno = all_keys[i].irqno;
free_irq(irqno, &all_keys[i]);
}
device_destroy(key_dev->cls, MKDEV(key_dev->major, 0));
class_destroy(key_dev->cls);
unregister_chrdev(key_dev->major, "key_dev");
kfree(key_dev);
}
module_init(key_drv_init);
module_exit(key_drv_exit);
MODULE_LICENSE("GPL");
应用层代码
#include <stdio.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <poll.h>
#include <sys/mman.h>
#include <string.h>
#include <linux/input.h>
#define PAGE_SIZE 1<<12
// 设计一个对象--描述按键产生的数据包
struct key_event{
int code; //什么按键: 左键, 回车键
int value; // 按键的状态: 按下/抬起 (1/0)
};
int main(int argc, char *argv[])
{
int on;
int ret;
char kbd_buf[128];
char *paddr;
struct key_event data;
//准备好要写数据
char rbuf[128]; //读取内存中的数据
char *test_data = "Hello linux mmap memory ^_6";
//直接将驱动模块当做文件来操作
int fd = open("/dev/key0", O_RDWR);
if(fd < 0)
{
perror("open");
exit(1);
}
//演示mmap的使用
//参数1---映射到用户进程空间的起始位置,一般填NULL, 由系统自动分配
//参数2--映射的长度
//参数3--映射之后的内存访问权限
/*
PROT_EXEC Pages may be executed.
PROT_READ Pages may be read.
PROT_WRITE Pages may be written.
PROT_NONE Pages may not be accessed.
*/
//参数4--是否私有或者共享--MAP_SHARED/MAP_PRIVATE
//参数5--文件描述符
//参数6--映射内核中内存的起始的偏移量,一般都是填0
//返回值--映射成功之后的用户空间的起始地址
paddr = (char *)mmap(NULL, PAGE_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
if(MAP_FAILED == paddr)
{
perror("mmap");
exit(1);
}
memcpy(paddr, test_data, strlen(test_data));
//测试是否成功
sleep(1);
memcpy(rbuf, paddr, 128);
printf("rbuf = %s\n", rbuf);
struct pollfd pfd[2];
pfd[0].fd = fd; //自己写的按键设备
pfd[0].events = POLLIN; //监控读 (POLLIN|POLLOUT|POLLERR)
pfd[1].fd = 0; //监控标准输入
pfd[1].events = POLLIN;
while(1)
{
//参数1--你需要监控的文件描述符的集合
//参数2--监控的文件的个数
//参数3--监控的时间--毫秒为单位,如果是负数,永久监控
ret = poll(pfd, 2, -1);
if(ret < 0)
{
perror("poll");
exit(1);
}
if(ret > 0)
{
//判断是哪个有数据
if(pfd[1].revents & POLLIN)
{
//表示键盘是输入
ret = read(0, kbd_buf, 128);
//fgets(kbd_buf, 128, stdin);
kbd_buf[ret] = '\0';
printf("kbd_buf = %s\n", kbd_buf);
}
if(pfd[0].revents & POLLIN)
{
//获取数据--不会阻塞
ret = read(pfd[0].fd, &data, sizeof(struct key_event));
//解析包
switch(data.code)
{
case KEY_UP:
if(data.value)
{
printf("<app>---KEY_UP pressed\n");
}else
{
printf("<app>---KEY_UP release\n");
}
break;
case KEY_DOWN:
if(data.value)
{
printf("<app>---KEY_DOWN pressed\n");
}else
{
printf("<app>---KEY_DOWN release\n");
}
break;
case KEY_LEFT:
if(data.value)
{
printf("<app>---KEY_LEFT pressed\n");
}else
{
printf("<app>---KEY_LEFT release\n");
}
break;
case KEY_RIGHT:
if(data.value)
{
printf("<app>---KEY_RIGHT pressed\n");
}else
{
printf("<app>---KEY_RIGHT release\n");
}
break;
}
}
}
}
munmap(paddr, PAGE_SIZE);
close(fd);
}