RK3568平台 Regmap子系统

一.Regmap API 简介

Linux 下使用 i2c_transfer 来读写 I2C 设备中的寄存器，SPI 接口的话使用 spi_write/spi_read 等。I2C/SPI 芯片又非常的多，因此 Linux 内核里面就会充斥了大量的 i2c_transfer 这类的冗余 代码，再者，代码的复用性也会降低。

基于代码复用的原则，Linux 内核引入了 regmap 模型，regmap 将寄存器访问的共同逻辑抽 象出来，驱动开发人员不需要再去纠结使用 SPI 或者 I2C 接口 API 函数，统一使用 regmap API 函数。这样的好处就是统一使用 regmap，降低了代码冗余，提高了驱动的可以移植性。

Linux内核后引入了regmap模型，将寄存器访问的共同逻辑抽象出来，只需初始化时指定总线类型、寄存器位宽等关键参数，即可通过regmap模型接口来操作器件寄存器。当然，regmap同样适用于操作cpu自身的寄存器。将i2c、spi、mmio、irq都抽象出统一的接口regmap_read、regmap_write、regmap_update_bits等接口 ，从而提高代码的可重用性，并且使得在使用如上内核基础组件时变得更为简单易用。

二.Regmap 驱动框架

regmap整体上分为三层，从下到上分别为物理总线、regmap核心、regmap api。

底层，对接的是具体物理总线，目前regmap框架支持i2c、spi、mmio、spmi、ac97总线
核心层，regmap 核心实现
api，抽象通用接口
对于使用regmap框架来说，可以不用关心regmap核心的实现过程，只需根据物理总线类型，配置好相关参数信息，即可调用regmap api访问芯片寄存器。

三.Regmap 操作函数

Regmap 申请与初始化:

regmap 支持多种物理总线，比如 I2C 和 SPI，我们需要根据所使用的接口来选 择合适的 regmap 初始化函数。

SPI 接口 初始化函数为 regmap_init_spi，函数原型如下：

struct regmap * regmap_init_spi(struct spi_device *spi,
 const struct regmap_config *config)

I2C 接口的 regmap 初始化函数为 regmap_init_i2c，函数原型如下：

struct regmap * regmap_init_i2c(struct i2c_client *i2c,
 const struct regmap_config *config)

在退出驱动的时候需要释放掉申请到的 regmap，不管是什么接口，全部使用 regmap_exit 这 个函数来释放 regmap，函数原型如下：

void regmap_exit(struct regmap *map)

regmap 设备访问 API 函数:

不管是 I2C 还是 SPI 等接口，还是 SOC 内部的寄存器，对于寄存器的操作就两种：读和 写。regmap 提供了最核心的两个读写操作：regmap_read 和 regmap_write。

regmap_read 函数原型如下：

int regmap_read(struct regmap *map,
 unsigned int reg,
 unsigned int *val)

regmap_write 函数原型如下：

int regmap_write(struct regmap *map,
 unsigned int reg,
 unsigned int val)

四.Regmap实验程序

 本实验例子主要是对比IIC Regmap api与传统的i2c_transfer的区别。

 #include 
 #include 
 #include 
 #include 
 #include 
 #include 
 #include 
 #include 
 #include 
 #include 
 #include 
 #include 
 #include 
 #include 
 #include 
 #include 
 #include 
 #include 
 #include "regmap_iic.h"

 #define AP3216C_MINOR	255
 #define AP3216C_NAME "ap3216c"

 typedef struct {
	struct i2c_client *client;
	unsigned short ir, als, ps;
	struct regmap *regmap;
	struct regmap_config regmap_config;
 }ap3216c_dev;

 ap3216c_dev ap3216c;

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

 /* msg[0]为发送要读取的首地址 */
 msg[0].addr = client->addr; /* ap3216c 地址 */
 msg[0].flags = 0; /* 标记为发送数据 */
 msg[0].buf = ® /* 读取的首地址 */
 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;
 }
 #endif 
	int ret = 0;
	reg = regmap_read(dev->regmap,reg,(unsigned int*)val);
 	return ret;
 }

 /*
 * @description: 向 ap3216c 多个寄存器写入数据
 * @param - dev: ap3216c 设备
 * @param - reg: 要写入的寄存器首地址
 * @param - val: 要写入的数据缓冲区
 * @param - len: 要写入的数据长度
 * @return : 操作结果
 */
static s32 ap3216c_write_regs(ap3216c_dev *dev, u8 reg,u8 *buf, u8 len)
{
#if 0
u8 b[256];
struct i2c_msg msg;
struct i2c_client *client = (struct i2c_client *)dev->client;

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);
 #endif
	regmap_write(dev->regmap, reg, (unsigned int) *buf);
	return 0;
 }

 /*
 * @description : 读取 AP3216C 的数据，包括 ALS,PS 和 IR, 注意！如果同时
 * :打开 ALS,IR+PS 两次数据读取的时间间隔要大于 112.5ms
 * @param – ir : ir 数据
 * @param - ps : ps 数据
 * @param - ps : als 数据
 * @return : 无。
 */
 void ap3216c_readdata(ap3216c_dev *dev)
 {
 	unsigned char i =0;
 	unsigned char buf[6];
 
 	/* 循环读取所有传感器数据 */
 	for(i = 0; i < 6; i++) {
 		ap3216c_read_regs(dev, AP3216C_IRDATALOW + i, buf+i, 1); 
 	}

 	if(buf[0] & 0X80) /* IR_OF 位为 1,则数据无效 */
 		dev->ir = 0; 
 	else /* 读取 IR 传感器的数据 */
 		dev->ir = ((unsigned short)buf[1] << 2) | (buf[0] & 0X03); 

	/* 读取ALS传感器的数据*/
 	dev->als = ((unsigned short)buf[3] << 8) | buf[2]; 
 
 	if(buf[4] & 0x40) /* IR_OF 位为 1,则数据无效 */
 		dev->ps = 0; 
 	else /* 读取 PS 传感器的数据 */
 		dev->ps = ((unsigned short)(buf[5] & 0X3F) << 4) | (buf[4] &0X0F);
 }

static int lcs_ap3216c_init(ap3216c_dev *dev)
{
	unsigned char buf = 0;
	/* 复位ap3216c */
	buf = 0x04;
	ap3216c_write_regs(dev, AP3216C_SYSTEMCONG, &buf, 1);

	/* 延时 */
	mdelay(50);

	/* 开启ALS、PS、IR*/
	buf = 0x03;
	ap3216c_write_regs(dev, AP3216C_SYSTEMCONG, &buf, 1);

	return 0;
}

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

	return 0;
 }

 /*
 * @description : 从设备读取数据
 * @param - filp : 要打开的设备文件(文件描述符)
 * @param - buf : 返回给用户空间的数据缓冲区
 * @param - cnt : 要读取的数据长度
 * @param - offt : 相对于文件首地址的偏移
 * @return : 读取的字节数，如果为负值，表示读取失败
 */
static ssize_t ap3216c_read(struct file *filp, char __user *buf,size_t cnt, loff_t *off)
 {
 	short data[3];
 	long err = 0;

	ap3216c_dev *dev = (ap3216c_dev*)filp->private_data;
	/* 读取ap3216c数据*/
	ap3216c_readdata(dev);

 	data[0] = dev->ir;
 	data[1] = dev->als;
 	data[2] = dev->ps;
 	err = copy_to_user(buf, data, sizeof(data));
 	return 0;
 }

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

 /* AP3216C 操作函数 */
 static const struct file_operations ap3216c_ops = {
 	.owner = THIS_MODULE,
 	.open = ap3216c_open,
 	.read = ap3216c_read,
 	.release = ap3216c_release,
 };

 /* MISC设备结构体 */
 static struct miscdevice ap3216c_miscdev = {
	.minor = AP3216C_MINOR,
	.name = AP3216C_NAME,
	.fops = &ap3216c_ops,
 };

 /*
 * @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)
 {
 	int ret = 0;
 	 
	/* 注册MISC子系统 */
	ret = misc_register(&ap3216c_miscdev);
	if(ret < 0){
		printk("ap3216 misc device register failed!\r\n");
		ret = -EFAULT;
 	}

	/* 获取I2C设备 */
	ap3216c.client = client;

	/* 初始化regmap_config设置 */
	ap3216c.regmap_config.reg_bits = 8;		/* 寄存器长度8bit */
	ap3216c.regmap_config.val_bits = 8;		/* 值长度8bit */

	/* 初始化I2C接口的regmap */
	ap3216c.regmap = regmap_init_i2c(client, &ap3216c.regmap_config);
	if(IS_ERR(ap3216c.regmap)){
		return PTR_ERR(ap3216c.regmap);
	}

	return 0;
 
 }

 /*
 * @description : i2c 驱动的 remove 函数，移除 i2c 驱动的时候此函数会执行
 * @param - client : i2c 设备
 * @return : 0，成功;其他负值,失败
 */
static int ap3216c_remove(struct i2c_client *client)
 {
	int ret = 0;
	/*释放regmap*/
	regmap_exit(ap3216c.regmap);
	/*MISC 驱动框架卸载*/
	misc_deregister(&ap3216c_miscdev);
	return ret;
 }

 /* 传统匹配方式 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;
 }

 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("ALIENTEK");
 MODULE_INFO(intree, "Y");