平台总线式驱动开发（id匹配和设备树匹配lv12-day3）

最新推荐文章于 2025-03-06 08:41:49 发布
原创 最新推荐文章于 2025-03-06 08:41:49 发布 · 1.7k 阅读 · 6 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
收录于
驱动开发

当前文章被收录于：

驱动开发
8 篇文章 1 人学习
订阅专栏 查看详情
本文详细介绍了Linux驱动开发中的ID匹配原理和步骤，包括如何在`xxx_device.c`和`xxx_driver.c`中进行相应配置。同时，提供了led驱动的ID匹配版实现，包括`fs4412_led.h`、`fs4412leds_device.c`和`fs4412leds_driver.c`三个部分的代码示例。此外，还简要提到了led驱动的设备树驱动版相关内容。

文章目录

1 ID匹配

id匹配（可想象成八字匹配）：一个驱动可以对应多个设备 ------在三种匹配方式中优先级次低。
注意事项：

1. device模块中，id的name成员必须与struct platform_device中的name成员内容一致，因此device模块中，structplatform_device中的name成员必须指定
2. driver模块中，struct platform_driver成员driver的name成员必须指定，但与device模块中name可以不相同
2 ID 匹配编写步骤
1 编写 xxx_device.c(设备)

1 在 platform_device xxxxxx中添加id_entry成员

struct platform_device fs4412led_device=
{
	//用于名称匹配
	.name="fs4412leds",
	//设备回收时会被调用
	.dev.release=fs4412led_dev_release,
	.resource=fs4412led_dev_res,
	//计算资源个数
	.num_resources=ARRAY_SIZE(fs4412led_dev_res),
	.id_entry=&fs4412leds_id,
};

2 编写 platform_device_id xxxxx

struct platform_device_id fs4412leds_id={

	//注意和上面的name一致
	.name="fs4412leds",
};
2 编写 xxx_driver.c(驱动)

1 在struct platform_driver xxxxx 中添加id_table成员

struct platform_driver fs4412leds_driver =
{
	.driver.name="leds",
	.probe=fs4412leds_driver_probe,
	.remove=fs4412leds_driver_remove,
	.id_table=fs4412leds_drv_ids,
};

2 编写struct platform_device_id xxxx_ids[]

struct platform_device_id fs4412leds_drv_ids[]={
	[0]={.name ="fs4412leds"},
	[1]={.name ="fs4412keys"},
	[2]={}//代表结束必须
};
3 led驱动id匹配版
3.1 fs4412_led.h
#ifndef MY_CHAR_H
#define MY_CHAR_H
#include <asm/ioctl.h>
#define LED_DEV_MAGIC 'g'
//#define MYCHAR_IOCTL_GET_MAXLEN _IOR(MY_CHAR_MAGIC,1,int*)
//#define MYCHAR_IOCTL_GET_CURLEN _IOR(MY_CHAR_MAGIC,2,int*)
#define MY_LED_OFF _IO(LED_DEV_MAGIC,0)
#define MY_LED_ON  _IO(LED_DEV_MAGIC,1)
// led2
#define GPX2CON 0x11000C40
#define GPX2DAT 0x11000C44
// led3
#define GPX1CON 0x11000C20
#define GPX1DAT 0x11000C24
//led4,5
#define GPF3CON 0x114001E0
#define GPF3DAT 0x114001E4

#endif
3.2 fs4412leds_device.c
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/platform_device.h>
#include "fs4412_led.h"
//做清理工作
void fs4412led_dev_release(struct device *pdev)
{
    printk("fs4412led_dev_release is called\n");
}
struct resource fs4412led_dev_res[]=
{
	[0]={.start=GPX1CON,.end=GPX1CON+3,.name="GPX1CON",.flags=IORESOURCE_MEM},
    [1]={.start=GPX1DAT,.end=GPX1DAT+3,.name="GPX1DAT",.flags=IORESOURCE_MEM},

    [2]={.start=GPX2CON,.end=GPX2CON+3,.name="GPX2CON",.flags=IORESOURCE_MEM},
    [3]={.start=GPX2DAT,.end=GPX2DAT+3,.name="GPX2DAT",.flags=IORESOURCE_MEM},

    [4]={.start=GPF3CON,.end=GPF3CON+3,.name="GPF3CON",.flags=IORESOURCE_MEM},
    [5]={.start=GPF3DAT,.end=GPF3DAT+3,.name="GPF3DAT",.flags=IORESOURCE_MEM},
};
struct platform_device_id fs4412leds_id={

	//注意和下面的name一致
	.name="fs4412leds",
};
struct platform_device fs4412led_device=
{
	//用于名称匹配
	.name="fs4412leds",
	//设备回收时会被调用
	.dev.release=fs4412led_dev_release,
	.resource=fs4412led_dev_res,
	//计算资源个数
	.num_resources=ARRAY_SIZE(fs4412led_dev_res),
	.id_entry=&fs4412leds_id,
};
int __init fs4412led_device_init(void)
{
    platform_device_register(&fs4412led_device);
	return 0;
}
void __exit fs4412led_device_exit(void)
{

    platform_device_unregister(&fs4412led_device);
}

MODULE_LICENSE("GPL");
module_init(fs4412led_device_init);
module_exit(fs4412led_device_exit);
3.3 fs4412leds_driver.c
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <asm/uaccess.h>
#include <linux/sched.h>
#include <linux/poll.h>
#include <linux/atomic.h>

#include <linux/mm.h>
#include <linux/slab.h>

#include <linux/io.h>
#include <linux/device.h>
#include <linux/platform_device.h>



#include "fs4412_led.h"
#define fs4412leds_driver_DEV_CNT 1
int major =11;//主设备号
int minor = 0;//次设备号
int fs4412leds_driver_num =fs4412leds_driver_DEV_CNT;//设备数量
struct fs4412leds_driver_dev
{

	struct cdev mydev;//建立一个设备对象
	//volatile为不做优化
	volatile unsigned long * led2con;
	volatile unsigned long * led2dat;
	volatile unsigned long * led3con;
	volatile unsigned long * led3dat;
	volatile unsigned long * led4con;
	volatile unsigned long * led4dat;
	volatile unsigned long * led5con;
	volatile unsigned long * led5dat;
	struct class *pcls;
	struct device *pdev;
};
struct fs4412leds_driver_dev *gmydev_arr[fs4412leds_driver_DEV_CNT];
//打开
int fs4412leds_driver_open(struct inode *pnode,struct file *pfile)
{
	/*为避免使用全局变量*/
	/*
	 *container_of是一个宏，可以用来求全局结构体变量的地址
	 *已知其成员的地址和成员名字，就可以求出其地址
	 *pnode->i_cdev:指向插入系统的设备对象(这里也是gmydev的成员mydev的地址)
	 *pnode->private_data:本次打开文件的私有数据，驱动中常来在几个操作函数间传递共用数据
	 */

	pfile->private_data=(void *)(container_of(pnode->i_cdev,struct fs4412leds_driver_dev,mydev));
	return 0;
}
//关闭
int fs4412leds_driver_close(struct inode *pnode,struct file *pfile)
{


	return 0;
}

void led_on(struct fs4412leds_driver_dev * pmydev,int ledno)
{
     switch(ledno)
	 {
	   case 2:
		    printk("2\n");
	        writel(readl(pmydev->led2dat) | (0x1<<7),pmydev->led2dat);//关闭led2
		    break;
	   case 3:
		    printk("3\n");
	        writel(readl(pmydev->led3dat) | (0x1<<0),pmydev->led3dat);//关闭led2
		    break;
	   case 4:
		    printk("4\n");
	        writel(readl(pmydev->led4dat) | (0x1<<4),pmydev->led4dat);//关闭led2
		    break;
       case 5:
		    printk("5\n");
	        writel(readl(pmydev->led5dat) | (0x1<<5),pmydev->led5dat);//关闭led2
		    break;
	 }
}
void led_off(struct fs4412leds_driver_dev * pmydev,int ledno)
{
     switch(ledno)
	 {
	   case 2:
			writel(readl(pmydev->led2dat) & (~(1<<7)),pmydev->led2dat);//关闭led2
		    break;
	   case 3:
			writel(readl(pmydev->led3dat) & (~(1<<0)),pmydev->led3dat);//关闭led3
		    break;
	   case 4:
			writel(readl(pmydev->led4dat) & (~(1<<4)),pmydev->led4dat);//关闭led4
		    break;
       case 5:
			writel(readl(pmydev->led5dat) & (~(1<<5)),pmydev->led5dat);//关闭led5
		    break;
	 }

}
long fs4412leds_driver_ioctl(struct file *pfile,unsigned int cmd,unsigned long arg)
{
  struct fs4412leds_driver_dev * pmydev = (struct fs4412leds_driver_dev*)pfile->private_data;
  if(arg<2||arg>5)
  {
	  return -1;
  }
  switch(cmd)
  {
    case MY_LED_ON:
		led_on(pmydev,arg);
		break;
    case MY_LED_OFF:
		led_off(pmydev,arg);
		break;
    default:
		return -1;
  }
  return 0;
}
struct file_operations myops={
	.owner=THIS_MODULE,
	.open=fs4412leds_driver_open,
	.unlocked_ioctl=fs4412leds_driver_ioctl,
	.release =fs4412leds_driver_close,
};
/**
 *  @brief           将寄存器物理地址映射为虚拟地址
 *  @param[in]       pmydev:设备对象结构体                                       
 *  @retval          NULL
 *
 */
void ioremap_ledreg(struct fs4412leds_driver_dev *pmydev,struct platform_device *p_pltdev)
{
	/*得到虚拟内存地址*/
	struct resource *pres=NULL;
    //获取相应资源
    pres =platform_get_resource(p_pltdev,IORESOURCE_MEM,2);
	pmydev->led2con=ioremap(pres->start,4);	
    pres =platform_get_resource(p_pltdev,IORESOURCE_MEM,3);
	pmydev->led2dat=ioremap(pres->start,4);	

    pres =platform_get_resource(p_pltdev,IORESOURCE_MEM,0);
	pmydev->led3con=ioremap(pres->start,4);	
    pres =platform_get_resource(p_pltdev,IORESOURCE_MEM,1);
	pmydev->led3dat=ioremap(pres->start,4);	

    pres =platform_get_resource(p_pltdev,IORESOURCE_MEM,4);
	pmydev->led4con=ioremap(pres->start,4);	
    pres =platform_get_resource(p_pltdev,IORESOURCE_MEM,5);
	pmydev->led4dat=ioremap(pres->start,4);	

	pmydev->led5con=pmydev->led4con;	
	pmydev->led5dat=pmydev->led4dat;	

}

/**
 *  @brief           将寄存器物理地址映射为虚拟地址
 *  @param[in]       pmydev:设备对象结构体                                       
 *  @retval          NULL
 *
 */
void set_output_ledconreg(struct fs4412leds_driver_dev *pmydev)
{
	writel((readl(pmydev->led2con) & (~(0xF<<28))) | (0x1<<28),pmydev->led2con);//设置GPX2_7为输出模式
	writel((readl(pmydev->led3con) & (~(0xF<<0)))  | (0x1<<0),pmydev->led3con);//设置GPX1_0为输出模式
	writel((readl(pmydev->led4con) & (~(0xF<<16))) | (0x1<<16),pmydev->led4con);//设置GPF3_4为输出模式
	writel((readl(pmydev->led5con) & (~(0xF<<20))) | (0x1<<20),pmydev->led5con);//设置GPF3_5为输出模式

	writel(readl(pmydev->led2dat) & (~(1<<7)),pmydev->led2dat);//关闭led2
	writel(readl(pmydev->led3dat) & (~(1<<0)),pmydev->led3dat);//关闭led3
	writel(readl(pmydev->led4dat) & (~(1<<4)),pmydev->led4dat);//关闭led4
	writel(readl(pmydev->led5dat) & (~(1<<5)),pmydev->led5dat);//关闭led5


}
/**
 *  @brief           解除寄存器物理地址和虚拟地址映射
 *  @param[in]       pmydev:设备对象结构体                                       
 *  @retval          NULL
 *
 */
void iounremap_ledreg(struct fs4412leds_driver_dev *pmydev)
{
	iounmap(pmydev->led2con);
	pmydev->led2con=NULL;
	iounmap(pmydev->led2dat);
	pmydev->led2dat=NULL;

	iounmap(pmydev->led3con);
	pmydev->led3con=NULL;
	iounmap(pmydev->led3dat);
	pmydev->led3dat=NULL;

	iounmap(pmydev->led4con);
	pmydev->led4con=NULL;
	iounmap(pmydev->led4dat);
	pmydev->led4dat=NULL;

	pmydev->led5con=NULL;
	pmydev->led5dat=NULL;

}
//初始化
int fs4412leds_driver_probe(struct platform_device *p_pltdev)
{
	int ret = 0;
	int i = 0;
	dev_t devno =MKDEV(major,minor);//组合成一个完整的设备号
	/*
	 * 手动申请设备号
	 *int register_chrdev_region(dev_t from, unsigned count, const char *name)
	 *参数分别为 设备号，设备数量，设备名字 
	 */
	ret=register_chrdev_region(devno,fs4412leds_driver_num,"fs4412leds");
	if(ret)
	{
		/*
		 *自动申请设备号
		 *int alloc_chrdev_region(dev_t *dev,unsigned baseminor,unsigned count, const char *name)
		 * dev：分配设备号成功后用来存放分配到的设备号
		 * baseminior：起始的次设备号，一般为0
		 * count：申请的设备数量
		 * name：/proc/devices文件中与该设备对应的名字，方便用户层查询主次设备号
		 */
		ret = alloc_chrdev_region(&devno,minor,fs4412leds_driver_num,"fs4412leds");
		if(ret)
		{
			printk("get devno failed\n");
			return -1;
		}
		major = MAJOR(devno);//分离主设备号(手动申请失败需要)
	}
	for(i=0;i<fs4412leds_driver_DEV_CNT;i++)
	{
		gmydev_arr[i]=(struct fs4412leds_driver_dev*)kmalloc(sizeof(struct fs4412leds_driver_dev),GFP_KERNEL);
		if(NULL==gmydev_arr[i])
		{
			printk("kmalloc failed\n");
			unregister_chrdev_region(devno,fs4412leds_driver_num);//注销设备号
			return -1;

		}
		memset(gmydev_arr[i],0,sizeof(struct fs4412leds_driver_dev));//初始化
	}

	/*指定操作函数集*/
	for(i=0;i<fs4412leds_driver_DEV_CNT;i++)
	{	
		devno =MKDEV(major,minor+i);
		cdev_init(&gmydev_arr[i]->mydev,&myops);//初始化设备对象
		/*将struct_cdev对象添加到内核对应的数据结构里*/
		gmydev_arr[i]->mydev.owner=THIS_MODULE;
		cdev_add(&gmydev_arr[i]->mydev,devno,1);//添加设备
		/*ioremap*/
		ioremap_ledreg(gmydev_arr[i],p_pltdev);//映射地址
		set_output_ledconreg(gmydev_arr[i]);//led初始化
		/*con_register set output*/
		gmydev_arr[i]->pcls=class_create(THIS_MODULE,"fs4412led");
		if(IS_ERR(gmydev_arr[i]->pcls))
		{
			printk("class_create failed\n");
			cdev_del(&gmydev_arr[i]->mydev);
		    iounremap_ledreg(gmydev_arr[i]);//取消映射
		    kfree(gmydev_arr[i]);
	        unregister_chrdev_region(devno,fs4412leds_driver_num);//注销设备号
		    gmydev_arr[i]=NULL;
				
			return -1;
		}
		gmydev_arr[i]->pdev=device_create(gmydev_arr[i]->pcls,NULL,devno,"NULL","fs4412led");
		if(NULL==gmydev_arr[i]->pdev)
		{
			printk("device_create failed\n");
			cdev_del(&gmydev_arr[i]->mydev);
		    iounremap_ledreg(gmydev_arr[i]);//取消映射
		    kfree(gmydev_arr[i]);
	        unregister_chrdev_region(devno,fs4412leds_driver_num);//注销设备号
		    gmydev_arr[i]=NULL;
			class_destroy(gmydev_arr[i]->pcls);
				
			return -1;

		}
	}

	return 0;
}
int fs4412leds_driver_remove(struct platform_device *p_pltdev)
{
	dev_t devno = MKDEV(major,minor);
	int i=0;
	/*iounremap*/
	for(i=0;i<fs4412leds_driver_DEV_CNT;i++)
	{
		iounremap_ledreg(gmydev_arr[i]);//取消映射
		device_destroy(gmydev_arr[i]->pcls,devno);
		class_destroy(gmydev_arr[i]->pcls);
		cdev_del(&gmydev_arr[i]->mydev);
	}
	for(i=0;i<fs4412leds_driver_DEV_CNT;i++)
	{

		kfree(gmydev_arr[i]);
		gmydev_arr[i]=NULL;
	}
	unregister_chrdev_region(devno,fs4412leds_driver_num);//注销设备号
	return 0;
}
struct platform_device_id fs4412leds_drv_ids[]={
	[0]={.name ="fs4412leds"},
	[1]={.name ="fs4412keys"},
	[2]={}//代表结束必须
};
struct platform_driver fs4412leds_driver =
{
	.driver.name="leds",
	.probe=fs4412leds_driver_probe,
	.remove=fs4412leds_driver_remove,
	.id_table=fs4412leds_drv_ids,
};
int __init fs4412leds_driver_init(void)
{
	platform_driver_register(&fs4412leds_driver);
	return 0;
}

void __exit fs4412leds_driver_exit(void)
{
	platform_driver_unregister(&fs4412leds_driver);
}
MODULE_LICENSE("GPL");

module_init(fs4412leds_driver_init);
module_exit(fs4412leds_driver_exit);
4 led驱动设备树驱动版
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <asm/uaccess.h>
#include <linux/sched.h>
#include <linux/poll.h>
#include <linux/atomic.h>

#include <linux/mm.h>
#include <linux/slab.h>

#include <linux/of_gpio.h>
#include <linux/gpio.h>

#include <linux/io.h>
#include <linux/of.h>
#include <linux/platform_device.h>
#include <linux/device.h>


#include "fs4412_led.h"
#define fs4412leds_driver_DEV_CNT 1
int major =11;//主设备号
int minor = 0;//次设备号
int fs4412leds_driver_num =fs4412leds_driver_DEV_CNT;//设备数量
struct fs4412leds_driver_dev
{

	struct cdev mydev;//建立一个设备对象
	unsigned int Led2Gpio;
	unsigned int Led3Gpio;
	unsigned int Led4Gpio;
	unsigned int Led5Gpio;
	struct class *pcls;
	struct device *pdev;
};
struct fs4412leds_driver_dev *gmydev_arr[fs4412leds_driver_DEV_CNT];
//打开
int fs4412leds_driver_open(struct inode *pnode,struct file *pfile)
{
	/*为避免使用全局变量*/
	/*
	 *container_of是一个宏，可以用来求全局结构体变量的地址
	 *已知其成员的地址和成员名字，就可以求出其地址
	 *pnode->i_cdev:指向插入系统的设备对象(这里也是gmydev的成员mydev的地址)
	 *pnode->private_data:本次打开文件的私有数据，驱动中常来在几个操作函数间传递共用数据
	 */

	pfile->private_data=(void *)(container_of(pnode->i_cdev,struct fs4412leds_driver_dev,mydev));
	return 0;
}
//关闭
int fs4412leds_driver_close(struct inode *pnode,struct file *pfile)
{


	return 0;
}

void led_on(struct fs4412leds_driver_dev * pmydev,int ledno)
{
     switch(ledno)
	 {
	   case 2:
		    printk("Led2On\n");
			gpio_set_value(pmydev->Led2Gpio,1);//设置为高电平
		    break;
	   case 3:
		    printk("Led3On\n");
			gpio_set_value(pmydev->Led3Gpio,1);//设置为高电平
		    break;
	   case 4:
		    printk("Led4On\n");
			gpio_set_value(pmydev->Led4Gpio,1);//设置为高电平
		    break;
       case 5:
;
		    printk("Led5On\n");
			gpio_set_value(pmydev->Led5Gpio,1);//设置为高电平
		    break;
	 }
}
void led_off(struct fs4412leds_driver_dev * pmydev,int ledno)
{

     switch(ledno)
	 {
	   case 2:
		    printk("Led2Off\n");
			gpio_set_value(pmydev->Led2Gpio,0);//设置为高电平
		    break;
	   case 3:
		    printk("Led3Off\n");
			gpio_set_value(pmydev->Led3Gpio,0);//设置为高电平
		    break;
	   case 4:
		    printk("Led4Off\n");
			gpio_set_value(pmydev->Led4Gpio,0);//设置为高电平
		    break;
       case 5:
		    printk("Led5Off\n");
			gpio_set_value(pmydev->Led5Gpio,0);//设置为高电平
		    break;
	 }
}
long fs4412leds_driver_ioctl(struct file *pfile,unsigned int cmd,unsigned long arg)
{
  struct fs4412leds_driver_dev * pmydev = (struct fs4412leds_driver_dev*)pfile->private_data;
  if(arg<2||arg>5)
  {
	  return -1;
  }
  switch(cmd)
  {
    case MY_LED_ON:
		led_on(pmydev,arg);
		break;
    case MY_LED_OFF:
		led_off(pmydev,arg);
		break;
    default:
		return -1;
  }
  return 0;
}
struct file_operations myops={
	.owner=THIS_MODULE,
	.open=fs4412leds_driver_open,
	.unlocked_ioctl=fs4412leds_driver_ioctl,
	.release =fs4412leds_driver_close,
};
/**
 *  @brief           申请gpio
 *  @param[in]       pmydev:设备对象结构体指针
 *                   pnode:设备树指针
 *  @retval          NULL
 *
 */
void RepuestLedsGpio(struct fs4412leds_driver_dev *pmydev,struct device_node *pnode)
{
   pmydev->Led2Gpio=of_get_named_gpio(pnode,"led2-gpio",0);//从设备树中提取gpio口
   gpio_request(pmydev->Led2Gpio,"led2");//申请led2的io口
   pmydev->Led3Gpio=of_get_named_gpio(pnode,"led3-gpio",0);
   gpio_request(pmydev->Led3Gpio,"led3");//申请led3的io口
   pmydev->Led4Gpio=of_get_named_gpio(pnode,"led4-gpio",0);
   gpio_request(pmydev->Led4Gpio,"led4");//申请led4的io口
   pmydev->Led5Gpio=of_get_named_gpio(pnode,"led5-gpio",0);
   gpio_request(pmydev->Led5Gpio,"led5");//申请led5的io口
}

/**
 *  @brief           设置对于的gpio管脚为输出模式
 *  @param[in]       pmydev:设备对象结构体                                       
 *  @retval          NULL
 *
 */
void set_leds_gpio_output(struct fs4412leds_driver_dev *pmydev)
{
    gpio_direction_output(pmydev->Led2Gpio,0);
    gpio_direction_output(pmydev->Led3Gpio,0);
    gpio_direction_output(pmydev->Led4Gpio,0);
    gpio_direction_output(pmydev->Led5Gpio,0);

}
/**
 *  @brief      　　 释放gpio     
 *  @param[in]       pmydev:设备对象结构体   
 *                  
 *
 *  @retval          NULL
 *
 */
void free_leds_gpio(struct fs4412leds_driver_dev *pmydev)
{
   gpio_free(pmydev->Led2Gpio);
   gpio_free(pmydev->Led3Gpio);
   gpio_free(pmydev->Led4Gpio);
   gpio_free(pmydev->Led5Gpio);
}
//初始化
int fs4412leds_driver_probe(struct platform_device *p_pltdev)
{
	int ret = 0;
	int i = 0;
	struct device_node *pnode = NULL;
	dev_t devno =MKDEV(major,minor);//组合成一个完整的设备号
	/*
	 * 手动申请设备号
	 *int register_chrdev_region(dev_t from, unsigned count, const char *name)
	 *参数分别为 设备号，设备数量，设备名字 
	 */
	ret=register_chrdev_region(devno,fs4412leds_driver_num,"fs4412leds_driver");
	if(ret)
	{
		/*
		 *自动申请设备号
		 *int alloc_chrdev_region(dev_t *dev,unsigned baseminor,unsigned count, const char *name)
		 * dev：分配设备号成功后用来存放分配到的设备号
		 * baseminior：起始的次设备号，一般为0
		 * count：申请的设备数量
		 * name：/proc/devices文件中与该设备对应的名字，方便用户层查询主次设备号
		 */
		ret = alloc_chrdev_region(&devno,minor,fs4412leds_driver_num,"fs4412leds_driver");
		if(ret)
		{
			printk("get devno failed\n");
			return -1;
		}
		major = MAJOR(devno);//分离主设备号(手动申请失败需要)
	}
	for(i=0;i<fs4412leds_driver_DEV_CNT;i++)
	{
		gmydev_arr[i]=(struct fs4412leds_driver_dev*)kmalloc(sizeof(struct fs4412leds_driver_dev),GFP_KERNEL);
		if(NULL==gmydev_arr[i])
		{
			printk("kmalloc failed\n");
			unregister_chrdev_region(devno,fs4412leds_driver_num);//注销设备号
			return -1;

		}
		memset(gmydev_arr[i],0,sizeof(struct fs4412leds_driver_dev));//初始化
	}
	/*指定操作函数集*/
	for(i=0;i<fs4412leds_driver_DEV_CNT;i++)
	{	
		devno =MKDEV(major,minor+i);
		cdev_init(&gmydev_arr[i]->mydev,&myops);//初始化设备对象
		/*将struct_cdev对象添加到内核对应的数据结构里*/
		gmydev_arr[i]->mydev.owner=THIS_MODULE;
		cdev_add(&gmydev_arr[i]->mydev,devno,1);//添加设备
		/*ioremap*/
        pnode=p_pltdev->dev.of_node;//匹配成功的节点指针
		RepuestLedsGpio(gmydev_arr[i],pnode);

		set_leds_gpio_output(gmydev_arr[i]);//led初始化
		/*con_register set output*/
		gmydev_arr[i]->pcls=class_create(THIS_MODULE,"fs4412led");
		if(IS_ERR(gmydev_arr[i]->pcls))
		{
			printk("class_create failed\n");
			cdev_del(&gmydev_arr[i]->mydev);
			free_leds_gpio(gmydev_arr[i]);
		    kfree(gmydev_arr[i]);
	        unregister_chrdev_region(devno,fs4412leds_driver_num);//注销设备号
		    gmydev_arr[i]=NULL;
				
			return -1;
		}
		gmydev_arr[i]->pdev=device_create(gmydev_arr[i]->pcls,NULL,devno,"NULL","fs4412led");
		if(NULL==gmydev_arr[i]->pdev)
		{
			printk("device_create failed\n");
			cdev_del(&gmydev_arr[i]->mydev);
			free_leds_gpio(gmydev_arr[i]);
		    kfree(gmydev_arr[i]);
	        unregister_chrdev_region(devno,fs4412leds_driver_num);//注销设备号
		    gmydev_arr[i]=NULL;
			class_destroy(gmydev_arr[i]->pcls);
				
			return -1;

		}
	}

	return 0;
}
int fs4412leds_driver_remove(struct platform_device *p_pltdev)
{
	dev_t devno = MKDEV(major,minor);
	int i=0;
	/*iounremap*/
	for(i=0;i<fs4412leds_driver_DEV_CNT;i++)
	{
		cdev_del(&gmydev_arr[i]->mydev);
		free_leds_gpio(gmydev_arr[i]);//释放gpio
		device_destroy(gmydev_arr[i]->pcls,devno);
		class_destroy(gmydev_arr[i]->pcls);
	}
	for(i=0;i<fs4412leds_driver_DEV_CNT;i++)
	{

		kfree(gmydev_arr[i]);
		gmydev_arr[i]=NULL;
	}
	unregister_chrdev_region(devno,fs4412leds_driver_num);//注销设备号
	return 0;
}

struct of_device_id fs4412leddrv_of_ids[]=
{
	[0]={.compatible = "fs4412,led2-5"},
	[1]={.compatible= "origen4412,led6-9"},
	[2]={},
};
struct platform_driver fs4412leds_driver =
{
	.driver={
		.name="leds",
        .of_match_table=fs4412leddrv_of_ids,
	},
	.probe=fs4412leds_driver_probe,
	.remove=fs4412leds_driver_remove,
};
int __init fs4412leds_driver_init(void)
{
      platform_driver_register(&fs4412leds_driver);
      return 0;
}
void __exit fs4412leds_driver_exit(void)
{
       platform_driver_unregister(&fs4412leds_driver);
}

MODULE_LICENSE("GPL");

module_init(fs4412leds_driver_init);
module_exit(fs4412leds_driver_exit);
标签
#驱动开发 #arm开发 #linux
Xilinx VU+系列多DIE FPGA时序约束与跨DIE信号优化策略
最新发布
weixin_29209801的博客
02-01 603
本文深入探讨了Xilinx VU+系列多DIE FPGA的时序约束与跨DIE信号优化策略。针对2.5D/3D封装技术带来的时序挑战，详细解析了SLR区域约束、Laguna寄存器配置及跨时钟域约束等关键技术，提供了实用的TCL脚本和RTL优化示例，帮助开发者有效提升设计性能和时序收敛效率。
YOLOv12改进入门篇 | 手把手讲解改进模块如何实现高效涨点，以SimAM注意力模块为例
Limiiiing的博客
03-06 2804
本文记录的是。SimAM注意力模块通过优化能量函数来获得每个神经元的三维权重，而或增加计算复杂度。若是有轻量化需求的小伙伴，无参的注意力模块也许是一个不错的选择。
平台总线式驱动开发（lv12-day2）
qq_56875484的博客
08-15 737
一个驱动可以对应多个设备 ------优先级次低 ​ device模块中，id的name成员必须与struct platform_device中的name成员内容一致 ​ 因此device模块中，struct platform_device中的name成员必须指定 ​ driver模块中，struct platform_driver成员driver的name成员必须指定，但与device模块中name可以不相同。​ 带来的问题-------怎样将二者进行关联（匹配）？hello_device.c (设备).
基于单片机的模拟音乐喷泉仿真设计（提供仿真图、源代码、讲解视频）
基于单片机的模拟音乐喷泉仿真设计（提供仿真图、源代码、讲解视频）本系统为基于单片机的模拟音乐喷泉protues仿真，通过按键切换播放的音乐和暂停等动作，蜂鸣器播放音乐，音乐的节拍同步显示在LED喷泉上，模拟音乐喷泉设计；功能具体如下：1、系统使用51单片机为主控，protues仿真设计；2、使用单片机定时器做音乐播放，蜂鸣器发出声音；3、按键切换音乐和音乐暂停；4、音乐节拍显示在8路LED音乐喷泉上，模拟实际音乐喷泉设计；5、该设计提供protues仿真团、源代码和讲解视频，可以二次开发；
嵌入式Linux驱动开发 03：平台（platform）总线驱动模型
Naisu的各种笔记
06-01 2294
前面文章 《嵌入式Linux驱动开发 01：基础开发与使用》 和 《嵌入式Linux驱动开发 02：将驱动程序添加到内核中》 介绍了驱动开发最基础的内容，这篇文章将在前面基础上更进一步，引入平台（platform）总线驱动模型。
嵌入式内核及驱动开发高级
m0_74976404的博客
09-23 1085
*I2C设备驱动：**即挂接在I2C总线上的二级外设的驱动，也称客户（client）驱动，实现对二级外设的各种操作，二级外设的几乎所有操作全部依赖于对其自身内部寄存器的读写，对这些二级外设寄存器的读写又依赖于I2C总线的发送和接收。在C语言中，结构体的对齐问题指的是结构体成员如何在内存中排列。这是内核设备按总线类型分层放置的目录结构， devices 中的所有设备都是连接于某种总线之下，在这里的每一种具体总线之下可以找到每一个具体设备的符号链接，它也是构成 Linux 统一设备模型的一部分；
平台总线开发（id和设备树匹配）
qq_52479948的博客
02-27 913
平台总线开发（id和设备树匹配）
嵌入式系统驱动高级【3】——平台总线式驱动开发下__ID匹配和设备树匹配
imysy_22_的博客
08-08 873
平台总线式驱动开发下__ID匹配和设备树匹配
【LV16 day2 平台总线驱动开发---名称匹配】
m0_46112340的博客
03-30 1021
​ driver模块中，struct platform_driver成员driver的name成员必须指定，但与device模块中name可以不相同。初期方案，各种device需要编码方式注册进内核中的设备管理结构中，为了进一步减少这样的编码，引进设备树。2.2 id匹配（可想象成八字匹配）：一个驱动可以对应多个设备 ------优先级次低。2.3 设备树匹配：内核启动时根据设备树自动产生的设备 ------ 优先级最高。​ 带来的问题-------怎样将二者进行关联（匹配）？
【LV16 Day3 平台总线开发 ID匹配和设备树匹配】
m0_46112340的博客
03-30 367
id匹配（可想象成八字匹配）：一个驱动可以对应多个设备 ------优先级次低用到结构体数组，一般不指定大小，初始化时最后加{}表示数组结束设备中增加资源，驱动中访问资源。
平台总线--ID匹配和设备树匹配
2302_76785838的博客
03-08 1065
id匹配（可想象成八字匹配）：一个驱动可以对应多个设备 ------优先级次低注意事项：device模块中，id的name成员必须与struct platform_device中的name成员内容一致，因此device模块中，struct platform_device中的name成员必须指定driver模块中，struct platform_driver成员driver的name成员必须指定，但与device模块中name可以不相同/*platform device框架*/​。
Linux内核平台设备驱动模型platform_device和platform_driver框架
D584640810的博客
11-17 4377
关于Linux内核的平台设备驱动模型框架
【复习】linux之LED驱动的设备树方式
王涵的博客
01-05 4380
【前言】感谢陆老师 linux中led驱动（设备树）编程笔记
平台总线驱动和设备树匹配
xurongxin2006的博客
11-21 1409
总线代表着同类设备需要共同遵循的工作时序，不同的总线对于物理电平的要求是不一样的，对于每个比特的电平维持宽度也是不一样的，总线上传递的命令也会有自己的格式约束。在Linux系统中总线可分为两种，1、一种是实际存在的总线（例如I2C、SPI、USB等总线）。2、另一种是虚拟存在的总线（platform总线）。1.linux设备驱动程序的演变1.1 硬件资源和驱动写在同一个文件里简单不易扩展,需重新编译,不同的引脚要写不同的驱动。1.2 总线设备驱动硬件资源用指定；
深入解析Linux Platform_device 及驱动
u010783226的专栏
02-21 1753
深入解析Linux Platform_device 及驱动 [导读] 前文分析了Linux设备驱动的驱动模型，本文来聊聊Platform_driver/Platform_device这个类。做嵌入式Linux的驱动，这个也是绕不开的，所以来学习分析总结一下。 上文阅读： 注：代码分析基于linux-5.4.31 为什么有Platform_driver 前文谈到的总线驱动模型（注这个图是照着bootlin的文档绘制的）： 同时，根据代码分析其基础数据结构框架关系如下（UML关系并不严谨，仅为理
【Linux】Linux驱动开发：platform总线驱动
W__winter的博客
05-06 2751
/定义在linux/module.h中使用时，参数如下：of：总线类型match_table：idtable数组首地址。
Linux Platform 平台设备驱动模型简介
JJ1116的博客
03-11 3048
内核版本：linux-3.10.61 1、Platform介绍 Platform 平台设备设备驱动模型的作用是将驱动的实现和资源分离，是一个虚拟的总线平台。这其中存在三个成员bus，device，drive。device需要在driver之前装载进内核，因为匹配工作在注册driver时实现。 Bus：由一个链表实现，不对应实际的物理总线。 Device：驱动的资源比如一些 I/O端口，中断号之类的。 Drive：驱动的功能实现比如 注册驱动，实现file_operations 等 2、主要结构体
Linux驱动-platform
Joyer_cc 的博客
04-01 528
platform实现设备和驱动分离，通过匹配方式建立连接 //在driver.c里 const struct platform_device_id beep_idtable = { .name = "beep_test", }; //在device.c里 // platform 设备结构体 struct platform_device beep_device = { .name = "beep_test", .id = -1, .resource = beep_res, .num_resou
平台总线式驱动开发——基本框架
m0_73492050的博客
01-07 979
硬件上同一总线上的设备遵循一致的时序通信，在其基础上增加管理设备和驱动的软件功能，于是引入总线（BUS），各种总线的核心框架有内核来实现，通信时序一般由SOC供应商支持；初期方案，各种device需要编码方式注册进内核中的设备管理结构中，为了进一步减少这样的编码，引入设备树。3.2 id匹配（可想象成八字匹配）：一个驱动可以对应多个设备 ------优先级次低。3.3 设备树匹配：内核启动时根据设备树自动产生的设备 ------ 优先级最高。总线：匹配设备和驱动——婚介所：提供沟通机制，完成拉郎配。
【Linux】内核驱动篇十--平台总线驱动开发
修成真的博客
05-25 1945
内核驱动篇十--平台总线驱动开发一、总线、设备、驱动1.1 初期解决思路：设备和驱动分离1.2 升级思路：根据设备树，在系统启动时自动产生每个节点对应的设备二、基本数据类型三、platform总线驱动3.1 核心数据类型之platform_device3.2 核心数据类型之platform_driver四、platform的三种匹配方式五、名称匹配之基础框架六、ID匹配之框架代码七、设备树匹配八、一个编写驱动用的宏 一、总线、设备、驱动 硬编码式的驱动开发带来的问题： 垃圾代码太多 结构不清晰 一些统.
Linux设备驱动模型4——基于平台总线的LED驱动实践
主要记录嵌入式学习与开发过程。
11-14 968
以下内容源于朱有鹏嵌入式课程的学习与整理，如有侵权请告知删除。
Linux设备驱动 | LED字符设备驱动(platform平台总线)
欲盖弥彰1314
03-25 2018
platform平台总线实现LED字符设备驱动 参考内核中存在的字符设备驱动进行编写，如misc.c这个经典的字符设备驱动。 LED字符设备驱动平台设备实现 1、查看手册获取相关寄存器 #define CCM_CCGR1 0x20C406C #define MUX_PAD_GPIO1_IO04 0x20E006C #define GPIO1_DR 0x209C000 #define GPIO1_GDIR 0
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值