本站微信 收藏本站 设为首页
 找回密码
 注册
关于网站域名变更的通知
EDA365电子论坛网»电子社区 › 研发技术版块 › ARM|DSP嵌入式论坛 › 《Linux总线、设备与驱动》ldd3中demo分析
返回列表 发新帖
查看: 576|回复: 4
打印 上一主题 下一主题

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

[复制链接]
pulbieup

该用户从未签到
跳转到指定楼层
1#
发表于 2021-8-2 13:54 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式

EDA365欢迎您登录！

您需要 登录 才可以下载或查看，没有帐号？注册

x
7 s1 O$ |) ^% _% `" @+ n4 P' C' s( x
一、古老方式(不支持热插拔)- q5 U4 Z9 J9 }+ X# [$ p
! M4 ?- E$ u. B3 y, @5 ^5 x
1.开机前硬件设备已经插入总线；
& \) s; r* b1 T6 O4 L) a, Z% T" H4 N+ I1 g
2.操作系统加载总线驱动，开始扫描设备、并为其申请struct device结构，最后挂入总线驱动devices链表；
! j! g% ?- U1 K9 x! O7 V
7 ], Q: `& [# h) c& M1 T3.操作系统加载设备驱动，注册struct device_driver结构，然后去总线驱动的devices链表中遍历没有绑定driver的设备(即struct device中struct device_driver为空的设备)，如果匹配、就device_bind_driver。
* x0 h* u" s  r+ Z3 Q( M
8 |0 F" K) r/ i7 L% z, W
, s( a1 N7 R2 }1 J/ X二、现在方式(支持热插拔)/ _' p! g, |! C! f$ Y& C

5 L" v( d2 Z2 Y1.操作系统加载总线驱动；; b( i6 g# t  Y" F, d& [  V

% M" k% P0 w: @6 f4 c2.当有硬件插入时；总线驱动扫描到设备、并为其申请struct device，然后去总线驱动的drivers链表去遍历设备驱动；
4 b8 q$ I, T; B  _  y2 o/ a
7 K! {7 D4 ~# o3.反之，当有设备驱动加载时；总线为其申请struct device_driver，然后去总线驱动的devices链表遍历设备。( V% r+ \" ~* {1 `1 g& m

' K8 S0 T; ]* `总结：由以上可以看出；总线驱动是核心，联系这设备和设备驱动。
# w6 }* L  ~$ N0 l( N7 z
. s" s% t0 D) W- L8 I三、深入讲解* N: d/ y- t+ v
9 R2 f7 ~. B. o' R2 n; L7 |
1.数据结构kernel/include/linux/device.h
) Q9 H* A3 t, f1 _% n- `& [! `; r2 c2 {- L3 B- i
总线：struct bus_type;; j" t( P& S: k3 y$ F

( j! S9 _3 \( f5 n: Z' u* n设备：struct device;
# F8 H, ~+ J% ^- R* K8 A" v7 R% n4 F# Q/ U& l( G; h
驱动：struct device_driver;5 H3 H9 x8 y) \( a) L4 X

: @( `8 }& x" V3 r9 _& R3 Y- [2.关系" s; i9 p; J( {/ ~) H

3 n4 T3 Z$ H1 r9 @总线驱动总会主动去扫描并为其上的设备分配struct device并添加到devices链表中；: o# f2 ?3 R: `

/ M5 m+ p7 p; A/ U  X反之，总线驱动是被动的接受设备驱动的struct device_driver并添加到drivers链表中。
6 j* s( Q, q/ X4 t  A6 ?0 i/ k
' y9 z1 T& O7 E7 \3 q
" X- A# p0 C1 Z  f1 m四、实例-ldd3里边的例子
* m& m" y/ d2 c: N! |! V
2 ]) o- P# o* {. u3 n: ]: Z* N1.总线驱动的注册与注销; \7 g9 z- {; O" Z& [+ L& ?) Z% [, e
" r! C; i$ L: b3 G* A+ T
  • 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);
    ; L* d/ k. J  H2 t
# B% e) k" @& h" R

' x0 d% ~# E; s4 ?- _% L2.总线驱动提供的设备驱动接口
& R3 [) Y* }) b0 v
5 i) f/ A+ @0 \* P8 O; K
  • 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);
  • }
    + ?( ^' r0 `8 z/ X' ^4 E

0 {4 {/ |8 c* e( C- n2 w5 L& b$ F. e' Q: l3 B6 ~4 N- O
3.总线在扫描到设备后的注册接口1 y( j1 a5 G' p4 _

- T, Q4 n" }1 A
  • 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.com
  •   return device_register(&ldddev->dev);
  •   //该函数很重要，会去bus上寻找匹配驱动（间接调用总线的match接口）、如果匹配成功会调用驱动的探测函数
  • }
      i3 {; D) Y* _  _" F8 a* \
) o% \0 m: j- F1 u' q3 v

1 O* k* \# `( d  g, R6 m* P五、以下贴上ldd3总线、设备、驱动demo
9 l' u, J. `3 E3 K: n
  X3 u7 J! s' D& X  z4 n9 j0 G# i$ _- Y. E
注意：
. i. k8 e$ f7 U: l# Y: O3 |, h. m- v
* {- K7 W) v6 o2 Z因为是模拟事件发生，因此、驱动程序module_init时有设备的注册过程，实际驱动中不需要这部分、是总线轮询或中断导致设备的注册（注意总线注册的设备不会进入设备文件系统下创建设备节点、它只是加入总线的设备链表并在匹配设备驱动时使用；设备文件系统下设备节点的创建，是在设备驱动的探测probe函数中完成）。
$ @6 f/ I8 d& {6 f% i$ {+ c
$ F/ e+ a) ]+ H  |# t1.总线2 v* R7 k( q. I2 b5 V1 F6 ]
( M" i' k/ v0 Y5 V4 Q, W/ N& E
testbus.c; V7 B4 k# [  p& E3 s4 L9 o0 U
) e6 H" q" |6 d' W7 r
  • #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.com
  •         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);
  • /*
  • * 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);8 H. |% t5 s0 D& ^6 }" d$ A, @
3 M+ m+ J4 {  k! `! Z4 m8 K) v

: `9 H! r4 Z, D9 S/ W& [" W7 Llddbus.h
& r# l# n$ m: a
$ h! o8 i) @7 ^1 y. r: M
  • /*
  • * 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 *);
    / G& F4 h$ c9 q# Q) t+ |
                                             . \& N& v4 W2 D2 d' s

, f2 S) o2 |" B6 R' o% p" M2.设备与设备驱动& _7 n" [2 d. h2 g7 Y

- r8 f+ C7 K! _7 b" @; H3 Btestmini.c" [, n& v1 }' @
) n! y. ~6 s8 w
  • #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");' ?8 L! J' l% C9 J; o
                              # @8 I) i/ @- _5 l$ w! U
7 H( X' C& `& e! W
Makefile
# G$ N  j- W5 b- d# F6 c" K7 P% |9 j
  •         obj-m := testlddbus.o testmini.o
  •         PWD := $(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.*- _6 v( ^$ r' l5 n* X  U. Q
  e4 j$ T" M5 D. k( l1 V

) n7 E- m7 ~- f$ f9 i

下载资料威望不够？点击查看获取威望的N种方法>>
回复

举报

EDA365微信号及QQ群号！
Heaven_1
  • TA的每日心情
    开心
    2023-5-15 15:14

    • 签到天数: 1 天

    [LV.1]初来乍到
    2#
    发表于 2021-8-2 20:38 | 只看该作者
    驱动数据结构，提供了探测、移除、挂起、回复和关闭的

    下载资料威望不够？点击查看获取威望的N种方法>>
    回复 支持 反对

    举报

    regngfpcb

    该用户从未签到
    3#
    发表于 2021-8-4 09:40 | 只看该作者
    操作系统加载总线驱动，开始扫描设备、并为其申请struct device结构，最后挂入总线驱动devices链表

    下载资料威望不够？点击查看获取威望的N种方法>>
    回复 支持 反对

    举报

    yin123
  • TA的每日心情
    怒
    2019-11-29 15:37

    • 签到天数: 1 天

    [LV.1]初来乍到
    4#
    发表于 2021-8-4 09:41 | 只看该作者
    数据结构kernel/include/linux/device.h

    下载资料威望不够？点击查看获取威望的N种方法>>
    回复 支持 反对

    举报

    domenica

    该用户从未签到
    5#
    发表于 2021-8-4 09:41 | 只看该作者
    支持热插拔

    下载资料威望不够？点击查看获取威望的N种方法>>
    回复 支持 反对

    举报

    返回列表 发新帖
    高级模式
    B Color Image Link Quote Code Smilies
    您需要登录后才可以回帖 登录 | 注册

    本版积分规则

    关闭

    推荐内容上一条 /1 下一条

    EDA365公众号

    关于我们|手机版|EDA365电子论坛网 ( 粤ICP备18020198号-1 )

    GMT+8, 2025-11-24 02:54 , Processed in 0.156250 second(s), 23 queries , Gzip On.

    深圳市墨知创新科技有限公司

    地址:深圳市南山区科技生态园2栋A座805 电话:19926409050

    快速回复 返回顶部 返回列表