《Linux总线、设备与驱动》自己写的demo

最新推荐文章于 2023-06-23 12:52:07 发布
置顶 最新推荐文章于 2023-06-23 12:52:07 发布
阅读量3.3k 收藏 5
点赞数 1
分类专栏： arm-Linux学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tankai19880619/article/details/11742979
版权

本demo基于Android2.3模拟器开发，内核代码(Linux2.6.29)和Android代码可以在网上下载、这里不在说明。

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

ldd3部分讲述总线驱动match以及设备驱动probe等，见Linux总线、设备与驱动——ldd3中demo分析

一、驱动

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_uevent(struct device *dev, char **envp, int num_envp,
		char *buffer, int buffer_size){
  printk("TK---testlddbus.c----->>>>ldd_uevent\n");
  envp[0] = buffer;
  if (snprintf(buffer, buffer_size, "LDDBUS_VERSION=%s", Version) >= buffer_size)
    return -ENOMEM;
  envp[1] = NULL;
  return 0;
}


static int ldd_match(struct device *dev, struct device_driver *driver){
  printk("TK---testbus.c----->>>>ldd_match\n");
  return !strncmp(dev->init_name, driver->name, strlen(driver->name));
}


static void ldd_bus_release(struct device *dev){
  printk("TK---testbus.c-->>>>ldd_bus_release\n");
}
	

struct bus_type ldd_bus_type = {
  .name = "ldd",
  .match = ldd_match,
  .uevent  = ldd_uevent,
};

struct device ldd_bus = {
  .init_name   = "ldd0",
  .release  = ldd_bus_release
};


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);


static void ldd_dev_release(struct device *dev){ 
  printk("TK-------->>>testubs.c>>>>>>ldd_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;
  ldddev->dev.init_name = ldddev->name;  
  return 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);


static int lddbus_drv_probe(struct device *_dev){
  printk("TK---testlddbus.c----->>>>ldd_drv_probe\n");
  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){
  printk("TK---testlddbus.c----->>>>ldd_drv_remove\n");
  struct ldd_driver *drv = to_ldd_driver(_dev->driver);
  struct ldd_device *dev = to_ldd_device(_dev);
  return drv->remove(dev);
}

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;
  ret = driver_register(&driver->driver);	
  if (ret)
    return ret;
  driver->version_attr.attr.name = "version";
  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){
  printk("TK---testlddbus.c----->>>>ldd_bus_init\n");
  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){
  printk("TK---testlddbus.c----->>>>ldd_bus_exit\n");
  device_unregister(&ldd_bus);
  bus_unregister(&ldd_bus_type);
}

module_init(ldd_bus_init);
module_exit(ldd_bus_exit);
2.设备模块

功能：模拟设备热插拔事件；insmod为插入设备，rmmod为删除设备。

testdev.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 ldd_device mini_device = {
  .name 	= "mini",
};

static int __init dev_init(void) {       
  printk("TK---testdev.c----->>>>mini_init\n");
  return register_ldd_device(&mini_device);
} 

static void __exit dev_exit(void) { 
  printk("TK---testdev.c----->>>>mini_exit\n");
  return unregister_ldd_device(&mini_device);
} 

module_init(dev_init); 
module_exit(dev_exit); 

MODULE_AUTHOR("ljf");
MODULE_LICENSE("Dual BSD/GPL");
3.设备驱动模块

功能：上述2的设备驱动程序；支持热插拔，目前提供设备节点的创建及open、close、read和write接口。

testdriver.c

#include <linux/platform_device.h> 
#include <linux/miscdevice.h>

#include <linux/interrupt.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>
#include <asm/uaccess.h>

#define MYMODULE_MAJOR    248
struct class *mymodule_class;
struct device *my_device;
EXPORT_SYMBOL(mymodule_class);

static ssize_t s3c2440mini_read(struct file * file, char __user * userbuf,
		size_t count, loff_t * off){
  printk ("TK-------->>>testdriver.c>>>>>>s3c2440mini_read\n");
  char cmd[20];
  strcpy(cmd,"456");
  copy_to_user(userbuf,cmd, 3);
  return 0;
}

static ssize_t s3c2440mini_write(struct file *file, const char __user *data,
		size_t len, loff_t *ppos){
  printk ("TK-------->>>testdriver.c>>>>>>s3c2440mini_write\n");
  char cmd[20];
  copy_from_user(cmd, data, 3);
  printk ("TK-------->>>testdriver.c>>>>>>s3c2440mini_write>>>>cmd is %s\n",cmd);
  return 0;
}

static int s3c2440mini_open(struct inode *inode, struct file *file){
  printk("TK-------->>>testdriver.c>>>>>>s3c2440mini_open\n");//add by tankai
  return 0;
}

static int s3c2440mini_release(struct inode *inode, struct file *file){
  printk ("TK-------->>>testdriver.c>>>>>s3c2440mini_release\n");
  return 0;
}

static struct file_operations mini_ops = {
  .owner  	= THIS_MODULE,
  .write 	= s3c2440mini_write,
  .read 	= s3c2440mini_read,
  .release	= s3c2440mini_release,
  .open	        = s3c2440mini_open,
};

static int mini_probe (struct ldd_device * dev){
  printk("TK----testdriver.c------>>>>driver_probe %s\n",dev->name);
  int err = 0;
  //只有register_chrdev不会自动创建设备节点；需要手动mknod
  if (register_chrdev(MYMODULE_MAJOR, "mymodule", &mini_ops)) {
    printk(KERN_ERR "mymodule: unable to get major %d\n", MYMODULE_MAJOR);
    err = -EIO;
    goto out;
  }
  mymodule_class = class_create(THIS_MODULE, "mymodule");
  if (IS_ERR(mymodule_class)) {
    err = PTR_ERR(mymodule_class);
    goto out_chrdev;
  }
  //device_create是自动创建设备节点的关键
  my_device = device_create(mymodule_class, NULL, MKDEV(MYMODULE_MAJOR, 0), NULL, "mymod0"); 
  //该设备的父设备即刚才总线发现的ldd设备
  //my_device->parent = &(dev->dev);
  err = 0;
  goto out;

out_chrdev:
	unregister_chrdev(MYMODULE_MAJOR, "mymodule");
out:
        return err;
}

static int mini_remove(struct ldd_device * dev){
  printk("TK----testdriver.c------>>>>driver_remove %s\n",dev->name);
  device_destroy(mymodule_class, MKDEV(MYMODULE_MAJOR, 0)); 
  class_destroy(mymodule_class);
  unregister_chrdev(MYMODULE_MAJOR, "mymodule");
}

static struct ldd_driver mini_driver = {
  .version = "$Revision: 1.21 $",
  .module = THIS_MODULE,
  .probe  = mini_probe,
  .remove = mini_remove,
  .driver = {
    .name = "mini",
  },
};

static int __init mini_init(void) {       
  printk("TK---testdriver.c----->>>>driver_init\n");
  return register_ldd_driver(&mini_driver);
} 

static void __exit mini_exit(void) { 
  printk("TK---testdriver.c----->>>>driver_exit\n");
  return unregister_ldd_driver(&mini_driver);
} 

module_init(mini_init); 
module_exit(mini_exit); 

MODULE_AUTHOR("ljf");
MODULE_LICENSE("Dual BSD/GPL");
4.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 *);

5.Makefile 
	obj-m := testbus.o testdriver.o testdev.o
	PWD := $(shell pwd)
	KERNELDIR := /home/android2.3/android2.3_kernel/
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.*
编译后分别为testbus.ko，testdev.ko和testdriver.ko。

二、测试用例

1.testldd.c

#include <fcntl.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <errno.h>
#include <sys/types.h> 
#include <sys/stat.h>
#include <string.h>

int main(){
  int fd = open("/dev/mymod0",O_RDWR,0);
  printf("TK------->>>fd is %d\n",fd);
  char buf[20];
  int result = read(fd,&buf,3);
  printf("TK------->>>readresult is %d,buf is %s\n",result,buf);
  strcpy(buf,"123");
  result = write(fd,&buf,3);
  printf("TK------->>>writeresult is %d,buf is %s\n",result,buf);
  close(fd);
  return 0;
}
2.Android.mk 

LOCAL_PATH:= $(call my-dir)
include $(CLEAR_VARS)

LOCAL_SRC_FILES:= \
	testldd.c

LOCAL_SHARED_LIBRARIES := \
	libutils 

LOCAL_MODULE:= testldd

LOCAL_MODULE_TAGS := optional

include $(BUILD_EXECUTABLE)
三、运行

1.insmod testbus.ko

结果：

TK---testlddbus.c----->>>>ldd_bus_init
ll /sys/devices/ldd0/ 
drwxr-xr-x root     root              2013-09-16 09:29 power
-rw-r--r-- root     root         4096 2013-09-16 09:29 uevent
ll /sys/bus/ldd/ 
drwxr-xr-x root     root              2013-09-16 09:46 devices
drwxr-xr-x root     root              2013-09-16 09:46 drivers
-rw-r--r-- root     root         4096 2013-09-16 09:30 drivers_autoprobe
--w------- root     root         4096 2013-09-16 09:30 drivers_probe
--w------- root     root         4096 2013-09-16 09:30 uevent
-r--r--r-- root     root         4096 2013-09-16 09:30 version
2.insmod testdriver.ko

结果：

TK---testdriver.c----->>>>driver_init
ll /sys/bus/ldd/drivers/ 
drwxr-xr-x root     root              2013-09-16 09:47 mini
3.模拟设备插入insmod testdev.ko( 实际这部分有总线驱动完成！！)

结果：

TK---testdev.c----->>>>mini_init
TK---testlddbus.c----->>>>ldd_uevent
TK---testbus.c----->>>>ldd_match
TK---testlddbus.c----->>>>ldd_drv_probe
TK----testdriver.c------>>>>driver_probe mini
ll /sys/devices/ldd0/ 
drwxr-xr-x root     root              2013-09-16 09:48 mini
drwxr-xr-x root     root              2013-09-16 09:29 power
-rw-r--r-- root     root         4096 2013-09-16 09:29 uevent
ll /sys/bus/ldd/devices/ 
lrwxrwxrwx root     root              2013-09-16 09:36 mini -> ../../../devices/ldd0/mini
ll /dev/mymod0 
crw------- root     root     248,   0 2013-09-16 09:48 mymod0
4.测试

./testldd

TK-------->>>testdriver.c>>>>>>s3c2440mini_open
TK------->>>fd is 3
TK-------->>>testdriver.c>>>>>>s3c2440mini_read
TK------->>>readresult is 0,buf is 456��`ү�
TK-------->>>testdriver.c>>>>>>s3c2440mini_write
TK-------->>>testdriver.c>>>>>>s3c2440mini_write>>>>cmd is 123�TG�0��`��`ͥ��K��
TK-------->>>testdriver.c>>>>>s3c2440mini_release
TK------->>>writeresult is 0,buf is 123

雷古拉斯
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
探究Linux的总线、设备、驱动模型
07-06
理解Linux的总线、设备、驱动模型是理解Linux驱动框架的关键，也是破解Linux为什么极易移植到不同的平台，以及被如此多广泛领域使用根源的关键。我的CSDN直播将以浅显易懂地语言，深入地把这一模型剖析清楚，道出这样的设计的好处。
【Linux】常用命令
weixin_43799388的博客
09-16 801
Linux常用命令
Android 驱动程序Demo及流程
Android framework
12-20 340
Android 驱动程序Demo及流程
Linux总线
summer_fish的专栏
06-01 1519
总线的原理是通过定义一组规范和接口，将相似类型的设备归类并提供统一的访问方式。设备驱动程序可以通过总线接口来发现、注册和控制设备，以及与设备进行数据交换。1. 统一接口：通过总线，不同类型的设备可以使用相同的接口进行访问，简化了设备的管理和驱动程序的开发。2. 热插拔支持：总线可以支持设备的热插拔，即在运行时插入或拔出设备而无需重新启动系统。3. 设备发现：总线提供了设备发现机制，可以自动识别和注册连接到总线上的设备。
linux系统总线怎么理解
weixin_41199566的博客
05-23 166
总线在操作系统中本质就是两个链表:挂载设备的链表和挂载驱动的链表。不同的边缘设备之间通信的总线，总线时序是不一样的，1.平台总线 (CPU核与硬件控制器之间的通信),对于这些总线，Linux 内核是单独实现的。在实际的硬件上，总线种类可以分成两大类。2.边缘设备之间通信的总线,
linux总线设备驱动模型的demo code
04-29
主要是在Linux平台编写了一个虚拟的总线设备驱动模型，方便加深对Linux总线的理解。Demo Code已经编译验证OK，方便理解可以参考这篇博客：...
Linux总线、设备、驱动模型
04-11
Linux总线 设备 驱动模型 .
基于ARM的Linux下LonWorks总线设备驱动设计
08-05
利用神经元芯片CYC53120和S3C2410芯片，实现嵌入式平台下LonWorks总线的运用；同时介绍嵌入式Linux 下设备驱动程序的构成，描述了LonWorks设备驱动程序的软件框架，为嵌入式Linux设备的开发提供借鉴。
linux 实现自己总线设备驱动
04-10
里面包含了三个文件件，分别是 bus：实现了自己的一个最简单的总线， kset和kobject:通过调用内核提供的接口，了解bus的内部机制
Linux 总线设备和驱动实验
04-25
Linux 总线设备和驱动实验
Linux 设备总线驱动模型
huangweiqing80的博客
09-19 4319
转自https://blog.csdn.net/lizuobin2/article/details/51570196 &amp;amp;amp;amp;amp;nbsp; &amp;amp;amp;amp;amp;nbsp; 尽管LDD3中说对多数程序员掌握设备驱动模型不是必要的，但对于嵌入式Linux的底层程序员而言，对设备驱动模型的学习非常重要。 &amp;amp;amp;am
Linux 内核总线
weixin_30445169的博客
07-07 167
一个总线是处理器和一个或多个设备之间的通道. 为设备模型的目的, 所有的设备都通过 一个总线连接, 甚至当它是一个内部的虚拟的,"平台"总线. 总线可以插入另一个 - 一个 USB 控制器常常是一个 PCI 设备, 例如. 设备模型表示在总线和它们控制的设备之间的 实际连接. 在 Linux 设备模型中, 一个总线由 bus_type 结构代表, 定义在 <linux/device....
Linux下的Tcp通信项目范例【demo】
caiji667788的博客
10-21 1423
设计一个可以符合多用户进行线上查阅乐器的商城，要求可以多个用户查看，管理员可随时修改内容，普通用户仅可查看，需要相应密码权限操作。
linux驱动：一、字符设备的介绍和demo
qq_40170041的博客
03-25 980
字符设备是 Linux 驱动中最基本的一类设备驱动，字符设备就是一个一个字节，按照字节流进行读写操作的设备，读写数据是分先后顺序的。比如我们最常见的点灯、按键、IIC、SPI，LCD 等等都是字符设备，这些设备的驱动就叫做字符设备驱动。在 Linux 中一切皆为文件，驱动加载成功以后会在“/dev”目录下生成一个相应的文件，应用程序通过对这个名为“/dev/xxx”(xxx 是具体的驱动文件名字)的文件进行相应的操作即可实现对硬件的操作。
Linux驱动开发--平台总线
最新发布
xinqi_1的博客
06-23 427
​ driver模块中，struct platform_driver成员driver的name成员必须指定，但与device模块中name可以不相同。2.2 id匹配（可想象成八字匹配）：一个驱动可以对应多个设备 ------优先级次低。2.3 设备树匹配：内核启动时根据设备树自动产生的设备 ------ 优先级最高。2.1 名称匹配：一个驱动只对应一个设备 ----- 优先级最低。​ 带来的问题-------怎样将二者进行关联（匹配）？总线：匹配设备和驱动——婚介所：提供沟通机制，完成拉郎配。
Linux驱动模型之总线
cqxcool66的博客
08-19 1240
在linux中有很多总线，其中有和实体对应的总线，比如：media 总线、spi 总线、i2c总线、hid 输入子系统总线、eMMC 存储设备总线。也有虚拟出来的总线，比如：platform虚拟平台总线。以platform总线为例，它的灵魂是：device（设备）driver（驱动）platform_bus（platform总线），它的特点是设备，驱动分层动态的管理和加载，当我们将设备和驱动注册到虚拟总线上（内核）时，在他们注册时，会互相寻找一次对方。...
31.【linux驱动】一文读懂linux设备驱动模型(总线bus)
柏鑫的博客
07-25 368
4
linux驱动-设备驱动模型(bus总线)
sty01z的博客
05-03 586
bus_register 创建并初始化 priv->klist_devices 和 priv->klist_drivers 这两条由该总线维护的非常重要的两条链表，该总线下的 dev 和 drv 会分别链入这两条链表。这个结构被用在两个地方 class 和 bus，在不同的位置有不同的含义，当它出现在 bus下用它描述 bus 在 /sys 中的层次结构。buses_init 在 driver_init 中被调用，用于初始化 bus 的根目录，以后所有的 bus 总线均为该目录的子目录。
07 Linux消息队列Demo
qq582880551的博客
03-05 187
07 Linux消息队列Demo
请解释一下Linux下驱动总线设备模型
03-27
它提供了一种标准的设备访问接口，使得设备驱动程序可以独立于硬件平台而存在，从而提高了设备驱动程序的可移植性和可维护性。 在Linux中，驱动总线设备模型包括以下几个主要的概念： 1. 总线（Bus）：总线是一种...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值