一、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_id
    bool 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.o

build: kernel_modules

kernel_modules:
	$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) modules

clean:
	$(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 平台，因为需要把设备和驱动分开，一种更好的框架。