platform总线驱动

最新推荐文章于 2024-08-28 10:45:44 发布
最新推荐文章于 2024-08-28 10:45:44 发布
阅读量391 收藏
点赞数 2
分类专栏： 驱动 文章标签： platform 驱动分析 linux 总线
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Peter_tang6/article/details/70498066
版权

在上一篇LED驱动中，设备与驱动是挂在总线上，通过总线上的macth（linux系统总线添加设备或驱动时调用各总线对应的match匹配函数判断驱动和设备是否匹配）进行设备与驱动的匹配，本篇一起学习另一种总线，platform，平台总线，一种虚拟总线，使板子代码与驱动代码分离，使驱动有更好的可扩展性和跨平台性。


platform总线相应的设备称为platform_device，驱动为platform_driver。

我们要实现的还是设备与驱动的注册与匹配，匹配成功之后调用probe函数，probe函数完成驱动注册最后工作，资源，中断调用函数以及其他相关工作。


接下来就分析一下我们的具体代码

1.platform设备与驱动的定义

static struct platform_device s3c_led_device = {
     .name    = "s3c_led",
     .id      = 1,
     .dev     =
     {
         .platform_data = &s3c_led_data,
         .release = platform_led_release,
     },
 };

static struct platform_driver s3c_led_driver = {
     .probe      = s3c_led_probe,
     .remove     = s3c_led_remove,
     .driver     = {
         .name       = "s3c_led",
         .owner      = THIS_MODULE,
     },
 };

这里可以看见我们的.name是一样的，这样才能匹配成功，才能绑定在一起。


2.platform平台设备与驱动的注册

static int __init s3c_led_init(void)
 {
    int       ret = 0;
 
    ret = platform_device_register(&s3c_led_device);     //注册平台设备
    if(ret)
    {
         printk(KERN_ERR "%s:%d: Can't register platform device %d\n", __FUNCTION__,__LINE__, ret);
         goto fail_reg_plat_dev;
    }
    dbg_print("Regist S3C LED Platform Device successfully.\n");
 
    ret = platform_driver_register(&s3c_led_driver);     //注册平台驱动
    if(ret)
    {
        printk(KERN_ERR "%s:%d: Can't register platform driver %d\n", __FUNCTION__,__LINE__, ret);
        goto fail_reg_plat_drv;
    }
    dbg_print("Regist S3C LED Platform Driver successfully.\n");
 
    return 0;

 fail_reg_plat_drv:
    platform_driver_unregister(&s3c_led_driver);
 fail_reg_plat_dev:
    return ret;
 }

注册的工作就是由init来完成，即一启动便注册。我们可以看到，注册平台设备和平台驱动时，分别取sc3_led_device和s3c_led_driver结构体的值，也就是我们刚才定义的platform设备与驱动结构体。

3.当驱动与设备的.name匹配成功后，我们的probe也该出来做媒了。

static int s3c_led_probe(struct platform_device *dev)
 {
     struct s3c_led_platform_data *pdata = dev->dev.platform_data;
     int result = 0;
     int i;
     dev_t devno;
    
    /* Initialize the LED status 对LED状态的初始化*/
     for(i=0; i<pdata->nleds; i++)
     {
          s3c2410_gpio_cfgpin(pdata->leds[i].gpio, S3C2410_GPIO_OUTPUT);
          if(ON == pdata->leds[i].status)
          {
             s3c2410_gpio_setpin(pdata->leds[i].gpio, pdata->leds[i].active_level);  //将输出值存在active_level中
          }
          else
          {
             s3c2410_gpio_setpin(pdata->leds[i].gpio, ~pdata->leds[i].active_level); 
          }
     }
	 
	
    /*  Alloc the device for driver 申请设备号*/
     if (0 != dev_major)
     {
         devno = MKDEV(dev_major, dev_minor);
         result = register_chrdev_region(devno, 1, DEV_NAME);
     }
     else
     {
         result = alloc_chrdev_region(&devno, dev_minor, 1, DEV_NAME);
         dev_major = MAJOR(devno);
     }
 
 
     /* Alloc for device major failure */
     if (result < 0)
     {
         printk("%s driver can't get major %d\n", DEV_NAME, dev_major);
         return result;
     }

	 
    /* Initialize button structure and register cdev*/
     memset(&led_device, 0, sizeof(led_device));         //memset函数初始化内存
     led_device.data = dev->dev.platform_data;
     cdev_init (&(led_device.cdev), &led_fops);        //初始化字符设备cdev
     led_device.cdev.owner  = THIS_MODULE;
 
     result = cdev_add (&(led_device.cdev), devno , 1);       //注册字符设备cdev
     if (result)
     {
         printk (KERN_NOTICE "error %d add %s device", result, DEV_NAME);
         goto ERROR;
     }

    led_device.dev_class = class_create(THIS_MODULE, DEV_NAME);      //定义一个类来自动创建设备节点，我们在测试程序时就不用再自己创建了。
     if(IS_ERR(led_device.dev_class))
     {
         printk("%s driver create class failture\n",DEV_NAME);
         result =  -ENOMEM;
         goto ERROR;
     }
 
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)     
     device_create(led_device.dev_class, NULL, devno, NULL, DEV_NAME);
 #else
     device_create (led_device.dev_class, NULL, devno, DEV_NAME);
 #endif

     /*  Initial the LED blink timer 初始化闪烁时间，这个timer函数在下面介绍*/
     init_timer(&(led_device.blink_timer));
     led_device.blink_timer.function = led_timer_handler;
     led_device.blink_timer.data = (unsigned long)pdata;
     led_device.blink_timer.expires  = jiffies + TIMER_TIMEOUT;
     add_timer(&(led_device.blink_timer));
 
     printk("S3C %s driver version %d.%d.%d initiliazed.\n", DEV_NAME, DRV_MAJOR_VER, DRV_MINOR_VER, DRV_REVER_VER);
 
     return 0;
 
 
 ERROR:
     printk("S3C %s driver version %d.%d.%d install failure.\n", DEV_NAME, DRV_MAJOR_VER, DRV_MINOR_VER,DRV_REVER_VER);
     cdev_del(&(led_device.cdev));
 
     unregister_chrdev_region(devno, 1);
     return result;
 
 }

probe函数主要完成了申请设备号，初始化和注册字符设备cdev，从cdev读出硬件资源。


4.重要的结构体：

static struct file_operations led_fops = {
     .owner = THIS_MODULE,
     .open = led_open,
     .release = led_release,
     .unlocked_ioctl = led_ioctl, /* compatible with kernel version >=2.6.38*/
 };

这个结构体说明了我们要用到的一些函数调用，我们的读写操作都要经过这里才能实现。

5.led_timer_handler函数

void led_timer_handler(unsigned long data)
 {
     int  i;
     struct s3c_led_platform_data *pdata = (struct s3c_led_platform_data *)data;
 
     for(i=0; i<pdata->nleds; i++)
     {
         if(ON == pdata->leds[i].status)
         {
               s3c2410_gpio_setpin(pdata->leds[i].gpio, pdata->leds[i].active_level);
         }
         else
         {
               s3c2410_gpio_setpin(pdata->leds[i].gpio, ~pdata->leds[i].active_level);
         }
 
         if(ENABLE == pdata->leds[i].blink )  /* LED should blink */
         {
             /* Switch status between 0 and 1 to turn LED ON or off */
             pdata->leds[i].status = pdata->leds[i].status ^ 0x01;
         }
         mod_timer(&(led_device.blink_timer), jiffies + TIMER_TIMEOUT);  //如果有blink，即闪烁属性，则每个循环改变一次状态。
     }
 }






这个函数定时读取每个LED引脚的状态存到active_level中。




好了，几个主要的函数已经分析完了，还有一些函数调用以及结构体的定义我们给一篇完整的驱动代码：


/*********************************************************************************
 *      Copyright:  (C) 2017 Tang Yanjun<519656780@qq.com>  
 *                  All rights reserved.
 *
 *       Filename:  s3c_led.c
 *    Description:  This is the common LED driver runs on S3C24XX.
 *                 
 *        Version:  1.0.0(10/27/2011~)
 *         Author:  Tang Yanjun <519656780@qq.com>
 *      ChangeLog:  1, Release initial version on "23/4/2017 11:39:10 AM"
 *                 
 ********************************************************************************/
#include "s3c_driver.h"

#define DRV_AUTHOR                "Tang Yanjun <519656780@qq.com>"
#define DRV_DESC                  "S3C24XX LED driver"

/* Driver version*/
#define DRV_MAJOR_VER             1
#define DRV_MINOR_VER             0
#define DRV_REVER_VER             0

#define DEV_NAME                  DEV_LED_NAME

#define DEV_MAJOR                 DEV_LED_MAJOR
#ifndef DEV_MAJOR
#define DEV_MAJOR                 0 /*  dynamic major by default */ 
#endif

#define TIMER_TIMEOUT             40

static int debug = DISABLE;
static int dev_major = DEV_MAJOR;
static int dev_minor = 0;


/* ============================ Platform Device part ===============================*/
/*  LED hardware informtation structure*/
struct s3c_led_info
{
    unsigned char           num;              /* The LED number  */
    unsigned int            gpio;             /* Which GPIO the LED used */  
    unsigned char           active_level;     /* The GPIO pin level(HIGHLEVEL or LOWLEVEL) to turn on or off  */
    unsigned char           status;           /* Current LED status: OFF/ON */
    unsigned char           blink;            /* Blink or not */           
};

/*  The LED platform device private data structure */
struct s3c_led_platform_data
{
    struct s3c_led_info    *leds;
    int                     nleds;
};


/*  LED hardware informtation data*/ 
static struct s3c_led_info  s3c_leds[] = {
    [0] = {
        .num = 1,
        .gpio = S3C2410_GPB(5),
        .active_level = LOWLEVEL,
        .status = OFF,
        .blink = ENABLE,
    },
    [1] = {
        .num = 2,
        .gpio = S3C2410_GPB(6),
        .active_level = LOWLEVEL,
        .status = OFF,
        .blink = DISABLE,
    },
    [2] = {
        .num = 3,
        .gpio = S3C2410_GPB(8),
        .active_level = LOWLEVEL,
        .status = OFF,
        .blink = DISABLE,
    },
    [3] = { 
        .num = 4,
        .gpio = S3C2410_GPB(10),
        .active_level = LOWLEVEL,
        .status = OFF,
        .blink = DISABLE,
    }, 
};

/*  The LED platform device private data */
static struct s3c_led_platform_data s3c_led_data = {
    .leds = s3c_leds,
    .nleds = ARRAY_SIZE(s3c_leds),
};

struct led_device
{
    struct s3c_led_platform_data    *data;
    struct cdev                     cdev;
    struct class                    *dev_class;
    struct timer_list               blink_timer;
} led_device;

static void platform_led_release(struct device * dev)
{
    int i;
    struct s3c_led_platform_data *pdata = dev->platform_data; 

    dbg_print("%s():%d\n", __FUNCTION__,__LINE__);

    /* Turn all LED off */
    for(i=0; i<pdata->nleds; i++)
    {
         s3c2410_gpio_setpin(pdata->leds[i].gpio, ~pdata->leds[i].active_level); 
    }
}

static struct platform_device s3c_led_device = {
    .name    = "s3c_led",
    .id      = 1,
    .dev     = 
    {
        .platform_data = &s3c_led_data, 
        .release = platform_led_release,
    },
};



/* ===================== led device driver part ===========================*/

void led_timer_handler(unsigned long data)
{ 
    int  i; 
    struct s3c_led_platform_data *pdata = (struct s3c_led_platform_data *)data;

    for(i=0; i<pdata->nleds; i++) 
    { 
        if(ON == pdata->leds[i].status)
        {
              s3c2410_gpio_setpin(pdata->leds[i].gpio, pdata->leds[i].active_level); 
        }
        else
        {
              s3c2410_gpio_setpin(pdata->leds[i].gpio, ~pdata->leds[i].active_level); 
        }

        if(ENABLE == pdata->leds[i].blink )  /* LED should blink */
        {
            /* Switch status between 0 and 1 to turn LED ON or off */
            pdata->leds[i].status = pdata->leds[i].status ^ 0x01;  
        }

        mod_timer(&(led_device.blink_timer), jiffies + TIMER_TIMEOUT);
    }
}


static int led_open(struct inode *inode, struct file *file)
{ 
    struct led_device *pdev ;
    struct s3c_led_platform_data *pdata;

    pdev = container_of(inode->i_cdev,struct led_device, cdev);
    pdata = pdev->data;

    file->private_data = pdata;

    return 0;
}


static int led_release(struct inode *inode, struct file *file)
{ 
    return 0;
}

static void print_led_help(void)
{
    printk("Follow is the ioctl() command for LED driver:\n");
    printk("Enable Driver debug command: %u\n", SET_DRV_DEBUG);
    printk("Get Driver verion  command : %u\n", GET_DRV_VER);
    printk("Turn LED on command        : %u\n", LED_ON);
    printk("Turn LED off command       : %u\n", LED_OFF);
    printk("Turn LED blink command     : %u\n", LED_BLINK);
}

/* compatible with kernel version >=2.6.38*/
static long led_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{ 
    struct s3c_led_platform_data *pdata = file->private_data;

    switch (cmd)
    {
        case SET_DRV_DEBUG:
            dbg_print("%s driver debug now.\n", DISABLE == arg ? "Disable" : "Enable");
            debug = (0==arg) ? DISABLE : ENABLE;
            break;
        case GET_DRV_VER:
            print_version(DRV_VERSION);
            return DRV_VERSION;

        case LED_OFF:
            if(pdata->nleds <= arg)
            {
               printk("LED%ld doesn't exist\n", arg);  
               return -ENOTTY;
            }
            pdata->leds[arg].status = OFF;
            pdata->leds[arg].blink = DISABLE;
            break;

        case LED_ON:
            if(pdata->nleds <= arg)
            {
               printk("LED%ld doesn't exist\n", arg);  
               return -ENOTTY;
            }
            pdata->leds[arg].status = ON;
            pdata->leds[arg].blink = DISABLE;
            break;

        case LED_BLINK:
            if(pdata->nleds <= arg)
            {
               printk("LED%ld doesn't exist\n", arg);  
               return -ENOTTY;
            }
            pdata->leds[arg].blink = ENABLE;
            pdata->leds[arg].status = ON;
            break;

        default: 
            dbg_print("%s driver don't support ioctl command=%d\n", DEV_NAME, cmd); 
            print_led_help();
            return -EINVAL;

    }
    return 0;
}


static struct file_operations led_fops = { 
    .owner = THIS_MODULE, 
    .open = led_open, 
    .release = led_release, 
    .unlocked_ioctl = led_ioctl, /* compatible with kernel version >=2.6.38*/
};


static int s3c_led_probe(struct platform_device *dev)
{
    struct s3c_led_platform_data *pdata = dev->dev.platform_data; 
    int result = 0;
    int i;
    dev_t devno;

    /* Initialize the LED status */
    for(i=0; i<pdata->nleds; i++)
    {
         s3c2410_gpio_cfgpin(pdata->leds[i].gpio, S3C2410_GPIO_OUTPUT);
         if(ON == pdata->leds[i].status)
         {
            s3c2410_gpio_setpin(pdata->leds[i].gpio, pdata->leds[i].active_level); 
         }
         else
         {
            s3c2410_gpio_setpin(pdata->leds[i].gpio, ~pdata->leds[i].active_level); 
         }
    }

    /*  Alloc the device for driver */
    if (0 != dev_major) 
    { 
        devno = MKDEV(dev_major, dev_minor); 
        result = register_chrdev_region(devno, 1, DEV_NAME); 
    } 
    else 
    { 
        result = alloc_chrdev_region(&devno, dev_minor, 1, DEV_NAME); 
        dev_major = MAJOR(devno); 
    }

    /* Alloc for device major failure */ 
    if (result < 0) 
    { 
        printk("%s driver can't get major %d\n", DEV_NAME, dev_major); 
        return result; 
    }

    /* Initialize button structure and register cdev*/
    memset(&led_device, 0, sizeof(led_device));
    led_device.data = dev->dev.platform_data;
    cdev_init (&(led_device.cdev), &led_fops);
    led_device.cdev.owner  = THIS_MODULE;

    result = cdev_add (&(led_device.cdev), devno , 1); 
    if (result) 
    { 
        printk (KERN_NOTICE "error %d add %s device", result, DEV_NAME); 
        goto ERROR; 
    } 
    
    led_device.dev_class = class_create(THIS_MODULE, DEV_NAME); 
    if(IS_ERR(led_device.dev_class)) 
    { 
        printk("%s driver create class failture\n",DEV_NAME); 
        result =  -ENOMEM; 
        goto ERROR; 
    }

#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)     
    device_create(led_device.dev_class, NULL, devno, NULL, DEV_NAME);
#else
    device_create (led_device.dev_class, NULL, devno, DEV_NAME);
#endif

    /*  Initial the LED blink timer */
    init_timer(&(led_device.blink_timer));
    led_device.blink_timer.function = led_timer_handler;
    led_device.blink_timer.data = (unsigned long)pdata;
    led_device.blink_timer.expires  = jiffies + TIMER_TIMEOUT;
    add_timer(&(led_device.blink_timer)); 

    printk("S3C %s driver version %d.%d.%d initiliazed.\n", DEV_NAME, DRV_MAJOR_VER, DRV_MINOR_VER, DRV_REVER_VER); 

    return 0;
               

ERROR: 
    printk("S3C %s driver version %d.%d.%d install failure.\n", DEV_NAME, DRV_MAJOR_VER, DRV_MINOR_VER, DRV_REVER_VER); 
    cdev_del(&(led_device.cdev)); 

    unregister_chrdev_region(devno, 1); 
    return result;

}

static int s3c_led_remove(struct platform_device *dev)
{
    dev_t devno = MKDEV(dev_major, dev_minor);

    del_timer(&(led_device.blink_timer));

    cdev_del(&(led_device.cdev)); 
    device_destroy(led_device.dev_class, devno); 
    class_destroy(led_device.dev_class); 
    
    unregister_chrdev_region(devno, 1); 
    printk("S3C %s driver removed\n", DEV_NAME);

    return 0;
}


static struct platform_driver s3c_led_driver = { 
    .probe      = s3c_led_probe, 
    .remove     = s3c_led_remove, 
    .driver     = { 
        .name       = "s3c_led", 
        .owner      = THIS_MODULE, 
    },
};


static int __init s3c_led_init(void)
{
   int       ret = 0;

   ret = platform_device_register(&s3c_led_device);
   if(ret)
   {
        printk(KERN_ERR "%s:%d: Can't register platform device %d\n", __FUNCTION__,__LINE__, ret); 
        goto fail_reg_plat_dev;
   }
   dbg_print("Regist S3C LED Platform Device successfully.\n");

   ret = platform_driver_register(&s3c_led_driver);
   if(ret)
   {
        printk(KERN_ERR "%s:%d: Can't register platform driver %d\n", __FUNCTION__,__LINE__, ret); 
        goto fail_reg_plat_drv;
   }
   dbg_print("Regist S3C LED Platform Driver successfully.\n");

   return 0;

fail_reg_plat_drv:
   platform_driver_unregister(&s3c_led_driver);
fail_reg_plat_dev:
   return ret;
}


static void s3c_led_exit(void)
{
    dbg_print("%s():%d remove LED platform drvier\n", __FUNCTION__,__LINE__);
    platform_driver_unregister(&s3c_led_driver);
    dbg_print("%s():%d remove LED platform device\n", __FUNCTION__,__LINE__);
    platform_device_unregister(&s3c_led_device);
}

module_init(s3c_led_init);
module_exit(s3c_led_exit);

module_param(debug, int, S_IRUGO);
module_param(dev_major, int, S_IRUGO);
module_param(dev_minor, int, S_IRUGO);

MODULE_AUTHOR(DRV_AUTHOR);
MODULE_DESCRIPTION(DRV_DESC);
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:S3C24XX_led");


 
 

  
  


 
 


 
 

  
  


 
 


 
 

  
  学习了platform总线驱动，以及LED驱动以后，满满的都是套路，都是各种申请，各种注册，最后匹配，platform比普通led多了个probe来对字符设备和驱动设备进行匹配，然后这里还有自动创建节点，以及定义led的闪烁，下一篇给出一个测试代码测试一下。
 
 


 
 

  
  


 
 


 
 

  
  ——————路漫漫其修远兮，我们的驱动之旅才刚开始。另外，请大家指出我理解不对的地方并加以指正，对我理解不够深刻的地方也希望大家帮助我学习。
 
 










                

        

        

    

  


    

      

        

            

              
                
                  Peter_tang6
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









                



	

		

			

				
					
platform 总线驱动

				
			

			

				

					tyustli
				

				

					01-13
					
					558
					
				

			

		

		

			
				
platform device 和 platform driver 

			
		

	



                

              
                



	

		

			

				
					
驱动开发-platform总线驱动

				
			

			

				

					weixin_47348012的博客
				

				

					10-20
					
					455
					
				

			

		

		

			
				
platmform总线驱动

			
		

	



                


  
              

                


	

		

			

				
					
Linux —— 驱动——platform平台总线

					
最新发布

				
			

			

				

					m0_71703182的博客
				

				

					08-28
					
					883
					
				

			

		

		

			
				
adcconadcdat0clkcon：这些是指向硬件寄存器的指针，用于控制ADC和时钟。wq：等待队列头，用于在ADC转换完成时唤醒等待的线程。condition：一个标志，用于指示ADC转换是否完成。arg：传递给中断处理程序的参数（在这个例子中，实际上并未在中断处理函数中使用）。

			
		

	





	

		

			

				
					
Platform 总线驱动程序

				
			

			

				

					qq_33559839的博客
				

				

					03-28
					
					1369
					
				

			

		

		

			
				
1.找出内核中自带的按键驱动程序代码
make menuconfig
	Device Drivers --->
		Input device support  --->
			[*]   Keyboards  ---> 
				< > SLsiAP push Keypad support
				//内核中自带的按键驱动程序不再参与编译
影响变量:
	CONFIG_KEYBOARD_NXP_KEY
路径:
	drivers/input/keyboard/Kconfig		
 

			
		

	



		

			
		



	

		

			

				
					
【ARM】Linux内核驱动之platform总线驱动

				
			

			

				

					凉开水白菜的博客
				

				

					08-16
					
					325
					
				

			

		

		

			
				
该驱动是基于前面的杂项设备进行增加的，该驱动和前面的模板只是替换了杂项设备注册的位置，当设备树和platform总线匹配上的时候执行probe函数的时候再进行和我们之前杂项设备同样的注册流程，使用该驱动模板需要注意在设备树中添加devicetree_platform_of_match中的匹配属性compatible ，相对于device和driver实际开发中我们的device习惯使用设备树生成，所以该种方式我放在了前面；

			
		

	





	

		

			

				
					
linux platform总线驱动开发实例

				
			

			

				

					04-10
				

			

		

		

			
				
通过这个"linux platform总线驱动开发实例"，开发者可以学习到如何根据实际硬件编写平台驱动，理解Linux内核驱动模型，掌握设备注册、匹配、中断处理等核心概念，为后续的驱动开发工作打下坚实基础。

			
		

	





	

		

			

				
					
Linux设备驱动开发-platform总线

				
			

			

				

					想坐在电脑前吹空调
				

				

					07-17
					
					604
					
				

			

		

		

			
				
在嵌入式系统里面，SoC系统中集成的独立的外设控制器、挂接在SoC内存空间的外设等确不依附于总线。也就是说在嵌入式CPU中，访问外设跟访问内存是一样的。基于这一背景，Linux发明了一种虚拟的总线，称为platform总线，相应的设备称为platform_device，而驱动成为 platform_driver。物理总线：芯片与各个功能外设之间传送信息的公共通信干线，其中又包括数据总线、地址总线和控制总线，以此来传输各种通信时序。驱动总线：负责管理设备和驱动。

			
		

	





	

		

			

				
					
platform总线驱动程序

				
			

			

				

					Herok
				

				

					04-11
					
					699
					
				

			

		

		

			
				
从这篇文章开始讲解驱动程序，Linux内核中有很多总线驱动，但都是由bus_type总线内管理，在/sys/bus目录下能够看到该内核定义了那些系统总线,常见的有platform、iic、spi、input等。内核中的总线与实际物理总线不一样，这里的总线是虚拟的，仅仅是一系列链表管理的对象，我们称这个管理链表为驱动总线。本文分析platform总线，这个总线在驱动结构中比较常用。

平台定义与注册...

			
		

	





	

		

			

				
					
platform总线下的简单驱动

				
			

			

				

					11-21
				

			

		

		

			
				
my_dev.c是设备文件，my_dri.c是驱动文件，使用echo可以对驱动进行调试。

			
		

	





	

		

			

				
					
【Linux】Linux驱动开发：platform总线驱动

				
			

			

				

					W__winter的博客
				

				

					05-06
					
					2173
					
				

			

		

		

			
				
/定义在linux/module.h中使用时，参数如下：of：总线类型match_table：idtable数组首地址。

			
		

	





	

		

			

				
					
platform总线驱动分析

				
			

			

				

					eurphan_y的博客
				

				

					06-07
					
					180
					
				

			

		

		

			
				
platform总线驱动分析

1.前言
在Linux的设备模型中，关心总线、设备和驱动这3个实体，总线将设备和驱动绑定。在系统每注册一个设备的时候，会寻找与之匹配的驱动；相反的，在系统每注册一个驱动的时候，会寻找与之匹配的设备，而匹配由总线完成。
一个现实的Linux设备和驱动通常都需要挂接在一种总线上，对于本身依附于PCI、USB、I2C、SPI等的设备而言，这自然不是问题，但是在嵌入式系统里...

			
		

	





	

		

			

				
					
嵌入式Linux驱动开发 03：平台（platform）总线驱动模型

				
			

			

				

					Naisu的各种笔记
				

				

					06-01
					
					1917
					
				

			

		

		

			
				
前面文章 《嵌入式Linux驱动开发 01：基础开发与使用》 和 《嵌入式Linux驱动开发 02：将驱动程序添加到内核中》 介绍了驱动开发最基础的内容，这篇文章将在前面基础上更进一步，引入平台（platform）总线驱动模型。

			
		

	





	

		

			

				
					
03_Platform总线设备驱动

				
			

			

				

					qq_34968572的博客
				

				

					05-07
					
					586
					
				

			

		

		

			
				
一：Platform总线简介

 linux设备驱动模型中，需关心总线，设备和驱动这三个实体，总线将设备和驱动绑定。在系统每注册一个设备的时候，会寻找与之匹配的驱动；相反的，在系统每注册一个驱动时，会寻找与之匹配的设备，而这种匹配就是有总线来完成。

 一个现实的linux设备和驱动通常都需要挂接在一个总线上，对于本身依附于PCI，USB，I2C，SPI等的设备而言，这...

			
		

	





	

		

			

				
					
Linux驱动开发之【Platform总线驱动模型】

				
			

			

				

					weixin_53351963的博客
				

				

					03-19
					
					869
					
				

			

		

		

			
				
自内核2.6版本开始，需要关注的是总线、设备和驱动这3个实体：总线将设备和驱动绑定。在Linux内核系统中注册一个设备的时候，会寻找与之对应驱动进行匹配;相反地，系统中注册一个驱动的时候，会去寻找一个对应的设备进行匹配。匹配的的工作由总线来完成。在Linux设备中有的是没有对应的物理总线的，但为了适配Linux的总线模型，内核针对这种没有物理总线的设备开发了一种虚拟总线--platform总线

			
		

	





	

		

			

				
					
Linux驱动（三）platform总线驱动

				
			

			

				

					cesheng3410的博客
				

				

					01-05
					
					1582
					
				

			

		

		

			
				
编写最简单的platform驱动讲解驱动框架和内核中的具体实现流程

			
		

	





	

		

			

				
					
5.linux设备驱动模型

				
			

			

				

					阿路
				

				

					11-14
					
					319
					
				

			

		

		

			
				
《5.linux驱动开发-第5部分-5.5.linux设备驱动模型》
第一部分、章节目录
5.5.1.linux设备驱动模型简介
5.5.2.设备驱动模型的底层架构
5.5.3.总线式设备驱动组织方式
5.5.4.platform平台总线简介1
5.5.5.platform平台总线工作原理2
5.5.6.platform平台总线工作原理3
5.5.7.平台总线实践环节1
5.5.8.平台总线实践环...

			
		

	





	

		

			

				
					
Device设备驱动模型与platform总线驱动的区别和联系

				
			

			

				

					05-30
				

			

		

		

			
				
设备驱动模型和platform总线驱动是操作系统中的两个概念，它们之间有一定的联系和区别。  首先，设备驱动模型是指操作系统中的设备驱动程序所使用的规范或模型。在Linux系统中，常用的设备驱动模型有两种：字符设备...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值