Linux，arm驱动框架套路合集（学习笔记）

已于 2024-04-12 21:08:51 修改
阅读量202 收藏 2
点赞数 1
文章标签： linux 学习 驱动开发 嵌入式硬件 单片机 c语言 笔记
于 2023-08-16 21:58:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51226647/article/details/132328722
版权

设备树相关函数，来自博客园作者明明1109的文章

GPIO

套路1：

特点：

  1. 哪都能用

  2. 退出驱动的时候需要手动释放资源

框架：

/* 1、利用设备树路径获取设备节点 */
/*
 * @description     : 获取设备节点
 * @param - path 	: 要操作的i2c
 * @return          : 节点; 负值/NULL,失败
 */
static inline struct device_node *of_find_node_by_path(const char *path)
{
	return of_find_node_opts_by_path(path, NULL);
}

/* 2、利用设备节点获取节点对应的gpio */
/*
 * @description     : 获取gpio号
 * @param - np     	: 设备节点
 * @param - propname: 给gpio命名，随意填
 * @param - index 	: gpio索引，不和其他io重复即可
 * @return          : gpio号; 负值,失败
 */
static inline int of_get_named_gpio(struct device_node *np,
                                   const char *propname, int index)
{
	return of_get_named_gpio_flags(np, propname, index, NULL);
}

/* 3、利用gpio符号向系统申请IO */
/*
 * @description     : 申请使用gpio
 * @param - gpio    : gpio号
 * @param - label   : 上一步的gpio的命名
 * @return          : 负值,失败
 */
static inline int gpio_request(unsigned gpio, const char *label)
{
	return -ENOSYS;
}

/* 4、设置：输出，高/低 */
/*
 * @description     : 设置gpio为输出，设置有效电平
 * @param - gpio    : gpio号
 * @param - value   : 1/0,对应高/低电平有效
 * @return          : 负值,失败
 */
static inline int gpio_direction_output(unsigned gpio, int value)
{
	return -ENOSYS;
}

/* 5、使用gpio */
/*
 * @description     : 设置gpio为输出，设置有效电平
 * @param - gpio    : gpio号
 * @param - value   : 让gpio输出1/0
 * @return          : 负值,失败
 */
static inline void gpio_set_value(unsigned gpio, int value)
{
	/* GPIO can never have been requested or set as output */
	WARN_ON(1);
}

示例：

    /* 获取设备节点 */
    gpioled.nd = of_find_node_by_path("/gpioled");
    if(gpioled.nd == NULL){
        ret = -EINVAL;
        goto faile_findnd;
    }

    /* 获取节点对应的gpio */
    gpioled.led_gpio = of_get_named_gpio(gpioled.nd, "led-gpios", 0);
    if(gpioled.led_gpio < 0){
        printk("cannot find led-gpios\r\n");
        ret = -EINVAL;
        goto faile_findnd;
    }
    printk("led gpio num = %d\r\n", gpioled.led_gpio);

    /* 申请IO */
    ret = gpio_request(gpioled.led_gpio, "led-gpios");
    if(ret < 0){
        printk("failed to request led-gpios\r\n");
        ret = -EINVAL;
        goto faile_findnd;
    }

    /* 使用IO，设置为输出 */
    ret = gpio_direction_output(gpioled.led_gpio, 1);
    if(ret){
        goto faile_setoutput;
    }

    /* 输出低电平，点亮LED */
    gpio_set_value(gpioled.led_gpio, 0);

return 0;
faile_setoutput:
    gpio_free(gpioled.led_gpio);
faile_findnd:
    device_destroy(gpioled.class, gpioled.devid);
return ret;

套路2：

特点：

  1. 需要用在IIC框架内，因为涉及到结构体i2c_client。

  2. devm开头的函数，在remove的时候由系统自动释放申请过的资源，不需要手动释放。

框架：

/* 1、根据设备树节点、设备树中gpio变量名，来申请gpio */
/*
 * @description     : 根据设备树节点、设备树中命名，来申请gpio
 * @param - np     	: 设备树节点
 * @param - propname: 设备树中gpio变量名
 * @param - index 	: gpio索引，不和其他io重复即可
 * @return          : gpio号; 负值,失败
 */
static inline int of_get_named_gpio(struct device_node *np,
                                   const char *propname, int index)
{
	return of_get_named_gpio_flags(np, propname, index, NULL);
}

/* 2、判断gpio是否有效 */
/*
 * @description     : 判断gpio是否有效
 * @param - number  : gpio号
 * @return          : 返回值为真则有效
 */
static inline bool gpio_is_valid(int number)
{
	return false;
}

/* 3、申请gpio，并且初始化设置 */
/*
 * @description     : 获取gpio号
 * @param - dev     : 设备结构体
 * @param - gpio    : gpio号
 * @param - flags   : 用#include<linux/gpio.h>中的宏定义，
                      例如：GPIOF_OUT_INIT_LOW，设置为输出，且初始化为低电平
 * @param - label   : 给gpio命名
 * @return          : 返回0.成功; 其它,失败
 */
static inline int devm_gpio_request_one(struct device *dev, unsigned gpio,
					unsigned long flags, const char *label)
{
	WARN_ON(1);
	return -EINVAL;
}

示例：

    struct gt911_dev {
	int irq_pin,reset_pin;					/* 中断和复位IO		*/
	int irqnum;								/* 中断号    		*/
	int irqtype;							/* 中断类型         */
	int max_x;								/* 最大横坐标   	*/
	int max_y; 								/* 最大纵坐标		*/
	void *private_data;						/* 私有数据 		*/
	struct input_dev *input;				/* input结构体 		*/
	struct i2c_client *client;				/* I2C客户端 		*/

};
struct gt911_dev gt911;

static irqreturn_t gt911_irq_handler(int irq, void *dev_id)
{
	return IRQ_HANDLED;
}
/*
 * @description     : gt911中断初始化
 * @param - client 	: 要操作的i2c
 * @param - multidev: 自定义的multitouch设备
 * @return          : 0，成功;其他负值,失败
 */
static int gt911_init_irq(struct i2c_client *client, struct gt911_dev *dev)
{
	int ret = 0;
	printk("gt911_ts_irq进\r\n");
	/* 2，申请中断,client->irq就是IO中断， */
	ret = devm_request_threaded_irq(&client->dev, client->irq, NULL,
					gt911_irq_handler, IRQ_TYPE_EDGE_RISING | IRQF_ONESHOT,
					client->name, &gt911);
	if (ret) {
		dev_err(&client->dev, "Unable to request touchscreen IRQ.\n");
		return ret;
	}
	printk("gt911_ts_irq出\r\n");
	return 0;
}
/*
  * @description     : i2c驱动的probe函数，当驱动与
  *                    设备匹配以后此函数就会执行
  * @param - client  : i2c设备
  * @param - id      : i2c设备ID
  * @return          : 0，成功;其他负值,失败
  */
int gt911_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
    gt911.client = client;
 	/* 1，获取设备树中的中断和复位引脚 */
	gt911.irq_pin = of_get_named_gpio(client->dev.of_node, "interrupt-gpios", 0);
	gt911.reset_pin = of_get_named_gpio(client->dev.of_node, "reset-gpios", 0);
    gt911_init_irq(client, &gt911);
    return 0;
}

/*
 * @description     : i2c驱动的remove函数，移除i2c驱动的时候此函数会执行
 * @param - client 	: i2c设备
 * @return          : 0，成功;其他负值,失败
 */
int gt911_remove(struct i2c_client *client)
{
    
    return 0;
}

/*
 *  传统驱动匹配表
 */ 
const struct i2c_device_id gt911_id_table[] = {
	{ "goodix,gt-911", 0, },
    { /* sentinel */ }
};

/*
 * 设备树匹配表 
 */
const struct of_device_id gt911_of_match_table[] = {
    {.compatible = "goodix,gt-911" },
    { /* sentinel */ }
};

/* i2c驱动结构体 */	
struct i2c_driver gt911_i2c_driver = {
    .driver = {
        .name  = "gt911",
        .owner = THIS_MODULE,
        .of_match_table = gt911_of_match_table,
    },
    .id_table = gt911_id_table,
    .probe  = gt911_probe,
    .remove = gt911_remove,
};

/*
 * @description	: 驱动入口函数
 * @param 		: 无
 * @return 		: 无
 */
static int __init  gt911_init(void)
{
	int ret = 0;

	ret = i2c_add_driver(&gt911_i2c_driver);
	return ret;
}

/*
 * @description	: 驱动出口函数
 * @param 		: 无
 * @return 		: 无
 */
static void __exit  gt911_exit(void)
{
	i2c_del_driver(&gt911_i2c_driver);
}

module_init(gt911_init);
module_exit(gt911_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("cwb");

IIC

套路1：

函数&结构体介绍：

struct i2c_client是使用函数i2c_add_driver注册i2c的时候由系统初始化的。

struct i2c_client提供了：

  1. 引脚中断号存在struct i2c_client->int irq，用于申请中断

  2. 设备树节点存在struct i2c_client->struct device->struct device_node

/*
 * @description	:  用于在I2C总线上进行数据传输
 * @param - adap:  该参数填struct i2c_client的成员
                   struct i2c_adapter *adapter，在I2C注册时由系统生成
 * @param - msgs:  存放传输数据的数组首地址
 * @param - num :  msgs的数组长度
 * @return 		:  非负，成功
 */
int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
{
	int ret;
}
//--------------------------------------------------------------------------
struct i2c_client {
	unsigned short flags;		/* div., see below		*/
	unsigned short addr;		/* chip address - NOTE: 7bit	*/
					/* addresses are stored in the	*/
					/* _LOWER_ 7 bits		*/
	char name[I2C_NAME_SIZE];
	struct i2c_adapter *adapter;	/* the adapter we sit on	*/
	struct device dev;		/* the device structure		*/
	int irq;			/* irq issued by device		*/
	struct list_head detected;
#if IS_ENABLED(CONFIG_I2C_SLAVE)
	i2c_slave_cb_t slave_cb;	/* callback for slave mode	*/
#endif
};
//--------------------------------------------------------------------------
struct device {
	struct device		*parent;

	struct device_private	*p;

	struct kobject kobj;
	const char		*init_name; /* initial name of the device */
	const struct device_type *type;

	struct mutex		mutex;	/* mutex to synchronize calls to
					 * its driver.
					 */

	struct bus_type	*bus;		/* type of bus device is on */
	struct device_driver *driver;	/* which driver has allocated this
					   device */
	void		*platform_data;	/* Platform specific data, device
					   core doesn't touch it */
	void		*driver_data;	/* Driver data, set and get with
					   dev_set/get_drvdata */
	struct dev_pm_info	power;
	struct dev_pm_domain	*pm_domain;

#ifdef CONFIG_PINCTRL
	struct dev_pin_info	*pins;
#endif

#ifdef CONFIG_NUMA
	int		numa_node;	/* NUMA node this device is close to */
#endif
	u64		*dma_mask;	/* dma mask (if dma'able device) */
	u64		coherent_dma_mask;/* Like dma_mask, but for
					     alloc_coherent mappings as
					     not all hardware supports
					     64 bit addresses for consistent
					     allocations such descriptors. */
	unsigned long	dma_pfn_offset;

	struct device_dma_parameters *dma_parms;

	struct list_head	dma_pools;	/* dma pools (if dma'ble) */

	struct dma_coherent_mem	*dma_mem; /* internal for coherent mem
					     override */
#ifdef CONFIG_DMA_CMA
	struct cma *cma_area;		/* contiguous memory area for dma
					   allocations */
#endif
	/* arch specific additions */
	struct dev_archdata	archdata;

	struct device_node	*of_node; /* associated device tree node */
	struct fwnode_handle	*fwnode; /* firmware device node */

	dev_t			devt;	/* dev_t, creates the sysfs "dev" */
	u32			id;	/* device instance */

	spinlock_t		devres_lock;
	struct list_head	devres_head;

	struct klist_node	knode_class;
	struct class		*class;
	const struct attribute_group **groups;	/* optional groups */

	void	(*release)(struct device *dev);
	struct iommu_group	*iommu_group;

	bool			offline_disabled:1;
	bool			offline:1;
};

框架&示例：

#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/i2c.h>
#include <asm/mach/map.h>
#include <asm/uaccess.h>
#include <asm/io.h>
#include "ap3216creg.h"

#define AP3216C_CNT	1
#define AP3216C_NAME	"ap3216c"

struct ap3216c_dev {
	dev_t devid;			/* 设备号 	 */
	struct cdev cdev;		/* cdev 	*/
	struct class *class;	/* 类 		*/
	struct device *device;	/* 设备 	 */
	struct device_node	*nd; /* 设备节点 */
	int major;			/* 主设备号 */
	void *private_data;	/* 私有数据 */
	unsigned short ir, als, ps;		/* 三个光传感器数据 */
};

static struct ap3216c_dev ap3216cdev;

/*
 * @description	: 从ap3216c读取多个寄存器数据
 * @param - dev:  ap3216c设备
 * @param - reg:  要读取的寄存器首地址
 * @param - val:  读取到的数据
 * @param - len:  要读取的数据长度
 * @return 		: 操作结果
 */
static int ap3216c_read_regs(struct ap3216c_dev *dev, u8 reg, void *val, int len)
{
	int ret;
	struct i2c_msg msg[2];
	struct i2c_client *client = (struct i2c_client *)dev->private_data;

	/* msg[0]为发送要读取的首地址 */
	msg[0].addr = client->addr;			/* ap3216c地址 */
	msg[0].flags = 0;					/* 标记为发送数据 */
	msg[0].buf = &reg;					/* 读取的首地址 */
	msg[0].len = 1;						/* reg长度*/

	/* msg[1]读取数据 */
	msg[1].addr = client->addr;			/* ap3216c地址 */
	msg[1].flags = I2C_M_RD;			/* 标记为读取数据*/
	msg[1].buf = val;					/* 读取数据缓冲区 */
	msg[1].len = len;					/* 要读取的数据长度*/

	ret = i2c_transfer(client->adapter, msg, 2);
	if(ret == 2) {
		ret = 0;
	} else {
		printk("i2c rd failed=%d reg=%06x len=%d\n",ret, reg, len);
		ret = -EREMOTEIO;
	}
	return ret;
}

/*
 * @description	: 向ap3216c多个寄存器写入数据
 * @param - dev:  ap3216c设备
 * @param - reg:  要写入的寄存器首地址
 * @param - val:  要写入的数据缓冲区
 * @param - len:  要写入的数据长度
 * @return 	  :   操作结果
 */
static s32 ap3216c_write_regs(struct ap3216c_dev *dev, u8 reg, u8 *buf, u8 len)
{
	u8 b[256];
	struct i2c_msg msg;
	struct i2c_client *client = (struct i2c_client *)dev->private_data;
	
	b[0] = reg;					/* 寄存器首地址 */
	memcpy(&b[1],buf,len);		/* 将要写入的数据拷贝到数组b里面 */
		
	msg.addr = client->addr;	/* ap3216c地址 */
	msg.flags = 0;				/* 标记为写数据 */

	msg.buf = b;				/* 要写入的数据缓冲区 */
	msg.len = len + 1;			/* 要写入的数据长度 */

	return i2c_transfer(client->adapter, &msg, 1);
}

 /*
  * @description     : i2c驱动的probe函数，当驱动与
  *                    设备匹配以后此函数就会执行
  * @param - client  : i2c设备
  * @param - id      : i2c设备ID
  * @return          : 0，成功;其他负值,失败
  */
static int ap3216c_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
	ap3216cdev.private_data = client;

	return 0;
}

/*
 * @description     : i2c驱动的remove函数，移除i2c驱动的时候此函数会执行
 * @param - client 	: i2c设备
 * @return          : 0，成功;其他负值,失败
 */
static int ap3216c_remove(struct i2c_client *client)
{
	return 0;
}

/* 传统匹配方式ID列表 */
static const struct i2c_device_id ap3216c_id[] = {
	{"alientek,ap3216c", 0},  
	{}
};

/* 设备树匹配列表 */
static const struct of_device_id ap3216c_of_match[] = {
	{ .compatible = "alientek,ap3216c" },
	{ /* Sentinel */ }
};

/* i2c驱动结构体 */	
static struct i2c_driver ap3216c_driver = {
	.probe = ap3216c_probe,
	.remove = ap3216c_remove,
	.driver = {
			.owner = THIS_MODULE,
		   	.name = "ap3216c",
		   	.of_match_table = ap3216c_of_match, 
		   },
	.id_table = ap3216c_id,
};
		   
/*
 * @description	: 驱动入口函数
 * @param 		: 无
 * @return 		: 无
 */
static int __init ap3216c_init(void)
{
	int ret = 0;

	ret = i2c_add_driver(&ap3216c_driver);
	return ret;
}

/*
 * @description	: 驱动出口函数
 * @param 		: 无
 * @return 		: 无
 */
static void __exit ap3216c_exit(void)
{
	i2c_del_driver(&ap3216c_driver);
}

/* module_i2c_driver(ap3216c_driver) */

module_init(ap3216c_init);
module_exit(ap3216c_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("zuozhongkai");

platform

简介：Platform虚拟总线是一种基于Linux内核的设备模型，它可以将系统中的各种硬件设备抽象出来，并以相同的方式进行管理。其基本原理是，在Linux内核中创建一个虚拟总线，系统中的各种硬件设备通过驱动程序和总线控制器与虚拟总线进行通信，然后由虚拟总线进行管理和调度。

Platform虚拟总线包括两个主要的子系统：Platform设备和Platform驱动程序。

平台设备是一种抽象的硬件设备，可以是任何类型的硬件设备，如CPU、内存、UART、GPIO等。平台设备包括设备名、设备ID、设备资源和设备驱动程序等信息。平台设备的注册和解除注册由驱动程序完成。

套路1

特点

  • 和字符设备驱动框架极其相似，只不过多套了一层probe

函数&结构体介绍:

platform_device 在platform_driver_register注册时，由系统完成初始化

extern struct resource *platform_get_resource(struct platform_device *,
					      unsigned int, unsigned int);
//---------------------------------------------------------------------

struct platform_device {
	const char	*name;
	int		id;
	bool		id_auto;
	struct device	dev;
	u32		num_resources;
	struct resource	*resource;

	const struct platform_device_id	*id_entry;
	char *driver_override; /* Driver name to force a match */

	/* MFD cell pointer */
	struct mfd_cell *mfd_cell;

	/* arch specific additions */
	struct pdev_archdata	archdata;
};

框架&示例

#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

/* 寄存器名 */
static void __iomem *IMX6U_CCM_CCGR1;
static void __iomem *SW_MUX_GPIO1_IO03;
static void __iomem *SW_PAD_GPIO1_IO03;
static void __iomem *GPIO1_DR;
static void __iomem *GPIO1_GDIR;

/* leddev设备结构体 */
struct leddev_dev{
	dev_t devid;			/* 设备号	*/
	struct cdev cdev;		/* cdev		*/
	struct class *class;	/* 类 		*/
	struct device *device;	/* 设备		*/
	int major;				/* 主设备号	*/		
};

struct leddev_dev leddev; 	/* led设备 */

/*
 * @description		: 打开设备
 * @param - inode 	: 传递给驱动的inode
 * @param - filp 	: 设备文件，file结构体有个叫做private_data的成员变量
 * 					  一般在open的时候将private_data指向设备结构体。
 * @return 			: 0 成功;其他 失败
 */
static int led_open(struct inode *inode, struct file *filp)
{
	filp->private_data = &leddev; /* 设置私有数据  */
	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)
{
	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;
	int ressize[5];
	u32 val = 0;
	struct resource *ledsource[5];

	printk("led driver and device has matched!\r\n");
	/* 1、获取资源 */
	for (i = 0; i < 5; 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 */
	/* 寄存器地址映射 */
 	IMX6U_CCM_CCGR1 = ioremap(ledsource[0]->start, ressize[0]);
	SW_MUX_GPIO1_IO03 = ioremap(ledsource[1]->start, ressize[1]);
  	SW_PAD_GPIO1_IO03 = ioremap(ledsource[2]->start, ressize[2]);
	GPIO1_DR = ioremap(ledsource[3]->start, ressize[3]);
	GPIO1_GDIR = ioremap(ledsource[4]->start, ressize[4]);
	
	/* 注册字符设备驱动 */
	/*1、创建设备号 */
	if (leddev.major) {		/*  定义了设备号 */
		leddev.devid = MKDEV(leddev.major, 0);
		register_chrdev_region(leddev.devid, LEDDEV_CNT, LEDDEV_NAME);
	} else {						/* 没有定义设备号 */
		alloc_chrdev_region(&leddev.devid, 0, LEDDEV_CNT, LEDDEV_NAME);	/* 申请设备号 */
		leddev.major = MAJOR(leddev.devid);	/* 获取分配号的主设备号 */
	}
	
	/* 2、初始化cdev */
	leddev.cdev.owner = THIS_MODULE;
	cdev_init(&leddev.cdev, &led_fops);
	
	/* 3、添加一个cdev */
	cdev_add(&leddev.cdev, leddev.devid, LEDDEV_CNT);

	/* 4、创建类 */
	leddev.class = class_create(THIS_MODULE, LEDDEV_NAME);
	if (IS_ERR(leddev.class)) {
		return PTR_ERR(leddev.class);
	}

	/* 5、创建设备 */
	leddev.device = device_create(leddev.class, NULL, leddev.devid, NULL, LEDDEV_NAME);
	if (IS_ERR(leddev.device)) {
		return PTR_ERR(leddev.device);
	}

	return 0;
}

/*
 * @description		: platform驱动的remove函数，移除platform驱动的时候此函数会执行
 * @param - dev 	: platform设备
 * @return 			: 0，成功;其他负值,失败
 */
static int led_remove(struct platform_device *dev)
{
	iounmap(IMX6U_CCM_CCGR1);
	iounmap(SW_MUX_GPIO1_IO03);
	iounmap(SW_PAD_GPIO1_IO03);
	iounmap(GPIO1_DR);
	iounmap(GPIO1_GDIR);

	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	= "imx6ul-led",			/* 驱动名字，用于和设备匹配 */
	},
	.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("zuozhongkai");

字符设备驱动框架

套路1

特点

  • 如果有步骤申请失败，记得释放掉前面申请过的
  • 对比于platform框架不同在于，申请注册过程放在
    static int __init led_init(void)中

框架&示例

#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.h>
#include <linux/of_address.h>
#include <asm/mach/map.h>
#include <asm/uaccess.h>
#include <asm/io.h>

#define DTSLED_CNT			1		  	/* 设备号个数 */
#define DTSLED_NAME			"dtsled"	/* 名字 */
#define LEDOFF 					0			/* 关灯 */
#define LEDON 					1			/* 开灯 */

/* 映射后的寄存器虚拟地址指针 */
static void __iomem *IMX6U_CCM_CCGR1;
static void __iomem *SW_MUX_GPIO1_IO03;
static void __iomem *SW_PAD_GPIO1_IO03;
static void __iomem *GPIO1_DR;
static void __iomem *GPIO1_GDIR;

/* dtsled设备结构体 */
struct dtsled_dev{
	dev_t devid;			/* 设备号 	 */
	struct cdev cdev;		/* cdev 	*/
	struct class *class;		/* 类 		*/
	struct device *device;	/* 设备 	 */
	int major;				/* 主设备号	  */
	int minor;				/* 次设备号   */
	struct device_node	*nd; /* 设备节点 */
};

struct dtsled_dev dtsled;	/* led设备 */

/*
 * @description		: 打开设备
 * @param - inode 	: 传递给驱动的inode
 * @param - filp 	: 设备文件，file结构体有个叫做private_data的成员变量
 * 					  一般在open的时候将private_data指向设备结构体。
 * @return 			: 0 成功;其他 失败
 */
static int led_open(struct inode *inode, struct file *filp)
{
	filp->private_data = &dtsled; /* 设置私有数据 */
	return 0;
}

/*
 * @description		: 从设备读取数据 
 * @param - filp 	: 要打开的设备文件(文件描述符)
 * @param - buf 	: 返回给用户空间的数据缓冲区
 * @param - cnt 	: 要读取的数据长度
 * @param - offt 	: 相对于文件首地址的偏移
 * @return 			: 读取的字节数，如果为负值，表示读取失败
 */
static ssize_t led_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
{
	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;
	}
	
	return 0;
}

/*
 * @description		: 关闭/释放设备
 * @param - filp 	: 要关闭的设备文件(文件描述符)
 * @return 			: 0 成功;其他 失败
 */
static int led_release(struct inode *inode, struct file *filp)
{
	return 0;
}

/* 设备操作函数 */
static struct file_operations dtsled_fops = {
	.owner = THIS_MODULE,
	.open = led_open,
	.read = led_read,
	.write = led_write,
	.release = 	led_release,
};

/*
 * @description	: 驱动出口函数
 * @param 		: 无
 * @return 		: 无
 */
static int __init led_init(void)
{
	u32 val = 0;
	int ret;
	u32 regdata[14];
	const char *str;
	struct property *proper;

	/* 获取设备树中的属性数据 */
	/* 1、获取设备节点：alphaled */
	dtsled.nd = of_find_node_by_path("/alphaled");
	if(dtsled.nd == NULL) {
		printk("alphaled node nost find!\r\n");
		return -EINVAL;
	} else {
		printk("alphaled node find!\r\n");
	}

	/* 2、获取compatible属性内容 */
	proper = of_find_property(dtsled.nd, "compatible", NULL);
	if(proper == NULL) {
		printk("compatible property find failed\r\n");
	} else {
		printk("compatible = %s\r\n", (char*)proper->value);
	}

	/* 3、获取status属性内容 */
	ret = of_property_read_string(dtsled.nd, "status", &str);
	if(ret < 0){
		printk("status read failed!\r\n");
	} else {
		printk("status = %s\r\n",str);
	}

	/* 4、获取reg属性内容 */
	ret = of_property_read_u32_array(dtsled.nd, "reg", regdata, 10);
	if(ret < 0) {
		printk("reg property read failed!\r\n");
	} else {
		u8 i = 0;
		printk("reg data:\r\n");
		for(i = 0; i < 10; i++)
			printk("%#X ", regdata[i]);
		printk("\r\n");
	}

	/* 初始化LED */
#if 0
	/* 1、寄存器地址映射 */
	IMX6U_CCM_CCGR1 = ioremap(regdata[0], regdata[1]);
	SW_MUX_GPIO1_IO03 = ioremap(regdata[2], regdata[3]);
  	SW_PAD_GPIO1_IO03 = ioremap(regdata[4], regdata[5]);
	GPIO1_DR = ioremap(regdata[6], regdata[7]);
	GPIO1_GDIR = ioremap(regdata[8], regdata[9]);
#else
	IMX6U_CCM_CCGR1 = of_iomap(dtsled.nd, 0);
	SW_MUX_GPIO1_IO03 = of_iomap(dtsled.nd, 1);
  	SW_PAD_GPIO1_IO03 = of_iomap(dtsled.nd, 2);
	GPIO1_DR = of_iomap(dtsled.nd, 3);
	GPIO1_GDIR = of_iomap(dtsled.nd, 4);
#endif

	/* 2、使能GPIO1时钟 */
	val = readl(IMX6U_CCM_CCGR1);
	val &= ~(3 << 26);	/* 清楚以前的设置 */
	val |= (3 << 26);	/* 设置新值 */
	writel(val, IMX6U_CCM_CCGR1);

	/* 3、设置GPIO1_IO03的复用功能，将其复用为
	 *    GPIO1_IO03，最后设置IO属性。
	 */
	writel(5, SW_MUX_GPIO1_IO03);
	
	/*寄存器SW_PAD_GPIO1_IO03设置IO属性
	 *bit 16:0 HYS关闭
	 *bit [15:14]: 00 默认下拉
     *bit [13]: 0 kepper功能
     *bit [12]: 1 pull/keeper使能
     *bit [11]: 0 关闭开路输出
     *bit [7:6]: 10 速度100Mhz
     *bit [5:3]: 110 R0/6驱动能力
     *bit [0]: 0 低转换率
	 */
	writel(0x10B0, SW_PAD_GPIO1_IO03);

	/* 4、设置GPIO1_IO03为输出功能 */
	val = readl(GPIO1_GDIR);
	val &= ~(1 << 3);	/* 清除以前的设置 */
	val |= (1 << 3);	/* 设置为输出 */
	writel(val, GPIO1_GDIR);

	/* 5、默认关闭LED */
	val = readl(GPIO1_DR);
	val |= (1 << 3);	
	writel(val, GPIO1_DR);

	/* 注册字符设备驱动 */
	/* 1、创建设备号 */
	if (dtsled.major) {		/*  定义了设备号 */
		dtsled.devid = MKDEV(dtsled.major, 0);
		register_chrdev_region(dtsled.devid, DTSLED_CNT, DTSLED_NAME);
	} else {						/* 没有定义设备号 */
		alloc_chrdev_region(&dtsled.devid, 0, DTSLED_CNT, DTSLED_NAME);	/* 申请设备号 */
		dtsled.major = MAJOR(dtsled.devid);	/* 获取分配号的主设备号 */
		dtsled.minor = MINOR(dtsled.devid);	/* 获取分配号的次设备号 */
	}
	printk("dtsled major=%d,minor=%d\r\n",dtsled.major, dtsled.minor);	
	
	/* 2、初始化cdev */
	dtsled.cdev.owner = THIS_MODULE;
	cdev_init(&dtsled.cdev, &dtsled_fops);
	
	/* 3、添加一个cdev */
	cdev_add(&dtsled.cdev, dtsled.devid, DTSLED_CNT);

	/* 4、创建类 */
	dtsled.class = class_create(THIS_MODULE, DTSLED_NAME);
	if (IS_ERR(dtsled.class)) {
		return PTR_ERR(dtsled.class);
	}

	/* 5、创建设备 */
	dtsled.device = device_create(dtsled.class, NULL, dtsled.devid, NULL, DTSLED_NAME);
	if (IS_ERR(dtsled.device)) {
		return PTR_ERR(dtsled.device);
	}
	
	return 0;
}

/*
 * @description	: 驱动出口函数
 * @param 		: 无
 * @return 		: 无
 */
static void __exit led_exit(void)
{
	/* 取消映射 */
	iounmap(IMX6U_CCM_CCGR1);
	iounmap(SW_MUX_GPIO1_IO03);
	iounmap(SW_PAD_GPIO1_IO03);
	iounmap(GPIO1_DR);
	iounmap(GPIO1_GDIR);

	/* 注销字符设备驱动 */
	cdev_del(&dtsled.cdev);/*  删除cdev */
	unregister_chrdev_region(dtsled.devid, DTSLED_CNT); /* 注销设备号 */

	device_destroy(dtsled.class, dtsled.devid);
	class_destroy(dtsled.class);
}

module_init(led_init);
module_exit(led_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("zuozhongkai");

Input

简介：Linux的Input系统是指操作系统中与输入设备（如键盘、鼠标、触摸屏等）交互的软件系统。它包含了输入设备的驱动程序、输入事件处理程序和用户空间的应用程序。

Linux系统中，输入设备驱动程序的主要任务是将硬件设备转化为一个或多个输入事件。这些事件包含了设备的输入信息，如按键、触摸、鼠标点击等。同时，也可以通过驱动程序配置输入设备，如设置鼠标滚轮的灵敏度、设置键盘的按键映射等。

当输入事件发生时，输入事件处理程序会将事件传递给用户空间的应用程序，这些应用程序可以根据输入事件来进行相应的操作。例如，当用户在终端中输入一个字符时，输入事件处理程序会将这个字符发送给终端应用程序进行处理。

套路1

特点

  • 不需要手动定义字符操作集fops

应用示例：

CSDN的JT同学这篇文章的例程可以直接复制使用

驱动示例：

CSDN的JT同学这篇文章的例程可以直接复制使用

中断

机制

铁手飞鹰
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Linux ARM 驱动笔记之一 : 准备
Imeng的专栏
10-09 1499
Linux ARM 驱动笔记之一 : 准备     本文以Linux ARMSPI设备驱动为例记录Linux驱动的开发中的一些套路和准备.本文内容抛开具体代码,描述相关的准备知识,描述书本中很少提及的内容.     1 驱动编写的套路 Linux 驱动编写归根揭底,涉及到底部,就是设置寄存器, 从设置寄存器的角度来看,Linux驱动编写分为两种套路: 1)     直接操控寄存器:
ARM Linux系统下奔图打印机驱动
02-20
ARM Linux系统下奔图打印机驱动。
手把手教你在ARM板上写一个驱动程序！
youzhangjing_的博客
11-23 3051
字符设备是Linux驱动中最基本的一类设备驱动，字符设备就是一个一个字节，按照字节流进行读写操作的设备，读写数据是分先后顺序的。比如我们最常见的点灯、按键、IIC、SPI，LCD 等等都是字符设备，这些设备的驱动就叫做字符设备驱动。那么在Linux下的应用程序是如何调用驱动程序的呢？Linux 应用程序对驱动程序的调用如图所示：​Linux应用程序对驱动程序的调用流程。
Linux之跟着正点原子学习记录
while（1）
09-17 447
必填
嵌入式 Linux LED 驱动开发实验（正点原子教程）
qq_62076153的博客
07-25 290
最近在学习正点原子linux驱动开发，写些文章帮助记忆stm32裸机开发中，驱动led只需要初始化io口就可以了，而linux系统驱动io口也需要初始化初始化就是配置寄存器，同时还要符合linux的驱动框架，开发板上的LED连接到I.MX6ULL的GPIO1_IO03这个引脚上。
【嵌入式环境下linux内核及驱动学习笔记-（1-linux内核结构）】
weixin_45499326的博客
04-07 1731
一个32位处理器的Linux的每个进程享有4G空间，一般0-3G属于用户空间，3G-4G属于内核空间。在ARM环境中，Linux系统充分利用CPU的硬件特性，实现了两级的操作模式，用户(usr)模式和管理模式(svc)。如图，虚拟文件系统为上层的应用程序提供了统一的调用接口，对下则负责调用具体底层文件系统或设备驱动中实现的file_operations结构体中的成员函数。如图，有操作系统后，应用程序可以不管具体的硬件细节，而都使用操作系统API的统一接口，这样利于大规模标准化开发，提高开发效率。
ARM-驱动/总结一
weixin_57039874的博客
06-22 1125
内核模块 / 字符设备驱动
10.7、驱动开发 -- 中断
feiffer·hu的博客
06-06 322
软件和硬件交互方式: 轮询: 软件主动反复的去读取硬件寄存器 效率很低,做很多无用功,浪费CPU资源 中断: 硬件主动通知软件,发生了事件!!! 硬件创建一个按键中断 修改设备树文件：vim arch/arm/boot/dts/exynos4412-fs4412.dts 1、添加 key2node{ compatible = "key 2"; interrupt-parent = <&gpx1>; //在gpx1 interrupts = <1 2&g.
Linux驱动之设备树-学习笔记
07-31
Linux驱动之设备树是Linux内核与硬件交互的关键机制，特别是在嵌入式系统中，它为内核提供了关于硬件配置的详细信息。设备树的概念源自于开放固件(openFirmware)标准，主要用于PowerPC架构，后来被广泛应用于ARM及...
ARM学习笔记.zip
07-25
ARM学习笔记.zip
嵌入式开发框架（arm体系结构、u-boot、内核驱动开发框架）
04-30
arm体系结构，嵌入式系统移植，内核驱动开发框架
嵌入式系统/ARM技术中的Linux设备驱动程序框架
11-08
一、linux的设备驱动程序与外界的接口可以分为三个部分： 　　1．驱动程序与操作系统内核的接口。通过file_operations(include/linux/fs.h)数据结构来完成的。 　　2．驱动程序与系统引导的接口。这部分利用驱动程序对设备进行初始化。 　　3．驱动程序与设备的接口。这部分描述了驱动程序如何与设备进行交互，与具体的设备密切相关。 　　二、根据功能划分，设备驱动程序的代码有以下几部分： 　　1．驱动程序的注册和注销。 　　2．设备的打开和释放。 　　3．设备的读写操作。 　　4．设备的控制操作。 　　5．设备的中断和轮询处理。 　　三、驱动程序的注册
linux驱动开发学习笔记十一：初识设备树
01-06
每年新出的 ARM 架构芯片少说都有数十、数百款，每一款芯片又会有很多款基于该芯片的板子，这些板子上的设备又不相同，每一块板子都要有自己的板级信息文件，所以Linux 内核下板级信息文件将会成指数级增长！...
linux驱动开发经验
qq_37812160的博客
01-04 903
如何使驱动程序通用、简洁、可维护、标准化
最全Linux驱动开发全流程详细解析（持续更新）
热门推荐
拉依达不拉跨的博客
02-19 4万+
Linux驱动开发详细解析
设备树下的LED驱动实验
lengyuefeng212的博客
08-04 388
文章目录一、设备树LED驱动原理二、硬件原理图分析三、实验程序编写1.修改设备树文件2.LED灯驱动程序编写3.编写测试APP四、运行测试 一、设备树LED驱动原理 我们使用设备树来向 Linux 内核传递相关的寄存器物理地址，Linux 驱动文件使用上一章讲解的 OF函数从设备树中获取所需的属性值，然后使用获取到的属性值来初始化相关的 IO。 ①、在 imx6ull-luatao-emmc.dts 文件中创建相应的设备节点。 ②、编写驱动程序，获取设备树中的相关属性值。 ③、使用获取到的有关属性值来初始
ARM-linux系统驱动复习(一)
xiaojionglian1的博客
05-30 525
前言:我认为写复习笔记在不借助资料的情况下可以对自己之前不懂的地方进行扫盲，然后盲点就看之前笔记就行了，框架比敲代码更重要(我自己认为的啊)。做一个东西时候有了框架我就知道我该干嘛，然后通过脑海里面的框架再对细节进行详细的写。
嵌入式Linux驱动教程(韦东山2期)
07-07
1.没有废话，句句都是干货！学习后保证可以跟着视频完成相应的实验。2.现场从0编写/调试工作中的绝大部分驱动，内容--- 理论 +
Linux~MySQL数据库具体操作
最新发布
javaMov的专栏
08-15 343
第二种：mysql -u root -p -e "CREATE DATABASE my_new_database;performance_schema : #【默认】：系统运行的状态信息，性能信息的存储库；语法：【mysqldump -uroot -p1 [备份参数] > /路径/文件名.sql】information_schema ：【默认】：系统运行的状态信息，性能信息的存储库；2.-B 数据库名 #备份指定数据库的数据信息。-B 数据库名 #备份指定数据库的数据信息。注意：需要先关闭数据库进行操作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值