20.1 platform 设备驱动

一、Linux 驱动的分离与分层

1. 驱动的分隔和分离

  现在有三个平台，A、B 和 C，这三个平台都有 MPU6050 设备。编写最简单的驱动框架如下图：

  每个平台下都有一个主机驱动和设备驱动，主机驱动是必要的，因为不同的平台 I2C 控制器不同。但设备驱动不建议这样。最好的方法是：每个平台的 IC2 控制器都提供一个统一的接口（主机驱动），每个设备只提供一个驱动程序（设备驱动）：

  因为不止这一个 MPU6050 这一个设备，所以实际的驱动框架如下：

  这就是驱动的分隔，将主机驱动和设备驱动分隔开。一般 I2C 的主机驱动已经由半导体厂商写好，设备驱动一般由设备厂家写好，我们只需要提供设备信息即可，比如 I2C 设备就提供设备连接到哪个 I2C 接口上，I2C 的速度是多少等等。 相当于将设备信息从设备驱动中剥离开来，驱动使用标准方法去获取到设备信息(比如从设备树中获取到设备信息)，然后根据获取到的设备信息来初始化设备。这相当于驱动只负责驱动，设备只负责设备。

  当我们需要向系统注册一个驱动的时候，总线就会在右侧的设备中去寻找，看有没有与之匹配的设备，如果有则关联起来。同样的，向系统注册一个设备的时候，总线会在左侧的驱动中查找看有没有与之匹配的设备，有的话也连接起来。

2. 驱动的分层

  驱动的分层的目的是为了在不同的层处理不同的内容。

  input 子系统负责管理所有跟输入有关的驱动，包括键盘、鼠标、触摸等等，最底层的就是设备原始驱动，负责获取输入设备的原始值，并把获取到的输入事件上报给 input 核心层。input 核心层会处理各种 IO 模型，并且提供 file_opeartions 操作集合。我们在编写输入设备驱动的时候只需要处理好输入事件的上报即可。

二、platform 平台驱动模型简介 

  驱动分离里有 总线（bus）、驱动（driver）和设备（device）模型。有些 SOC 外设没有总线，所有 Linux 提出了 platform 虚拟总线，相应就有 platform_bus、platform_driver 和 platform_device。

1. platform 总线

  Linux 系统内核使用 bus_type 结构体表示总线，bus_type 结构体内容如下：

struct bus_type {const char *name;const char *dev_name;struct device *dev_root;const struct attribute_group **bus_groups;const struct attribute_group **dev_groups;const struct attribute_group **drv_groups;int (*match)(struct device *dev, struct device_driver *drv);int (*uevent)(struct device *dev, struct kobj_uevent_env *env);int (*probe)(struct device *dev);int (*remove)(struct device *dev);void (*shutdown)(struct device *dev);int (*online)(struct device *dev);int (*offline)(struct device *dev);int (*suspend)(struct device *dev, pm_message_t state);int (*resume)(struct device *dev);int (*num_vf)(struct device *dev);int (*dma_configure)(struct device *dev);const struct dev_pm_ops *pm;const struct iommu_ops *iommu_ops;struct subsys_private *p;struct lock_class_key lock_key;bool need_parent_lock;
};

  其中，match 函数很重要，它是用来完成设备和驱动之间相互匹配。总线是使用 match 函数来根据注册的设备查找对应的的驱动，或者根据驱动查找对应的设备，所以每条总线都要用这个函数。

  match 函数有两个参数：dev 和 drv，两个参数分别为 device 和 device_driver 类型，也就是设备和驱动。

  设备和驱动如何匹配？来看一下 platform_match 函数：

static int platform_match(struct device *dev, struct device_driver *drv)
{struct platform_device *pdev = to_platform_device(dev);    // 将device结构体转化为platform_device结构体struct platform_driver *pdrv = to_platform_driver(drv);/* 当 driver_override 设置时，只与匹配的驱动程序绑定 */if (pdev->driver_override)return !strcmp(pdev->driver_override, drv->name);/* 首先尝试 OF 样式匹配，of_match_table有个成员变量compatible，里面存放驱动的匹配表设备树中的每个设备节点的 compatible 属性会和 of_match_table 表中的所有成员比较，如果有的话就表示设备和此驱动匹配*/if (of_driver_match_device(dev, drv))return 1;/* 然后尝试 ACPI 样式匹配 */if (acpi_driver_match_device(dev, drv))return 1;/* 尝试使用 id 表进行匹配，因为之前把device_driver转化为platform_driver结构体，它里面有个id_table的成员变量，变量里保存了很多的id信息，id信息存放着platformd驱动所支持的驱动类型*/if (pdrv->id_table)return platform_match_id(pdrv->id_table, pdev) != NULL;/* 回退到驱动程序名称匹配，第三种方式不行之间比较驱动和设备name字段，看是否匹配 */return (strcmp(pdev->name, drv->name) == 0);
}

2. platform 驱动

  platform_driver 结构体表示 platform 驱动，以下是 platform_driver 结构体内容：

struct platform_driver {int (*probe)(struct platform_device *);    // 当驱动与设备匹配成功后probe函数会执行，如果自己要编全新的驱动，probe需要自行实现int (*remove)(struct platform_device *);void (*shutdown)(struct platform_device *);int (*suspend)(struct platform_device *, pm_message_t state);int (*resume)(struct platform_device *);struct device_driver driver;    // driver是device_deriver的结构体变量，Linux内核大量使用面向对象的思想。// device_driver相当于基类，提供最基础的驱动框架，platform_driver继承这个基类，又在原有的基础上添加成员变量const struct platform_device_id *id_table;    // id_table类似于表，每个元素类型都是platform_device_idbool prevent_deferred_probe;
};

   在编写 platform 驱动的时候，首先得定义一个 platform_driver 结构体变量，虽然每个成员变量都要实现，但重点实现匹配方法和 probe 函数。当驱动和设备匹配成功后 probe 函数会自动执行，具体的驱动程序在 probe 函数中编写。

  当定义好 platform_driver 结构体变量后，需要在驱动入口处调用 platform_driver_register 函数向 Linux 内核注册 platform 驱动。

/** @description : 注册platform驱动* @param - handler : 信号的处理函数* @return : 负数，失败； 0，成功*/
int platform_driver_register (struct platform_driver *driver);

  platform 驱动框架如下：

struct xxx_dev{struct cdev cdev;/* 其他设备结构体成员 */
};struct xxx_dev xxxdev; /* 定义设备结构体变量 */static int xxx_open(struct inode *inode, struct file *filp)
{/* 打开设备时执行的具体操作 */return 0;
}static ssize_t xxx_write(struct file *filp, const char __user *buf,size_t cnt, loff_t *offt)
{/* 写操作时执行的具体操作 */return 0;
}/** 字符设备驱动操作集*/
static struct file_operations xxx_fops = {.owner = THIS_MODULE,.open = xxx_open,.write = xxx_write,
};/** platform 驱动的 probe 函数* 驱动与设备匹配成功后会执行这个函数* 之前驱动入口init函数里的字符驱动程序全部放在probe里面*/
static int xxx_probe(struct platform_device *dev)
{......cdev_init(&xxxdev.cdev, &xxx_fops); /* 注册字符设备驱动 *//* 具体的操作 */return 0;
}/** platform_driver里的remove成员变量* 关闭platform驱动的时候，此函数执行* 之前的exit函数里的字节程序全部放到此处来*/
static int xxx_remove(struct platform_device *dev)
{......cdev_del(&xxxdev.cdev); /* 删除 cdev *//* 具体的操作 */return 0;
}/* 匹配列表 如果使用了设备树将通过此匹配表来进行驱动和设备的匹配 */
static const struct of_device_id xxx_of_match[] = {{ .compatible = "xxx-gpio" },    // 当设备树中设备节点的 compatible 属性值为“xxx-gpio”的时候此设备就会与此驱动匹配{ /* Sentinel */ }    // 这行是一个标记， of_device_id 表最后一个匹配项必须是空的
};/** platform 平台驱动结构体* 提供有设备树和无设备树两种匹配方式*/
static struct platform_driver xxx_driver = {.driver = {.name = "xxx",        // 传统检查驱动和设备的name是否相投.of_match_table = xxx_of_match,    // 用于设备树下的驱动与设备检查},.probe = xxx_probe,.remove = xxx_remove,
};/* 驱动入口 */
static int __init xxxdriver_init(void)
{return platform_driver_register(&xxx_driver);    // 注册platform驱动
}/* 驱动出口 */
static void __exit xxxdriver_exit(void)
{platform_driver_unregister(&xxx_driver);    // 卸载platform驱动
}module_init(xxxdriver_init); /* 模块初始化 */
module_exit(xxxdriver_exit); /* 模块卸载 */MODULE_LICENSE("GPL"); /* 模块许可证 */
MODULE_AUTHOR("zuozhongkai"); /* 模块作者 */

  platform 驱动并不是独立于字符、块、网络设备驱动的其他种类的驱动，而是为了驱动的分离与分层提出来的一种框架。

  总之，platform还是基于传统的字符、块、网络驱动设备，只是套上了platform，目的是使用总线、驱动、设备来实现驱动的分层和分离。

3. platform 设备

  platform_device 结构体表示 platform 设备。注意，如果内核支持设备树就不要使用 platform_device 来描述设备，改用设备树去描述。以下是 platform_device 结构体内容：

struct platform_device {const char *name;        // 表示设备名字，在platform驱动中的name字段一样，否则无法匹配到正确的驱动int id;bool id_auto;struct device dev;u64 platform_dma_mask;u32 num_resources;    // 资源数量struct resource *resource;    // 资源，也是设备信息，比如外设寄存器等。const struct platform_device_id *id_entry;char *driver_override; /* 要强制匹配的驱动程序名称 *//* MFD单元格指针 */struct mfd_cell *mfd_cell;/* arch specific additions */struct pdev_archdata archdata;
};

  以下是 resource 结构体内容：

struct resource {resource_size_t start;    // 资源的起始信息resource_size_t end;      // 资源的终止信息const char *name;         // 资源名字unsigned long flags;      // 资源类型unsigned long desc;struct resource *parent, *sibling, *child;
};

  可选的资源类型都定义在 include/linux/ioport.h 里面：

#define IORESOURCE_BITS 0x000000ff /* Bus-specific bits */#define IORESOURCE_TYPE_BITS 0x00001f00 /* Resource type */
#define IORESOURCE_IO 0x00000100 /* 表示 IO 口的资源 */
#define IORESOURCE_MEM 0x00000200 /* 表示内存地址 */
#define IORESOURCE_REG 0x00000300 /* Register offsets */
#define IORESOURCE_IRQ 0x00000400 /* 中断号 */
#define IORESOURCE_DMA 0x00000800 /* DMA 通道号 */
#define IORESOURCE_BUS 0x00001000 /* 总线号 */
...#define IORESOURCE_PCI_FIXED (1<<4) /* Do not move resource */

  注册和销毁设备信息函数如下：

/** @description : 注册设备信息到Linux内核* @param - pdev : 要注册的 platform 设备* @return : 负数，失败； 0，成功*/
int platform_device_register(struct platform_device *pdev);/************************* 分割线 *************************/
/** @description : 注销设备信息* @param - pdev : 要注销的 platform 设备* @return : 负数，失败； 0，成功*/
void platform_device_unregister(struct platform_device *pdev);

  platfrom 设备信息框架如下：

/* 寄存器地址定义*/
#define PERIPH1_REGISTER_BASE (0X20000000) /* 外设 1 寄存器首地址 */
#define PERIPH2_REGISTER_BASE (0X020E0068) /* 外设 2 寄存器首地址 */
#define REGISTER_LENGTH 4/* 没有设备树的情况下 */
/* 资源 */
static struct resource xxx_resources[] = {    // 这里有两个资源，都是寄存器信息[0] = {.start = PERIPH1_REGISTER_BASE,.end = (PERIPH1_REGISTER_BASE + REGISTER_LENGTH - 1),.flags = IORESOURCE_MEM,    // 这里flag表示内存地址},[1] = {.start = PERIPH2_REGISTER_BASE,.end = (PERIPH2_REGISTER_BASE + REGISTER_LENGTH - 1),.flags = IORESOURCE_MEM,},
};/* platform设备结构体 */
static struct platform_device xxxdevice = {.name = "xxx-gpio",        // 这里的name字段必须和驱动中的name字段一样.id = -1,.num_resources = ARRAY_SIZE(xxx_resources),        // 资源大小，ARRAY_SIZE()测量一个数组的元素个数.resource = xxx_resources,  
};/* 设备模块加载 */
static int __init xxxdevice_init(void)
{return platform_device_register(&xxxdevice);    // 注册platform设备
}/* 设备模块注销 */
static void __exit xxxdevice_exit(void)
{platform_device_unregister(&xxxdevice);        // 注销platform设备
}module_init(xxxdevice_init);
module_exit(xxxdevice_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("zuozhongkai");

  上面这一段代码是不支持设备树的 Linux 版本使用，如果支持设备树后，就不需要用户手动注册 platform 设备，因为设备信息都放到了设备树中去描述，Linux 内核启动的时候就会去设备树中读取设备信息，将其变为 platform_device 形式。

三、程序编写

  在 /linux/atk-mpl/Drivers/ 文件夹下新建 17_platform，并且在里面创建 Vscode 工程，新建 leddevice.c和 leddriver.c 。

  在 leddevice.c 输入以下内容：

#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/gpio.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of_gpio.h>
#include <linux/semaphore.h>
#include <linux/timer.h>
#include <linux/irq.h>
#include <linux/wait.h>
#include <linux/poll.h>
#include <linux/fs.h>
#include <linux/fcntl.h>
#include <linux/platform_device.h>
#include <asm/mach/map.h>
#include <asm/uaccess.h>
#include <asm/io.h>/* 寄存器物理地址 */
#define PERIPH_BASE     		     	(0x40000000)
#define MPU_AHB4_PERIPH_BASE			(PERIPH_BASE + 0x10000000)
#define RCC_BASE        		    	(MPU_AHB4_PERIPH_BASE + 0x0000)	
#define RCC_MP_AHB4ENSETR				(RCC_BASE + 0XA28)
#define GPIOI_BASE						(MPU_AHB4_PERIPH_BASE + 0xA000)	
#define GPIOI_MODER      			    (GPIOI_BASE + 0x0000)	
#define GPIOI_OTYPER      			    (GPIOI_BASE + 0x0004)	
#define GPIOI_OSPEEDR      			    (GPIOI_BASE + 0x0008)	
#define GPIOI_PUPDR      			    (GPIOI_BASE + 0x000C)	
#define GPIOI_BSRR      			    (GPIOI_BASE + 0x0018)
#define REGISTER_LENGTH					4/* @description		: 释放flatform设备模块的时候此函数会执行	* @param - dev 	: 要释放的设备 * @return 			: 无*/
static void	led_release(struct device *dev)
{printk("led device released!\r\n");	
}/*  * 设备资源信息，也就是LED0所使用的所有寄存器*/
static struct resource led_resources[] = {[0] = {.start 	= RCC_MP_AHB4ENSETR,.end 	= (RCC_MP_AHB4ENSETR + REGISTER_LENGTH - 1),.flags 	= IORESOURCE_MEM,},	[1] = {.start	= GPIOI_MODER,.end	= (GPIOI_MODER + REGISTER_LENGTH - 1),.flags	= IORESOURCE_MEM,},[2] = {.start	= GPIOI_OTYPER,.end	= (GPIOI_OTYPER + REGISTER_LENGTH - 1),.flags	= IORESOURCE_MEM,},[3] = {.start	= GPIOI_OSPEEDR,.end	= (GPIOI_OSPEEDR + REGISTER_LENGTH - 1),.flags	= IORESOURCE_MEM,},[4] = {.start	= GPIOI_PUPDR,.end	= (GPIOI_PUPDR + REGISTER_LENGTH - 1),.flags	= IORESOURCE_MEM,},[5] = {.start	= GPIOI_BSRR,.end	= (GPIOI_BSRR + REGISTER_LENGTH - 1),.flags	= IORESOURCE_MEM,},
};/** platform设备结构体 */
static struct platform_device leddevice = {.name = "stm32mp1-led",		// 这里很重要，设备name和驱动name要相匹配.id = -1,.dev = {.release = &led_release,},.num_resources = ARRAY_SIZE(led_resources),.resource = led_resources,
};/** @description	: 设备模块加载 * @param 		: 无* @return 		: 无*/
static int __init leddevice_init(void)
{return platform_device_register(&leddevice);	// 注册设备
}/** @description	: 设备模块注销* @param 		: 无* @return 		: 无*/
static void __exit leddevice_exit(void)
{platform_device_unregister(&leddevice);			// 注销设备
}module_init(leddevice_init);
module_exit(leddevice_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("ALIENTEK");
MODULE_INFO(intree, "Y");

  编写 leddriver.c 文件： 

#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/gpio.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of_gpio.h>
#include <linux/semaphore.h>
#include <linux/timer.h>
#include <linux/irq.h>
#include <linux/wait.h>
#include <linux/poll.h>
#include <linux/fs.h>
#include <linux/fcntl.h>
#include <linux/platform_device.h>
#include <asm/mach/map.h>
#include <asm/uaccess.h>
#include <asm/io.h>#define LEDDEV_CNT		1			/* 设备号长度 	*/
#define LEDDEV_NAME		"platled"	/* 设备名字 	*/
#define LEDOFF 			0
#define LEDON 			1/* 映射后的寄存器虚拟地址指针 */	// 这里没有用gpio子系统
static void __iomem *MPU_AHB4_PERIPH_RCC_PI;
static void __iomem *GPIOI_MODER_PI;
static void __iomem *GPIOI_OTYPER_PI;
static void __iomem *GPIOI_OSPEEDR_PI;
static void __iomem *GPIOI_PUPDR_PI;
static void __iomem *GPIOI_BSRR_PI;/* leddev设备结构体 */
struct leddev_dev{dev_t devid;			/* 设备号	*/struct cdev cdev;		/* cdev		*/struct class *class;	/* 类 		*/struct device *device;	/* 设备		*/		
};struct leddev_dev leddev; 	/* led设备 *//** @description		: LED打开/关闭* @param - sta 	: LEDON(0) 打开LED，LEDOFF(1) 关闭LED* @return 			: 无*/
void led_switch(u8 sta)
{u32 val = 0;if(sta == LEDON) {val = readl(GPIOI_BSRR_PI);val |= (1 << 16);	writel(val, GPIOI_BSRR_PI);}else if(sta == LEDOFF) {val = readl(GPIOI_BSRR_PI);val|= (1 << 0);	writel(val, GPIOI_BSRR_PI);}	
}/** @description		: 取消映射* @return 			: 无*/
void led_unmap(void)
{/* 取消映射 */iounmap(MPU_AHB4_PERIPH_RCC_PI);iounmap(GPIOI_MODER_PI);iounmap(GPIOI_OTYPER_PI);iounmap(GPIOI_OSPEEDR_PI);iounmap(GPIOI_PUPDR_PI);iounmap(GPIOI_BSRR_PI);
}/** @description		: 打开设备* @param - inode 	: 传递给驱动的inode* @param - filp 	: 设备文件，file结构体有个叫做private_data的成员变量* 					  一般在open的时候将private_data指向设备结构体。* @return 			: 0 成功;其他 失败*/
static int led_open(struct inode *inode, struct file *filp)
{return 0;
}/** @description		: 向设备写数据 * @param - filp 	: 设备文件，表示打开的文件描述符* @param - buf 	: 要写给设备写入的数据* @param - cnt 	: 要写入的数据长度* @param - offt 	: 相对于文件首地址的偏移* @return 			: 写入的字节数，如果为负值，表示写入失败*/
static ssize_t led_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt)
{int retvalue;unsigned char databuf[1];unsigned char ledstat;retvalue = copy_from_user(databuf, buf, cnt);if(retvalue < 0) {printk("kernel write failed!\r\n");return -EFAULT;}ledstat = databuf[0];		/* 获取状态值 */if(ledstat == LEDON) {led_switch(LEDON);		/* 打开LED灯 */}else if(ledstat == LEDOFF) {led_switch(LEDOFF);	/* 关闭LED灯 */}return 0;
}/* 设备操作函数 */
static struct file_operations led_fops = {.owner = THIS_MODULE,.open = led_open,.write = led_write,
};/** @description		: flatform驱动的probe函数，当驱动与设备匹配以后此函数就会执行* @param - dev 	: platform设备* @return 			: 0，成功;其他负值,失败*/
static int led_probe(struct platform_device *dev)
{	int i = 0, ret;int ressize[6];u32 val = 0;struct resource *ledsource[6];printk("led driver and device has matched!\r\n");/* 1、获取资源 */for (i = 0; i < 6; i++) {ledsource[i] = platform_get_resource(dev, IORESOURCE_MEM, i); /* 依次MEM类型资源 */if (!ledsource[i]) {dev_err(&dev->dev, "No MEM resource for always on\n");return -ENXIO;}ressize[i] = resource_size(ledsource[i]);	}	/* 2、初始化LED *//* 寄存器地址映射 */MPU_AHB4_PERIPH_RCC_PI = ioremap(ledsource[0]->start, ressize[0]);GPIOI_MODER_PI = ioremap(ledsource[1]->start, ressize[1]);GPIOI_OTYPER_PI = ioremap(ledsource[2]->start, ressize[2]);GPIOI_OSPEEDR_PI = ioremap(ledsource[3]->start, ressize[3]);GPIOI_PUPDR_PI = ioremap(ledsource[4]->start, ressize[4]);GPIOI_BSRR_PI = ioremap(ledsource[5]->start, ressize[5]);/* 3、使能PI时钟 */val = readl(MPU_AHB4_PERIPH_RCC_PI);val &= ~(0X1 << 8); /* 清除以前的设置 */val |= (0X1 << 8);  /* 设置新值 */writel(val, MPU_AHB4_PERIPH_RCC_PI);/* 4、设置PI0通用的输出模式。*/val = readl(GPIOI_MODER_PI);val &= ~(0X3 << 0); /* bit0:1清零 */val |= (0X1 << 0);  /* bit0:1设置01 */writel(val, GPIOI_MODER_PI);/* 5、设置PI0为推挽模式。*/val = readl(GPIOI_OTYPER_PI);val &= ~(0X1 << 0); /* bit0清零，设置为上拉*/writel(val, GPIOI_OTYPER_PI);/* 6、设置PI0为高速。*/val = readl(GPIOI_OSPEEDR_PI);val &= ~(0X3 << 0); /* bit0:1 清零 */val |= (0x2 << 0); /* bit0:1 设置为10*/writel(val, GPIOI_OSPEEDR_PI);/* 7、设置PI0为上拉。*/val = readl(GPIOI_PUPDR_PI);val &= ~(0X3 << 0); /* bit0:1 清零*/val |= (0x1 << 0); /*bit0:1 设置为01*/writel(val,GPIOI_PUPDR_PI);/* 8、默认关闭LED */val = readl(GPIOI_BSRR_PI);val |= (0x1 << 0);writel(val, GPIOI_BSRR_PI);/* 注册字符设备驱动 *//* 1、申请设备号 */ret = alloc_chrdev_region(&leddev.devid, 0, LEDDEV_CNT, LEDDEV_NAME);	if(ret < 0)goto fail_map;/* 2、初始化cdev */leddev.cdev.owner = THIS_MODULE;cdev_init(&leddev.cdev, &led_fops);/* 3、添加一个cdev */ret = cdev_add(&leddev.cdev, leddev.devid, LEDDEV_CNT);if(ret < 0)goto del_unregister;/* 4、创建类 */leddev.class = class_create(THIS_MODULE, LEDDEV_NAME);if (IS_ERR(leddev.class)) {goto del_cdev;}/* 5、创建设备 */leddev.device = device_create(leddev.class, NULL, leddev.devid, NULL, LEDDEV_NAME);if (IS_ERR(leddev.device)) {goto destroy_class;}return 0;destroy_class:class_destroy(leddev.class);
del_cdev:cdev_del(&leddev.cdev);
del_unregister:unregister_chrdev_region(leddev.devid, LEDDEV_CNT);
fail_map:led_unmap();return -EIO;
}/** @description		: platform驱动的remove函数，移除platform驱动的时候此函数会执行* @param - dev 	: platform设备* @return 			: 0，成功;其他负值,失败*/
static int led_remove(struct platform_device *dev)
{led_unmap();	/* 取消映射 */cdev_del(&leddev.cdev);/*  删除cdev */unregister_chrdev_region(leddev.devid, LEDDEV_CNT); /* 注销设备号 */device_destroy(leddev.class, leddev.devid);	/* 注销设备 */class_destroy(leddev.class);	/* 注销类 */return 0;
}/* 由于没有设备树，所以匹配列表是不用的 *//* platform驱动结构体 */
static struct platform_driver led_driver = {.driver		= {.name	= "stm32mp1-led",			/* 驱动名字，用于和设备匹配 *///.of_match_table = xxx_of_match	// 这里也是用于设备树下的驱动和设备检查},.probe		= led_probe,.remove		= led_remove,
};/** @description	: 驱动模块加载函数* @param 		: 无* @return 		: 无*/
static int __init leddriver_init(void)
{return platform_driver_register(&led_driver);
}/** @description	: 驱动模块卸载函数* @param 		: 无* @return 		: 无*/
static void __exit leddriver_exit(void)
{platform_driver_unregister(&led_driver);
}module_init(leddriver_init);
module_exit(leddriver_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("ALIENTEK");
MODULE_INFO(intree, "Y");

  新建 ledplatformApp.c 并输入以下内容：

#include "stdio.h"
#include "unistd.h"
#include "sys/types.h"
#include "sys/stat.h"
#include "fcntl.h"
#include "stdlib.h"
#include "string.h"#define LEDOFF 	0
#define LEDON 	1/** @description		: main主程序* @param - argc 	: argv数组元素个数* @param - argv 	: 具体参数* @return 			: 0 成功;其他 失败*/
int main(int argc, char *argv[])
{int fd, retvalue;char *filename;unsigned char databuf[1];if(argc != 3){printf("Error Usage!\r\n");return -1;}filename = argv[1];/* 打开led驱动 */fd = open(filename, O_RDWR);if(fd < 0){printf("file %s open failed!\r\n", argv[1]);return -1;}databuf[0] = atoi(argv[2]);	/* 要执行的操作：打开或关闭 */retvalue = write(fd, databuf, sizeof(databuf));if(retvalue < 0){printf("LED Control Failed!\r\n");close(fd);return -1;}retvalue = close(fd); /* 关闭文件 */if(retvalue < 0){printf("file %s close failed!\r\n", argv[1]);return -1;}return 0;
}

四、运行测试

  编写 Makefile文件：

KERNELDIR := /home/alientek/linux/atk-mpl/linux/my_linux/linux-5.4.31
CURRENT_PATH := $(shell pwd)obj-m := leddevice.o
obj-m += leddriver.obuild: kernel_moduleskernel_modules:$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) modulesclean:$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean

  编译 leddevice.c 、leddriver.c 和 ledpaltformApp.c 文件：

make
arm-none-linux-gnueabihf-gcc ledplatformApp.c -o ledplatformApp

  将编译好的 leddevice.ko、leddriver.ko 和 ledplatformApp 复制：

sudo cp ledplatformApp leddevice.ko leddriver.ko /home/alientek/linux/nfs/rootfs/lib/modules/5.4.31/ -f

  开启开发板，输入以下命令：

cd lib/modules/5.4.31/
depmod
modprobe leddevice.ko    # 加载设备模块
modprobe leddriver.ko    # 加载驱动模块

   之后会看到这样的消息：

  led 驱动和设备驱动匹配成功。

  在 /sys/bus/platform/driver 目录下可以看到 stm32mp1-led 驱动文件：

  在 /sys/bus/platform/device 目录下可以看到 stm32mp1-led 设备文件：

   测试 LED 驱动：

./ledplatformApp /dev/platled 1        # 点亮
./ledplatformApp /dev/platled 0        # 熄灭

   卸载驱动：

rmmod leddevice.ko
rmmod leddriver.ko

总结

  这章起始不必太过关注没有设备树部分，关注为什么要有 platform 平台，因为需要把设备和驱动分开，一种更好的框架。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.rhkb.cn/news/191037.html

如若内容造成侵权/违法违规/事实不符，请联系长河编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

设计模式JAVA

设计模式JAVA

1 创建型 如何合理的创建对象&#xff1f; 1.1 单例模式 字面意思就是只能创建一个对象实例时使用。 例如&#xff0c;Windows中只能打开一个任务管理器&#xff0c;这样可以避免因打开多个任务管理器窗口而造成内存资源的浪费&#xff0c;或出现各个窗口显示内容的不一致等…
阅读更多...
软件开发流程

软件开发流程

目录 1 软件开发流程 第1阶段&#xff1a;需求分析 第2阶段&#xff1a;设计 第3阶段&#xff1a;编码 第4阶段&#xff1a;测试 第5阶段&#xff1a;上线运维 2 角色分工 3 软件环境 1). 开发环境(development) 2). 测试环境(testing) 3). 生产环境(production) &a…
阅读更多...
ctfshow sql171-179

ctfshow sql171-179

mysql 先打开我们本地的mysql&#xff0c;可以看到这些数据库 information_schema information_schema 库: 是信息数据库&#xff0c;其中保存着关于MySQL服务器所维护的所有其他数据库的信息比如数据库名&#xff0c;数据库表&#xff0c; SCHEMATA表: 提供了当前MySQL实例…
阅读更多...
web前端开发第3次Dreamweave课堂练习/html练习代码《网页设计语言基础练习案例》

web前端开发第3次Dreamweave课堂练习/html练习代码《网页设计语言基础练习案例》

目标图片&#xff1a; 文字素材&#xff1a; 网页设计语言基础练习案例 ——几个从语义上和文字相关的标签 * h标签&#xff08;h1~h6&#xff09;&#xff1a;用来定义网页的标题&#xff0c;成对出现。 * p标签&#xff1a;用来设置网页的段落&#xff0c;成对出现。 * b…
阅读更多...
【数据仓库】数仓分层方法

【数据仓库】数仓分层方法

文章目录 一. 数仓分层的意义1. 清晰数据结构。2. 减少重复开发3. 方便数据血缘追踪4. 把复杂问题简单化5. 屏蔽原始数据的异常6. 数据仓库的可维护性 二. 如何进行数仓分层&#xff1f;1. ODS层2. DW层2.1. DW层分类2.2. DWD层2.3. DWS 3. ADS层 4、层次调用规范 一. 数仓分层…
阅读更多...
Ubuntu中安装R语言环境并在jupyter kernel里面增加R kernel

Ubuntu中安装R语言环境并在jupyter kernel里面增加R kernel

❤️觉得内容不错的话&#xff0c;欢迎点赞收藏加关注&#x1f60a;&#x1f60a;&#x1f60a;&#xff0c;后续会继续输入更多优质内容❤️ &#x1f449;有问题欢迎大家加关注私戳或者评论&#xff08;包括但不限于NLP算法相关&#xff0c;linux学习相关&#xff0c;读研读博…
阅读更多...
程序运行前后内存分区存储

程序运行前后内存分区存储

程序运行前是源码 在程序运行后&#xff0c;生成了exe可执行程序 分为代码区和全局区 代码区&#xff1a; 存放CPU执行的机器指令代码区是共享的&#xff0c;共享的目的是对于频繁被执行的程序&#xff0c;只需要在内存中有一份代码就可以了代码区是只读的&#xff0c;其只读…
阅读更多...
Redis解决缓存问题

Redis解决缓存问题

目录 一、引言二、缓存三、Redis缓存四、缓存一致性1.缓存更新策略2.主动更新 五、缓存穿透六、缓存雪崩七、缓存击穿1.基于互斥锁解决具体业务2.基于逻辑过期解决具体业务 一、引言 在一些大型的网站中会有十分庞大的用户访问流量&#xff0c;而过多的用户访问对我们的MySQL数…
阅读更多...
基于SpringBoot+Redis的前后端分离外卖项目-苍穹外卖(四)

基于SpringBoot+Redis的前后端分离外卖项目-苍穹外卖(四)

编辑员工和分类模块功能开发 1. 编辑员工1.1 需求分析与设计1.1.1 产品原型1.1.2 接口设计 1.2 代码开发1.2.1 回显员工信息功能1.2.2 修改员工信息功能 1.3 功能测试 2. 分类模块功能开发2.1 需求分析与设计2.1.1 产品原型2.1.2 接口设计2.1.3 表设计 2.2 代码实现2.2.1 Mappe…
阅读更多...
windows服务器热备、负载均衡配置

windows服务器热备、负载均衡配置

安装网络负载平衡 需要加入的服务器上全部需要安装网络负载平衡管理器 图形化安装&#xff1a;使用服务器管理器安装 在服务器管理器中&#xff0c;使用“添加角色和功能”向导添加网络负载均衡功能。 完成向导后&#xff0c;将安装 NLB&#xff0c;并且不需要重启计算机。 …
阅读更多...
做一个Sprngboot文件上传-阿里云

做一个Sprngboot文件上传-阿里云

概述 这个模块是用来上传头像以及文章封面的&#xff0c;图片的值是一个地址字符串&#xff0c;一般存放在本地或阿里云服务中 1、本地文件上传 我们将文件保存在一个本地的文件夹下&#xff0c;由于可能两个人上传不同图片但是却同名的图片&#xff0c;那么就会一个人的图片就…
阅读更多...
【c++】——类和对象(中)——实现完整的日期类

【c++】——类和对象(中)——实现完整的日期类

作者:chlorine 专栏:c专栏 我的花一定会开。 【学习目标】 拷贝复制——赋值运算符重载 目录 &#x1f393;运算符重载(-><...) &#x1f393;日期&天数 &#x1f393;前置和后置重载 我们完成了赋值运算符重载章节的学习&#xff0c;对operator关键字的使用有…
阅读更多...
如何使用`open-uri`模块

如何使用`open-uri`模块

首先&#xff0c;我们需要使用open-uri模块来打开网页&#xff0c;并使用Nokogiri模块来解析网页内容。然后&#xff0c;我们可以使用Nokogiri的css方法来选择我们想要的元素&#xff0c;例如标题&#xff0c;作者&#xff0c;内容等。最后&#xff0c;我们可以使用open-uri模块…
阅读更多...
线圈寿命预测 数据集讲解

线圈寿命预测 数据集讲解

来自-郭师兄 1.这个是线圈数据的阻抗、电抗等数据&#xff0c;我想根据这个个数据进行线圈寿命预测也就是RUL预测&#xff0c;请问有什么思路吗。 最简单的思路&#xff1a; 数据通过某种方法进行压缩表征到一维再通过 同时需要标签。 确定一个特征 使用降维方法如同PCA来构…
阅读更多...
互联网Java工程师面试题·微服务篇·第二弹

互联网Java工程师面试题·微服务篇·第二弹

目录 18、什么是 Spring 引导的执行器&#xff1f; 19、什么是 Spring Cloud&#xff1f; 20、Spring Cloud 解决了哪些问题&#xff1f; 21、在 Spring MVC 应用程序中使用 WebMvcTest 注释有什么用处&#xff1f; 22、你能否给出关于休息和微服务的要点&#xff1f; 23、…
阅读更多...
Vue.js中的状态管理：理解和使用Vuex

Vue.js中的状态管理：理解和使用Vuex

目录 前言 Vue.js 样式绑定 Vue.js class class 属性绑定 实例 1 实例 2 实例 3 实例 4 数组语法 实例 5 实例 6 Vue.js style(内联样式) 实例 7 实例 8 实例 9 Vue.js 组件 全局组件 全局组件实例 局部组件 局部组件实例 Prop Prop 实例 动态 Prop Pro…
阅读更多...
Makefile应用

Makefile应用

Makefile实例 在c.c里面&#xff0c;包含一个头文件c.h&#xff0c;在c.h里面定义一个宏&#xff0c;把这个宏打印出来。 c.c&#xff1a; #include <stdio.h> #include <c.h>void func_c() {printf("This is C %d\n", C); }c.h #define C 1然后上传…
阅读更多...
ubuntu开机系统出错且无法恢复。请联系系统管理员。

ubuntu开机系统出错且无法恢复。请联系系统管理员。

背景&#xff1a; ubuntu22.04.2命令行&#xff0c;执行自动安装系统推荐显卡驱动命令&#xff0c;字体变大&#xff0c;重启后出现如下图错误&#xff0c;无法进入系统&#xff0c;无法通过CTRLALTF1-F3进入TTY模式。 解决办法&#xff1a; 1.首先要想办法进入系统&#xff…
阅读更多...
Python 日志记录器logging 百科全书 之 日志回滚

Python 日志记录器logging 百科全书 之 日志回滚

Python 日志记录器logging 百科全书 之 日志回滚 前言 在之前的文章中&#xff0c;我们学习了关于Python日志记录的基础配置。 本文将深入探讨Python中的日志回滚机制&#xff0c;这是一种高效管理日志文件的方法&#xff0c;特别适用于长时间运行或高流量的应用。 知识点&…
阅读更多...
飞天使-django创建一个初始项目过程

飞天使-django创建一个初始项目过程

创建django项目 运行项目 运行命令 pyhont manage.py runserver 然后访问 http://127.0.0.1:8000/&#xff0c; 则可以打开本地新建的项目 虚拟环境的部署-mac 在一台计算机上可以通过虚拟环境实现多个版本Django的开发环境 安装虚拟环境工具&#xff1a;如果你的系统中没有安…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023