在刚开始写Linux设备驱动程序的时候，很多时候都是利用mknod命令手动创建设备节点，实际上Linux内核为我们提供了一组函数，可以用来在模块加载的时候自动在/dev目录下创建相应设备节点，并在卸载模块时删除该节点。
在2.6.17以前，在/dev目录下生成设备文件很容易，
devfs_mk_bdev
devfs_mk_cdev
devfs_mk_symlink
devfs_mk_dir
devfs_remove
这几个是纯devfs的api，2.6.17以前可用，但后来devfs被sysfs+udev的形式取代，同时期sysfs文件系统可以用的api：
class_device_create_file，在2.6.26以后也不行了，现在，使用的是device_create ，从2.6.18开始可用
struct device *device_create(struct class *class, struct device *parent,
dev_t devt, const char *fmt, ...)
从2.6.26起又多了一个参数drvdata： the data to be added to the device for callbacks
不会用可以给此参数赋NULL
struct device *device_create(struct class *class, struct device *parent,
dev_t devt, void *drvdata, const char *fmt, ...)
下面着重讲解第三种方法udev
在驱动用加入对udev的支持主要做的就是：在驱动初始化的代码里调用class_create(...)为该设备创建一个class，再为每个设备调用device_create(...)( 在2.6较早的内核中用class_device_create)创建对应的设备。
内核中定义的struct class结构体，顾名思义，一个struct class结构体类型变量对应一个类，内核同时提供了class_create(…)函数，可以用它来创建一个类，这个类存放于sysfs下面，一旦创建好了这个类，再调用 device_create(…)函数来在/dev目录下创建相应的设备节点。这样，加载模块的时候，用户空间中的udev会自动响应 device_create(…)函数，去/sysfs下寻找对应的类从而创建设备节点。
struct class和class_create(…) 以及device_create(…)都包含在在/include/linux/device.h中，使用的时候一定要包含这个头文件，否则编译器会报错。
struct class定义在头文件include/linux/device.h中
class_create(…)在/drivers/base/class.c中实现
device_create(…)函数在/drivers/base/core.c中实现
class_destroy(...),device_destroy(...)也在/drivers/base/core.c中实现调用过程类似如下：
static struct class *spidev_class
/*-------------------------------------------------------------------------*/
static int __devinit spidev_probe(struct spi_device *spi)
{
....
dev =device_create(spidev_class, &spi->dev, spidev->devt,
spidev, "spidev%d.%d",
spi->master->bus_num, spi->chip_select)
...
}
static int __devexit spidev_remove(struct spi_device *spi)
{
......
device_destroy(spidev_class, spidev->devt)
.....
return 0
}
static struct spi_driver spidev_spi = {
.driver = {
.name ="spidev",
.owner =THIS_MODULE,
},
.probe =spidev_probe,
.remove =__devexit_p(spidev_remove),
}
/*-------------------------------------------------------------------------*/
static int __init spidev_init(void)
{
....
spidev_class =class_create(THIS_MODULE, "spidev")
if (IS_ERR(spidev_class)) {
unregister_chrdev(SPIDEV_MAJOR, spidev_spi.driver.name)
return PTR_ERR(spidev_class)
}
....
}
module_init(spidev_init)
static void __exit spidev_exit(void)
{
......
class_destroy(spidev_class)
......
}
module_exit(spidev_exit)
MODULE_DESCRIPTION("User mode SPI device interface")
MODULE_LICENSE("GPL")
下面以一个简单字符设备驱动来展示如何使用这几个函数
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/device.h>
int HELLO_MAJOR = 0
int HELLO_MINOR = 0
int NUMBER_OF_DEVICES = 2
struct class *my_class
//struct cdev cdev
//dev_t devno
struct hello_dev {
struct device *dev
dev_t chrdev
struct cdev cdev
}
static struct hello_dev *my_hello_dev = NULL
struct file_operations hello_fops = {
.owner = THIS_MODULE
}
static int __init hello_init (void)
{
int err = 0
struct device *dev
my_hello_dev = kzalloc(sizeof(struct hello_dev), GFP_KERNEL)
if (NULL == my_hello_dev) {
printk("%s kzalloc failed!\n",__func__)
return -ENOMEM
}
devno = MKDEV(HELLO_MAJOR, HELLO_MINOR)
if (HELLO_MAJOR)
err= register_chrdev_region(my_hello_dev->chrdev, 2, "memdev")
else
{
err = alloc_chrdev_region(&my_hello_dev->chrdev, 0, 2, "memdev")
HELLO_MAJOR = MAJOR(devno)
}
if (err) {
printk("%s alloc_chrdev_region failed!\n",__func__)
goto alloc_chrdev_err
}
printk("MAJOR IS %d\n",HELLO_MAJOR)
cdev_init(&(my_hello_dev->cdev), &hello_fops)
my_hello_dev->cdev.owner = THIS_MODULE
err = cdev_add(&(my_hello_dev->cdev), my_hello_dev->chrdev, 1)
if (err) {
printk("%s cdev_add failed!\n",__func__)
goto cdev_add_err
}
printk (KERN_INFO "Character driver Registered\n")
my_class =class_create(THIS_MODULE,"hello_char_class") //类名为hello_char_class
if(IS_ERR(my_class))
{
err = PTR_ERR(my_class)
printk("%s class_create failed!\n",__func__)
goto class_err
}
dev = device_create(my_class,NULL,my_hello_dev->chrdev,NULL,"memdev%d",0) //设备名为memdev
if (IS_ERR(dev)) {
err = PTR_ERR(dev)
gyro_err("%s device_create failed!\n",__func__)
goto device_err
}
printk("hello module initialization\n")
return 0
device_err:
device_destroy(my_class, my_hello_dev->chrdev)
class_err:
cdev_del(my_hello_dev->chrdev)
cdev_add_err:
unregister_chrdev_region(my_hello_dev->chrdev, 1)
alloc_chrdev_err:
kfree(my_hello_dev)
return err
}
static void __exit hello_exit (void)
{
cdev_del (&(my_hello_dev->cdev))
unregister_chrdev_region (my_hello_dev->chrdev,1)
device_destroy(my_class, devno)//delete device node under /dev//必须先删除设备，再删除class类
class_destroy(my_class)//delete class created by us
printk (KERN_INFO "char driver cleaned up\n")
}
module_init (hello_init)
module_exit (hello_exit)
MODULE_LICENSE ("GPL")
这样，模块加载后，就能在/dev目录下找到memdev这个设备节点了。
例2:内核中的drivers/i2c/i2c-dev.c
在i2cdev_attach_adapter中调用device_create(i2c_dev_class, &adap->dev,
MKDEV(I2C_MAJOR, adap->nr), NULL,
"i2c-%d", adap->nr)
这样在dev目录就产生i2c-0 或i2c-1节点
接下来就是udev应用，udev是应用层的东西，udev需要内核sysfs和tmpfs的支持，sysfs为udev提供设备入口和uevent通道，tmpfs为udev设备文件提供存放空间
udev的源码可以在去相关网站下载，然后就是对其在运行环境下的移植，指定交叉编译环境，修改Makefile下的CROSS_COMPILE，如为mipsel-linux-，DESTDIR=xxx，或直接make CROSS_COMPILE=mipsel-linux-,DESTDIR=xxx 并install
把主要生成的udevd、udevstart拷贝rootfs下的/sbin/目录内，udev的配置文件udev.conf和rules.d下的rules文件拷贝到rootfs下的/etc/目录内
并在rootfs/etc/init.d/rcS中添加以下几行：
echo “Starting udevd...”
/sbin/udevd --daemon
/sbin/udevstart
（原rcS内容如下：
# mount filesystems
/bin/mount -t proc /proc /proc
/bin/mount -t sysfs sysfs /sys
/bin/mount -t tmpfs tmpfs /dev
# create necessary devices
/bin/mknod /dev/null c 1 3
/bin/mkdir /dev/pts
/bin/mount -t devpts devpts /dev/pts
/bin/mknod /dev/audio c 14 4
/bin/mknod /dev/ts c 10 16
）
这样当系统启动后，udevd和udevstart就会解析配置文件，并自动在/dev下创建设备节点文件
From:http://m.blog.csdn.net/blog/liliyaya/91881931. 在\kernel\of\fdt.c 中有如下初始化函数 注释上：展开设备树，创建device_nodes到全局变量allnodes中
void __init unflatten_device_tree(void)
{
__unflatten_device_tree(initial_boot_params, &allnodes,
early_init_dt_alloc_memory_arch)
/* Get pointer to "/chosen" and "/aliasas" nodes for use everywhere */
of_alias_scan(early_init_dt_alloc_memory_arch)
}
unflatten_device_tree函数被setup_arch函数调用，
因为我们使用得是arm平台所以存在\kernel\arch\arm\kernel\setup.c中
void __init setup_arch(char **cmdline_p)
{
unflatten_device_tree()
}
setup_arch函数在kernel启动是被调用，如下启动kernel存在\kernel\init\main.c中
asmlinkage void __init start_kernel(void)
{
setup_arch(&command_line)
}
这些工作完成解析DTS文件。保存到全局链表allnodes中。
2、在makefile中有这段话来编译dts文件：
$(obj)/A20%.dtb: $(src)/dts/A20%.dts FORCE
$(call if_changed_dep,dtc)
$(obj)/A68M%.dtb: $(src)/dts/A68M%.dts FORCE
$(call if_changed_dep,dtc)
和.c文件生成.o文件一样 回生成.dtb文件。在
/home/liyang/workspace/SZ_JB-mr1-8628-bsp-1012/out/target/product/msm8226/obj/KERNEL_OBJ/arch/arm/boot
目录下，与zimage一个目录。
3、
在 board-8226.c中有初始化函数-->启动自动掉用
void __init msm8226_init(void)
{
of_platform_populate(NULL, of_default_bus_match_table, adata, NULL)
}
of_platform_populate在kernel\driver\of\platform.c中定义，回查询
root = root ? of_node_get(root) : of_find_node_by_path("/")
for_each_child_of_node(root, child)
{
rc = of_platform_bus_create(child, matches, lookup, parent, true)
if (rc)
break
}
of_node_put(root)
在这里用到得函数of_find_node_by_path会最终调用到kernel\driver\of\base.c中得函数
struct device_node *of_find_node_by_path(const char *path)
{
遍历第1步中得allnodes找到根节点
}
of_platform_bus_create()函数中创建得内容存在了 adata中。
以下内容为转载：
（2）使用DTS注册总线设备的过程
以高通8974平台为例，在注册i2c总线时，会调用到qup_i2c_probe()接口，该接口用于申请总线资源和添加i2c适配器。在成功添加i2c适配器后，会调用of_i2c_register_devices()接口。此接口会解析i2c总线节点的子节点（挂载在该总线上的i2c设备节点），获取i2c设备的地址、中断号等硬件信息。然后调用request_module()加载设备对应的驱动文件，调用i2c_new_device()，生成i2c设备。此时设备和驱动都已加载，于是drvier里面的probe方法将被调用。后面流程就和之前一样了。
简而言之，Linux采用DTS描述设备硬件信息后，省去了大量板文件垃圾信息。Linux在开机启动阶段，会解析DTS文件，保存到全局链表allnodes中，在掉用.init_machine时，会跟据allnodes中的信息注册平台总线和设备。值得注意的是，加载流程并不是按找从树根到树叶的方式递归注册，而是只注册根节点下的第一级子节点，第二级及之后的子节点暂不注册。Linux系统下的设备大多都是挂载在平台总线下的，因此在平台总线被注册后，会根据allnodes节点的树结构，去寻找该总线的子节点，所有的子节点将被作为设备注册到该总线上。
在Linux虚拟机镜像中添加设备可以分为两种情况：一是添加虚拟设备；二是添加物理设备。添加虚拟设备
在Linux虚拟机镜像中添加虚拟设备一般有两种方式：一种是通过虚拟机管理软件添加虚拟设备，另一种是在虚拟机中安装驱动程序来添加虚拟设备。以VirtualBox为例，可以通过以下步骤添加虚拟设备：
在VirtualBox中选择要添加设备的虚拟机，点击“设置”按钮。
在“设置”窗口中选择“设备”选项卡，点击“添加”按钮。
在“添加硬件”窗口中选择要添加的设备类型，如网络适配器、USB控制器等，点击“添加”按钮。
配置设备参数，如网络适配器的连接方式、USB控制器的速度等。
点击“确定”按钮保存设置，启动虚拟机即可使用添加的设备。
添加物理设备
在Linux虚拟机镜像中添加物理设备需要先将物理设备与虚拟机关联起来，然后在虚拟机中安装相应的驱动程序。以下是添加物理设备的一般步骤：
在虚拟机管理软件中将物理设备与虚拟机关联起来，如将USB设备与虚拟机关联。
在虚拟机中安装相应的驱动程序，如USB设备的驱动程序。
启动虚拟机，使用添加的设备。
需要注意的是，在将物理设备与虚拟机关联时，需要将设备的所有权转移到虚拟机，否则虚拟机无法访问该设备。在Linux中，可以使用udev规则将设备所有权转移给虚拟机。具体 *** 作可以参考Linux的官方文档。
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）