《Linux总线、设备与驱动》ldd3中demo分析

2024-03-15 14:32
文章标签 分析 linux 驱动 总线 设备 demo ldd3

本文主要是介绍《Linux总线、设备与驱动》ldd3中demo分析，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

说明：本文基于Android2.3和Linux2.6；其他版本仅供参考。

Android2.3及Linux2.6.29内核模拟器版本编译与调试

一、古老方式(不支持热插拔)

1.开机前硬件设备已经插入总线；

2.操作系统加载总线驱动，开始扫描设备、并为其申请struct device结构，最后挂入总线驱动devices链表；

3.操作系统加载设备驱动，注册struct device_driver结构，然后去总线驱动的devices链表中遍历没有绑定driver的设备(即struct device中struct device_driver为空的设备)，如果匹配、就device_bind_driver。

二、现在方式(支持热插拔)

1.操作系统加载总线驱动；

2.当有硬件插入时；总线驱动扫描到设备、并为其申请struct device，然后去总线驱动的drivers链表去遍历设备驱动；

3.反之，当有设备驱动加载时；总线为其申请struct device_driver，然后去总线驱动的devices链表遍历设备。

总结：由以上可以看出；总线驱动是核心，联系这设备和设备驱动。

三、深入讲解

1.数据结构kernel/include/linux/device.h

总线：struct bus_type;

设备：struct device;

驱动：struct device_driver;

2.关系

总线驱动总会主动去扫描并为其上的设备分配struct device并添加到devices链表中；

反之，总线驱动是被动的接受设备驱动的struct device_driver并添加到drivers链表中。

四、实例-ldd3里边的例子

1.总线驱动的注册与注销

struct bus_type ldd_bus_type = {.name = "ldd",.match = ldd_match, 
//当一个总线上的新设备或者新驱动被添加时，会一次或者多次调用这个函数；用来匹配总线上的设备和驱动。
/*
static int ldd_match(struct device *dev, struct device_driver *driver){//return !(strncmp(dev->bus_id, driver->name, strlen(driver->name));return !strncmp(dev->init_name, driver->name, strlen(driver->name));  //change by tankai//本测试demo，只是判断设备名和驱动名是否一样；实际可能会比较复杂，如USB是通过VID和PID
}
*/.uevent  = ldd_hotplug,
};
bus_register(&ldd_bus_type);
bus_unregister(&ldd_bus_type);
struct device ldd_bus = {.bus_id   = "ldd0",.release  = ldd_bus_release
};
device_register(&ldd_bus);
device_unregister(&ldd_bus);

2.总线驱动提供的设备驱动接口

int register_ldd_driver(struct ldd_driver *driver){int ret;driver->driver.bus = &ldd_bus_type;if (driver->probe)driver->driver.probe = lddbus_drv_probe;if (driver->remove)driver->driver.remove = lddbus_drv_remove;if (driver->shutdown)driver->driver.shutdown = lddbus_drv_shutdown;if (driver->suspend)driver->driver.suspend = lddbus_drv_suspend;if (driver->resume)driver->driver.resume = lddbus_drv_resume;ret = driver_register(&driver->driver); //该函数很重要，会去bus上寻找匹配设备（间接调用总线的match接口）、如果匹配成功会调用驱动的探测函数	if (ret)return ret;driver->version_attr.attr.name = "version";//driver->version_attr.attr.owner = driver->module;driver->version_attr.attr.mode = S_IRUGO;driver->version_attr.show = show_version;driver->version_attr.store = NULL;return driver_create_file(&driver->driver, &driver->version_attr);
}

3.总线在扫描到设备后的注册接口

int register_ldd_device(struct ldd_device *ldddev){ldddev->dev.bus = &ldd_bus_type;ldddev->dev.parent = &ldd_bus;ldddev->dev.release = ldd_dev_release;//strncpy(ldddev->dev.bus_id, ldddev->name, BUS_ID_SIZE);ldddev->dev.init_name = ldddev->name;  //change by tank@tcl.comreturn device_register(&ldddev->dev);   //该函数很重要，会去bus上寻找匹配驱动（间接调用总线的match接口）、如果匹配成功会调用驱动的探测函数
}
五、以下贴上ldd3总线、设备、驱动demo

注意：

因为是模拟事件发生，因此、驱动程序module_init时有设备的注册过程，实际驱动中不需要这部分、是总线轮询或中断导致设备的注册（注意总线注册的设备不会进入设备文件系统下创建设备节点、它只是加入总线的设备链表并在匹配设备驱动时使用；设备文件系统下设备节点的创建，是在设备驱动的探测probe函数中完成）。

1.总线

testbus.c

#include <linux/device.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/string.h>
#include "lddbus.h"MODULE_AUTHOR("Jonathan Corbet");
MODULE_LICENSE("Dual BSD/GPL");
static char *Version = "$Revision: 1.9 $";/** Respond to hotplug events.*/
static int ldd_hotplug(struct device *dev, char **envp, int num_envp,char *buffer, int buffer_size)
{envp[0] = buffer;if (snprintf(buffer, buffer_size, "LDDBUS_VERSION=%s",Version) >= buffer_size)return -ENOMEM;envp[1] = NULL;return 0;
}/** Match LDD devices to drivers.  Just do a simple name test.*/
static int ldd_match(struct device *dev, struct device_driver *driver)
{//return !(strncmp(dev->bus_id, driver->name, strlen(driver->name));return !strncmp(dev->init_name, driver->name, strlen(driver->name));  //change by tank@tcl.com
}/** The LDD bus device.*/
static void ldd_bus_release(struct device *dev)
{printk(KERN_DEBUG "lddbus release\n");
}/** And the bus type.*/
struct bus_type ldd_bus_type = {.name = "ldd",.match = ldd_match,//.uevent  = ldd_hotplug,.uevent  = ldd_uevent,
};struct device ldd_bus = {.init_name   = "ldd0",.release  = ldd_bus_release
};/** Export a simple attribute.*/
static ssize_t show_bus_version(struct bus_type *bus, char *buf)
{return snprintf(buf, PAGE_SIZE, "%s\n", Version);
}static BUS_ATTR(version, S_IRUGO, show_bus_version, NULL);/** LDD devices.*//** For now, no references to LDDbus devices go out which are not* tracked via the module reference count, so we use a no-op* release function.*/
static void ldd_dev_release(struct device *dev)
{ printk(KERN_ALERT"lddbus dev release \n");
}int register_ldd_device(struct ldd_device *ldddev)
{ldddev->dev.bus = &ldd_bus_type;ldddev->dev.parent = &ldd_bus;ldddev->dev.release = ldd_dev_release;//strncpy(ldddev->dev.bus_id, ldddev->name, BUS_ID_SIZE);ldddev->dev.init_name = ldddev->name;  //change by tank@tcl.comreturn device_register(&ldddev->dev);
}
EXPORT_SYMBOL(register_ldd_device);void unregister_ldd_device(struct ldd_device *ldddev)
{device_unregister(&ldddev->dev);
}
EXPORT_SYMBOL(unregister_ldd_device);/** Crude driver interface.*/
static int lddbus_drv_probe(struct device *_dev)
{struct ldd_driver *drv = to_ldd_driver(_dev->driver);struct ldd_device *dev = to_ldd_device(_dev);return drv->probe(dev);
}static int lddbus_drv_remove(struct device *_dev)
{struct ldd_driver *drv = to_ldd_driver(_dev->driver);struct ldd_device *dev = to_ldd_device(_dev);return drv->remove(dev);
}static void lddbus_drv_shutdown(struct device *_dev)
{struct ldd_driver *drv = to_ldd_driver(_dev->driver);struct ldd_device *dev = to_ldd_device(_dev);drv->shutdown(dev);
}static int lddbus_drv_suspend(struct device *_dev, pm_message_t state)
{struct ldd_driver *drv = to_ldd_driver(_dev->driver);struct ldd_device *dev = to_ldd_device(_dev);return drv->suspend(dev, state);
}static int lddbus_drv_resume(struct device *_dev)
{struct ldd_driver *drv = to_ldd_driver(_dev->driver);struct ldd_device *dev = to_ldd_device(_dev);return drv->resume(dev);
}/*static*/ int lddbus_kill(struct ldd_device *dev)
{printk("lddbus_kill: %s\n",dev->dev.init_name);return 0;
}
EXPORT_SYMBOL(lddbus_kill);static ssize_t show_version(struct device_driver *driver, char *buf)
{struct ldd_driver *ldriver = to_ldd_driver(driver);sprintf(buf, "%s\n", ldriver->version);return strlen(buf);
}int register_ldd_driver(struct ldd_driver *driver)
{int ret;driver->driver.bus = &ldd_bus_type;if (driver->probe)driver->driver.probe = lddbus_drv_probe;if (driver->remove)driver->driver.remove = lddbus_drv_remove;if (driver->shutdown)driver->driver.shutdown = lddbus_drv_shutdown;if (driver->suspend)driver->driver.suspend = lddbus_drv_suspend;if (driver->resume)driver->driver.resume = lddbus_drv_resume;ret = driver_register(&driver->driver);if (ret)return ret;driver->version_attr.attr.name = "version";//driver->version_attr.attr.owner = driver->module;driver->version_attr.attr.mode = S_IRUGO;driver->version_attr.show = show_version;driver->version_attr.store = NULL;return driver_create_file(&driver->driver, &driver->version_attr);
}void unregister_ldd_driver(struct ldd_driver *driver)
{driver_unregister(&driver->driver);
}
EXPORT_SYMBOL(register_ldd_driver);
EXPORT_SYMBOL(unregister_ldd_driver);static int __init ldd_bus_init(void)
{int ret;ret = bus_register(&ldd_bus_type);if (ret)return ret;if (bus_create_file(&ldd_bus_type, &bus_attr_version))printk(KERN_NOTICE "Unable to create version attribute\n");ret = device_register(&ldd_bus);if (ret)printk(KERN_NOTICE "Unable to register ldd0\n");return ret;
}static void ldd_bus_exit(void)
{device_unregister(&ldd_bus);bus_unregister(&ldd_bus_type);
}module_init(ldd_bus_init);
module_exit(ldd_bus_exit);

lddbus.h

/** Definitions for the virtual LDD bus.** $Id: lddbus.h,v 1.4 2004/08/20 18:49:44 corbet Exp $*///extern struct device ldd_bus;
extern struct bus_type ldd_bus_type;/** The LDD driver type.*//** A device type for things "plugged" into the LDD bus.*/struct ldd_device {char *name;//struct ldd_driver *driver;struct device dev;
};#define to_ldd_device(x) container_of((x), struct ldd_device, dev)struct ldd_driver {char *version;struct module *module;int (*probe)(struct ldd_device *);int (*remove)(struct ldd_device *);void (*shutdown)(struct ldd_device *);int (*suspend)(struct ldd_device *, pm_message_t state);int (*resume)(struct ldd_device *);	struct device_driver driver;struct driver_attribute version_attr;
};#define to_ldd_driver(drv) container_of(drv, struct ldd_driver, driver)extern int lddbus_kill(struct ldd_device *dev);extern int register_ldd_device(struct ldd_device *);
extern void unregister_ldd_device(struct ldd_device *);
extern int register_ldd_driver(struct ldd_driver *);
extern void unregister_ldd_driver(struct ldd_driver *);
2.设备与设备驱动

testmini.c

#include <linux/platform_device.h> 
#include <linux/miscdevice.h>#include <linux/interrupt.h>
//#include <asm/arch/map.h>
#include <asm/io.h>
#include <linux/irq.h>
#include <linux/wait.h>
#include <linux/semaphore.h>#include <linux/module.h>
#include <linux/fs.h>#include "lddbus.h"#include <linux/sched.h>//指向系统所拥有的资源信息，此信息为公用信息
//可以被多用户共同使用
static struct resource *mini_mem;
static struct resource *mini_irq;
static void __iomem *mini_base;static unsigned char wq_flag = 0 ; //wait queue 队列的唤醒标志//设备的数据结构，独立于platform的数据结构，此数据结构
//为驱动开发人员所要重点考虑的
//数据为用户公用的
struct Mini_Dev 
{struct miscdevice mdev;wait_queue_head_t wq;struct semaphore sem;
};struct Mini_Dev *p_mdev;static ssize_t s3c2440mini_read(struct file * file, char __user * userbuf,size_t count, loff_t * off)
{printk ("MINI TEST ..............READ\n");return 0;
}static ssize_t s3c2440mini_write(struct file *file, const char __user *data,size_t len, loff_t *ppos)
{printk ("MINI TEST ..............write\n");return 0;
}#define IOCTL_MINI_WAITIRQ _IOR('M',1,int)
#define IOCTL_MINI_SENDDATA _IOR('M',2,int)static int s3c2440mini_ioctl(struct inode *inode, struct file *file,	unsigned int cmd, unsigned long arg)
{int i;switch(cmd){case IOCTL_MINI_WAITIRQ:wait_event_interruptible(p_mdev->wq, (wq_flag)&0x01);wq_flag = 0;break;case IOCTL_MINI_SENDDATA:for ( i = 0 ; i < 0x1000000; i ++){writeb(0xff,mini_base);}break;}return 0;
}static int s3c2440mini_open(struct inode *inode, struct file *file)
{return 0;
}static int s3c2440mini_release(struct inode *inode, struct file *file)
{printk ("MINI TEST ..............release\n");return 0;
}//设备所具有的file 操作结构是驱动的工作重点
//同时也是设备功能实现的地方
static struct file_operations mini_ops = {.owner  	= THIS_MODULE,.write 	= s3c2440mini_write,.read 	= s3c2440mini_read,.unlocked_ioctl		= s3c2440mini_ioctl,.release	= s3c2440mini_release,.open	= s3c2440mini_open,
};//kernel interface//platform 驱动数据结构，提供了探测、移除、挂起、回复和关闭的
//的系统接口，使系统设备更加的规范
//.driver 挂接着设备的数据结构和资源信息，这些信息已经提前被
//注册到系统里，只有在.name相同的情况下调用platform_driver_register才能
//注册成功static struct ldd_device mini_device = {.name 	= "mini",
};static int mini_probe (struct ldd_device * dev)
{printk("mini_probe %s\n",dev->name);lddbus_kill(dev);return 0;
}static struct ldd_driver mini_driver = {.version = "$Revision: 1.21 $",.module = THIS_MODULE,.probe	= mini_probe,.driver = {.name = "mini",},
};static int __init mini_init(void) 
{ register_ldd_device(&mini_device);return register_ldd_driver(&mini_driver);
} static void __exit mini_exit(void) 
{ unregister_ldd_device(&mini_device);return 	unregister_ldd_driver(&mini_driver);
} module_init(mini_init); 
module_exit(mini_exit); MODULE_AUTHOR("ljf");
MODULE_LICENSE("Dual BSD/GPL");

Makefile

	obj-m := testlddbus.o testmini.oPWD := $(shell pwd)KERNELDIR := /usr/src/linux-headers-3.0.0-26-generic/
default:$(MAKE) -C $(KERNELDIR) M=$(PWD) modules
#	cp -rf mini.ko ../module/
#	cp -rf lddbus.ko ../module/
clean:rm *.mod.c *.o *.ko *.bak modules.* Module.*

这篇关于《Linux总线、设备与驱动》ldd3中demo分析的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/812281。

相关文章

基于Go语言实现Base62编码的三种方式以及对比分析

基于Go语言实现Base62编码的三种方式以及对比分析

《基于Go语言实现Base62编码的三种方式以及对比分析》Base62编码是一种在字符编码中使用62个字符的编码方式,在计算机科学中,,Go语言是一种静态类型、编译型语言,它由Google开发并开源,... 目录一、标准库现状与解决方案1. 标准库对比表2. 解决方案完整实现代码（含边界处理）二、关键实现细
阅读更多...
如何在Ubuntu上安装NVIDIA显卡驱动? Ubuntu安装英伟达显卡驱动教程

如何在Ubuntu上安装NVIDIA显卡驱动? Ubuntu安装英伟达显卡驱动教程

《如何在Ubuntu上安装NVIDIA显卡驱动?Ubuntu安装英伟达显卡驱动教程》Windows系统不同，Linux系统通常不会自动安装专有显卡驱动，今天我们就来看看Ubuntu系统安装英伟达显卡... 对于使用NVIDIA显卡的Ubuntu用户来说，正确安装显卡驱动是获得最佳图形性能的关键。与Windo
阅读更多...
ubuntu16.04如何部署dify? 在Linux上安装部署Dify的技巧

ubuntu16.04如何部署dify? 在Linux上安装部署Dify的技巧

《ubuntu16.04如何部署dify?在Linux上安装部署Dify的技巧》随着云计算和容器技术的快速发展，Docker已经成为现代软件开发和部署的重要工具之一，Dify作为一款优秀的云原生应用... Dify 是一个基于 docker 的工作流管理工具，旨在简化机器学习和数据科学领域的多步骤工作流。它
阅读更多...
PostgreSQL 序列(Sequence) 与 Oracle 序列对比差异分析

PostgreSQL 序列(Sequence) 与 Oracle 序列对比差异分析

《PostgreSQL序列(Sequence)与Oracle序列对比差异分析》PostgreSQL和Oracle都提供了序列(Sequence)功能,但在实现细节和使用方式上存在一些重要差异,... 目录PostgreSQL 序列(Sequence) 与 oracle 序列对比一 基本语法对比1.1 创建序
阅读更多...
Linux高并发场景下的网络参数调优实战指南

Linux高并发场景下的网络参数调优实战指南

《Linux高并发场景下的网络参数调优实战指南》在高并发网络服务场景中,Linux内核的默认网络参数往往无法满足需求,导致性能瓶颈、连接超时甚至服务崩溃,本文基于真实案例分析,从参数解读、问题诊断到优... 目录一、问题背景：当并发连接遇上性能瓶颈1.1 案例环境1.2 初始参数分析二、深度诊断：连接状态与
阅读更多...
Android与iOS设备MAC地址生成原理及Java实现详解

Android与iOS设备MAC地址生成原理及Java实现详解

《Android与iOS设备MAC地址生成原理及Java实现详解》在无线网络通信中,MAC（MediaAccessControl）地址是设备的唯一网络标识符,本文主要介绍了Android与iOS设备M... 目录引言1. MAC地址基础1.1 MAC地址的组成1.2 MAC地址的分类2. android与I
阅读更多...
Linux系统调试之ltrace工具使用与调试过程

Linux系统调试之ltrace工具使用与调试过程

《Linux系统调试之ltrace工具使用与调试过程》：本文主要介绍Linux系统调试之ltrace工具使用与调试过程,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐... 目录一、ltrace 定义与作用二、ltrace 工作原理1. 劫持进程的 PLT/GOT 表2. 重定
阅读更多...
Linux区分SSD和机械硬盘的方法总结

Linux区分SSD和机械硬盘的方法总结

《Linux区分SSD和机械硬盘的方法总结》在Linux系统管理中,了解存储设备的类型和特性是至关重要的,不同的存储介质（如固态硬盘SSD和机械硬盘HDD）在性能、可靠性和适用场景上有着显著差异,本文... 目录一、lsblk 命令简介基本用法二、识别磁盘类型的关键参数：ROTA查询 ROTA 参数ROTA
阅读更多...
嵌入式Linux之使用设备树驱动GPIO的实现方式

嵌入式Linux之使用设备树驱动GPIO的实现方式

《嵌入式Linux之使用设备树驱动GPIO的实现方式》：本文主要介绍嵌入式Linux之使用设备树驱动GPIO的实现方式,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐... 目录一、设备树配置1.1 添加 pinctrl 节点1.2 添加 LED 设备节点二、编写驱动程序2.1
阅读更多...
嵌入式Linux驱动中的异步通知机制详解

嵌入式Linux驱动中的异步通知机制详解

《嵌入式Linux驱动中的异步通知机制详解》：本文主要介绍嵌入式Linux驱动中的异步通知机制,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录前言一、异步通知的核心概念1. 什么是异步通知2. 异步通知的关键组件二、异步通知的实现原理三、代码示例分析1. 设备结构
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2