linux设备驱动与加载

第12章工程中的 Linux设备驱动之Linux设备驱动的固件加载 12.7 Linux设备驱动的固件加载    一个外设的运行可能依赖于固件,如某公司的WiFi 模块,在启动前需要加载固件。传统的设备驱动将固件的二进制码作为一个数组直接编译进目标代码,在 Linux 2.6 中,有一套成熟的固件加载流程。    首先,申请固件的驱动程序发起如下请求:    linux/firmware.h    int request_firmware(const struct... 阅读详情

在http://www.douzhe.com/linuxtips/1036.html发现的一篇关于设备驱动的文章,写得很好,仿造写了一段实验代码把它移植到嵌入linux中发现就是makefile文件中的定义与原来的不一致,对于我的驱动和应用来说如下:

#add by lzg 2005-06-29
ifeq ($(CONFIG_TESTDRIVE),y)
obj-$(CONFIG_TESTDRIVE) += armtest.o
endif

原文如下:

一. linux设备概述
在概念上一般把设备分为字符设备、块设备。字符设备是指设备发送和接收数据以字符形式的进行;而块设备则以整个数据缓冲区的形式进行。但是,由于网络设备等有其特殊性,实际上系统对它们单独处理。

系统用主设备号(MAJOR)加次设备(MINOR)号来唯一标识一个设备。相同主设备号表示同一类设备,例如都是硬盘;次设备号标识同类设备的个数。所有设备在适当的目录(通常在/dev目录下)下必须有相应的文件,这样字符设备和块设备都可以通过文件操作的系统调用了完成。不同的是,块设备操作经常要和缓冲区打交道,更加复杂一点。



[目录]

--------------------------------------------------------------------------------


数据结构

二. 主要数据结构
与设备管理有关的主要数据结构如下:
1、登记设备管理
系统对已登记设备的管理是由chrdevs和blkdevs这两张列表来完成的:
/*srcfsdevices.c*/
struct device_struct {
const char * name; //指向设备名称
struct file_operations * fops; //指向设备的访问操作函数集,file_operati
ons定义在
include/linux/fs.h中
};
static struct device_struct chrdevs[MAX_CHRDEV] = {
{ NULL, NULL },
}; //所有系统登记的字符设备列表
static struct device_struct blkdevs[MAX_BLKDEV] = {
{ NULL, NULL },
} //所有系统登记的块设备列表

实际上这两张列表的结构是一样的,但在登记时每个结构元素的值会不同(见初始化部分)。linux对设备的进行访问时,访问文件系统中相应的文件,通过文件系统和文件的属性描述块,系统可以找到该文件系统或文件对应设备的设备号。在实际访问列表时,以chrdevs[MAJOR][MINOR]或blkdevs[MAJOR][MINOR]形式访问,相同主设备号(MAJOR)的元素中fops的内容相同。

文件系统中相关的的数据结构如下:
struct super_block {
kdev_t s_dev; //该文件系统所在设备的设备标志符
…
} //每个文件系统对应一个super_block
struct inode {
kdev_t i_dev; //该文件所在设备的设备标志符通过它可以找到在设备列表中
… 相应设备
} //每个文件对应一个inode

2、I/O请求管理

系统会把一部分系统内存作为块设备驱动程序与文件系统接口之间的一层缓冲区,每个缓冲区与某台块设备中的特定区域相联系,文件系统首先试图存在相应的缓冲区,如未找到就向该设备发出I/O读写请求,由设备驱动程序对这些请求进行处理。因此,需要有相应的数据结构进行管理。

/*srcincludelinuxlkdev.h*/
struct blk_dev_struct {
void (*request_fn)(void); //指向请求处理函数的指针,请求处理函数是写设备驱动程序的重要一环,设备驱动程序在此函数中通过outb向位于I/O空间中的设备命令寄存器发出命令

struct request * current_request; //指向当前正在处理的请求,它和plug共同维护了该设备的请求队列
struct request plug; //这是LINUX2.0版本与以前版本的一个不同之处,plug主要被用于异步提前读写操作,在这种情况下,由于没有特别的请求,为了提高系统性能,需要等发送完所有的提前读写请求才开始进行请求处理,即unplug_device。
struct tq_struct plug_tq; //设备对应的任务队列
};
/*srcdriverslockll_rw_blk.c*/
struct blk_dev_struct blk_dev[MAX_BLKDEV];
其中每个请求以request的类型的结构进行传递,定义如下:
/*srcincludelinuxlk_dev.h*/
struct request {
volatile int rq_status; //表示请求的状态
kdev_t rq_dev; //是该请求对应的设备号,kdev_t是unsigned s
hort类型,高8位是主设备号,低8位是从设备号,每一请求都针对一个设备发出的;
int cmd; //表示该请求对应的命令,取READ或WRITE;
int errors;
unsigned long sector; //每一扇区的字节数
unsigned long nr_sectors; //每一扇区的扇区数
unsigned long current_nr_sectors; //当前的扇区数;
char * buffer; //存放buffer_head.b_data值,表示发出请求的
数据存取地址;
struct semaphore * sem; //一个信号量,用来保证设备读写的原语操作,
当
sem=0时才能处理该请求;
struct buffer_head * bh; //读写缓冲区的头指针
struct buffer_head * bhtail; //读写缓冲区的尾指针
struct request * next; //指向下一个请求
};

对不同块设备的所有请求都放在请求数组all_requests中,该数组实际上是一个请求缓冲池,请求的释放与获取都是针对这个缓冲池进行;同时各个设备的请求用next指针联结起来,形成各自的请求队列。定义如下:

/*srcdriverslokcll_rw_blk.c*/
static struct request all_requests[NR_REQUEST];

3、中断请求

设备进行实际的输入/输出操作时,如果时间过长而始终被占用CPU,就会影响系统的效率,必须有一种机制来克服这个问题而又不引起其他问题。中断是最理想的方法。和中断有关的数据结构是;

struct irqaction {
void (*handler)(int, void *, struct pt_regs *); //指向设备的中断响应函数,它在系统初始化时被置入。当中断发生时,系统自动调用该函数
unsigned long flags; //指示了中断类型,如正常中断、快速中断等
unsigned long mask; //中断的屏蔽字
const char *name; //设备名
void *dev_id; //与设备相关的数据类型,中断响应函数可以根

据需要将它转化所需的数据指针,从而达到访问系统数据的功能
struct irqaction *next; //指向下一个irqaction
};

由于中断数目有限,且很少更新,所以系统在初始化时,从系统堆中分配内存给每一个irq_action指针,通过next指针将它们连成一个队列。

4、高速缓冲区

为了加速对物理设备的访问速度,linux将块缓冲区放在Cache内,块缓冲区是由buffer_head连成的链表结构。buffer_head的数据结构如下:
/*includelinuxfs.h*/
struct buffer_head {
unsigned long b_blocknr; /* block number */
kdev_t b_dev; /* device (B_FREE = free) */
kdev_t b_rdev; /* Real device */
unsigned long b_rsector; /* Real buffer location on disk */
struct buffer_head * b_next; /* Hash queue list */
struct buffer_head * b_this_page; /* circular list of buffers in one page *
/
unsigned long b_state; /* buffer state bitmap (see above) */
struct buffer_head * b_next_free;
unsigned int b_count; /* users using this block */
unsigned long b_size; /* block size */
char * b_data; /* pointer to data block (1024 bytes) */
unsigned int b_list; /* List that this buffer appears */
unsigned long b_flushtime; /* Time when this (dirty) buffer should be
written */
unsigned long b_lru_time; /* Time when this buffer was last used. */
struct wait_queue * b_wait;
struct buffer_head * b_prev; /* doubly linked list of hash-queue */
struct buffer_head * b_prev_free; /* doubly linked list of buffers */
struct buffer_head * b_reqnext; /* request queue */
};

块缓冲区主要由链表组成。空闲的buffer_head组成的链表是按块大小的不同分类组成,linux目前支持块大小为512、1024、2048、4096和8192字节;第二部分是正在用的块,块以Hash_table的形式组织,具有相同hash索引的缓冲块连在一起,hash索引根据设备标志符和该数据块的块号得到;同时将同一状态的缓冲区块用LRU算法连在一起。对缓冲区的各个链表定义如下:
/* fsuffer.c*/
static struct buffer_head ** hash_table;
static struct buffer_head * lru_list[NR_LIST] = {NULL, };
static struct buffer_head * free_list[NR_SIZES] = {NULL, };
static struct buffer_head * unused_list = NULL;
static struct buffer_head * reuse_list = NULL;




[目录]

--------------------------------------------------------------------------------


初始化

三. 设备的初始化
LINUX启动时,完成了实模式下的系统初始化(arch/i386/boot/setup.S)与保护模式下的核心初始化包括初始化寄存器和数据区(arch/i386/boot/compressed/head.S)、核心代码解压缩、页表初始化(arch/i386/kernel/head.S)、初始化idt、gdt和ldt等工作
后,系统转入了核心。调用函数start_kernel启动核心(init/main.c)后,将继续各方面的初始化工作,其中start_kernel最后将调用kernel_thread (init, NULL, 0),创建init进程进行系统配置(其中包括所有设备的初始化工作)。
static int init(void * unused)
{
…………
/* 创建后台进程bdflush,以不断循环写出文件系统缓冲区中"脏"的内容 */
kernel_thread(bdflush, NULL, 0);
/* 创建后台进程kswapd,专门处理页面换出工作 */
kswapd_setup();
kernel_thread(kswapd, NULL, 0);
…………
setup();
…………
在setup函数中,调用系统调用sys_setup()。sys_setup()的定义如下:
//fs/filesystems.c
asmlinkage int sys_setup(void)
{
static int callable = 1;
… …
if (!callable)
return -1;
callable = 0;
… …
device_setup();
… …
在该系统调用中,静态变量callable保证只被调用实际只一次,再次调用时后面的初始化程序不执行。在该调用开始就先进行设备的初始化:device_setup()。
//dirvers/block/genhd.c
void device_setup(void)
{
extern void console_map_init(void);
… …
chr_dev_init();
blk_dev_init();
… …
可以看到device_setup()将依次执行chr_dev_init()、blk_dev_init()等各类设备的初始化程序。每个具体的init函数的内容和具体设备就有关了,但是它们都有一些必须完成的任务:
1、 告诉内核这一驱动程序使用的主设备号,同时提供指向file_operation的指针,以完成对chrdevs和blkdevs的初始化。
2、 对块设备,需要将输入/输出处理程序的入口地址告诉内核。
3、 对块设备,需要告诉缓冲区设备存取的数据块的大小。





[目录]

--------------------------------------------------------------------------------


管理流程

四. 设备管理的流程
下面我们介绍一下整个设备管理的流程。我们以块设备为例,字符设备的流程也和块设备类似,只是没有请求队列管理。
首先,文件系统通过调用ll_rw_block发出块读写命令,读写请求管理层接到命令后,向系统申请一块读写请求缓冲区,在填写完请求信息后,请求进入设备的读写请求队列等候处理。如果队列是空的,则请求立即得到处理,否则由系统负责任务调度,唤醒请求处理。在请求处理过程中,系统向I/O空间发出读写指令返回。当读写完毕后,通过中断通知系统,同时调用与设备相应的读写中断响应函数。





[目录]

--------------------------------------------------------------------------------


添加字符设备

五. 添加一个字符设备
作为对linux设备管理的分析的总结,我们介绍一下如何添加一个设备,首先介绍如何添加一个字符设备。在后面的文章中,我们将新添加的设备称为新设备,说明以我们实现的虚拟的字符设备为例,步骤基本如下:
1. 确定设备的设备名称和主设备号:
我们必须找一个还没有被使用的主设备号,分配给自己的字符设备。假设主设备号为30(在2.0.34的内核中还没有以30作为主设备号的字符设备)。

2. 确定编写需要的file_operations中的操作函数,包括:
static int my_open(struct inode * inode,struct file * file)
//通过宏指令MINOR()提取inode参数的I_rdev字段,确定辅助设备号,然后检查相应的读写忙标志,看新设备是否已经打开。如果是,返回错误信息;
否则置读写忙标志为true,阻止再次打开新设备。
static void my_release(struct inode * inode,struct file * file)
//同my_open类似,只是置读写忙标志为false,允许再次打开新设备。
static int my _write(struct inode * inode,struct file * file,const char * bu
ffer,int count)
//用于对该设备的写
static int my _read(struct inode * inode , struct file * file,char * buffer,
int count)
//用于对该设备的读
static int my_ioctl(struct inode * inode, struct file * file,
unsigned int cmd, unsigned long arg)
//用于传送特殊的控制信息给设备驱动程序,或者长设备驱动程序取得状态信息,在我们实现的虚拟字符设备中,这个函数的功能是用来打开和关闭跟踪功能。

3. 确定编写需要的初始化函数:
void my_init(void)
//首先需要将上述的file_operations中的操作函数的地址赋给某个file_operations的结构变量my_fops中的相应域;然后调用标准内核函数登记该设备:register_chrdev(30,"mychd",&my_fops);最后对必要的变量(例如读写忙标志、跟踪标志等)赋初值。

4. 在drivers/char/mem.c中添加相应语句;
在chr_dev_init函数之前添加drgn_init的原型说明:
void my_init (void);
在chr_dev_init函数的return语句之前添加以下语句:
my_init (); //用于在字符设备初始化时初始化新设备

5. 修改drivers/char/Makefile;
假设我们把所以必要的函数写mychd.c中,则找到"L_OBJS := tty_io.o n_tty.o con
sole.o "行,将"mychd.o"加到其中。
6. 将该设备私有的*.c,*.h复制到目录drivers/char下。
7. 用命令:make clean;make dep;make zImage重新编译内核。
8. 用mknod命令在目录/dev下建立相应主设备号的用于读写的特殊文件。
完成了上述步骤,你在linux环境下编程时就可以使用新设备了。





[目录]

--------------------------------------------------------------------------------


添加块设备

六. 添加一个块设备
接下来我们将介绍如何添加一个块设备。在后面的文章中,我们将新添加的块设备称为新设备,块设备的添加过程和字符设备有相似之处,我们将主要介绍其不同点,步骤基本如下:
1. 确定设备的设备名称和主设备号
我们必须找一个还没有被使用的主设备号,分配给自己的新设备。假设主设备号为30(在2.0.34的内核中还没有以30作为主设备号的块设备),则需要在include/linux/major.h中加入如下句:
#define MY_MAJOR 30
这样我们可以通过MY_MAJOR来确定设备为新设备,保证通用性。

2. 确定编写需要的file_operations中的操作函数:
static int my_open(struct inode * inode,struct file * file)
static void my_release(struct inode * inode,struct file * file)
static int my_ioctl(struct inode * inode, struct file * file,
unsigned int cmd, unsigned long arg)
由于使用了高速缓存,块设备驱动程序就不需要包含自己的read()、write()和fsync()函数,但必须使用自己的open()、 release()和 ioctl()函数,这些函数的作用和字符设备的相应函数类似。

3. 确定编写需要的输入/输出函数:
static int my _read(void) //正确处理时返回值为1,错误时返回值为0
static int my _write(void) //正确处理时返回值为1,错误时返回值为0
值得注意的是这两个函数和字符设备中的my read()、mywrite()函数不同:

参数不同:字符设备中的函数是带参数的,用于对其工作空间(也可以看成是简单的缓冲区)中的一定长度(长度也是参数传递的)的字符进行读写;而块设备的函数是没有参数的,它通过当前请求中的信息访问高速缓存中的相应的块,因此不需要参数输入。
调用形式不同:字符设备中的函数地址是存放在file_operations中的,在对字符设备进行读写时就调用了;而块设备的读写函数是在需要进行实际I/O时在request中调用。这在后面可以看到。

4. 确定编写需要的请求处理函数:
static void my_request(void)
在块设备驱动程序中,不带中断服务子程序的请求处理函数是简单的,典型的格式如下
:
static void my_request(void)
{
loop:
INIT_REQUEST;

if (MINOR(CURRENT->dev)>MY_MINOR_MAX)
{
end_request(0);
goto loop;
}

if (CURRENT ->cmd==READ)
//CUREENT是指向请求队列头的request结构指针
{
end_request(my_read()); //my_read()在前面已经定义
goto loop;
}

if (CURRENT ->cmd==WRITE)
{
end_request(my_write()); //my_write()在前面已经定义
goto loop;
}

end_request(0);
goto loop;
}
实际上,一个真正的块设备一般不可能没有中断服务子程序,另外设备驱动程序是在系统调用中被调用的,这时由内核程序控制CPU,因此不能抢占,只能自愿放弃;因此驱动程序必须调用sleep_on()函数,释放对CPU的占用;在中断服务子程序将所需的数据复制到内核内存后,再由它来发出wake_up()调用,

5. 如果需要,编写中断服务子程序
实际上,一个真正的块设备一般不可能没有中断服务子程序,另外设备驱动程序是在系统调用中被调用的,这时由内核程序控制CPU,因此不能抢占,只能自愿放弃;因此驱动程序必须调用sleep_on()函数,释放对CPU的占用;在中断服务子程序将所需的数据复制到内核内存后,再由它来发出wake_up()调用。
另外两段中断服务子程序都要访问和修改特定的内核数据结构时,必须要仔细协调,以防止出现灾难性的后果。

首先,在必要时可以禁止中断,这可以通过sti()和cli()来允许和禁止中断请求。
其次,修改特定的内核数据结构的程序段要尽可能的短,使中断不至于延时过长。含有中断服务子程序的块设备驱动程序的编写相对比较复杂,我们还没有完全实现,主要问题是在中断处理之间的协调。因为这些程序是要加入内核的,系统默认为你是完全正确的,如果引起循环或者中断长时间不响应,结果非常严重。我们正在努力实现这一程序。

6. 确定编写需要的初始化函数:
void my_init(void)
需要将的file_operations中的操作函数的地址赋给某个file_operations的结构变量my_fops中的相应域;一个典型的形式是:
struct file_operations my_fops=
{
0,
block_read,
block_write,
0,
0,
my_ioctl,
0,
my_open,
my_release,
block_fsync,
0,
0,
0,
}
my_init中需要作的工作有:

首先调用标准内核函数登记该设备:
register_chrdev(MY_MOJOR,"my--bdev",&my_fops);
将request()函数的地址告诉内核:
blk_dev[MY_MAJOR].request_fn=DEVICE_REQUEST;
DEVICE_REQUEST是请求处理函数的地址,它的定义将在稍后可以看到。
告诉新设备的高速缓存的数据块的块大小:
my_block_size=512; //也可以是1024等等
blksize_size[MY_MAJOR]=& my_block_size;
为了系统在初始化时能够对新设备进行初始化,需要在blk_dev_init()中添加一行代码,可以插在blk_dev_init()中return 0的前面,格式为:
my_init();

7. 在include/linux/blk.h中添加相应语句;
到目前为止,除了DEVICE_REQUEST符合外,还没有告诉内核到那里去找你的request()函数,为此需要将一些宏定义加到blk.h中。在blk.h中找到类似的一行:
#endif /*MAJOR_NR==whatever */
在这行前面加入如下宏定义:
#elif (MAJOR_NR==whatever)

static void my_request(void);
#define DEVICE_NAME "MY_BLK_DEV" //驱动程序名称
#define DEVICE_REQUEST my_request //request()函数指针
#define DEVIEC_NR(device) (MINOR(device)) //计算实际设备号
#define DEVIEC_ON(device) //用于需要打开的设备
#define DEVIEC_OFF(device) //用于需要关闭的设备
8. 修改drivers/block/Makefile;
假设我们把所以必要的函数写mybd.c中,则找到"L_OBJS := tty_io.o n_tty.o cons
ole.o "行,将"mybd.o"加到其中。
9. 将该设备私有的*.c,*.h复制到目录drivers/block下。
10. 用命令:make clean;make dep;make zImage重新编译内核。
11. 用mknod命令在目录/dev下建立相应主设备号的用于读写的特殊文件。
完成了上述步骤,你在linux环境下编程时就可以使用新设备了。





[目录]

--------------------------------------------------------------------------------


一个虚拟的字符设备驱动程序

七. 一个虚拟的字符设备驱动程序
以下是一个虚拟的字符设备驱动程序,该程序是我和潘刚同学的试验结果,本来我们还打算写一个虚拟的块设备驱动程序,由于时间关系,没有能够完全明白中断中断服务子程序的编写方法,因此没有没有能够实现一个可以所有的虚拟的块设备,非常遗憾。不过主要步骤已经在上文中进行了介绍,我想再有一段时间应该能够完成,到时候一定交给李老师看一下。
虚拟的字符设备驱动程序如下,在潘刚同学的试验报告中也有介绍:
/* drgn.h */
#ifdef KERNEL
#define TRACE_TXT(text) {if(drgn_trace) {console_print(text);console_print("
");}}
#define TRACE_CHR(chr) {if(drgn_trace) console_print(chr);}
#define DRGN_READ 1
#define DRGN_WRITE 0
#endif
#define FALSE 0
#define TRUE 1
#define MAX_BUF 120
#define DRGN_TRON (('M' << icon_cool.gif|0x01)
#define DRGN_TROFF (('M' << icon_cool.gif|0x02)
struct drgn_buf
{
int buf_size;
char buffer[MAX_BUF];
struct drgn_buf *link;
};
/* drgn.c */
#define KERNEL
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/tty.h>
#include <linux/signal.h>
#include <linux/errno.h>
#include <linux/malloc.h>
#include <linux/mm.h>
#include <asm/io.h>
#include <asm/segment.h>
#include <asm/system.h>
#include <asm/irq.h>
#include "drgn.h"
static int drgn_trace;
static int write_busy;
static int read_busy;
static struct drgn_buf * qhead;
static struct drgn_buf * qtail;
static int drgn_read(struct inode * , struct file * , char * , int );
static int drgn_write(struct inode * , struct file * , const char *, int );
static int drgn_ioctl(struct inode * , struct file * , unsigned int , unsig
ned long );
static int drgn_open(struct inode *,struct file *);
static void drgn_release(struct inode *,struct file *);
/* extern void console_print(char *);*/
struct file_operations drgn_fops=
{
NULL,
drgn_read,
drgn_write,
NULL,
NULL,
drgn_ioctl,
NULL,
drgn_open,
drgn_release,
NULL,
NULL,
NULL,
NULL
};
void drgn_init(void)
{
drgn_trace=TRUE;
if(register_chrdev(30,"drgn",&drgn_fops))
TRACE_TXT("Cannot register drgn driver as major device 30.")
else
TRACE_TXT("Tiny devie driver registered successfully.")
qhead=0;
write_busy=FALSE;
read_busy=FALSE;
/* drgn_trace=FALSE;*/
return;
}
static int drgn_open(struct inode * inode,struct file * file)
{
TRACE_TXT("drgn_open")
switch (MINOR(inode->i_rdev))
{
case DRGN_WRITE:
if(write_busy)
return -EBUSY;
else{
write_busy=TRUE;
return 0;
}
case DRGN_READ:
if(read_busy)
return -EBUSY;
else{
read_busy=TRUE;
return 0;
}
default:
return -ENXIO;
}
}
static void drgn_release(struct inode * inode,struct file * file)
{
TRACE_TXT("drgn_release")
switch (MINOR(inode->i_rdev))
{
case DRGN_WRITE:
write_busy=FALSE;
return;
case DRGN_READ:
read_busy=FALSE;
return;
}
}
static int drgn_write(struct inode * inode,struct file * file,
const char * buffer,int count)
{
int i,len;
struct drgn_buf * ptr;
TRACE_TXT("drgn_write")
if (MINOR(inode->i_rdev)!=DRGN_WRITE)
return -EINVAL;
if ((ptr=kmalloc(sizeof(struct drgn_buf),GFP_KERNEL))==0)
return -ENOMEM;
len=count < MAX_BUF?count:MAX_BUF;
if (verify_area(VERIFY_READ,buffer,len))
return -EFAULT;
for(i=0;i < count && i<MAX_BUF;++i)
{
ptr->buffer[i]=(char) get_user((char*)(buffer+i));
TRACE_CHR("w")
}
ptr->link=0;
if(qhead==0)
qhead=ptr;
else
qtail->link=ptr;
qtail=ptr;
TRACE_CHR(" ")
ptr->buf_size=i;
return i;
}
static int drgn_read(struct inode * inode , struct file * file,
char * buffer, int count)
{
int i,len;
struct drgn_buf * ptr;
TRACE_TXT("drgn_read")
if(MINOR(inode->i_rdev)!=DRGN_READ)
return -EINVAL;
if (qhead==0)
return -ENODATA;
ptr=qhead;
qhead=qhead->link;
len=count < ptr->buf_size?count:ptr->buf_size;
if (verify_area(VERIFY_WRITE,buffer,len))
return -EFAULT;
for (i=0; i<count && i<ptr->buf_size; ++i)
{
put_user((char) ptr->buffer[i],(char *)(buffer+i));
TRACE_CHR("r")
}
TRACE_CHR(" ")
kfree_s(ptr,sizeof(struct drgn_buf));
return i;
}
static int drgn_ioctl(struct inode * inode, struct file * file,
unsigned int cmd, unsigned long arg)
{
TRACE_TXT("drgn_ioctl")
/* if (cmd==DRGN_TRON){
drgn_trace=TRUE;
return 0;
}
else
if (cmd==DRGN_TROFF){
drgn_trace=FALSE;
return 0;
}
else
return -EINVAL;*/
switch(cmd)
{
case DRGN_TRON:
drgn_trace=TRUE;
return 0;
case DRGN_TROFF:
drgn_trace=FALSE;
return 0;
default:
return -EINVAL;
}
}

Linux自动加载设备驱动模块编程 请注意,上述示例代码中的"my_device_driver"、“/dev/my_device”、MAJOR_NUMBER和MINOR_NUMBER是占位符,请根据实际情况替换为您自己的驱动模块名称、设备文件路径和主次设备号。要实现自动加载设备驱动模块的功能,我们可以使用udev(用户空间设备管理器)来监测系统中的设备事件,并根据需要加载相应的驱动模块。当系统中的设备事件匹配我们定义的规则时,udev将自动执行我们编写的Shell脚本,从而实现设备驱动模块的自动加载。如有任何疑问,请随时提问。 阅读详情

相关推荐

国产麒麟系统下用Rider开发C#桌面应用:从环境配置到Avalonia UI实战

本文详细介绍了在国产麒麟系统上使用JetBrains Rider开发C#桌面应用的完整流程,重点讲解了Avalonia UI框架的实战应用。从环境配置、Rider安装到Avalonia项目创建和UI开发技巧,全面覆盖了在非Windows环境下进行C#开发的关键步骤和优化建议,助力开发者高效构建跨平台桌面应用。

weixin_27791839的博客 387

linux设备加载分析

要点:1.设备注册2.设备驱动注册3.设备与驱动如何绑定4.驱动如何初始化设备资源当内核版本:linux 4.6.3以led为例(leds-sunfire.c)在设备树中创建led设备节点,在内核初始化时将所有节点创建出来(内核采用先创建节点,后初始化对应驱动,有设备无驱动则设备不工作,无设备则驱动初始化不起来)当前篇幅我们只分析驱动的加载:一.内核调用sunfire_leds_init流程:在编...

一只拖鞋 587

YF-S401水流量传感器在STM32上的精准计量实现

本文详细介绍了YF-S401水流量传感器与STM32微控制器的集成应用,实现精准水流计量。通过外部中断和外部时钟两种脉冲计数方案,结合硬件配置、软件滤波和校准技巧,确保高精度流量测量。适用于智能家居和工业自动化中的水控系统,提升系统稳定性和测量准确性。

rainy的博客 897

Linux设备驱动模块自加载示例与原理解析

本文介绍Linux设备驱动模块在设备注册时如何实现自动加载和创建设备节点。 在Linux系统中,基于sysfs文件系统、设备驱动模型和udev工具可以实现在设备模块“冷、热”加载时自动加载设备对应的驱动程序,同时可以按需在/dev目录下创建设备节点。 本文中我搭建好环境并写了两个简单的示例程序demo_device.c和device_driver.c来模拟“设备”与“驱动”的自动加载和设备节点自动创建的过程。最后通过内核源代码来理解其中的原理知识。

My Linux Journey 1万+

一起玩儿物联网人工智能小车(ESP32)——48. 利用循迹模块实现循迹小车(三)

摘要:本文介绍循迹小车的接线方法及类的基础知识

一起玩儿科技 1137

AHP层次分析法在项目风险评估中的实战应用(含Excel模板)

本文详细介绍了AHP层次分析法在项目风险评估中的实战应用。通过构建风险层次模型、利用判断矩阵量化主观判断,并结合Excel工具进行权重计算与一致性检验,将模糊的定性风险转化为清晰的量化排序。文章以新产品上线项目为例,提供了完整的分析流程和可操作的Excel模板,帮助项目经理高效识别并优先处理核心风险。

weixin_29061465的博客 572

Linux内核架构浅谈66 - Linux设备驱动模块:动态加载与卸载的实现

Linux设备驱动模块机制突破了宏内核的静态局限,通过动态加载/卸载实现了内核功能的灵活扩展。模块加载涉及二进制验证、内存分配、符号解析等步骤,并与内核子系统紧密集成;卸载时需严格检查引用计数并对称释放资源,避免内核崩溃风险。kmod与udev协同实现硬件热插拔时的驱动自动加载。该机制完美平衡了宏内核性能与模块化灵活性,降低了驱动开发门槛,支撑了Linux多样化的硬件生态,但要求开发者遵循严格的资源管理和并发控制规范。

文石_2009的博客 1145

【Mode】多模干涉仪的设计 Multi-mode interferometer(MMI)

与 Splitter 器件一样,MMI 器件也是一种常见的分光器件,可以根据用户的需求将光束分成不同的比例。本文,我们将介绍如何仿真 MMI 器件。这里我们使用的是 1x2 MMI,其本质上是由四个部分组成的,中间的矩形多模式干涉区域以及左右两侧的三个 taper 模式转换区域。之前的教程中我们也提及了,为了获取稳定的模式场分布,通常,我们需要进行模式收敛性扫描。这里以官网给出的案例为例。如何提取 S 参数我们先暂时不做介绍,后续有时间了我们再做介绍。

u011699626的博客 1219

linux设备和驱动加载的先后顺序

Linux驱动先注册总线,总线上可以先挂device,也可以先挂driver,那么究竟怎么控制先后的顺序呢。 Linux系统使用两种方式去加载系统中的模块:动态和静态。 静态加载:将所有模块的程序编译到Linux内核中,由do_initcall函数加载 核心进程(/init/main.c)kernel_inità do_basic_setup()àdo_initcalls()该函数中会将在_

maopig的专栏 2万+

Vins-Fusion 外参camera-imu 标定

Vins-Fusion是一种基于优化的多传感器状态估计器,一大特色是支持实时camera-imu外参校准(相机和IMU之间的旋转)。Vins-Fusion 外参camera-imu校准是利用两帧间计算相机位姿和imu预积分得到位姿,构建最小二乘问题,并通过SVD求解camera-imu外参旋转矩阵。

u010196944的博客 2493

【Python基础】FastAPI 从入门到项目实战操作详解

【Python基础】FastAPI从入门到使用实战操作详解

congge_study的博客 462

linux设备驱动——bus、device、driver加载顺序与匹配流程

Linux设备驱动相关知识

holly的专栏 9520

VB摄像头监控

该VB模块可对摄像头捕获的画面进行录像等,可在创建的窗口进行控制

Linux 设备驱动的固件加载

作为一个驱动作者, 你可能发现你面对一个设备必须在它能支持工作前下载固件到它里面. 硬件市场的许多地方的竞争是如此得强烈, 以至于甚至一点用作设备控制固件的 EEPROM 的成本制造商都不愿意花费. 因此固件发布在随硬件一起的一张 CD 上, 并且操作系统负责传送固件到设备自身.      硬件越来越复杂,硬件的许多功能使用了程序实现,与直接硬件实现相比,固件拥有处理复杂事物的灵活性和便于升级、

知秋一叶 1万+

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

IEM模型,地表粗糙度模拟

利用微波反演土壤水分时候,利用IEM模型可以实现对随机地表的模拟

嵌入式Linux系统引导过程中的设备驱动加载

其中,my_driver.c是设备驱动模块的源代码文件,my_driver_module.c是与设备驱动相关的模块代码文件。设备驱动程序是内核的一部分,用于与硬件设备进行通信和控制。其中,register_chrdev函数用于注册字符设备驱动程序,第一个参数是主设备号,第二个参数是设备名称,第三个参数是文件操作结构体指针。在设备驱动程序的生命周期中,需要在模块初始化函数中注册设备驱动,并在模块卸载函数中注销设备驱动。在设备驱动程序中,需要实现相应的注册和注销函数,以便将驱动程序与相应的硬件设备关联起来。

D_ovis的博客 1010

C# WinForm 基于DirectShow.dll编写的程序,可边预览边保存视频,音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择(默认选中第一个)2.可录制wmv和avi两种格式的视频并且都带有音频,avi可以录制的分辨率和帧数进行选择,wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照,也可边录制视频边拍照4.添加了视频和音频的压缩功能(酌情使用)这次二次开发发现C#对DirectShow的相关信息太少,这次做完也不敢藏私共享出来,还望大家指正

linux设备驱动加载方式

在类unix操作系统中,驱动加载方式一般分为:动态加载和静态加载,下面分别对其详细论述。一、动态加载动态加载是将驱动模块加载到内核中,而不能放入/lib/modules/下。    在2.4内核中,加载驱动命令为:insmod ,删除模块为:rmmod;    在2.6以上内核中,除了insmod与rmmod外,加载命令还有modprobe;    insmod与modprobe不同之处:   

oceanlee2的专栏 3348

linux加载usb设备驱动程序,linux如何发现和加载对应的USB设备驱动

linux如何发现和加载对应的USB对应的设备驱动1.整体流程加载USB设备驱动-->注册USB设备(注册的USB设备结构体包含了USB设备的vender ID和product ID)USB设备插入后,匹配到vendor ID和product ID,即调用改USB注册结构里的probe函数,开始和USB设备进行通信。2.USB设备结构体static struct usb_driver tes...

weixin_35817272的博客 1703

linux下自动加载设备驱动程序模块

假设你的设备驱动程序为:yourdrivername.ko1 cp yourdrivername.ko /lib/modules/"version"/kernel/drivers/misc其中,version为linux的版本,默认为:2.6.23.1-42.fc82 编辑/lib/modules/"version"/modules.de...

weixin_34192993的博客 440

关于linux-设备驱动加载卸载

linux设备驱动 devices以及driver都是在系统启动的时候加载(probe外设初始化),在关机流程里卸载(remove),在系统运行过程中,可以通过设置work驱动具体设备,比如打开了相机才去操作相关camera寄存器,退出相机,停止对camera的寄存器操作。同样的,在 /sys/firmware/devicetree/base 下设备树的一堆节点,下面是mtk平台开机部分log,各种驱动probe都发生在开机的十几秒。节点下面还有具体挂载的外设,以及该节点的compatible信息等。

weixin_39223971的博客 563

Linux驱动开发1:设备驱动模块加载与卸载

设备驱动模块加载与卸载

weixin_45783574的博客 972

Linux设备驱动框架、配置文件及加载

Linux设备驱动概述 本讲主要概述Linux设备驱动框架、驱动程序的配置文件及常用的加载驱动程序的方法;并且介绍Red Hat Linux安装程序是如何加载驱动的,通过了解这个过程, 我们可以自己将驱动程序放到引导盘中;安装完系统后,使用kudzu自动配置硬件程序。 #lsmod (与cat /proc/modules 得出的内容是一致的)Module Size Used by Not ta

menuconfig的专栏 1683

linux设备树节点添加新的复位属性之后设备驱动加载异常问题分析

若新添加的设备属性需要执行具体的功能,那需要按照3.1章的部分去添加对应的设备驱动程序。若不需要,则在原始的设备驱动初始化流程直接去解析对应的设备属性即可。

天使之翼 2376
上一篇: 我是不停止的风
下一篇: 自己写的嵌入linux驱动试验程序源码
仰泳的鱼儿
博客等级 码龄24年 42粉丝 84原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值