[linux 驱动]regmap子系统详解与实战

嵌入式成长家

已于 2024-09-24 19:52:32 修改

阅读量1.2k

点赞数 14

分类专栏： linux驱动详解与实战文章标签： linux驱动 regmap子系统

于 2024-09-24 14:51:41 首次发布

本文链接：https://blog.csdn.net/weixin_49406449/article/details/142489712

版权

linux驱动详解与实战专栏收录该内容

8 篇文章 0 订阅

订阅专栏

3.1.1 regmap_init_i2c

3.1.2 regmap_init_spi

3.1.3 regmap_exit

3.2 regmap 设备访问 API 函数

3.2.1 regmap_read

3.2.2 regmap_write

4 示例

1 描述

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

通过 regmap 模型提供的统一接口函数来访问器件的寄存器，SOC 内部的寄存器也可以使用 regmap 接口函数来访问。

regmap 是 Linux 内核为了减少慢速 I/O 在驱动上的冗余开销，提供了一种通用的接口来操作硬件寄存器。另外，regmap 在驱动和硬件之间添加了 cache，降低了低速 I/O 的操作次数，提高了访问效率，缺点是实时性会降低。

regmap 框架结构如下图所示。

2 结构体

2.1 regmap

 52 struct regmap {
 53         union {
 54                 struct mutex mutex;
 55                 struct {
 56                         spinlock_t spinlock;
 57                         unsigned long spinlock_flags;
 58                 };
 59         };
 60         regmap_lock lock;
 61         regmap_unlock unlock;
 62         void *lock_arg; /* This is passed to lock/unlock functions */
 63         gfp_t alloc_flags;
 64 
 65         struct device *dev; /* Device we do I/O on */
 66         void *work_buf;     /* Scratch buffer used to format I/O */
 67         struct regmap_format format;  /* Buffer format */
 68         const struct regmap_bus *bus;
 69         void *bus_context;
 70         const char *name;
 71 
 72         bool async;
 73         spinlock_t async_lock;
 74         wait_queue_head_t async_waitq;
 75         struct list_head async_list;
 76         struct list_head async_free;
 77         int async_ret;
 78 
 79 #ifdef CONFIG_DEBUG_FS
 80         bool debugfs_disable;
 81         struct dentry *debugfs;
 82         const char *debugfs_name;
 83 
 84         unsigned int debugfs_reg_len;
 85         unsigned int debugfs_val_len;
 86         unsigned int debugfs_tot_len;
 87 
 88         struct list_head debugfs_off_cache;
 89         struct mutex cache_lock;
 90 #endif
 91 
 92         unsigned int max_register;
 93         bool (*writeable_reg)(struct device *dev, unsigned int reg);
 94         bool (*readable_reg)(struct device *dev, unsigned int reg);
 95         bool (*volatile_reg)(struct device *dev, unsigned int reg);
 96         bool (*precious_reg)(struct device *dev, unsigned int reg);
 97         bool (*readable_noinc_reg)(struct device *dev, unsigned int reg);
 98         const struct regmap_access_table *wr_table;
 99         const struct regmap_access_table *rd_table;
100         const struct regmap_access_table *volatile_table;
101         const struct regmap_access_table *precious_table;
102         const struct regmap_access_table *rd_noinc_table;
103 
104         int (*reg_read)(void *context, unsigned int reg, unsigned int *val);
105         int (*reg_write)(void *context, unsigned int reg, unsigned int val);
106         int (*reg_update_bits)(void *context, unsigned int reg,
107                                unsigned int mask, unsigned int val);
108 
109         bool defer_caching;
110 
111         unsigned long read_flag_mask;
112         unsigned long write_flag_mask;
113 
114         /* number of bits to (left) shift the reg value when formatting*/
115         int reg_shift;
116         int reg_stride;
117         int reg_stride_order;
118 
119         /* regcache specific members */
120         const struct regcache_ops *cache_ops;
121         enum regcache_type cache_type;
122 
123         /* number of bytes in reg_defaults_raw */
124         unsigned int cache_size_raw;
125         /* number of bytes per word in reg_defaults_raw */
126         unsigned int cache_word_size;
127         /* number of entries in reg_defaults */
128         unsigned int num_reg_defaults;
129         /* number of entries in reg_defaults_raw */
130         unsigned int num_reg_defaults_raw;
131 
132         /* if set, only the cache is modified not the HW */
133         bool cache_only;
134         /* if set, only the HW is modified not the cache */
135         bool cache_bypass;
136         /* if set, remember to free reg_defaults_raw */
137         bool cache_free;
138 
139         struct reg_default *reg_defaults;
140         const void *reg_defaults_raw;
141         void *cache;
142         /* if set, the cache contains newer data than the HW */
143         bool cache_dirty;
144         /* if set, the HW registers are known to match map->reg_defaults */
145         bool no_sync_defaults;
146 
147         struct reg_sequence *patch;
148         int patch_regs;
149 
150         /* if set, converts bulk read to single read */
151         bool use_single_read;
152         /* if set, converts bulk read to single read */
153         bool use_single_write;
154         /* if set, the device supports multi write mode */
155         bool can_multi_write;
156 
157         /* if set, raw reads/writes are limited to this size */
158         size_t max_raw_read;
159         size_t max_raw_write;
160 
161         struct rb_root range_tree;
162         void *selector_work_buf;        /* Scratch buffer used for selector */
163 
164         struct hwspinlock *hwlock;
165 };

2.2 regmap_bus

regmap_bus 的结构体，它用于描述一种与寄存器映射（regmap）交互的硬件总线或接口的属性和功能。在嵌入式系统或硬件驱动开发中，寄存器映射是一种常见的技术，用于通过内存地址空间访问硬件设备的寄存器。这种方式使得软件可以像操作内存一样来读写硬件的寄存器，从而控制硬件设备。

regmap_bus结构定义了读写函数和默认的寄存器地址和寄存器值的大小端。

492 struct regmap_bus {             
 493         bool fast_io;
 494         regmap_hw_write write; 
 495         regmap_hw_gather_write gather_write;
 496         regmap_hw_async_write async_write;
 497         regmap_hw_reg_write reg_write;
 498         regmap_hw_reg_update_bits reg_update_bits;
 499         regmap_hw_read read;
 500         regmap_hw_reg_read reg_read;
 501         regmap_hw_free_context free_context;
 502         regmap_hw_async_alloc async_alloc;
 503         u8 read_flag_mask;
 504         enum regmap_endian reg_format_endian_default;
 505         enum regmap_endian val_format_endian_default;
 506         size_t max_raw_read;         
 507         size_t max_raw_write;        
 508 };

bool fast_io;：一个布尔值，指示是否使用快速I/O模式。这可能会影响读写操作的性能和方式。

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;：一个无符号8位整数，用作读操作时的标志掩码，可能用于控制读操作的某些方面。

enum regmap_endian reg_format_endian_default;：一个枚举类型，表示寄存器格式（即寄存器在硬件中的存储方式）的默认字节序（大端或小端）。

enum regmap_endian val_format_endian_default;：一个枚举类型，表示值格式（即写入或读取到寄存器的值的存储方式）的默认字节序。

size_t max_raw_read; 和 size_t max_raw_write;：分别表示在一次操作中能够读取或写入的最大原始数据量（以字节为单位）。这对于了解硬件的限制和优化数据传输效率很重要。