2021.05.16 嵌入式学习笔记2：proc文件，中断，io映射

最新推荐文章于 2024-07-18 19:41:56 发布
最新推荐文章于 2024-07-18 19:41:56 发布
阅读量228 收藏
点赞数
分类专栏： 嵌入式 文章标签： linux 嵌入式 arm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_19772443/article/details/116887238
版权

添加的功能

procfs

在添加设备到proc目录下，procfs，sysfs,debugfs注册方式类似，可以提供一文件访问接口，在proc_dir_entry中有fops，如read_proc,wirte_proc和fops都进行初始化，在使用echo 或者cat等命令访问文件时，fops执行。如下图：

当注释掉fops之后

这两个之间，有个优先级的关系，内核代码还没有分析，先挖个坑。

static struct proc_dir_entry *proc_dir,*proc_file; 
int led_proc_read(char *page, char **start, off_t off, int count, int *eof, void *data)
{
	gpio = (struct gpio_led *)data;
	printk("proc read\n");
	sprintf(page,"%s proc read\n",gpio->mem);	
	return count ;
}
int led_proc_write(struct file *file, const char *buffer,unsigned long count, void *data)
{
	int len,ret;
	gpio = (struct gpio_led *)data;
	if(count > SIZE)
       		len = SIZE;
	else
		len = count;
	ret = copy_from_user(gpio->mem, buffer, len); 
	if(ret)
		printk(KERN_EMERG "copy_from_user failed\n");
	gpio->mem[len]='\0';
	printk("proc write\n");
	return count ;
}
//init函数中
            proc_dir = proc_mkdir(NAME,NULL);// 创建proc下的目录
			proc_file = create_proc_entry(NAME,0644,proc_dir);//在该目录下创建文件
			proc_file -> read_proc =  led_proc_read;//关联读函数
			proc_file -> write_proc = led_proc_write;//关联写函数
			//proc_file -> proc_fops = &led_proc_fops;//priority higher than proc_read and write

中断

申请中断的gpio,对gpio口进行初始化，并释放，之后申请中断号，注册相应的中断处理函数。在中断中添加了tasklet。在open中有spin_lock_irq，是为了验证在文件打开后没有释放锁时，中断确实是关闭的 。此时摁按键，中断函数不会执行。

查手册可发现9与10对应int1[1],int1[2],需要设置为0xf，且为下降沿出触发。

static irqreturn_t eint9_interrupt(int irq,void *dev)
{
	gpio = (struct gpio_led *)dev;
	printk("int9 %s\n",gpio->name);
	printk("%s(%d)\n", __FUNCTION__,__LINE__);
	if(gpio_get_value(gpio_led_array[0]))
		gpio_set_value(gpio_led_array[0],0);
	else
		gpio_set_value(gpio_led_array[0],1);
	tasklet_schedule(&gpio_tasklet);
	return IRQ_HANDLED;
}
static irqreturn_t eint10_interrupt(int irq,void *dev)
{
	gpio = (struct gpio_led *)dev;
	printk("int10 %s\n",gpio->name);
	printk("%s(%d)\n", __FUNCTION__,__LINE__);
	if(gpio_get_value(gpio_led_array[1]))
		gpio_set_value(gpio_led_array[1],0);
	else
		gpio_set_value(gpio_led_array[1],1);
	return IRQ_HANDLED;
}
//init函数中
ret =  gpio_request(EXYNOS4_GPX1(1),"irq1");	
			if (ret)
				printk(KERN_EMERG"interrupt1 request failed ret = %d\n",ret);
			ret =  gpio_request(EXYNOS4_GPX1(2),"irq2");	
			if (ret)
				printk(KERN_EMERG"interrupt2 request failed ret = %d\n",ret);
			s3c_gpio_cfgpin(EXYNOS4_GPX1(1),S3C_GPIO_SFN(0XF));
			s3c_gpio_setpull(EXYNOS4_GPX1(1),S3C_GPIO_PULL_UP);
			gpio_free(EXYNOS4_GPX1(1));
			s3c_gpio_cfgpin(EXYNOS4_GPX1(2),S3C_GPIO_SFN(0XF));
			s3c_gpio_setpull(EXYNOS4_GPX1(1),S3C_GPIO_PULL_UP);
			gpio_free(EXYNOS4_GPX1(2));
			ret = request_irq(IRQ_EINT(9),eint9_interrupt,IRQ_TYPE_EDGE_FALLING,"interrupt9",gpio);
			if(ret){
				printk("request_irq faile IRQ_EINT(9) = %d",IRQ_EINT(9));
			}
			ret = request_irq(IRQ_EINT(10),eint10_interrupt,IRQ_TYPE_EDGE_FALLING,"interrupt10",gpio);
			if(ret){
				printk("request_irq faile IRQ_EINT(10) = %d",IRQ_EINT(10));

 

PWM

此处主要时为了学一下如何使用数据手册。

时钟源有内部的和外部的 ，时钟经过倍频后分频，得到PCLK、FCLK和HCLK，PCLK供APB总线使用，HCLK供AHB总线使用，FCLK则供cpu使用。

pclk经过（1-255）的预分频器，得到合适的时钟信号,由多路选择器mux输出分频之后时钟信号，时钟信号的计时需要用到TCMP和TCNT两个寄存器。TCNT>TCMP，TCNT是递减计数，每有一次时钟信号则减一，当等于TCMP的值时，电平反转，当减到零时，电平再次反转。pwm的占空比就由两个寄存器的值确定了。

由此可知想要产生一个pwm,需要配置一个CPIO口，并且初始化该口相应的TCMP和TCNT寄存器。

蜂鸣器链接的是MOTOR_PWM，对应端口是GPIOD0，查数据手册得：

GPD0控制寄存器，低四位赋值0X2确定为模拟信号输出

GPIOD0数据寄存器，这里使用默认值即可

GPIOD0上/下拉寄存器，控制端口上拉还是下拉，此处要输出pwm波，必要关掉。

以上就是GPIO的配置过程，之后还需要配置TCMP和TCNT寄存器。

在数据手册中直接搜PWM

由此可知PCLK是66Mhz。、

数据手册中说的很清楚，想要高占空比，就增大TCMP,反之则减小。起始电平是低，cnt--,减到和cmp的值一样了，反转从成高电平，cnt继续减减，减到0，变成低电平。因此cmp值越大，低电平时间越少。占空比约大。

继续往下找则会查到相应的寄存器，这个才是想要的

这里用到了前五个寄存器。

用到是timer0,给低八位赋值即可，我用的是0xf9及就是250.

赋值0x4，16分频

赋值cmp和cnt寄存器，调节占空比

0x3 更新cnt和cmp的值并启动定时器0

0x8| 0x1 重载并启动定时器0

volatile unsigned long virt_addr_tcfg,virt_addr_gpio,phys_addr_tcfg,phys_addr_gpio;//用于存放虚拟地址和物理地址
volatile unsigned long *GPD0CON,*GPD0PUD,*GPD0DAT;
struct {  
	unsigned int    TCFG0;  
	unsigned int    TCFG1;  
	unsigned int    TCON;  
	unsigned int    TCNTB0;  
	unsigned int    TCMPB0;
}*pwm;	
void pmw_init()
{
	phys_addr_gpio =  0x11400000+0xA0;
	virt_addr_gpio =(unsigned long ) ioremap(phys_addr_gpio,0x0c);//需要12个字节
	GPD0CON = (unsigned long *) virt_addr_gpio;
	GPD0DAT = (unsigned long *) (virt_addr_gpio+0x04);
	GPD0PUD = (unsigned long *) (virt_addr_gpio+0x08);	
	*GPD0CON = (*GPD0CON&(~(0xf)))|(0x2);//TOUT_0 响
	*GPD0PUD = *GPD0PUD&(~(0xf));//浮空
	phys_addr_tcfg = EXYNOS4_PA_TIMER;// 0x139D0000
	virt_addr_tcfg =(unsigned long ) ioremap(phys_addr_tcfg,0x14);//需要20个字节
	pwm = (unsigned long *)virt_addr_tcfg;
	(*pwm).TCFG0 = (*pwm).TCFG0 | 0xf9;
	(*pwm).TCFG1 = (*pwm).TCFG1 | 0x04;
	(*pwm).TCMPB0 = 8;
	(*pwm).TCNTB0 = 16;
	(*pwm).TCON = (*pwm).TCON | 0x03;
	(*pwm).TCON = (*pwm).TCON | 0x01 | 0x08;

}

 

示例代码

#include<linux/module.h>
#include<linux/fs.h>
#include<linux/init.h>
#include<linux/cdev.h>
#include<linux/slab.h>
#include<linux/platform_device.h>
#include<linux/miscdevice.h>
#include<linux/slab.h>
#include<linux/device.h>
#include<linux/gpio.h>
#include<plat/gpio-cfg.h>
#include<mach/gpio.h>
#include<mach/gpio-exynos4.h>
#include<mach/map-exynos4.h>//0x139D0000
#include<linux/miscdevice.h>
#include<linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/jiffies.h>
#include <asm/uaccess.h>//copy_from_user 
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/spinlock.h>
#include <linux/limits.h>
#include <asm/io.h>
#include<linux/jiffies.h>//计时器
#define NAME "gpio_led"
#define SIZE 50
MODULE_LICENSE("Dual BSD/GPL");
MODULE_AUTHOR("CASEY");
struct gpio_led {
	struct cdev cdev;
	char *name;
	spinlock_t lock;
	unsigned char mem[SIZE];
};
static struct gpio_led *gpio;
static struct proc_dir_entry *proc_dir,*proc_file; 
int gpio_tasklet_data = 0;
volatile unsigned long virt_addr_tcfg,virt_addr_gpio,phys_addr_tcfg,phys_addr_gpio;//用于存放虚拟地址和物理地址
volatile unsigned long *GPD0CON,*GPD0PUD,*GPD0DAT;
struct {  
	unsigned int    TCFG0;  
	unsigned int    TCFG1;  
	unsigned int    TCON;  
	unsigned int    TCNTB0;  
	unsigned int    TCMPB0;
}*pwm;	
			    
void gpio_tasklet_fun(unsigned long data)
{
	gpio_tasklet_data++;
	printk("call gpio_tasklet  data = %lu \n",data);
	if(gpio_tasklet_data>10)
		 printk(KERN_INFO "%s : data = %d\n", __func__, gpio_tasklet_data);
}
DECLARE_TASKLET(gpio_tasklet,gpio_tasklet_fun,0);

int led_proc_read(char *page, char **start, off_t off, int count, int *eof, void *data)
{
	gpio = (struct gpio_led *)data;
	printk("proc read\n");
	sprintf(page,"%s proc read\n",gpio->mem);	
	return count ;
}
int led_proc_write(struct file *file, const char *buffer,unsigned long count, void *data)
{
	int len,ret;
	gpio = (struct gpio_led *)data;
	if(count > SIZE)
       		len = SIZE;
	else
		len = count;
	ret = copy_from_user(gpio->mem, buffer, len); 
	if(ret)
		printk(KERN_EMERG "copy_from_user failed\n");
	gpio->mem[len]='\0';
	printk("proc write\n");
	return count ;
}

static struct class *this_class;
int dev_major;
int dev_minor;
static int gpio_led_array[] = {
	EXYNOS4_GPK1(1),
	EXYNOS4_GPL2(0),
};

static long led_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
//	struct gpio_led *dev = file -> private_date;
	printk("cmd is %d, arg is %ld \n",cmd,arg);
	gpio_set_value(gpio_led_array[arg],cmd);
	return 0;
}

static int led_open(struct inode *inode, struct file *file)
{
//	file -> private_date = gpio;
	/* 自选锁实验,在open后，按键的中断被禁止了
	int k =1000; 
	spin_lock_irq(&gpio->lock);
	while(k--)
		printk("locking\n");
	spin_unlock_irq(&gpio->lock);
	*/
	printk("led open\n");
	return 0;
}

static int led_release(struct inode *inode, struct file *file)
{
	printk("led release\n");
	return 0;
}

static ssize_t led_read(struct file *filei,char __user *buff,size_t count,loff_t *ppos)
{
	printk("led read\n");
	return 0;
}
static ssize_t led_write(struct file *file,const char __user * buff,size_t count,loff_t *ppos)
{
	printk("led write\n");
	return 0;
}
static struct file_operations led_fops={
	.owner = THIS_MODULE,
	.open = led_open,
	.release = led_release,//close 
	.unlocked_ioctl = led_ioctl, 	
};

// pay attention to the return value ,irqreturn_t is function type

static irqreturn_t eint9_interrupt(int irq,void *dev)
{
	gpio = (struct gpio_led *)dev;
	printk("int9 %s\n",gpio->name);
	printk("%s(%d)\n", __FUNCTION__,__LINE__);
	if(gpio_get_value(gpio_led_array[0]))
		gpio_set_value(gpio_led_array[0],0);
	else
		gpio_set_value(gpio_led_array[0],1);
	tasklet_schedule(&gpio_tasklet);
	return IRQ_HANDLED;
}
static irqreturn_t eint10_interrupt(int irq,void *dev)
{
	gpio = (struct gpio_led *)dev;
	printk("int10 %s\n",gpio->name);
	printk("%s(%d)\n", __FUNCTION__,__LINE__);
	if(gpio_get_value(gpio_led_array[1]))
		gpio_set_value(gpio_led_array[1],0);
	else
		gpio_set_value(gpio_led_array[1],1);
	return IRQ_HANDLED;
}
const static struct file_operations led_proc_fops={
	.owner = THIS_MODULE,
	.open = led_open,
	.read = led_read,
	.write = led_write,
	.release = led_release,//close 
	.unlocked_ioctl = led_ioctl, 	
};
void pmw_init()
{
	phys_addr_gpio =  0x11400000+0xA0;
	virt_addr_gpio =(unsigned long ) ioremap(phys_addr_gpio,0x0c);
	GPD0CON = (unsigned long *) virt_addr_gpio;
	GPD0DAT = (unsigned long *) (virt_addr_gpio+0x04);
	GPD0PUD = (unsigned long *) (virt_addr_gpio+0x08);	
	*GPD0CON = (*GPD0CON&(~(0xf)))|(0x2);//TOUT_0 响
	*GPD0PUD = *GPD0PUD&(~(0xf));//浮空
	phys_addr_tcfg = EXYNOS4_PA_TIMER;// 0x139D0000
	virt_addr_tcfg =(unsigned long ) ioremap(phys_addr_tcfg,0x14);
	pwm = (unsigned long *)virt_addr_tcfg;
	(*pwm).TCFG0 = (*pwm).TCFG0 | 0xf9;
	(*pwm).TCFG1 = (*pwm).TCFG1 | 0x04;
	(*pwm).TCMPB0 = 8;
	(*pwm).TCNTB0 = 16;
	(*pwm).TCON = (*pwm).TCON | 0x03;
	(*pwm).TCON = (*pwm).TCON | 0x01 | 0x08;

}
static int led_init(void)
{
	int ret,i;
	dev_t devnum=0;
	/*
	baseminor :次设备号的起始
	count: 申请次设备号的个数
	name :执行 cat /proc/devices显示的名称
	*/
	int baseminor = 0;
	int count = 1;
	ret = alloc_chrdev_region(&devnum,baseminor,count,NAME);//动态注册设备号
	
	//devnum = MKDEV(200,0);
	//ret = register_chrdev_region(devnum,count,NAME);//静态注册设备号
	//以上两种方式都可以在/proc/devices 下读到设备号
	if(ret<0){
		printk(KERN_EMERG "request fail  %d",ret);
	}else{
		dev_major = MAJOR(devnum);
		dev_minor = MINOR(devnum);
		printk(KERN_EMERG "major = %d , minor = %d\n",dev_major,dev_minor);
		this_class = class_create(THIS_MODULE,NAME);
		device_create(this_class,NULL,devnum,NULL,NAME);
		gpio =  kmalloc(sizeof(struct gpio_led),GFP_KERNEL);
		if(!gpio){
			printk(KERN_EMERG "request mem failed \n");
			goto fail_malloc;
		}else{
			for(i=0;i<ARRAY_SIZE(gpio_led_array);i++){
				ret = gpio_request(gpio_led_array[i],"GPIO_LED");
				if(ret){
					printk(KERN_EMERG "request_gpio failed ret = %d \n",ret);
				}
				s3c_gpio_cfgpin(gpio_led_array[i],S3C_GPIO_OUTPUT);
				gpio_set_value(gpio_led_array[i],0);
			}
			cdev_init(&gpio->cdev,&led_fops);
			gpio->cdev.owner = THIS_MODULE;
			gpio->name = NAME;
			ret = cdev_add(&gpio->cdev,devnum,1);
			/**************proc fs****************/

			proc_dir = proc_mkdir(NAME,NULL);// create directory
			proc_file = create_proc_entry(NAME,0644,proc_dir);//创建文件，在刚申请的路径下。
			proc_file -> read_proc =  led_proc_read;
			proc_file -> write_proc = led_proc_write;
			spin_lock_init(&gpio->lock);//初始化自旋锁
			//proc_file -> proc_fops = &led_proc_fops;//priority higher than proc_read and write
			
			strcpy(gpio->mem, "procfs");     	proc_file -> data = gpio;
			/**************proc fs*************/

			/***************interrupt **************/
			ret =  gpio_request(EXYNOS4_GPX1(1),"irq1");	
			if (ret)
				printk(KERN_EMERG"interrupt1 request failed ret = %d\n",ret);
			ret =  gpio_request(EXYNOS4_GPX1(2),"irq2");	
			if (ret)
				printk(KERN_EMERG"interrupt2 request failed ret = %d\n",ret);
			s3c_gpio_cfgpin(EXYNOS4_GPX1(1),S3C_GPIO_SFN(0XF));
			s3c_gpio_setpull(EXYNOS4_GPX1(1),S3C_GPIO_PULL_UP);
			gpio_free(EXYNOS4_GPX1(1));
			s3c_gpio_cfgpin(EXYNOS4_GPX1(2),S3C_GPIO_SFN(0XF));
			s3c_gpio_setpull(EXYNOS4_GPX1(1),S3C_GPIO_PULL_UP);
			gpio_free(EXYNOS4_GPX1(2));
			ret = request_irq(IRQ_EINT(9),eint9_interrupt,IRQ_TYPE_EDGE_FALLING,"interrupt9",gpio);
			if(ret){
				printk("request_irq faile IRQ_EINT(9) = %d",IRQ_EINT(9));
			}
			ret = request_irq(IRQ_EINT(10),eint10_interrupt,IRQ_TYPE_EDGE_FALLING,"interrupt10",gpio);
			if(ret){
				printk("request_irq faile IRQ_EINT(10) = %d",IRQ_EINT(10));
			}
			/***************interrupt **************/

			/**************pwm******************/
			pmw_init();
			/**************pwm*****************/
			printk(KERN_EMERG "success \n");
		}

	}
	printk(KERN_EMERG "led diver Init\n");
	return 0;
// 此处踩了个小坑，正常的return要在这种错误处理之前，否则会执行，所以一开始/proc下没有打印设备号，因为被下面的代码取消了
fail_malloc:
	unregister_chrdev_region(devnum,1);
	return 1;
}
static void led_exit(void)
{
	int i;
	dev_t devnum = MKDEV(dev_major,dev_minor);
	for(i=0;i<ARRAY_SIZE(gpio_led_array);i++){
		gpio_free(gpio_led_array[i]);
	}
	free_irq(IRQ_EINT(9),gpio);
	free_irq(IRQ_EINT(10),gpio);
	(*pwm).TCON = (*pwm).TCON | 0x00;
	*GPD0CON = (*GPD0CON)|(0x1);//OUTPUT
	*GPD0DAT = (*GPD0DAT)|(0x0);//拉低
	cdev_del(&gpio->cdev);
	kfree(gpio);
	unregister_chrdev_region(devnum,1);
	device_destroy(this_class,devnum);
	class_destroy(this_class);
	remove_proc_entry(NAME, proc_dir);
    	remove_proc_entry(NAME, NULL);
	printk(KERN_EMERG "led driver exit\n");
}
module_init(led_init);
module_exit(led_exit);

 

rookiest
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux 驱动学习笔记
小灰灰的博客
07-22 318
设备树（Device Tree）是一种数据结构，用于描述硬件设备及其相互关系的图形表示。在Linux系统中，设备树被用于描述硬件设备的配置和属性，以及设备与内核之间的接口。设备注册和管理：设备树提供了对硬件设备的注册和管理机制。驱动程序可以将自己的设备信息添加到设备树中，并实现与设备树的交互，从而方便系统对设备的识别和管理。设备配置和初始化：设备树可以帮助驱动程序了解设备的配置信息和属性，以便进行相应的初始化操作。驱动程序可以根据设备树的描述来配置设备的寄存器、分配内存资源等。
【学习笔记】Linux
Eddie_hyh的博客
06-11 2027
Linux
Linux驱动实践：如何编写【 GPIO 】设备的驱动程序？
IOT物联网小镇
12-07 3276
作 者：道哥，10+年嵌入式开发老兵，专注于：C/C++、嵌入式、Linux。 关注下方公众号，回复【书籍】，获取 Linux、嵌入式领域经典书籍；回复【PDF】，获取所有原创文章( PDF 格式)。 文章目录示例程序目标编写驱动程序创建驱动目录和驱动程序创建 Makefile 文件编译驱动模块加载驱动模块设备节点应用程序卸载驱动模块 别人的经验，我们的阶梯！ 大家好，我是道哥。 在前几篇文章中，我们一块讨论了：在 Linux 系统中，编写字符设备驱动程序的基本框架，主要是从代码流程和 API 函数这.
挂接在/proc上的GPIO控制一个外部接口驱动
软件工程
01-07 2289
驱动代码： #include #include #include #include #include #include #include #define USER_ROOT_DIR "uart_en" #define USER_ENTRY1 "uart_en_entry1" static struct proc_dir_entry *uart_en_root; static
如何在proc目录下增加设备文件
farsky16的专栏
05-28 1993
如何在proc目录下增加设备文件原文网址：http://www.linuxforum.net/forum/gshowflat.php?Cat=&Board=linuxK&Number=335192&page=7&view=expanded&sb=5&o=all&vc=1         因为原来的代码编译时存在错误，因此我作了改动，并在redhat 9.0(内核版本是2.4.20-8)上测
Proc 文件系统简介
Sofine
03-15 392
一、Proc文件系统简介 Proc file system是一种虚拟文件系统，其中的文件存储当前内核运行状态，用户可以通过proc文件系统中的文件对内核进行访问，和内核进行数据交互，如获取cpuinfo、meminfo、uptime等信息 下图所示为即为 /proc/文件系统下的文件。 二、 二、Proc下常见文件介绍 1、cmdline 内核启动参数 2、cpuinfo 当前CPU的信息，各个CPU的型号，生产厂商和频率等 3、crypto ...
嵌入式 内核中针对proc…
caoshunxin01的专栏
02-23 290
原文地址：内核中针对proc文件系统的编程函数总结">嵌入式 内核中针对proc文件系统的编程函数总结作者：skdkjxy一、头文件：     #include 二、创建与删除proc文件：     创建普通文件：         1.创建不可读写的普通文件                          struct proc_dir_entry* create_proc_entry (co
嵌入式之uboot源码分析-启动第一阶段学习笔记
donke_dong
10-21 1543
注： 以下的内容来自朱老师物联网大讲堂uboot部分课件 1. start.S引入 根据之前的学习经验我们知道，程序的运行肯定都要有一个入口，uboot的程序运行也是一样的，我们在裸机的部分知道了程序执行开始必须执行一段汇编代码进行相关的设定后（关看门狗、设置SVC栈、开/关icache、重定位等），才能调用C语言程序，所以这里我们要先找到汇编代码的入口。 1.1 u-boot.lds中找到start.S入口 (1)在C语言中整个项目的入口就是main函数（这是C语言规定的），所以譬如说一个有10000个
Linux基础（5）：Linux文件操作与系统调用
最新发布
lishing6的博客
07-18 1017
本文章为本人在学习野火开发板时的笔记记录。在Linux系统中有一个重要的概念：一切皆文件，它把一切资源都看作是文件，包括硬件设备，通常称为设备文件。前面我们也尝试过通过脚本读写文件的方式，实现了对硬件的访问。所以如果不了解Linux的文件操作，那想要点亮开发板的LED灯都费劲！本章通过C标准库及系统调用的方式操作文件，揭示用户应用程序、C标准库与系统调用之间的关系。本章的示例代码目录为：base_code/linux_app/file_io。
【Docker技术入门与实践（第2版）】Docker入门_学习笔记
DreamSeeker_1314的博客
11-23 2311
第一章 1 Docker入门须知 1.1 Docker基本知识        Docker是基于Go语言实现的开源容器项目，诞生于2013年年初，最初发 起者是dotCloud公司。Docker自开源后受到广泛的关注和讨论，目前已有多个相关项目(包括Docker三剑客、Kubernetes等)，逐渐形成了围绕Docker容器的生态体系。现在主流的Linux操作系统都已经支持Docker。例如...
Linux嵌入式 -- 内核 - proc文件系统
weixin_30482181的博客
08-11 110
1.什么是proc文件系统？ 实例：通过 /proc/meminfo，查询当前内存使用情况。 结论：proc文件系统是一种在用户态检查内核状态的机制。 2.Proc文件分类 特点 每个文件都规定了严格的权限可读？可写？哪个用户可读？哪个用户可写？ 可以用文本编辑程序读取（more命令，cat命令，vi程序等等） 不仅可以有文件，还可以有子目录。 ...
轻松学ARM系列之玩转蜂鸣器
华清远见 | 程序员的学习天堂
07-24 7937
作者：熊老师,华清远见嵌入式学院讲师。 今天我们来学习轻松学arm系列之玩转蜂鸣器，基于arm的cortex_a8内核的三星S5PV210开发平台。 那么我们来看一下如何学习使用pwm控制蜂鸣器？ 一、总体架构图 搞定蜂鸣器之前需要我们对三星的GPIO简介的相关章节有一定的了解，主要是timer 定时器。 二、玩转定时器的几个要领 2.1 查看开发板上蜂鸣器的连接的原理图 蜂鸣器
Linux 内核编程 or 内核模块编程的文件读写与信号传输问题
Trust Bo
06-30 1540
Linux内核编程时，内核代码执行只能直接访问内存上的数据，硬盘上的文件系统必须通过间接的方式才能被内核读写，本文结束一般内核操作文件读写三种方式，并做对比
linux设备模型 （2） led设备驱动
kevinfeng的专栏
12-06 512
接上文，本文记录 led工程中 driver/目录下的3个文件 s5pc100_led.h s5pc100_leddriver.c Makefile s5pc100_led.h 这个文件和上文一样，不列举了，主要是s5pc100_leddriver.c，先列出完整的函数内容： #include #include #include #include #include #incl
s5p4418 Android 4.4.2 驱动层 HAL层 服务层 应用层 开发流程记录（一 硬件驱动层）
sean
03-16 4717
本文章是记录Android开发中驱动层、HAL层、应用层之间的关系，以及其开发方法，本文将会以实现LED的控制为例来进行记录。 一是可以给以后自己做开发做参考，二是希望可以帮助正在学习的朋友参考。 一般的app不需要我们去关注hal和驱动，但在设计一个硬件系统时，原生的Android并未提供合适的服务，所以我们才需要去了解这个流程。由于也是刚入门，很多还不太懂，朋友们有什么疑问可以留言。
嵌入式linux之/proc文件系统（介绍加实例验证）
qq_41782149的博客
04-17 725
文章目录/proc文件系统介绍/proc文件系统特点内核描述创建proc文件创建目录删除目录/文件读写实现流程mini6410下的实例代码在/proc下先创建目录后创建文件 /proc文件系统介绍 /proc文件系统是一种特殊的、由软件创建的文件系统，内核使用它向外界导出信息。/proc下面的每一个文件都绑定于一个内核函数，用户读取其中的文件时，该函数动态地生成文件的“”内容“” 比如：通过/pr...
[转]Linux procfs详解
zdragon2002的专栏
09-30 1340
Linux procfs详解
嵌入式Linux | proc文件系统详解
嵌入式大杂烩
11-21 1192
上一篇：《文件系统有很多，但这几个最为重要》介绍了procfs（进程文件系统的缩写），包含一个伪文件系统（启动时动态生成的...
linux驱动22：自旋锁spinlock
dongyoubin的博客
05-22 898
自旋锁： 和信号量不同的是自旋锁可在不能休眠的代码中使用，如中断处理例程。在正确使用时，自旋锁通常比信号量具有更高的性能。 如果锁可用，则锁定位被设置，代码继续进入临界区；相反则代码进入忙循环并重复检查锁，直到该锁可用。 所有自旋锁在本质上是不可中断的，一旦调用了spin_lock，在获得锁之前一直处于自旋状态。 自旋锁的实现由于linux所支持的架构不同而不同。 自旋锁的核心规则是：任何拥有自旋锁的代码必须是原子的。自旋锁不能休眠。 自旋锁必须在可能的最短时间内拥有。 头文件：<lin
嵌入式Linux系统开发：文件系统详解
7. **嵌入式文件系统**：针对资源有限的嵌入式设备，如`cramfs`、`jffs`、`yaffs`等。这些文件系统通常体积小，启动速度快，适合于闪存设备。 嵌入式Linux市场的快速发展得益于其技术的进步、国际标准的建立和商业...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值