背景
在学习SPI框架的时候，看到了有一个rtc驱动用到了regmap，本想通过传统方式访问spi接口的我，突然有点不适应，翻了整个驱动，愣是没有找到读写spi的范式；因此了解了regmap以后，才发现regmap做了这个事情。
介绍
在Linu 3.1开始，Linux引入了regmap来统一管理内核的I2C, SPI等总线，将I2C, SPI驱动做了一次重构，把I/O读写的重复逻辑在regmap中实现。只需初始化时指定总线类型、寄存器位宽等关键参数，即可通过regmap模型接口来操作器件寄存器。
当然，regmap同样适用于操作cpu自身的寄存器。将i2c、spi、mmio、irq都抽象出统一的接口regmap_read、regmap_write、regmap_update_bits等接口 ，从而提高代码的可重用性，并且使得在使用如上内核基础组件时变得更为简单易用。
regmap是在 linux 内核为减少慢速 I/O 驱动上的重复逻辑，提供一种通用的接口来操作底层硬件寄存器的模型框架。
此外，如果在regmap在驱动和硬件寄存器之间使用cache，会减少底层低速 I/O 的操作次数，提高访问效率；但降低了实时性会有所降低。
传统的写法
用一个I2C设备为例，在3.1之前的I2C设备驱动，需要各自调用i2c_transfer来实现读写，比如：
static int raydium_i2c_pda2_write(struct i2c_client *client,
unsigned char addr, unsigned char *w_data, unsigned short length)
{
int retval = -1;
unsigned char retry;
unsigned char buf[MAX_WRITE_PACKET_SIZE + 1];
struct raydium_ts_data *data = i2c_get_clientdata(client);
struct i2c_msg msg[] = {
{
.addr = RAYDIUM_I2C_NID,
.flags = RAYDIUM_I2C_WRITE,
.len = length + 1,
.buf = buf,
},
};
if (length > MAX_WRITE_PACKET_SIZE)
{
return -EINVAL;
}
u8_i2c_mode = PDA2_MODE;
buf[0] = addr;
memcpy(&buf[1], w_data, length);
for (retry = 0; retry < SYN_I2C_RETRY_TIMES; retry++)
{
if (i2c_transfer(client->adapter, msg, 1) == 1)
{
retval = length;
break;
}
msleep(20);
}
if (retry == SYN_I2C_RETRY_TIMES)
{
dev_err(&data->client->dev,"[touch]%s: I2C write over retry limit.addr[0x%x]
",__func__, addr);
retval = -EIO;
}
return retval;
}
需要自行构建i2c_msg，然后使用i2c_transfer传输数据。
使用regmap机制进行读写
但是使用regmap机制，就会变的更为简单。
使用regmap比较简单：
1、使用前，只需根据外设属性配置配置regmap信息（总线类型、寄存器位宽、缓存类型、读写属性等参数）；
2、接着注册一个regmap实例；
3、然后调用抽象访问接口访问寄存器；
4、不想使用的时候，释放regmap实例即可。
例如：
// 1.构建regmap_config结构
static const struct regmap_config mlx90632_regmap = {
// 寄存器地址位宽
.reg_bits = 16,
// 寄存器值的位宽，必须填写
.val_bits = 16,
// 可选，判断寄存器是否可写，可读，是否可缓冲等回调
.volatile_table = &mlx90632_volatile_regs_tbl,
.rd_table = &mlx90632_readable_regs_tbl,
.wr_table = &mlx90632_writeable_regs_tbl,
.use_single_rw = true,
.reg_format_endian = REGMAP_ENDIAN_BIG,
.val_format_endian = REGMAP_ENDIAN_BIG,
.cache_type = REGCACHE_RBTREE,
};
// 2. 初始化regmap（或者regmap_init_spi）
struct regmap *map= regmap_init_i2c(client, &mlx90632_regmap);
//3.读写操作
ret = regmap_read(mlx90632->regmap, MLX90632_EE_VERSION, &read);
//4. 释放regmap
regmap_exit(&mlx90632_regmap);
读写特性
regmap的write操作：
- 先尝试向缓冲cache中write.
- 如果bypass了,或者volatile,或者cache none情况,调用对应的底层协议进行写操作。
_regmap_read：
_regmap_read
- 先拿到context，在以后的
map->reg_read会用到 - 如果不是bypass的，调用
regcache_read从cache中读 - 如果不能从cache中read到，调用
map->reg_read
regmap_config原型
在regmap_config，定义了寄存器的各种信息，比如寄存器地址长度，寄存器值的长度，读写寄存器的地址范围的信息，寄存器地址和值的大小端以及缓冲方式。
// include/linux/regmap.h
struct regmap_config {
const char *name; // 可选，寄存器名字
int reg_bits; // 寄存器地址位宽，必须填写
int reg_stride; // 寄存器操作宽度，比如为1时，所有寄存器可操作，为2时，只有2^n可操作
int pad_bits;
int val_bits; // 寄存器值的位宽，必须填写
// 可选，判断寄存器是否可写，可读，是否可缓冲等回调
bool (*writeable_reg)(struct device *dev, unsigned int reg);
bool (*readable_reg)(struct device *dev, unsigned int reg);
bool (*volatile_reg)(struct device *dev, unsigned int reg);
bool (*precious_reg)(struct device *dev, unsigned int reg);
regmap_lock lock;
regmap_unlock unlock;
void *lock_arg;
// 寄存器读写方法，可选
int (*reg_read)(void *context, unsigned int reg, unsigned int *val);
int (*reg_write)(void *context, unsigned int reg, unsigned int val);
bool fast_io;
unsigned int max_register;
const struct regmap_access_table *wr_table; //可选，可写寄存器
const struct regmap_access_table *rd_table;//可选，可读寄存器
const struct regmap_access_table *volatile_table;
const struct regmap_access_table *precious_table;
const struct reg_default *reg_defaults;
unsigned int num_reg_defaults;
enum regcache_type cache_type; // 缓冲方式
const void *reg_defaults_raw;
unsigned int num_reg_defaults_raw;
u8 read_flag_mask;
u8 write_flag_mask;
bool use_single_rw;
bool can_multi_write;
enum regmap_endian reg_format_endian;
enum regmap_endian val_format_endian;
const struct regmap_range_cfg *ranges;
unsigned int num_ranges;
};
regmap_init_i2c
当设备驱动配置好config以后，调用对应的regmap_init_xx，例如，这里是regmap_init_i2c
// drivers/base/regmap/regmap-i2c.c
struct regmap *regmap_init_i2c(struct i2c_client *i2c,
const struct regmap_config *config)
{
// regmap_bus 定位了对应总线的读写函数。
const struct regmap_bus *bus = regmap_get_i2c_bus(i2c, config);
if (IS_ERR(bus))
return ERR_CAST(bus);
return regmap_init(&i2c->dev, bus, &i2c->dev, config);
}
注意到2个新的数据结构：
struct regmap_bus *busstruct regmap *regmap_init_i2c(..
regmap_get_i2c_bus
对于普通I2C设备，regmap_bus为：
// drivers/base/regmap/regmap-i2c.c
static const struct regmap_bus *regmap_get_i2c_bus(struct i2c_client *i2c,
const struct regmap_config *config)
{
if (i2c_check_functionality(i2c->adapter, I2C_FUNC_I2C))
return ®map_i2c;
// ...
return ERR_PTR(-ENOTSUPP);
}
static struct regmap_bus regmap_i2c = {
.write = regmap_i2c_write,
.gather_write = regmap_i2c_gather_write,
.read = regmap_i2c_read,
.reg_format_endian_default = REGMAP_ENDIAN_BIG,
.val_format_endian_default = REGMAP_ENDIAN_BIG,
};
regmap_bus结构定义了读写函数和默认的寄存器地址和寄存器值的大小端。
regmap_bus原型
/**
* struct regmap_bus - Description of a hardware bus for the register map
* infrastructure.
*
* @fast_io: Register IO is fast. Use a spinlock instead of a mutex
* to perform locking. This field is ignored if custom lock/unlock
* functions are used (see fields lock/unlock of
* struct regmap_config).
* @write: Write operation.
* @gather_write: Write operation with split register/value, return -ENOTSUPP
* if not implemented on a given device.
* @async_write: Write operation which completes asynchronously, optional and
* must serialise with respect to non-async I/O.
* @reg_write: Write a single register value to the given register address. This
* write operation has to complete when returning from the function.
* @reg_update_bits: Update bits operation to be used against volatile
* registers, intended for devices supporting some mechanism
* for setting clearing bits without having to
* read/modify/write.
* @read: Read operation. Data is returned in the buffer used to transmit
* data.
* @reg_read: Read a single register value from a given register address.
* @free_context: Free context.
* @async_alloc: Allocate a regmap_async() structure.
* @read_flag_mask: Mask to be set in the top byte of the register when doing
* a read.
* @reg_format_endian_default: Default endianness for formatted register
* addresses. Used when the regmap_config specifies DEFAULT. If this is
* DEFAULT, BIG is assumed.
* @val_format_endian_default: Default endianness for formatted register
* values. Used when the regmap_config specifies DEFAULT. If this is
* DEFAULT, BIG is assumed.
* @max_raw_read: Max raw read size that can be used on the bus.
* @max_raw_write: Max raw write size that can be used on the bus.
*/
struct regmap_bus {
bool fast_io;
regmap_hw_write write;
regmap_hw_gather_write gather_write;
regmap_hw_async_write async_write;
regmap_hw_reg_write reg_write;
regmap_hw_reg_update_bits reg_update_bits;
regmap_hw_read read;
regmap_hw_reg_read reg_read;
regmap_hw_free_context free_context;
regmap_hw_async_alloc async_alloc;
u8 read_flag_mask;
enum regmap_endian reg_format_endian_default;
enum regmap_endian val_format_endian_default;
size_t max_raw_read;
size_t max_raw_write;
};
regmap_i2c_read
我们看下i2c对应的regmap_bus.read实现：
@/kernel/driver/base/rgmap/regmap-i2c.c
static int regmap_i2c_read(void *context,
const void *reg, size_t reg_size,
void *val, size_t val_size)
{
struct device *dev = context;
struct i2c_client *i2c = to_i2c_client(dev);
struct i2c_msg xfer[2];
int ret;
xfer[0].addr = i2c->addr;
xfer[0].flags = 0;
xfer[0].len = reg_size;
xfer[0].buf = (void *)reg;
xfer[1].addr = i2c->addr;
xfer[1].flags = I2C_M_RD;
xfer[1].len = val_size;
xfer[1].buf = val;
ret = i2c_transfer(i2c->adapter, xfer, 2);
if (ret == 2)
return 0;
else if (ret < 0)
return ret;
else
return -EIO;
}
可以看到其实就是构造i2c_msg，选择操作寄存器地址然后读寄存器值。这正是regmap要做的事情，抽离出总线读写操作到regmap中，避免驱动去重复实现。
等到设备驱动调用regmap_read以后，最终会调用到regmap_i2c_read，这样子就会执行i2c驱动典型的驱动流程。
regmap_init
当在regmap_get_i2c_bus获取到对应的bus以后，就可以进行regmap的初始化了。
regmap_init主要是把config和描述i2c设备的bus设置到regmap中
struct regmap *regmap_init(struct device *dev,
const struct regmap_bus *bus,
void *bus_context,
const struct regmap_config *config)
{
struct regmap *map;
int ret = -EINVAL;
enum regmap_endian reg_endian, val_endian;
map = kzalloc(sizeof(*map), GFP_KERNEL);
// 将regmap_config定义的参数赋值到regmap中
map->format.reg_bytes = DIV_ROUND_UP(config->reg_bits, 8);
map->format.pad_bytes = config->pad_bits / 8;
map->format.val_bytes = DIV_ROUND_UP(config->val_bits, 8);
map->format.buf_size = DIV_ROUND_UP(config->reg_bits +
config->val_bits + config->pad_bits, 8);
map->reg_shift = config->pad_bits % 8;
if (config->reg_stride)
map->reg_stride = config->reg_stride;
else
map->reg_stride = 1;
map->use_single_rw = config->use_single_rw;
map->can_multi_write = config->can_multi_write;
map->dev = dev;
map->bus = bus;
map->bus_context = bus_context;
map->max_register = config->max_register;
map->wr_table = config->wr_table;
map->rd_table = config->rd_table;
map->volatile_table = config->volatile_table;
map->precious_table = config->precious_table;
map->writeable_reg = config->writeable_reg;
map->readable_reg = config->readable_reg;
map->volatile_reg = config->volatile_reg;
map->precious_reg = config->precious_reg;
map->cache_type = config->cache_type;
map->name = config->name;
/* regmap中有reg_read操作方法，通过bus是否为空赋值 */
if (!bus) {
// 对于该驱动，此处只会走这里
map->reg_read = config->reg_read;
map->reg_write = config->reg_write;
map->defer_caching = false;
goto skip_format_initialization;
} else if (!bus->read || !bus->write) {
map->reg_read = _regmap_bus_reg_read;
map->reg_write = _regmap_bus_reg_write;
map->defer_caching = false;
goto skip_format_initialization;
} else {
map->reg_read = _regmap_bus_read;
}
// 设置地址和寄存器值的大小端
reg_endian = regmap_get_reg_endian(bus, config);
val_endian = regmap_get_val_endian(dev, bus, config);
// 根据寄存器地址位宽和大小端解析寄存器地址
switch (config->reg_bits + map->reg_shift) {
case 32:
switch (reg_endian) {
case REGMAP_ENDIAN_BIG:
map->format.format_reg = regmap_format_32_be;
break;
case REGMAP_ENDIAN_NATIVE:
map->format.format_reg = regmap_format_32_native;
break;
default:
goto err_map;
}
break;
}
// 根据寄存器值位宽和大小端解析寄存器值
switch (config->val_bits) {
case 16:
switch (val_endian) {
case REGMAP_ENDIAN_BIG:
map->format.format_val = regmap_format_16_be;
map->format.parse_val = regmap_parse_16_be;
map->format.parse_inplace = regmap_parse_16_be_inplace;
break;
case REGMAP_ENDIAN_LITTLE:
map->format.format_val = regmap_format_16_le;
map->format.parse_val = regmap_parse_16_le;
map->format.parse_inplace = regmap_parse_16_le_inplace;
break;
case REGMAP_ENDIAN_NATIVE:
map->format.format_val = regmap_format_16_native;
map->format.parse_val = regmap_parse_16_native;
break;
default:
goto err_map;
}
break;
}
/* 对于val_bits = 16,reg_bits=16,regmap写函数选择_regmap_bus_raw_write */
if (map->format.format_write) {
map->defer_caching = false;
map->reg_write = _regmap_bus_formatted_write;
} else if (map->format.format_val) {
map->defer_caching = true;
map->reg_write = _regmap_bus_raw_write;
}
// 缓存初始化
ret = regcache_init(map, config);
}
regmap_init()函数初始化了regmap，regmap中函数bus指针和config寄存器参数，已经足够用来操作I2C的寄存器了。
同时，也设置了regmap.reg_read为_regmap_bus_read
regmap原型
struct regmap {
union {
struct mutex mutex;
struct {
spinlock_t spinlock;
unsigned long spinlock_flags;
};
};
regmap_lock lock;
regmap_unlock unlock;
void *lock_arg; /* This is passed to lock/unlock functions */
gfp_t alloc_flags;
struct device *dev; /* Device we do I/O on */
void *work_buf; /* Scratch buffer used to format I/O */
struct regmap_format format; /* Buffer format */
const struct regmap_bus *bus;
void *bus_context;
const char *name;
bool async;
spinlock_t async_lock;
wait_queue_head_t async_waitq;
struct list_head async_list;
struct list_head async_free;
int async_ret;
unsigned int max_register;
bool (*writeable_reg)(struct device *dev, unsigned int reg);
bool (*readable_reg)(struct device *dev, unsigned int reg);
bool (*volatile_reg)(struct device *dev, unsigned int reg);
bool (*precious_reg)(struct device *dev, unsigned int reg);
const struct regmap_access_table *wr_table;
const struct regmap_access_table *rd_table;
const struct regmap_access_table *volatile_table;
const struct regmap_access_table *precious_table;
int (*reg_read)(void *context, unsigned int reg, unsigned int *val);
int (*reg_write)(void *context, unsigned int reg, unsigned int val);
int (*reg_update_bits)(void *context, unsigned int reg,
unsigned int mask, unsigned int val);
bool defer_caching;
unsigned long read_flag_mask;
unsigned long write_flag_mask;
/* number of bits to (left) shift the reg value when formatting*/
int reg_shift;
int reg_stride;
int reg_stride_order;
/* regcache specific members */
const struct regcache_ops *cache_ops;
enum regcache_type cache_type;
/* number of bytes in reg_defaults_raw */
unsigned int cache_size_raw;
/* number of bytes per word in reg_defaults_raw */
unsigned int cache_word_size;
/* number of entries in reg_defaults */
unsigned int num_reg_defaults;
/* number of entries in reg_defaults_raw */
unsigned int num_reg_defaults_raw;
/* if set, only the cache is modified not the HW */
bool cache_only;
/* if set, only the HW is modified not the cache */
bool cache_bypass;
/* if set, remember to free reg_defaults_raw */
bool cache_free;
struct reg_default *reg_defaults;
const void *reg_defaults_raw;
void *cache;
/* if set, the cache contains newer data than the HW */
bool cache_dirty;
/* if set, the HW registers are known to match map->reg_defaults */
bool no_sync_defaults;
struct reg_sequence *patch;
int patch_regs;
/* if set, converts bulk read to single read */
bool use_single_read;
/* if set, converts bulk read to single read */
bool use_single_write;
/* if set, the device supports multi write mode */
bool can_multi_write;
/* if set, raw reads/writes are limited to this size */
size_t max_raw_read;
size_t max_raw_write;
struct rb_root range_tree;
void *selector_work_buf; /* Scratch buffer used for selector */
};
_regmap_bus_read
reg_read回调函数是我们在读数据要使用的方法，
刚刚已经说了，map->reg_read = _regmap_bus_read;
我们需要看其实现：
// drivers/base/regmap/regmap.c
static int _regmap_bus_read(void *context, unsigned int reg,
unsigned int *val)
{
int ret;
struct regmap *map = context;
if (!map->format.parse_val)
return -EINVAL;
// 读出寄存器数据
ret = _regmap_raw_read(map, reg, map->work_buf, map->format.val_bytes);
if (ret == 0) // 根据寄存器位值宽和大小端得到寄存器值
*val = map->format.parse_val(map->work_buf);
return ret;
}
_regmap_raw_read
继续看：
static int _regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
unsigned int val_len)
{
struct regmap_range_node *range;
int ret;
WARN_ON(!map->bus);
if (!map->bus || !map->bus->read)
return -EINVAL;
// 从范围中找到某一页(但在这里没有用到)。
range = _regmap_range_lookup(map, reg);
if (range) {
ret = _regmap_select_page(map, ®, range,
val_len / map->format.val_bytes);
if (ret != 0)
return ret;
}
map->format.format_reg(map->work_buf, reg, map->reg_shift);
regmap_set_work_buf_flag_mask(map, map->format.reg_bytes,
map->read_flag_mask);
trace_regmap_hw_read_start(map, reg, val_len / map->format.val_bytes);
// 使用bus定义的read函数指针读数据，这样子就会调用到`regmap_i2c_read`
ret = map->bus->read(map->bus_context, map->work_buf,
map->format.reg_bytes + map->format.pad_bytes,
val, val_len);
trace_regmap_hw_read_done(map, reg, val_len / map->format.val_bytes);
return ret;
}
查找range（不理解）
这个部分的代码好像是不会执行的。
// drivers/base/regmap/internal.h
struct regmap_range_node {
struct rb_node node;
const char *name;
struct regmap *map;
unsigned int range_min;
unsigned int range_max;
unsigned int selector_reg;
unsigned int selector_mask;
int selector_shift;
// range_min、range_max是当前reg范围的开始与结束地址，window_len是”窗”的长度.
unsigned int window_start;
unsigned int window_len;
};
// drivers/base/regmap/regmap.c
static struct regmap_range_node *_regmap_range_lookup(struct regmap *map,
unsigned int reg)
{
struct rb_node *node = map->range_tree.rb_node;
// reg是当前寄存器的index
// range_min、range_max是当前reg范围的开始与结束地址
while (node) {
struct regmap_range_node *this =
rb_entry(node, struct regmap_range_node, node);
// 找到 落在 min 与 max 这个范围中的 reg
if (reg < this->range_min)
node = node->rb_left;
else if (reg > this->range_max)
node = node->rb_right;
else
return this;
}
return NULL;
}
static int _regmap_select_page(struct regmap *map, unsigned int *reg,
struct regmap_range_node *range,
unsigned int val_num)
{
void *orig_work_buf;
unsigned int win_offset;
unsigned int win_page;
bool page_chg;
int ret;
// 计算偏移
win_offset = (*reg - range->range_min) % range->window_len;
win_page = (*reg - range->range_min) / range->window_len;
if (val_num > 1) {
/* Bulk write shouldn't cross range boundary */
if (*reg + val_num - 1 > range->range_max)
return -EINVAL;
/* ... or single page boundary */
if (val_num > range->window_len - win_offset)
return -EINVAL;
}
/* It is possible to have selector register inside data window.
In that case, selector register is located on every page and
it needs no page switching, when accessed alone. */
/* 如果目标寄存器跨越1个寄存器(超过4个字节了)
调用_regmap_update_bits来拿到新的数据
_regmap_update_bits调用_regmap_read
先从i2c中目标寄存器中读出值orig,
然后把该值orig掩码掉mask,然后或上val,
将得到的结果调用_regmap_write写入到目标寄存器
*/
if (val_num > 1 ||
range->window_start + win_offset != range->selector_reg) {
/* Use separate work_buf during page switching */
orig_work_buf = map->work_buf;
map->work_buf = map->selector_work_buf;
ret = _regmap_update_bits(map, range->selector_reg,
range->selector_mask,
win_page << range->selector_shift,
&page_chg, false);
map->work_buf = orig_work_buf;
if (ret != 0)
return ret;
}
*reg = range->window_start + win_offset;
return 0;
}
regmap_read
regmap_read函数用来读取寄存器值，实现如下：
int regmap_read(struct regmap *map, unsigned int reg, unsigned int *val)
{
int ret;
// 通过寄存器操作宽度判断寄存器操作是否合法
if (reg % map->reg_stride)
return -EINVAL;
map->lock(map->lock_arg);
ret = _regmap_read(map, reg, val);
map->unlock(map->lock_arg);
return ret;
}
static int _regmap_read(struct regmap *map, unsigned int reg,
unsigned int *val)
{
// 1.直接从缓存取值
if (!map->cache_bypass) {
ret = regcache_read(map, reg, val);
if (ret == 0)
return 0;
}
// 2.最终调用bus定义的read读寄存器数据
ret = map->reg_read(context, reg, val);
// 3.将寄存器结果写入缓存
if (!map->cache_bypass)
regcache_write(map, reg, *val);
return ret;
}
regmap_read函数最后调用bus的read函数，同理，regmap_write函数最终也会调用bus的write函数。
regmap机制中的缓存
关于缓冲，需要解释的是，在regmap中加入了一层缓存，减少IO操作次数，提供硬件操作效率；
/* An enum of all the supported cache types */
enum regcache_type {
REGCACHE_NONE,
REGCACHE_RBTREE,//红黑树类型
REGCACHE_COMPRESSED,//压缩类型
REGCACHE_FLAT,//普通数据类型
};
在Linux 4.0 版本中，已经有 3 种缓存类型，分别是数据（flat）、LZO 压缩和红黑树（rbtree）。
- 数据好理解，是最简单的缓存类型，当设备寄存器很少时，可以用这种类型来缓存寄存器值。
- LZO(Lempel–Ziv–Oberhumer) 是 Linux 中经常用到的一种压缩算法，Linux 编译后就会用这个算法来压缩。这个算法有 3 个特性：压缩快，解压不需要额外内存，压缩比可以自动调节。在这里，你可以理解为一个数组缓存，套了一层压缩，来节约内存。当设备寄存器数量中等时，可以考虑这种缓存类型。
- 而最后一类红黑树，它的特性就是索引快，所以当设备寄存器数量比较大，或者对寄存器操作延时要求低时，就可以用这种缓存类型。
缓存的类型是在 regmap 初始化时，由配置regmap_config的 cache_type 来指定的。
对于 regmap_read 来说，会先判断当前缓存是否有值，然后再检查是否需要 bypass，若没有，则可以直接从缓存里面取值，调用regcache_read来获取值，若需要从硬件上读取，则调用具体协议的读写函数，若是 I2C，调用i2c_transfer。
写的过程也是大同小异。
到此，在驱动程序中regmap的基本使用方法和调用简析就结束了。