lv14 ioctl、printk及多个此设备支持 6

最新推荐文章于 2024-07-19 15:41:30 发布
最新推荐文章于 2024-07-19 15:41:30 发布
阅读量437 收藏 6
点赞数 6
分类专栏： 嵌入式开发 文章标签： linux arm开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_60718520/article/details/135438084
版权
本文详细解释了Linux内核中ioctl操作的原理，涉及ioctl函数的参数、不同访问模式的定义以及cdev在多设备支持中的应用，通过mychar.c示例展示了如何使用ioctl进行设备控制和参数交换。
摘要由CSDN通过智能技术生成

1 ioctl操作实现

对相应设备做指定的控制操作（各种属性的设置获取等等）

long xxx_ioctl (struct file *filp, unsigned int cmd, unsigned long arg);
功能：对相应设备做指定的控制操作（各种属性的设置获取等等）
参数：
    filp：指向open产生的struct file类型的对象，表示本次ioctl对应的那次open
    cmd：用来表示做的是哪一个操作
    arg：和cmd配合用的参数
返回值：成功为0，失败-1

cmd组成

  • dir（direction），ioctl 命令访问模式（属性数据传输方向），占据 2 bit，可以为 IOC_NONE、IOC_READ、IOC_WRITE、IOC_READ | _IOC_WRITE，分别指示了四种访问模式：无数据、读数据、写数据、读写数据；

  • type（device type），设备类型，占据 8 bit，在一些文献中翻译为 “幻数” 或者 “魔数”，可以为任意 char 型字符，例如 ‘a’、’b’、’c’ 等等，其主要作用是使 ioctl 命令有唯一的设备标识；

  • nr（number），命令编号/序数，占据 8 bit，可以为任意 unsigned char 型数据，取值范围 0~255，如果定义了多个 ioctl 命令，通常

    从 0 开始编号递增；

  • size，涉及到 ioctl 函数 第三个参数 arg ，占据 13bit 或者 14bit（体系相关，arm 架构一般为 14 位），指定了 arg 的数据类型及长度，如果在驱动的 ioctl 实现中不检查，通常可以忽略该参数；

#define _IOC(dir,type,nr,size) (((dir)<<_IOC_DIRSHIFT)| \
                               ((type)<<_IOC_TYPESHIFT)| \
                               ((nr)<<_IOC_NRSHIFT)| \
                               ((size)<<_IOC_SIZESHIFT))
//用于解码ioctl数字
/* used to create numbers */
​
// 定义不带参数的 ioctl 命令
#define _IO(type,nr)   _IOC(_IOC_NONE,(type),(nr),0)
​
//定义带读参数的ioctl命令（copy_to_user） size为类型名
#define _IOR(type,nr,size)  _IOC(_IOC_READ,(type),(nr),(_IOC_TYPECHECK(size)))
​
//定义带写参数的 ioctl 命令（copy_from_user） size为类型名
#define _IOW(type,nr,size)  _IOC(_IOC_WRITE,(type),(nr),(_IOC_TYPECHECK(size)))
​
//定义带读写参数的 ioctl 命令 size为类型名
#define _IOWR(type,nr,size) _IOC(_IOC_READ|_IOC_WRITE,(type),(nr),(_IOC_TYPECHECK(size)))
​
//用于解码ioctl数字
/* used to decode ioctl numbers */
#define _IOC_DIR(nr)        (((nr) >> _IOC_DIRSHIFT) & _IOC_DIRMASK)
#define _IOC_TYPE(nr)       (((nr) >> _IOC_TYPESHIFT) & _IOC_TYPEMASK)
#define _IOC_NR(nr)     (((nr) >> _IOC_NRSHIFT) & _IOC_NRMASK)
#define _IOC_SIZE(nr)      (((nr) >> _IOC_SIZESHIFT) & _IOC_SIZEMASK)

头文件位置

1.1 示例：

mychar.h

#ifndef MY_CHAR_H
#define MY_CHAR_H

#include <asm/ioctl.h>

#define MY_CHAR_MAGIC 'k'

#define MYCHAR_IOCTL_GET_MAXLEN _IOR(MY_CHAR_MAGIC,1,int*)
#define MYCHAR_IOCTL_GET_CURLEN _IOR(MY_CHAR_MAGIC,2,int*)


#endif

mychar.c

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <asm/uaccess.h>

#include "mychar.h"

#define BUF_LEN 100

int major = 11;
int minor = 0;
int mychar_num = 1;

//新建结构体类型
struct mychar_dev
{
	struct cdev mydev;
	char mydef_buf[BUF_LEN];  //相当于结构体的私有变量
	int curlen;          //相当于结构体的私有变量
};

struct mychar_dev gmydev;

int mychar_open(struct inode *pnode, struct file *pfile)
{
	//利用private_data私有变量来指向全局变量结构体地址
	pfile->private_data = (void*)(container_of(pnode->i_cdev,struct mychar_dev,mydev));
    printk("mychar_open is called\n");
    return 0;
}

int mychar_close(struct inode *pnode, struct file *pfile)
{
    printk("mychar_close is called\n");
    return 0;
}


ssize_t mychar_read(struct file *filp, char __user *pbuf, size_t count, loff_t *ppos)
{
	int ret = 0;
	int size = 0;
	//获取全家变量结构体地址
	struct mychar_dev *pmydev = (struct mychar_dev *)filp->private_data;

 	if(count > pmydev->curlen)
	{
		size = pmydev->curlen;
	}
	else
	{
		size = count;
	}

	//将内核空间中的数据复制到用户空间
	ret = copy_to_user(pbuf,pmydev->mydef_buf,size);
	if(ret)
	{
	
		printk("copy_to_user failed\n");
		return -1;
	}
	//读完之后把后面的内容再拷贝过来，同时更新curlen
	memcpy(pmydev->mydef_buf,pmydev->mydef_buf+size,pmydev->curlen - size);
	pmydev->curlen = pmydev->curlen - size;

	return size;

}

ssize_t mychar_write (struct file *filp, const char __user *pbuf, size_t count, loff_t *ppos)
{

	int size = 0;
	int ret  = 0;
	//获取全家变量结构体地址
	struct mychar_dev *pmydev = (struct mychar_dev *)filp->private_data;

	if(count > BUF_LEN - pmydev->curlen)
	{
		size = BUF_LEN - pmydev->curlen;
	}
	else
	{
		size = count;
	}

	//将用户空间中的数据复制到内核空间中
	ret = copy_from_user(pmydev->mydef_buf + pmydev->curlen, pbuf, size);
	if(ret)
	{
		printk("copy_from_user failed\n");
		return -1;
	}
    //更新curlen
	pmydev->curlen = pmydev->curlen + size;
	return size;
}

long mychar_ioctl(struct file *filp, unsigned int cmd,unsigned long arg)
{
    int __user *pret = (int *)arg;
	int maxlen = BUF_LEN;
	int ret = 0;
	struct mychar_dev *pmydev = (struct mychar_dev *)filp->private_data;

	switch(cmd)
	{
		case MYCHAR_IOCTL_GET_MAXLEN:
			ret = copy_to_user(pret,&maxlen,sizeof(int));
			if(ret)
			{
				printk("copy_to_user MAXLEN failed\n");
				return -1;
			}
			break;
		case MYCHAR_IOCTL_GET_CURLEN:
			ret = copy_to_user(pret,&pmydev->curlen,sizeof(int));
			if(ret)
			{
				printk("copy_to_user CURLEN failed\n");
				return -1;
			}
			break;
		default:
			printk("The cmd is unknow\n");
			return -1;
	}
	return 0;
}

//结构体初始化:部分变量赋值初始化
struct file_operations myops = {
    .owner = THIS_MODULE,
    .open = mychar_open,
    .release = mychar_close,
	.read = mychar_read,
	.write = mychar_write,
	.unlocked_ioctl = mychar_ioctl
};

int mychar_init(void)
{
    int ret = 0;
    dev_t devno = MKDEV(major, minor);

    /* 申请设备号 */
    ret = register_chrdev_region(devno, mychar_num, "mychar");
    if (ret) {
        ret = alloc_chrdev_region(&devno, minor, mychar_num, "mychar");
        if (ret) {
            printk("get devno failed\n");
            return -1;
        }
		major = MAJOR(devno); // 容易遗漏，注意
    }

    /* 给struct cdev对象指定操作函数集 */
    cdev_init(&gmydev.mydev, &myops);

    /* 将 struct cdev对象添加到内核对应的数据结构里 */
    gmydev.mydev.owner = THIS_MODULE;
    cdev_add(&gmydev.mydev, devno, mychar_num);

    return 0;
}

void __exit mychar_exit(void)
{
    dev_t devno = MKDEV(major, minor);

    cdev_del(&gmydev.mydev);

    unregister_chrdev_region(devno, mychar_num);
}

//表示支持GPL的开源协议
MODULE_LICENSE("GPL");

module_init(mychar_init);
module_exit(mychar_exit);

Makefile

ifeq ($(KERNELRELEASE),)

ifeq ($(ARCH),arm)
KERNELDIR ?= /home/linux/Linux_4412/kernel/linux-3.14
ROOTFS ?= /opt/4412/rootfs
else
KERNELDIR ?= /lib/modules/$(shell uname -r)/build
endif
PWD := $(shell pwd)


modules:
	$(MAKE) -C $(KERNELDIR) M=$(PWD) modules

modules_install:
	$(MAKE) -C $(KERNELDIR) M=$(PWD) modules INSTALL_MOD_PATH=$(ROOTFS) modules_install

clean:
	rm -rf  *.o  *.ko  .*.cmd  *.mod.*  modules.order  Module.symvers   .tmp_versions

else
CONFIG_MODULE_SIG=n
obj-m += mychar.o

endif

testmychar_app.c

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>

#include "mychar.h"
#include <stdio.h>


int main(int argc,char *argv[])
{
	int fd = -1;
	char buf[8] = "";
	int max = 0;
	int cur = 0;

	if(argc < 2)
	{
		printf("The argument is too few\n");
		return 1;
	}

	fd = open(argv[1],O_RDWR);
	if(fd < 0)
	{
		printf("open %s failed\n",argv[1]);
		return 2;
	}

	ioctl(fd,MYCHAR_IOCTL_GET_MAXLEN,&max);
	printf("max len is %d\n",max);

	write(fd,"hello",6);

	ioctl(fd,MYCHAR_IOCTL_GET_CURLEN,&cur);
	printf("cur len is %d\n",cur);

	read(fd,buf,8);
	printf("buf=%s\n",buf);

	close(fd);
	fd = -1;
	return 0;
}

 编译执行，测试获取设备参数

 

2 printk

//日志级别
#define KERN_EMERG  "<0>"   /* system is unusable           */
#define KERN_ALERT  "<1>"   /* action must be taken immediately */
#define KERN_CRIT   "<2>"   /* critical conditions          */
#define KERN_ERR    "<3>"   /* error conditions         */
​
#define KERN_WARNING    "<4>"   /* warning conditions           */
​
#define KERN_NOTICE "<5>"   /* normal but significant condition */
#define KERN_INFO   "<6>"   /* informational            */
#define KERN_DEBUG  "<7>"   /* debug-level messages         */
​
用法：printk(KERN_INFO"....",....)
    
    printk(KERN_INFO"Hello World"); =====> printk("<6>""Hello World") ====> printk("<6>Hello World")
  

dmesg --level=emerg,alert,crit,err,warn,notice,info,debug 

（dmesg中7个级别对应printk中7个级别）

#define HELLO_DEBUG
#undef PDEBUG
#ifdef HELLO_DEBUG
#define PDEBUG(fmt, args...) printk(KERN_DEBUG fmt, ##args)
#else
#define PDEBUG(fmt, args...)
#endif

3 多个次设备的支持

  • linux支持一个具体的设备同时占用1个主设备号多个次设备号的情况（这种情况主要是根据cdev_add中参数来决定的，一般是1，需要多个次设备号改写参数）
  • 另一种情况是针对一份驱动代码对应多个同类次设备（主设备号一样，次设备不一样的设备）

本节讲得是第二个情况，必须有一个struct cdev来代表它

  • cdev_init
  • cdev.owner赋值
  • cdev_add

以上三个操作对每个具体设备都要进行

3.1 示例

multimychar.c

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <asm/uaccess.h>

#include "mychar.h"

#define BUF_LEN 100
#define MYCHAR_DEV_CNT 3

int major = 11;
int minor = 0;
int mychar_num = MYCHAR_DEV_CNT; //支持多个设备

//新建结构体类型
struct mychar_dev
{
	struct cdev mydev;
	char mydef_buf[BUF_LEN];  //相当于结构体的私有变量
	int curlen;          //相当于结构体的私有变量
};

struct mychar_dev gmydev_arr[MYCHAR_DEV_CNT];  //多个设备实现：创建结构体数组


int mychar_open(struct inode *pnode, struct file *pfile)
{
	//利用private_data私有变量来指向全局变量结构体地址
	pfile->private_data = (void*)(container_of(pnode->i_cdev,struct mychar_dev,mydev));
    printk("mychar_open is called\n");
    return 0;
}

int mychar_close(struct inode *pnode, struct file *pfile)
{
    printk("mychar_close is called\n");
    return 0;
}


ssize_t mychar_read(struct file *filp, char __user *pbuf, size_t count, loff_t *ppos)
{
	int ret = 0;
	int size = 0;
	//获取全家变量结构体地址
	struct mychar_dev *pmydev = (struct mychar_dev *)filp->private_data;

 	if(count > pmydev->curlen)
	{
		size = pmydev->curlen;
	}
	else
	{
		size = count;
	}

	//将内核空间中的数据复制到用户空间
	ret = copy_to_user(pbuf,pmydev->mydef_buf,size);
	if(ret)
	{
	
		printk("copy_to_user failed\n");
		return -1;
	}
	//读完之后把后面的内容再拷贝过来，同时更新curlen
	memcpy(pmydev->mydef_buf,pmydev->mydef_buf+size,pmydev->curlen - size);
	pmydev->curlen = pmydev->curlen - size;

	return size;

}

ssize_t mychar_write (struct file *filp, const char __user *pbuf, size_t count, loff_t *ppos)
{

	int size = 0;
	int ret  = 0;
	//获取全家变量结构体地址
	struct mychar_dev *pmydev = (struct mychar_dev *)filp->private_data;

	if(count > BUF_LEN - pmydev->curlen)
	{
		size = BUF_LEN - pmydev->curlen;
	}
	else
	{
		size = count;
	}

	//将用户空间中的数据复制到内核空间中
	ret = copy_from_user(pmydev->mydef_buf + pmydev->curlen, pbuf, size);
	if(ret)
	{
		printk("copy_from_user failed\n");
		return -1;
	}
    //更新curlen
	pmydev->curlen = pmydev->curlen + size;
	return size;
}

long mychar_ioctl(struct file *filp, unsigned int cmd,unsigned long arg)
{
    int __user *pret = (int *)arg;
	int maxlen = BUF_LEN;
	int ret = 0;
	struct mychar_dev *pmydev = (struct mychar_dev *)filp->private_data;

	switch(cmd)
	{
		case MYCHAR_IOCTL_GET_MAXLEN:
			ret = copy_to_user(pret,&maxlen,sizeof(int));
			if(ret)
			{
				printk("copy_to_user MAXLEN failed\n");
				return -1;
			}
			break;
		case MYCHAR_IOCTL_GET_CURLEN:
			ret = copy_to_user(pret,&pmydev->curlen,sizeof(int));
			if(ret)
			{
				printk("copy_to_user CURLEN failed\n");
				return -1;
			}
			break;
		default:
			printk("The cmd is unknow\n");
			return -1;
	}
	return 0;
}

//结构体初始化:部分变量赋值初始化
struct file_operations myops = {
    .owner = THIS_MODULE,
    .open = mychar_open,
    .release = mychar_close,
	.read = mychar_read,
	.write = mychar_write,
	.unlocked_ioctl = mychar_ioctl
};

int mychar_init(void)
{
    int ret = 0;
	int i = 0;
    dev_t devno = MKDEV(major, minor);

    /* 申请设备号 */
    ret = register_chrdev_region(devno, mychar_num, "mychar");
    if (ret) {
        ret = alloc_chrdev_region(&devno, minor, mychar_num, "mychar");
        if (ret) {
            printk("get devno failed\n");
            return -1;
        }
		major = MAJOR(devno); // 容易遗漏，注意
    }

	for(i = 0;i < MYCHAR_DEV_CNT;i++)
	{
		devno = MKDEV(major,minor+i);  //设备号需要重新组合
		/* 给struct cdev对象指定操作函数集 */
		cdev_init(&gmydev_arr[i].mydev, &myops);

		/* 将 struct cdev对象添加到内核对应的数据结构里 */
		gmydev_arr[i].mydev.owner = THIS_MODULE;
		cdev_add(&gmydev_arr[i].mydev, devno, 1);   //这里需要填1
 	}

    return 0;
}

void __exit mychar_exit(void)
{
    dev_t devno = MKDEV(major, minor);
	int i = 0;
	for(i = 0; i< MYCHAR_DEV_CNT; i ++)
	{
		cdev_del(&gmydev_arr[i].mydev);
	}
	
    unregister_chrdev_region(devno, mychar_num);
}

//表示支持GPL的开源协议
MODULE_LICENSE("GPL");

module_init(mychar_init);
module_exit(mychar_exit);

mychar.h(未修改)

#ifndef MY_CHAR_H
#define MY_CHAR_H

#include <asm/ioctl.h>

#define MY_CHAR_MAGIC 'k'

#define MYCHAR_IOCTL_GET_MAXLEN _IOR(MY_CHAR_MAGIC,1,int*)
#define MYCHAR_IOCTL_GET_CURLEN _IOR(MY_CHAR_MAGIC,2,int*)


#endif

testmychar_app.c(维修工)

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>

#include "mychar.h"
#include <stdio.h>


int main(int argc,char *argv[])
{
	int fd = -1;
	char buf[8] = "";
	int max = 0;
	int cur = 0;

	if(argc < 2)
	{
		printf("The argument is too few\n");
		return 1;
	}

	fd = open(argv[1],O_RDWR);
	if(fd < 0)
	{
		printf("open %s failed\n",argv[1]);
		return 2;
	}

	ioctl(fd,MYCHAR_IOCTL_GET_MAXLEN,&max);
	printf("max len is %d\n",max);

	write(fd,"hello",6);

	ioctl(fd,MYCHAR_IOCTL_GET_CURLEN,&cur);
	printf("cur len is %d\n",cur);

	read(fd,buf,8);
	printf("buf=%s\n",buf);

	close(fd);
	fd = -1;
	return 0;
}

Makefile

ifeq ($(KERNELRELEASE),)

ifeq ($(ARCH),arm)
KERNELDIR ?= /home/linux/Linux_4412/kernel/linux-3.14
ROOTFS ?= /opt/4412/rootfs
else
KERNELDIR ?= /lib/modules/$(shell uname -r)/build
endif
PWD := $(shell pwd)


modules:
	$(MAKE) -C $(KERNELDIR) M=$(PWD) modules

modules_install:
	$(MAKE) -C $(KERNELDIR) M=$(PWD) modules INSTALL_MOD_PATH=$(ROOTFS) modules_install

clean:
	rm -rf  *.o  *.ko  .*.cmd  *.mod.*  modules.order  Module.symvers   .tmp_versions

else
CONFIG_MODULE_SIG=n
obj-m += mychar.o

endif

编译运行

 

4IOT
关注
  • 6
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
字符设备驱动基础下_并发控制(lv11-day6)
qq_56875484的博客
08-09 269
/成功获得自旋锁立即返回真，否则返回假，而不是像上一个那样"在原地打转”//成功获得自旋锁立即返回，否则自旋在那里直到该自旋锁的保持者释放。竞态：多任务并行执行时，如果在一个时刻同时操作同一个资源，会引起资源的错乱，这种错乱情形被称为竞态。为了解决竞态，需要提供一种控制机制，来避免在同一时刻使用共享资源，这种机制被称为并发控制机制。适用场合：任务上下文之间且临界区执行时间较长时的互斥或同步问题。适用场合：任务上下文之间且临界区执行时间较长时的互斥问题。e.操作并测试：运算后结果为0则返回真，否则返回假。..
设备模型（lv12-day1）
qq_56875484的博客
08-15 249
uevent机制：sysfs + uevent + udevd（上层app）1 包含头文件#include""一种用内存模拟的文件系统，系统启动时mount到/sys目录。sysfs用途：（类似于windows的设备管理器）4 调用 device_create(…4 ##### 代码中自动mknod步骤。3 调用 class_create(…5 ##### 参考代码。......
lv14 内核内存管理、动态分频及IO访问 12
m0_60718520的博客
01-27 942
内核将物理内存等分成N块4KB，称之为一页，每页都用一个struct page来表示，采用伙伴关系算法维护Linux内存管理采用了虚拟内存机制，这个机制可以在内存有限的情况下提供更多可用的内存空间。当应用程序需要访问某些数据时，它会使用虚拟地址来引用这些数据。实际上，这些虚拟地址并不是直接映射到物理内存，而是由操作系统进行转换。操作系统将虚拟地址映射到物理内存中的一些页框（Page Frame），这个过程称为页表映射（Page Table Mapping）。
linux设备驱动程序第10章,第十章 LINUX驱动程序实验
weixin_42387482的博客
05-04 341
10-1ADC驱动程序10-1-1说明程序源代码说明：驱动源代码所在目录drivers/spi/驱动程序名称mcp3201.c设备号mcp3201属于杂项设备，设备自动生成设备名/dev/mcp3201测试程序源代码目录Examples/Drivers/ADC测试程序名称test-mcp3201.c测试程序可执行文件名称test-mcp3201要写实际的驱动,就必须了解相关的硬件资源,比如用到的...
lv14 信号量、互斥锁、并发控制机制选择
m0_60718520的博客
01-20 903
a.定义信号量b.初始化信号量c.获得信号量Pd.释放信号量V适用场合：任务上下文之间且临界区执行时间较长时的互斥或同步问题注意：pv操作成对出现。
平台总线式驱动开发（id匹配和设备树匹配lv12-day3）
qq_56875484的博客
08-17 1233
id匹配（可想象成八字匹配）：一个驱动可以对应多个设备 ------在三种匹配方式中优先级次低。 注意事项： 2 ID 匹配编写步骤 1 编写 xxx_device.c(设备) 1 在 platform_device xxxxxx中添加id_entry成员 2 编写 platform_device_id xxxxx 2 编写 xxx_driver.c(驱动) 1 在struct platform_driver xxxxx 中添加id_table成员 2 编写struct platform_device_
构建64位操作系统-设备驱动
x13262608581的博客
03-15 220
构建64位操作系统-设备驱动
linux 平台设备rtc文件,Linux RTC驱动分析(一)
weixin_32558527的博客
05-01 939
本文的RTC使用I2C接口操作pcf8563，这里针对pcf8563对Linux的RTC框架进行分析。Linux常见的驱动在driver目录下都有一个文件夹，进入kernel主目录下的drivers/rtc，发现下面包含了许多芯片的RTC驱动，我们这里是以pcf8563为主，她是我们要分析的核心。其他几个相关联的文件分别是：alarm.c、alarm-dev.c、class.c、hctosys.c...
《Linux驱动：USB设备驱动看这一篇就够了》
热门推荐
qq_40709487的博客
08-28 1万+
这一篇学习分析USB设备驱动程序，主要涉及到USB驱动基本概念，USB版本对比、USB主从结构、USB设备的传输类型、USB设备描述符关系、USB的数据传输对象；详细分析了USB总线驱动框架，USB Core、USB HCD、USB总线-设备-驱动模型；最后总结了USB驱动开发中的一般流程并模拟实现一个USB设备驱动程序。USB core注册了一个USB总线，并向USB总线中注册了三个驱动，分别是USB接口驱动、HUB驱动、USB设备驱动。......
Linux LED字符设备驱动，基于平台驱动的LED字符设备驱动，支持多个LED灯，没有体现分层设计思想
03-04
本文将深入探讨一种特定类型的驱动——LED字符设备驱动，特别是基于平台驱动的实现，以及如何支持多个LED灯。 首先，我们要理解什么是Linux平台驱动。在Linux内核中，平台驱动是一种通用的驱动模型，用于处理那些...
如何驱动GPIO及对应设备
11-13
总结来说，驱动GPIO及对应设备主要包括以下几个步骤： 1. 检查并注册I/O端口，防止资源冲突。 2. 实现GPIO的读写操作，通常通过I/O端口访问函数。 3. 提供`ioctl`接口，以便用户程序控制设备。 4. 设备文件管理，...
imx6ul gpio ioctl简单驱动
06-15
本篇将详细讲解如何使用gpiolib库和ioctl系统调用来编写一个简单的IMX6ULL GPIO驱动。 首先，我们需要了解gpiolib库。gpiolib是Linux内核中用于GPIO操作的标准API，它提供了一套统一的接口，使得驱动开发者无需关心...
1_chrdevbase_IMX6ULL_weatherb6w_字符设备驱动例程_
09-30
本文将深入探讨标题"1_chrdevbase_IMX6ULL_weatherb6w_字符设备驱动例程_"所涉及的基于IMX6ULL芯片的weatherb6w开发板上的字符设备驱动程序。 IMX6ULL（i.MX6 UltraLite）是由NXP（恩智浦半导体）制造的一款高性能...
linux设备驱动归纳总结（三）：4.ioctl的实现
12-24
本篇文章将深入探讨Linux设备驱动中的一个重要特性——ioctl接口的实现，这是设备驱动程序与用户空间进行复杂交互的主要手段。 ioctl（Input/Output Control）是一种特殊的I/O控制命令，允许用户空间程序对设备进行...
LINUX:懒汉单例模式线程池
W2155的博客
07-16 437
创建一个线程，就是要这个线程去完成某种任务的。池化技术就是，提前创建一批线程，有任务这一批线程就会执行。而不是有任务的时候在去创建线程。池化技术有着更高的效率，因为线程都是提前创建好的，直接执行任务。
Qmi8658a姿态传感器使用心得（2）linux
Starry的博客
07-19 856
COD 原理，CTRL9，自检（详细代码示例）
文件在Linux下为binary格式在Windows下为utf-8格式
qq_38220334的博客
07-17 324
想着是不是之前遇到的问题，有可能是文件中含有特殊字符，然后用vim命令来编辑这个文件，发现，还真是含有一个特殊字符，然后将它删除掉，文件就变成utf-8格式的文件了。在Windows下和Mac下都是没有问题的，在华为云服务器上也是没问题的（操作系统不是centos），但是在自己搭建的Linux服务器（centos）上是有问题的。用shell或者Python脚本去将这个文件转为utf-8格式的，但是都失败了。
Linux 注意事项
最新发布
m0_74012211的博客
07-19 310
Linux 与 Windows 是两个相互独立的操作系统，两者有较大差距

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

4IOT

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值