IO静态映射和动态映射

最新推荐文章于 2024-07-04 08:27:00 发布
最新推荐文章于 2024-07-04 08:27:00 发布
阅读量1k 收藏 3
点赞数
分类专栏： Cortex-A8
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lushoumin/article/details/86498862
版权

1：静态映射方法的特点：

  内核移植时以代码的形式硬编码，如果要更改必须改源代码后重新编译内核在内核启动时建立静态映射表，到内核关机时销毁，中间一直有效对于移植好的内核，你用不用他都在那里

 

2：动态映射方法的特点：

  驱动程序根据需要随时动态的建立映射、使用、销毁映射映射是短期临时的

 

3：如何选择虚拟地址映射方法

  (1)2种映射并不排他，可以同时使用

  (2)静态映射类似于C语言中全局变量，动态方式类似于C语言中malloc堆内存

  (3)静态映射的好处是执行效率高，坏处是始终占用虚拟地址空间；动态映射的 好处是按需使用虚拟地址空间，坏处是每次使用前后都需要代码去建立映射&销毁映射（还得学会使用那些内核函数的使用）

 

4：静态映射表

  不同版本的内核，其静态映射表的文件名以及文件路径不一定相同，但是一般都在arch/arm/xxx/map_xx.h文件中

  (1)s5pv210的主映射表位于：arch/arm/plat-s5p/include/plat/map-s5p.h。

CPU在安排寄存器地址时不是随意乱序分布的，而是按照模块去区分的。每一个模块内部的很多个寄存器的地址是连续的。所以内核在定义寄存器地址时都是先找到基地址，然后再用基地址+偏移量来寻找具体的一个寄存器。这个文件夹下面的虚拟地址基地址是不全的，原因是三星在移植的时候只是移植了自己需要的部分，将来我们需要添加其他基地址的时候直接添加就行了。map-s5p.h中定义的就是要用到的几个模块的寄存器基地址（虚拟地址）。

  (2)虚拟地址基地址定义在：arch/arm/plat-samsung/include/plat/map-base.h

#define S3C_ADDR_BASE (0xFD000000) // 三星移植时确定的静态映射表的基地址，表中的所有虚拟地址都是以这个地址+偏移量来指定的。

  (3)GPIO相关的主映射表位于：arch/arm/machs5pv210/include/mach/regs-gpio.h

表中是GPIO的各个端口的基地址的定义

  (4)GPIO的具体寄存器定义位于：arch/arm/mach-s5pv210/include/mach/gpio-bank.h

#include <linux/module.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <mach/regs-gpio.h>
#include <mach/gpio-bank.h>
#include <linux/io.h>
#include <asm/uaccess.h>

#define GPJ0CON		S5PV210_GPJ0CON
#define GPJ0DAT		S5PV210_GPJ0DAT
 
//#define MYMAJOR	200
#define MYCNT		1
#define MYNAME		"testchar"
 
char kbuf[100];
 
static dev_t mydev;
static struct cdev test_cdev;
static struct class *test_class;

static int test_chrdev_open(struct inode *inode, struct file *file)
{
	printk(KERN_INFO "test_chrdev_open...\n");

	/* 配置IO为输出 */
	writel((1 << 12) | (1 << 16) | (1 << 20), GPJ0CON);
	writel((1 << 3) | (1 << 4) | (1 << 5), GPJ0DAT);
	
	return 0;
}
 
static int test_chrdev_release(struct inode *inode, struct file *file)
{
	printk(KERN_INFO "test_chrdev_release...\n");

	/* 关闭所有LED */
	writel((1 << 3) | (1 << 4) | (1 << 5), GPJ0DAT);
	
	return 0;
}
 
ssize_t test_chrdev_read(struct file *file, char __user *ubuf, size_t count, loff_t *ppos)
{
	printk(KERN_INFO "test_chrdev_read...\n");
	
	return 0;
}
 
static ssize_t test_chrdev_write(struct file *file, const char __user *ubuf, size_t count, loff_t *ppos)
{
	int ret = -1;
	
	printk(KERN_INFO "test_chrdev_write...\n");

	/* 清空内存 */
	memset(kbuf, 0, sizeof(kbuf));
	
	/* 将数据从用户空间拷贝到内核空间 */
	ret = copy_from_user(kbuf, ubuf, count);
	if (ret)
	{
		printk(KERN_ERR "copy_from_user fail\n");
		return -EINVAL;
	}
	
	/* 判断LED打开还是关闭 */
	if (kbuf[0] == '1')
		writel((0 << 3) | (0 << 4) | (0 << 5), GPJ0DAT);
	else if (kbuf[0] == '0')
		writel((1 << 3) | (1 << 4) | (1 << 5), GPJ0DAT);
	
	return 0;
}
 
static const struct file_operations test_fops = {
	.owner		= THIS_MODULE,
	
	.open		= test_chrdev_open,
	.release	= test_chrdev_release,
	.write 		= test_chrdev_write,
	.read		= test_chrdev_read,
};
 
static int __init chrdev_init(void)
{	
	int retval;
	
	printk(KERN_INFO "chrdev_init...\n");
 
	/* 分配主次设备号 */
/*
	mydev = MKDEV(MYMAJOR, 0);
	retval = register_chrdev_region(mydev, MYCNT, MYNAME);
	if (retval) {
		printk(KERN_ERR "Unable to register minors for %s\n", MYNAME);
		return -EINVAL;
	}
*/
	retval = alloc_chrdev_region(&mydev, 12, MYCNT, MYNAME);
	if (retval < 0) 
	{
		printk(KERN_ERR "Unable to alloc minors for %s\n", MYNAME);
		goto flag1;
	}
	printk(KERN_INFO "alloc_chrdev_region success\n");
	printk(KERN_INFO "major = %d, minor = %d.\n", MAJOR(mydev), MINOR(mydev));
 
	/* 注册字符设备驱动 */
	cdev_init(&test_cdev, &test_fops);
	retval = cdev_add(&test_cdev, mydev, MYCNT);
	if (retval) {
		printk(KERN_ERR "Unable to cdev_add\n");
		goto flag2;
	}
	printk(KERN_INFO "cdev_add success\n");
 
	/* 创建设备类 */
	test_class = class_create(THIS_MODULE, "test_class");
	if (IS_ERR(test_class)) {
		printk(KERN_ERR "Unable to class_create\n");
		goto flag3;
	}
	
	/* 创建设备节点 */
	device_create(test_class, NULL, mydev, NULL, "test");

	return 0;
 
flag3:
	cdev_del(&test_cdev);

flag2:
	unregister_chrdev_region(mydev, MYCNT);
flag1:	
	return -EINVAL;
}
 
static void __exit chrdev_exit(void)
{
	printk(KERN_INFO "chrdev_exit...\n");
 
	/* 销毁设备类节点 */
	device_destroy(test_class, mydev);
	class_destroy(test_class);

	/* 注销字符设备驱动 */
	cdev_del(&test_cdev);
	/* 注销申请的主次设备号 */
	unregister_chrdev_region(mydev, MYCNT);
}
 
module_init(chrdev_init);
module_exit(chrdev_exit);
 
MODULE_LICENSE("GPL");				// 描述模块的许可证
MODULE_AUTHOR("lsm");				// 描述模块的作者
MODULE_DESCRIPTION("module test");	// 描述模块的介绍信息
MODULE_ALIAS("alias xxx");			// 描述模块的别名信息

 

5：动态映射操作LED

5.1：如何建立动态映射

  （1）request_mem_region：向内核申请（报告）需要映射的内存资源。

  （2）ioremap：真正用来实现映射，传给他物理地址他返回给你一个虚拟地址

  返回值：成功返回一个虚拟地址（或者是一段虚拟地址的首地址，具体取决于我们需要映射的字节长度），失败返回0

5.2：如何销毁动态映射

  （1）iounmap：解除映射

  （2）release_mem_region：释放映射

#include <linux/module.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/io.h>
#include <asm/uaccess.h>

#define GPJ0CON_PA	0xe0200240
#define GPJ0DAT_PA 	0xe0200244

unsigned int *pGPJ0CON;
unsigned int *pGPJ0DAT;
 
//#define MYMAJOR	200
#define MYCNT		1
#define MYNAME		"testchar"
 
char kbuf[100];
 
static dev_t mydev;
static struct cdev test_cdev;
static struct class *test_class;

static int test_chrdev_open(struct inode *inode, struct file *file)
{
	printk(KERN_INFO "test_chrdev_open...\n");

	/* 配置IO为输出 */
	writel((1 << 12) | (1 << 16) | (1 << 20), pGPJ0CON);
	writel((1 << 3) | (1 << 4) | (1 << 5), pGPJ0DAT);
	
	return 0;
}
 
static int test_chrdev_release(struct inode *inode, struct file *file)
{
	printk(KERN_INFO "test_chrdev_release...\n");

	/* 关闭所有LED */
	writel((1 << 3) | (1 << 4) | (1 << 5), pGPJ0DAT);
	
	return 0;
}
 
ssize_t test_chrdev_read(struct file *file, char __user *ubuf, size_t count, loff_t *ppos)
{
	printk(KERN_INFO "test_chrdev_read...\n");
	
	return 0;
}
 
static ssize_t test_chrdev_write(struct file *file, const char __user *ubuf, size_t count, loff_t *ppos)
{
	int ret = -1;
	
	printk(KERN_INFO "test_chrdev_write...\n");

	/* 清空内存 */
	memset(kbuf, 0, sizeof(kbuf));
	
	/* 将数据从用户空间拷贝到内核空间 */
	ret = copy_from_user(kbuf, ubuf, count);
	if (ret)
	{
		printk(KERN_ERR "copy_from_user fail\n");
		return -EINVAL;
	}
	
	/* 判断LED打开还是关闭 */
	if (kbuf[0] == '1')
		writel((0 << 3) | (0 << 4) | (0 << 5), pGPJ0DAT);
	else if (kbuf[0] == '0')
		writel((1 << 3) | (1 << 4) | (1 << 5), pGPJ0DAT);
	
	return 0;
}
 
static const struct file_operations test_fops = {
	.owner		= THIS_MODULE,
	
	.open		= test_chrdev_open,
	.release	= test_chrdev_release,
	.write 		= test_chrdev_write,
	.read		= test_chrdev_read,
};
 
static int __init chrdev_init(void)
{	
	int retval;
	
	printk(KERN_INFO "chrdev_init...\n");
 
	/* 分配主次设备号 */
/*
	mydev = MKDEV(MYMAJOR, 0);
	retval = register_chrdev_region(mydev, MYCNT, MYNAME);
	if (retval) {
		printk(KERN_ERR "Unable to register minors for %s\n", MYNAME);
		return -EINVAL;
	}
*/
	retval = alloc_chrdev_region(&mydev, 12, MYCNT, MYNAME);
	if (retval < 0) 
	{
		printk(KERN_ERR "Unable to alloc minors for %s\n", MYNAME);
		goto flag1;
	}
	printk(KERN_INFO "alloc_chrdev_region success\n");
	printk(KERN_INFO "major = %d, minor = %d.\n", MAJOR(mydev), MINOR(mydev));
 
	/* 注册字符设备驱动 */
	cdev_init(&test_cdev, &test_fops);
	retval = cdev_add(&test_cdev, mydev, MYCNT);
	if (retval) {
		printk(KERN_ERR "Unable to cdev_add\n");
		goto flag2;
	}
	printk(KERN_INFO "cdev_add success\n");
 
	/* 创建设备类 */
	test_class = class_create(THIS_MODULE, "test_class");
	if (IS_ERR(test_class)) {
		printk(KERN_ERR "Unable to class_create\n");
		goto flag3;
	}
	
	/* 创建设备节点 */
	device_create(test_class, NULL, mydev, NULL, "test");

	/* 申请内存 */
	if (!request_mem_region(GPJ0CON_PA, 4, "GPJ0CON"))
		goto err4;
	if (!request_mem_region(GPJ0DAT_PA, 4, "GPJ0DAT"))
		goto err5;	
	
	/* 内存映射 */
	pGPJ0CON = ioremap(GPJ0CON_PA, 4);
	pGPJ0DAT = ioremap(GPJ0DAT_PA, 4);
	
	return 0;

err5:
	release_mem_region(GPJ0CON_PA, 4);
err4:
	device_destroy(test_class, mydev);
	class_destroy(test_class);

flag3:
	cdev_del(&test_cdev);

flag2:
	unregister_chrdev_region(mydev, MYCNT);
flag1:	
	return -EINVAL;
}
 
static void __exit chrdev_exit(void)
{
	printk(KERN_INFO "chrdev_exit...\n");
 
 	iounmap(pGPJ0CON);
	iounmap(pGPJ0DAT);
	release_mem_region(GPJ0CON_PA, 4);
	release_mem_region(GPJ0DAT_PA, 4);
 
	/* 销毁设备类节点 */
	device_destroy(test_class, mydev);
	class_destroy(test_class);

	/* 注销字符设备驱动 */
	cdev_del(&test_cdev);
	/* 注销申请的主次设备号 */
	unregister_chrdev_region(mydev, MYCNT);
}
 
module_init(chrdev_init);
module_exit(chrdev_exit);
 
MODULE_LICENSE("GPL");				// 描述模块的许可证
MODULE_AUTHOR("lsm");				// 描述模块的作者
MODULE_DESCRIPTION("module test");	// 描述模块的介绍信息
MODULE_ALIAS("alias xxx");			// 描述模块的别名信息

 

Stone_lu。
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
linux下静态映射与动态映射原理分析
qq_40334837的博客
08-06 1709
  2017年10月1号 （1）外设IO寄存器地址独立编址的CPU，这时该称外设IO寄存器为IO端口，访问IO寄存器可通过ioport_map将其映射到虚拟地址空间，但实际上这是给开发人员制造的一个“”假象”，并没有映射到内核虚拟地址，仅仅是为了可以使用和IO内存一样的接口访问IO寄存器 例如：x86平台普通使用了名为内存映射的技术，IO设备端口被映射到内存空间，映射后，CPU访问IO端口就...
io-mapping IO映射1
08-03
在32位处理器上，特别是对于大图形窗口（aperture）的场景，由于使用`ioremap_wc`静态映射整个窗口会消耗过多的内核地址空间，因此`io_mapping`接口尤为重要。 `io_mapping_create_wc`函数是创建映射对象的主要方法...
静态映射和动态映射
weixin_42031299的博客
03-27 3149
内核访问外设I/O内存资源 为什么需要映射 动态映射和静态映射的比较 动态映射 静态映射 https://blog.csdn.net/maopig/article/details/58056652
【Elasticsearch】Elasticsearch动态映射与静态映射详解
最新发布
屿小夏.的知识博客
07-04 5万+
Elasticsearch 是一个分布式搜索和分析引擎，广泛应用于实时数据分析和全文检索中。在使用 Elasticsearch 时，映射（Mapping）是定义索引中文档结构和字段类型的过程。映射主要分为动态映射和静态映射两种方式。本文将详细介绍这两种映射的区别及其在不同场景中的应用。映射是 Elasticsearch 中定义索引中文档结构、字段类型及其属性的过程。通过映射，Elasticsearch 可以理解数据的结构和类型，从而进行有效的存储和检索。
IO 静态内存映射详解
hunanchenxingyu的专栏
06-11 3265
静态映射(map_desc)方式 下面重点介绍静态映射方式即通过map_desc结构体静态创建I/O资源映射表。 内核提供了在系统启动时通过map_desc结构体静态创建I/O资源到内核地址空间的线性映射表(即page table)的方式，这种映射表是一种一一映射的关系。程序员可以自己定义该I/O内存资源映射后的虚拟地址。创建好了静态映射表，在内核或驱动中访问该I/O资源时则无需再进行iore
linux设备驱动归纳总结（五）：3.IO静态映射
Andoubi的博客
06-02 381
linux设备驱动归纳总结（五）：3.操作硬件——IO静态映射 xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 有时候会觉得，每次访问硬件都要先通过ioremap来获取虚拟地址，其实有没有一种一劳永逸的方法，只要一次的操作，以后就能通过这个地址来访问
Linux-IO内存-静态映射
Yfw的博客
11-01 298
通常来说，BSP需要提供芯片级驱动，并要为板级驱动提供一些服务，在为具体芯片移植linux内核时，通常都会建立芯片级外设I/O内存物理地址到虚拟地址的静态映射，这通常是通过板文件中的MACHINE_START宏中的map_io函数来实现的，map_io函数中通常通过调用 iotable_init函数来建立页映射关系，如：iotable_init(s3c_iodesc, ARRAY_SIZE(s3c...
动态映射和静态映射
u012787604的博客
10-28 351
https://blog.csdn.net/maopig/article/details/58056652 linux访问io 动态映射和静态映射；
linux 内核动态映射与静态映射
shenhuxi_yu的专栏
04-20 674
linux 内核多级分页机制中的概念 页全局目录（Page Global Directory） 页上级目录（Page Upper Directory） 页中间目录（Page Middle Directory） 页表（Page Table） —————————————————————————————————————————————————— Linux内核访问外设I/O内存资源的方式
IO静态映射
SHARPZOU的专栏
10-19 1423
<br /><br />http://www.cublog.cn/u3/101649/showart.php?id=2276926共享资源，欢迎转载：http://blog.chinaunix.net/u3/99873/showart_2057181.html<br />我们知道默认外设I/O资源是不在Linux内核空间中的（如sram或硬件接口寄存器等），若需要访问该外设I/O资源，必须先将其地址映射到内核空间中来，然后才能在内核空间中访问它。<br />Linux内核访问外设I/O内存资源的方式有两种：
Linux内核访问外设io--动态映射和静态映射
sheng__jun的博客
10-11 565
我们知道默认外设I/O资源是不在Linux内核空间中的（如sram或硬件接口寄存器等），若需要访问该外设I/O资源，必须先将其地址映射到内核空间中来，然后才能在内核空间中访问它。 Linux内核访问外设I/O内存资源的方式有两种：动态映射(ioremap)和静态映射(map_desc)。 一、动态映射(ioremap)方式 动态映射方式是大家使用了比较多的，也比较简单。即直接通过内核提供的i
嵌入式系统/ARM技术中的ARM Linux静态映射分析
11-08
静态映射允许内核在启动时将物理内存地址映射到虚拟内存地址，使得软件能够直接访问硬件设备，而无需每次访问都通过MMU（内存管理单元）进行动态翻译。这种方式对于性能敏感的外设如GPIO、USB和LCD控制器来说尤其...
jsp静态化和伪静态化
02-18
在JSP中，实现伪静态化通常需要借助Web服务器（如Apache、Nginx）或应用服务器（如Tomcat）的URL重写模块，通过配置规则将看似静态的URL映射到实际的动态处理程序。 总的来说，静态化和伪静态化都是优化Web性能的...
asp.net动态生成静态网页
12-06
IIS（Internet Information Services）提供URL Rewrite模块，ASP.NET中也可以使用HttpModule来自定义重写规则，确保动态请求被正确地映射到静态文件。 7. **SEO优化**：静态网页对搜索引擎爬虫更友好，因为它们可以...
JAVA IO-NIO 详解
04-24
其中，NIO（New IO）是Java 1.4版本引入的一种新的IO处理方式，相较于传统的阻塞IO，NIO提供了更高的效率和灵活性。 #### 二、传统IO与NIO的区别 **1. 阻塞与非阻塞** - **传统IO**: 阻塞式操作，当进行读写操作...
独立编址与统一编址
lushoumin的博客
07-17 1万+
在不同的系统中，I/O端口的地址编排有两种形式： 存储器统一编址和I/O独立编址。  存储器统一编址(存储器映像编址)： 在这种编址方式中，I/O端口和内存单元统一编址， 即把I/O端口当作内存单元对待， 从整个内存空间中划出一个子空间给I/O端口， 每一个I/O端口分配一个地址码， 用访问存储器的指令对I/O端口进行操作。  存储器统一编址的优点是： I/O端口的数目几乎不受限制； 访问内存指令...
ARM的异常处理
lushoumin的博客
07-17 1万+
经典ARM微处理器包括7种异常： 1、 复位异常 2、 未定义指令异常 3、 软件中断异常 4、 预取指令异常 5、 数据异常 6、 IRQ（中断） 7、 FIQ（快速中断） 异常，单片机为中断，笼统来讲可以把异常类似的看作中断，本质上两者还是有区别的。异常/中断是硬件和软件进行异步工作的一种方式。 经典ARM微处理器发生异常时，ARM微处理器会自动调用预先写好的异常处理程序。为...
linux内核start_kernel分析
lushoumin的博客
12-27 6798
经历了跟体系结构密切相关的汇编代码之后，就可以进入C语言编写的结构无关的代码了。 这个入口的函数是start_kernel函数，它主要更进一步地初始化系统相关的内容，以便系统进入一种服务状态，提供一种虚拟机的服务，提供各种API调用的服务。 在start_kernel函数里，需要非常注意的是里面初始化函数的顺序，这些初始化函数不能随便调换初始化顺序，否则就会导致系统运行出错。 asmlinka...
Groovy编程实践：探索动态与静态特性
在Groovy中，动态和静态类型的灵活运用是其一大特色。Groovy支持动态类型，允许在不声明变量类型的情况下进行编程，提供了与脚本语言类似的简洁性。同时，随着Groovy 2.4的发布，引入了静态类型检查（Static Typing...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值