linux创建字符设备

A. linux用mknod怎么创建设备怎么用

首先要明白什么是设备文件，简单的我们说，操作系统与外部设备（入磁盘驱动器，打印机，modern，终端
等等）都是通过设备文件来进行通信的，在Unix/Linux系统与外部设备通讯之前，这个设备必须首先要有一个设备文件，设备文件均放在/dev目录下。
一般情况下在安装系统的时候系统自动创建了很多已检测到的设备的设备文件，但有时候我们也需要自己手动创建，命令行生成设备文件的方式有
insf，mksf，mknod等等
根据mknod命令的使用参数来看【mknod
Name
{
b
|
c
}
Major
Minor
】，使用mknod之前，至少要明白以下几点：
设备文件类型：分为块设备和字符设备。ls
-l
/dev
结果显示第一个字段有b***
和
c****，这里即标识了块设备和字符设备。
字符设备文件----字符设备文件传送数据给设备的时候，一次传送一个字符，终端，打印机，绘图仪，modern等设备都经过字符设备文件传送数据
块设备---系统通过块设备文件存取一个设备的时候，先从内存中的buffer中读或写数据，而不是直接传送数据到物理磁盘，这种方式能有效的提高磁盘和CD-ROMS的I/O性能。磁盘和CD-ROMS即可以使用字符设备文件也可使用块设备文件。
主号和次号
主号：当在任意目录使用ls
-l
时，结果的第5个字段就是主号，设备主号代表了这个设备使用的是哪个设备驱动程序
次号：次号是一个24位的十六进制数字，定义了设个设备在系统中的物理的位置
就拿我们常用的创建卷组来看：
先来看看mknod
命令，如果该设备文件你想放在一个特定的文件夹下当然就先创建文件夹
mknod
设备文件名[/dev/xyz]
b/c
主号
次号
{
mkdir
/dev/vg01
mknod
/dev/vg01/group
c
64
0X010000}
创建之后，就可以使用你想要创建的设备对于德创建命令了，如我现在的卷组的创建命令：
vgcreate
/dev/vg01
/dev/dsk/c*t*d*
一直进行下去，之后的步骤根据不同的设备而不尽相同。

B. linux 设备的含义

inux 中的设备有2种类型：字符设备(无缓冲且只能顺序存取)、块设备(有缓冲且可以随机存取)。这些设备中，有些设备是对实际存在的物理硬件的抽象，而有些设备则是内核自身提供的功能(不依赖于特定的物理硬件，又称为"虚拟设备")。每个设备在 /dev 目录下都有一个对应的文件(节点)。
常见设备及相应/dev/下的文件名：

/dev/usb/hiddev0 | /dev/usb/hiddev1 --- USB 字符设备（鼠标/键盘/游戏杆/手写版等人操作计算机的设备）
/dev/uba | /dev/ubb --- USB 块设备(U盘之类)
/dev/sda | /dev/sdb --- 第n个 SCSI 磁盘(整个磁盘)
/dev/hda | /dev/hdb --- 第n个 IDE 磁盘(整个磁盘)
/dev/sdc1 | /dev/sdc2 --- 第3个 SCSI 磁盘的第n个 分区 Linux/i386来说，分区1-4是主分区，5-15是逻辑分区。
/dev/scd0 | /dev/scd1 --- 第n个 SCSI CD-ROM
/dev/tty0 | /dev/tty1 --- 当前虚拟控制台、第n个虚拟控制台 TTY(终端)设备

Linux系统Mount点：mount的时候，mount的目标文件夹/media/cdrom要手动创建

mount /dev/cdrom /media/cdrom

C. 在Linux内核中,注册字符设备驱动程序的函数是

字符设备驱动程序框架 1、写出open、write函数 2、告诉内核 1）、定义一个struct file_operations结构并填充好 static struct file_operations first_drv_fops = { .owner = THIS_MODULE, /* 这是一个宏，推向编译模块时自动创建的__this_mole变量 */ .open = first_drv_open, .write = first_drv_write, }; 2）、把struct file_operations结构体告诉内核 major = register_chrdev(0, "first_drv", &first_drv_fops); // 注册, 告诉内核相关参数：第一个，设备号，0自动分配主设备号，否则为主设备号0－255 第二个：设备名第二个：struct file_operations结构体 4）、register_chrdev由谁调用（入口函数调用） static int first_drv_init(void) 5）、入口函数须使用内核宏来修饰 mole_init(first_drv_init); mole_init会定义一个结构体，这个结构体里面有一个函数指针指向first_drv_init这个函数，当我们加载或安装一个驱动时，内核会自动找到这个结构体，然后调用里面的函数指针，这个函数指针指向first_drv_init这个函数，first_drv_init这个函数就是把struct file_operations结构体告诉内核 6）、有入口函数就有出口函数 mole_exit(first_drv_exit); 最后加上协议 MODULE_LICENSE("GPL"); 3、mdev根据系统信息自动创建设备节点： 每次写驱动都要手动创建设备文件过于麻烦，使用设备管理文件系统则方便很多。在2.6的内核以前一直使用的是devfs，但是它存在许多缺陷。它创建了大量的设备文件，其实这些设备更本不存在。而且设备与设备文件的映射具有不确定性，比如U盘即可能对应sda，又可能对应sdb。没有足够的主/辅设备号。2.6之后的内核引入了sysfs文件系统，它挂载在/sys上，配合udev使用，可以很好的完成devfs的功能，并弥补了那些缺点。（这里说一下，当今内核已经使用netlink了）。 udev是用户空间的一个应用程序，在嵌入式中用的是mdev，mdev在busybox中。mdev是udev的精简版。首先在busybox中添加支持mdev的选项： Linux System Utilities ---> [*] mdev [*] Support /etc/mdev.conf [*] Support subdirs/symlinks [*] Support regular expressions substitutions when renaming device [*] Support command execution at device addition/removal 然后修改/etc/init.d/rcS: echo /sbin/mdev > /proc/sys/kernel/hotplug /sbin/mdev -s 执行mdev -s ：以‘-s’为参数调用位于 /sbin目录写的mdev（其实是个链接，作用是传递参数给/bin目录下的busybox程序并调用它），mdev扫描 /sys/class 和 /sys/block 中所有的类设备目录，如果在目录中含有名为“dev”的文件，且文件中包含的是设备号，则mdev就利用这些信息为这个设备在/dev 下创建设备节点文件。一般只在启动时才执行一次 “mdev -s”。热插拔事件：由于启动时运行了命 令：echo /sbin/mdev > /proc/sys/kernel/hotplug ，那么当有热插拔事件产生时，内核就会调用位于 /sbin目录的mdev。这时mdev通过环境变量中的 ACTION 和 DEVPATH，来确定此次热插拔事件的动作以及影响了/sys中的那个目录。接着会看看这个目录中是否“dev”的属性文件，如果有就利用这些信息为 这个设备在/dev 下创建设备节点文件重新打包文件系统，这样/sys目录，/dev目录就有东西了下面是create_class的原型： #define class_create(owner, name) / ({ / static struct lock_class_key __key; / __class_create(owner, name, &__key); / }) extern struct class * __must_check __class_create(struct mole *owner, const char *name, struct lock_class_key *key); class_destroy的原型如下： extern void class_destroy(struct class *cls); device_create的原型如下： extern struct device *device_create(struct class *cls, struct device *parent, dev_t devt, void *drvdata, const char *fmt, ...) __attribute__((format(printf, 5, 6))); device_destroy的原型如下： extern void device_destroy(struct class *cls, dev_t devt); 具体使用如下，可参考后面的实例： static struct class *firstdrv_class; static struct class_device *firstdrv_class_dev; firstdrv_class = class_create(THIS_MODULE, "firstdrv"); firstdrv_class_dev = class_device_create(firstdrv_class, NULL, MKDEV(major, 0), NULL, "xyz"); /* /dev/xyz */ class_device_unregister(firstdrv_class_dev); class_destroy(firstdrv_class); 下面再来看一下应用程序如何找到这个结构体的在应用程序中我们使用open打开一个设备：如：open(/dev/xxx, O_RDWR); xxx有一个属性，如字符设备为c,后面为读写权限，还有主设备名、次设备名，我们注册时 通过register_chrdev(0, "first_drv", &first_drv_fops)（有主设备号，设备名，struct file_operations结构体）将first_drv_fops结构体注册到内核数组chrdev中去的，结构体中有open,write函数，那么应用程序如何找到它的，事实上是根据打开的这个文件的属性中的设备类型及主设备号在内核数组chrdev里面找到我们注册的first_drv_fops，实例代码： #include #include #include #include #include #include #include #include #include #include static struct class *firstdrv_class; static struct class_device *firstdrv_class_dev; volatile unsigned long *gpfcon = NULL; volatile unsigned long *gpfdat = NULL; static int first_drv_open(struct inode *inode, struct file *file) { //printk("first_drv_open\n"); /* 配置GPF4,5,6为输出 */ *gpfcon &= ~((0x3<<(4*2)) | (0x3<<(5*2)) | (0x3<<(6*2))); *gpfcon |= ((0x1<<(4*2)) | (0x1<<(5*2)) | (0x1<<(6*2))); return 0; } static ssize_t first_drv_write(struct file *file, const char __user *buf, size_t count, loff_t * ppos) { int val; //printk("first_drv_write\n"); _from_user(&val, buf, count); // _to_user(); if (val == 1) { // 点灯 *gpfdat &= ~((1<<4) | (1<<5) | (1<<6)); } else { // 灭灯 *gpfdat |= (1<<4) | (1<<5) | (1<<6); } return 0; } static struct file_operations first_drv_fops = { .owner = THIS_MODULE, /* 这是一个宏，推向编译模块时自动创建的__this_mole变量 */ .open = first_drv_open, .write = first_drv_write, }; int major; static int first_drv_init(void) { major = register_chrdev(0, "first_drv", &first_drv_fops); // 注册, 告诉内核 firstdrv_class = class_create(THIS_MODULE, "firstdrv"); firstdrv_class_dev = class_device_create(firstdrv_class, NULL, MKDEV(major, 0), NULL, "xyz"); /* /dev/xyz */ gpfcon = (volatile unsigned long *)ioremap(0x56000050, 16); gpfdat = gpfcon + 1; return 0; } static void first_drv_exit(void) { unregister_chrdev(major, "first_drv"); // 卸载 class_device_unregister(firstdrv_class_dev); class_destroy(firstdrv_class); iounmap(gpfcon); } mole_init(first_drv_init); mole_exit(first_drv_exit); MODULE_LICENSE("GPL"); 编译用Makefile文件 KERN_DIR = /work/system/linux-2.6.22.6 all: make -C $(KERN_DIR) M=`pwd` moles clean: make -C $(KERN_DIR) M=`pwd` moles clean rm -rf moles.order obj-m += first_drv.o 测试程序： #include #include #include #include /* firstdrvtest on * firstdrvtest off */ int main(int argc, char **argv) { int fd; int val = 1; fd = open("/dev/xyz", O_RDWR); if (fd < 0) { printf("can't open!\n"); } if (argc != 2) { printf("Usage :\n"); printf("%s \n", argv[0]); return 0; } if (strcmp(argv[1], "on") == 0) { val = 1; } else { val = 0; } write(fd, &val, 4); return 0; }

D. linux设备驱动第三篇：如何写一个简单的字符设

#include<iostream>
#include<cstring>
using namespace std;
class string
{
private:
char *str;
public:
string(char *s);
~string(){delete str;};
int getlen(){return strlen(str)+1;}
char *get(){return str;}
void print();
};

string::string(char *s)
{
str=new char[strlen(s)+1];
strcpy(str,s);
cout<<"constructing string"<<endl;
}
void string::print()
{
cout<<"原数组为:"<<str<<endl;
}

class editstring : public string
{
private:
char *str;
unsigned int cursor;
public:
editstring(char *s);
~editstring(){delete str;};
void setcurright()
{
if(cursor<strlen(str)+1)
cursor++;
cout<<"光标点右移为:"<<cursor<<endl;
};
void setcurleft()
{
if(cursor>0)
cursor--;
cout<<"光标点左移为:"<<cursor<<endl;
};
void insert(char c);
void deletes();
char *get(){return str;}
void replace(char c);
void print();
};
editstring::editstring(char *s):string(s)
{
str=new char[strlen(s)+1];
strcpy(str,s);
cursor=0;
cout<<"constructing editstring"<<endl;
}
void editstring::insert(char c)
{
cout<<"插入字母:"<<c<<""<<endl<<"目前光标点为"<<cursor<<""<<endl;
int max=strlen(str)+1;
max++;
char *temp=new char[max];
strcpy(temp,str);
str=new char[max];
strcpy(str,temp);
unsigned int j;
for(j=cursor;j<max-1;j++)
{
str[j+1]=temp[j];
}
str[cursor]=c;
delete []temp; //delete temp.一样吗？
}
void editstring::deletes()
{
cout<<"删除函数被调用。"<<endl<<"目前光标点为"<<cursor<<""<<endl;
int max=strlen(str)+1;
int i=0;
for(i=cursor;i<max;i++)
{
str[i]=str[i+1];
}
i--;
str[i]='\0';
}
void editstring::replace(char c)
{
cout<<"替换函数被调用。"<<endl<<"目前光标点为"<<cursor<<""<<endl;
str[cursor]=c;
}
void editstring::print()
{
cout<<"编辑后的数组为:"<<str<<endl;
}

void main()
{
editstring p("china");
p.string::print();
p.setcurright();
p.setcurright();
p.setcurleft();
p.deletes();
p.editstring::print();
p.insert('a');
p.editstring::print();
p.deletes();
p.editstring::print();
p.replace('s');
p.editstring::print();

}

E. 1）Linux2.6内核下，在编写字符设备驱动程序时，设备文件节点的创建有几种方法，分别是什么

1手动mknod
2 自动调用函数

F. linux中什么是块设备和字符设备

块设备是I/O设备中的一类，是将信息存储在固定大小的块中，每个块都有自己的地址，还可以在设备的任意位置读取一定长度的数据。数据块的大小通常在512字节到32768字节之间。块设备的基本特征是每个块都能独立于其它块而读写。

字符设备是在I/O传输过程中以字符为单位进行传输的设备。在linux系统中，字符设备以特别文件方式在文件目录树中占据位置并拥有相应的结点。结点中的文件类型指明该文件是字符设备文件。可以使用与普通文件相同的文件操作命令对字符设备文件进行操作。

(6)linux创建字符设备扩展阅读：

在大多数的linux操作系统中，块设备只支持以块为单位的访问方式，如磁盘等。KYLIN支持以字符方式来访问块设备，即支持以字符为单位来读写磁盘等块设备。所以在／dev目录中的块设备，如磁盘等，均以字符设备的外观出现。

当一台字符型设备在硬件上与主机相连之后，必须为这台设备创建字符特别文件。linux操作系统的mknod命令被用来建立设备特别文件。

参考资料来源：

网络——块设备

网络——字符设备

G. 嵌入式开发（七）：linux字符型设备驱动初步

姓名：王芷若    学号：19020100180

学院：电子工程学院

【嵌牛导读】：本篇文章整理Linux知识点—Linux字符型设备驱动初步。

【嵌牛鼻子】：Linux设备类型，结构体，驱动模块

【嵌牛提问】：Linux设备有什么类型？关键函数有哪些？

【嵌牛内容】–linux字符型设备驱动初步

一、Linux字符设备驱动初步

1、Linux设备类型

（1）字符设备：只能一个字节一个字节的读写的设备，不能随机读取设备内存中的某一数据，读取数据需要按照先后顺序进行。字符设备是面向流的设备，常见的字符设备如鼠标、键盘、串口、控制台、LED等。

（2）块设备：是指可以从设备的任意位置读取一定长度的数据设备。块设备如硬盘、磁盘、U盘和SD卡等存储设备。

（3）网络设备：网络设备比较特殊，不在是对文件进行操作，而是由专门的网络接口来实现。应用程序不能直接访问网络设备驱动程序。在/dev目录下也没有文件来表示网络设备。

2、开发流程

在这里插入图片描述

3、关键函数讲解（以2.6以下版本内核为例）

（1）驱动模块注册register_chrdev（）函数

原型：register_chrdev(unsigned int major, const char *name,const struct file_operations *fops)；

major:主设备号，该值为 0 时，自动运行分配。而实际值不是 0 ；

name:设备名称；

fops:操作函数，实现驱动定义的open、read、write、close等内核函数与应用程序调用的open、read、write、close间的映射；

返回值：

major 值为 0 ，正常注册后，返回分配的主设备号。如果分配失败，返回 EBUSY 的负值 ( -EBUSY ) 。major 值若大于 linux/major.h (2.4内核)中声明的最大值 (#define MAX_CHRDEV 255) ，则返回EINVAL 的负值 (-EINVAL) 。指定 major 值后，若有注册的设备，返回 EBUSY 的负值 (-EBUSY)。若正常注册，则返回 0 值

（2）驱动注销unregister_chrdev（）函数

原型：

#include <linux.fs.h>

int unregister_chrdev (unsigned int major, const char *name)

变量：

major 主设备号

name 设备文件

返回值：

major 值若大于 linux/major.h (2.4 内核)中声明的最大值 (#define MAX_CHRDEV 255)，返回 EINVAL的负值 (-EINVAL)。指定了 major的值后，若将要注销的 major 值并不是注册的设备驱动程序，返回 EINVAL的负值 ( -EINVAL )。正常注销则返回 0值。

（3）File_operation结构体

file_operations结构是建立驱动程序和设备编号的连接，内部是一组函数指针，每个打开的文件，也就是file结构，和一组函数关联，这些操作主要用来实现系统调用的

struct file_operations {

struct mole *owner;//拥有该结构的模块的指针，一般为THIS_MODULES

loff_t (*llseek) (struct file *, loff_t, int);//用来修改文件当前的读写位置

ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);//从设备中同步读取数据

ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);//向设备发送数据

ssize_t (*aio_read) (struct kiocb *, const struct iovec *, unsigned long, loff_t);//初始化一个异步的读取操作

ssize_t (*aio_write) (struct kiocb *, const struct iovec *, unsigned long, loff_t);//初始化一个异步的写入操作

int (*readdir) (struct file *, void *, filldir_t);//仅用于读取目录，对于设备文件，该字段为NULL

unsigned int (*poll) (struct file *, struct poll_table_struct *); //轮询函数，判断目前是否可以进行非阻塞的读写或写入

int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long); //执行设备I/O控制命令

long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long); //不使用BLK文件系统，将使用此种函数指针代替ioctl

long (*compat_ioctl) (struct file *, unsigned int, unsigned long); //在64位系统上，32位的ioctl调用将使用此函数指针代替

int (*mmap) (struct file *, struct vm_area_struct *); //用于请求将设备内存映射到进程地址空间

int (*open) (struct inode *, struct file *); //打开

int (*flush) (struct file *, fl_owner_t id);

int (*release) (struct inode *, struct file *); //关闭

int (*fsync) (struct file *, struct dentry *, int datasync); //刷新待处理的数据

int (*aio_fsync) (struct kiocb *, int datasync); //异步刷新待处理的数据

int (*fasync) (int, struct file *, int); //通知设备FASYNC标志发生变化

int (*lock) (struct file *, int, struct file_lock *);

ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);

unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);

int (*check_flags)(int);

int (*flock) (struct file *, int, struct file_lock *);

ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);

ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);

int (*setlease)(struct file *, long, struct file_lock **);

};

H. linux中显卡是字符设备

是的。
有些字符设备有可以支持随机访问，比如显卡，显卡也是字符设备。
有时候称帧缓存设备，我们可以修改某个具体位置的帧缓存数据，从而改变显示输出某一些像素点的像素值。

I. linux字符设备驱动简述-1

Linux系统中，应用程序访问外设是通过文件的形式来进行的，Linux将所有的外设都看做文件，统一存放在/dev目录下。
应用程序使用内核提供的标准系统调用来与内核中的驱动程序进行通讯，这些系统调用有：
open(), read(), write(), ioctl(), close() 等等。

file_operations重要的成员

struct inode 结构代表一个实实在在文件，每个文件只对应一个inode；
struct file 结构代表一个打开的文件，同一个文件可以对应多个file结构；
struct file_operations结构代表底层操作硬件函数的集合

找到 first_drv的主设备号是249，如下图

进阶字符设备写法请看下一篇文章

J. Linux设备驱动开发 新手，创建第一个字符设备驱动时对一些代码的功能不是很了解，能解释一下吗

上层的read函数最终会调用read_test，write亦是如此。

read_test中：

if是判断是否准备好；for循环是来将要读取的count个数据写到buf(用户空间)中去，这里写的是‘a’.

release_test:

主要作用是将引用计数减1；引用计数是用来统计使用该模块的次数的。由此推断在open中有引用计数加一。这样就将资源的释放交给了内核，当引用计数为零时，内核将释放该驱动申请的资源。