2 * Register map access API
4 * Copyright 2011 Wolfson Microelectronics plc
6 * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License version 2 as
10 * published by the Free Software Foundation.
13 #include <linux/slab.h>
14 #include <linux/module.h>
15 #include <linux/mutex.h>
16 #include <linux/err.h>
18 #define CREATE_TRACE_POINTS
19 #include <trace/events/regmap.h>
23 static void regmap_format_4_12_write(struct regmap
*map
,
24 unsigned int reg
, unsigned int val
)
26 __be16
*out
= map
->work_buf
;
27 *out
= cpu_to_be16((reg
<< 12) | val
);
30 static void regmap_format_7_9_write(struct regmap
*map
,
31 unsigned int reg
, unsigned int val
)
33 __be16
*out
= map
->work_buf
;
34 *out
= cpu_to_be16((reg
<< 9) | val
);
37 static void regmap_format_8(void *buf
, unsigned int val
)
44 static void regmap_format_16(void *buf
, unsigned int val
)
48 b
[0] = cpu_to_be16(val
);
51 static unsigned int regmap_parse_8(void *buf
)
58 static unsigned int regmap_parse_16(void *buf
)
62 b
[0] = be16_to_cpu(b
[0]);
68 * regmap_init(): Initialise register map
70 * @dev: Device that will be interacted with
71 * @bus: Bus-specific callbacks to use with device
72 * @config: Configuration for register map
74 * The return value will be an ERR_PTR() on error or a valid pointer to
75 * a struct regmap. This function should generally not be called
76 * directly, it should be called by bus-specific init functions.
78 struct regmap
*regmap_init(struct device
*dev
,
79 const struct regmap_bus
*bus
,
80 const struct regmap_config
*config
)
88 map
= kzalloc(sizeof(*map
), GFP_KERNEL
);
94 mutex_init(&map
->lock
);
95 map
->format
.buf_size
= (config
->reg_bits
+ config
->val_bits
) / 8;
96 map
->format
.reg_bytes
= config
->reg_bits
/ 8;
97 map
->format
.val_bytes
= config
->val_bits
/ 8;
100 map
->max_register
= config
->max_register
;
101 map
->writeable_reg
= config
->writeable_reg
;
102 map
->readable_reg
= config
->readable_reg
;
103 map
->volatile_reg
= config
->volatile_reg
;
104 map
->precious_reg
= config
->precious_reg
;
106 switch (config
->reg_bits
) {
108 switch (config
->val_bits
) {
110 map
->format
.format_write
= regmap_format_4_12_write
;
118 switch (config
->val_bits
) {
120 map
->format
.format_write
= regmap_format_7_9_write
;
128 map
->format
.format_reg
= regmap_format_8
;
132 map
->format
.format_reg
= regmap_format_16
;
139 switch (config
->val_bits
) {
141 map
->format
.format_val
= regmap_format_8
;
142 map
->format
.parse_val
= regmap_parse_8
;
145 map
->format
.format_val
= regmap_format_16
;
146 map
->format
.parse_val
= regmap_parse_16
;
150 if (!map
->format
.format_write
&&
151 !(map
->format
.format_reg
&& map
->format
.format_val
))
154 map
->work_buf
= kmalloc(map
->format
.buf_size
, GFP_KERNEL
);
155 if (map
->work_buf
== NULL
) {
160 regmap_debugfs_init(map
);
165 module_put(map
->bus
->owner
);
171 EXPORT_SYMBOL_GPL(regmap_init
);
174 * regmap_exit(): Free a previously allocated register map
176 void regmap_exit(struct regmap
*map
)
178 regmap_debugfs_exit(map
);
179 kfree(map
->work_buf
);
180 module_put(map
->bus
->owner
);
183 EXPORT_SYMBOL_GPL(regmap_exit
);
185 static int _regmap_raw_write(struct regmap
*map
, unsigned int reg
,
186 const void *val
, size_t val_len
)
193 /* Check for unwritable registers before we start */
194 if (map
->writeable_reg
)
195 for (i
= 0; i
< val_len
/ map
->format
.val_bytes
; i
++)
196 if (!map
->writeable_reg(map
->dev
, reg
+ i
))
199 map
->format
.format_reg(map
->work_buf
, reg
);
201 trace_regmap_hw_write_start(map
->dev
, reg
,
202 val_len
/ map
->format
.val_bytes
);
204 /* If we're doing a single register write we can probably just
205 * send the work_buf directly, otherwise try to do a gather
208 if (val
== map
->work_buf
+ map
->format
.reg_bytes
)
209 ret
= map
->bus
->write(map
->dev
, map
->work_buf
,
210 map
->format
.reg_bytes
+ val_len
);
211 else if (map
->bus
->gather_write
)
212 ret
= map
->bus
->gather_write(map
->dev
, map
->work_buf
,
213 map
->format
.reg_bytes
,
216 /* If that didn't work fall back on linearising by hand. */
217 if (ret
== -ENOTSUPP
) {
218 len
= map
->format
.reg_bytes
+ val_len
;
219 buf
= kmalloc(len
, GFP_KERNEL
);
223 memcpy(buf
, map
->work_buf
, map
->format
.reg_bytes
);
224 memcpy(buf
+ map
->format
.reg_bytes
, val
, val_len
);
225 ret
= map
->bus
->write(map
->dev
, buf
, len
);
230 trace_regmap_hw_write_done(map
->dev
, reg
,
231 val_len
/ map
->format
.val_bytes
);
236 static int _regmap_write(struct regmap
*map
, unsigned int reg
,
240 BUG_ON(!map
->format
.format_write
&& !map
->format
.format_val
);
242 trace_regmap_reg_write(map
->dev
, reg
, val
);
244 if (map
->format
.format_write
) {
245 map
->format
.format_write(map
, reg
, val
);
247 trace_regmap_hw_write_start(map
->dev
, reg
, 1);
249 ret
= map
->bus
->write(map
->dev
, map
->work_buf
,
250 map
->format
.buf_size
);
252 trace_regmap_hw_write_done(map
->dev
, reg
, 1);
256 map
->format
.format_val(map
->work_buf
+ map
->format
.reg_bytes
,
258 return _regmap_raw_write(map
, reg
,
259 map
->work_buf
+ map
->format
.reg_bytes
,
260 map
->format
.val_bytes
);
265 * regmap_write(): Write a value to a single register
267 * @map: Register map to write to
268 * @reg: Register to write to
269 * @val: Value to be written
271 * A value of zero will be returned on success, a negative errno will
272 * be returned in error cases.
274 int regmap_write(struct regmap
*map
, unsigned int reg
, unsigned int val
)
278 mutex_lock(&map
->lock
);
280 ret
= _regmap_write(map
, reg
, val
);
282 mutex_unlock(&map
->lock
);
286 EXPORT_SYMBOL_GPL(regmap_write
);
289 * regmap_raw_write(): Write raw values to one or more registers
291 * @map: Register map to write to
292 * @reg: Initial register to write to
293 * @val: Block of data to be written, laid out for direct transmission to the
295 * @val_len: Length of data pointed to by val.
297 * This function is intended to be used for things like firmware
298 * download where a large block of data needs to be transferred to the
299 * device. No formatting will be done on the data provided.
301 * A value of zero will be returned on success, a negative errno will
302 * be returned in error cases.
304 int regmap_raw_write(struct regmap
*map
, unsigned int reg
,
305 const void *val
, size_t val_len
)
309 mutex_lock(&map
->lock
);
311 ret
= _regmap_raw_write(map
, reg
, val
, val_len
);
313 mutex_unlock(&map
->lock
);
317 EXPORT_SYMBOL_GPL(regmap_raw_write
);
319 static int _regmap_raw_read(struct regmap
*map
, unsigned int reg
, void *val
,
320 unsigned int val_len
)
322 u8
*u8
= map
->work_buf
;
325 map
->format
.format_reg(map
->work_buf
, reg
);
328 * Some buses flag reads by setting the high bits in the
329 * register addresss; since it's always the high bits for all
330 * current formats we can do this here rather than in
331 * formatting. This may break if we get interesting formats.
333 if (map
->bus
->read_flag_mask
)
334 u8
[0] |= map
->bus
->read_flag_mask
;
336 trace_regmap_hw_read_start(map
->dev
, reg
,
337 val_len
/ map
->format
.val_bytes
);
339 ret
= map
->bus
->read(map
->dev
, map
->work_buf
, map
->format
.reg_bytes
,
342 trace_regmap_hw_read_done(map
->dev
, reg
,
343 val_len
/ map
->format
.val_bytes
);
348 static int _regmap_read(struct regmap
*map
, unsigned int reg
,
353 if (!map
->format
.parse_val
)
356 ret
= _regmap_raw_read(map
, reg
, map
->work_buf
, map
->format
.val_bytes
);
358 *val
= map
->format
.parse_val(map
->work_buf
);
359 trace_regmap_reg_read(map
->dev
, reg
, *val
);
366 * regmap_read(): Read a value from a single register
368 * @map: Register map to write to
369 * @reg: Register to be read from
370 * @val: Pointer to store read value
372 * A value of zero will be returned on success, a negative errno will
373 * be returned in error cases.
375 int regmap_read(struct regmap
*map
, unsigned int reg
, unsigned int *val
)
379 mutex_lock(&map
->lock
);
381 ret
= _regmap_read(map
, reg
, val
);
383 mutex_unlock(&map
->lock
);
387 EXPORT_SYMBOL_GPL(regmap_read
);
390 * regmap_raw_read(): Read raw data from the device
392 * @map: Register map to write to
393 * @reg: First register to be read from
394 * @val: Pointer to store read value
395 * @val_len: Size of data to read
397 * A value of zero will be returned on success, a negative errno will
398 * be returned in error cases.
400 int regmap_raw_read(struct regmap
*map
, unsigned int reg
, void *val
,
405 mutex_lock(&map
->lock
);
407 ret
= _regmap_raw_read(map
, reg
, val
, val_len
);
409 mutex_unlock(&map
->lock
);
413 EXPORT_SYMBOL_GPL(regmap_raw_read
);
416 * regmap_bulk_read(): Read multiple registers from the device
418 * @map: Register map to write to
419 * @reg: First register to be read from
420 * @val: Pointer to store read value, in native register size for device
421 * @val_count: Number of registers to read
423 * A value of zero will be returned on success, a negative errno will
424 * be returned in error cases.
426 int regmap_bulk_read(struct regmap
*map
, unsigned int reg
, void *val
,
430 size_t val_bytes
= map
->format
.val_bytes
;
432 if (!map
->format
.parse_val
)
435 ret
= regmap_raw_read(map
, reg
, val
, val_bytes
* val_count
);
439 for (i
= 0; i
< val_count
* val_bytes
; i
+= val_bytes
)
440 map
->format
.parse_val(val
+ i
);
444 EXPORT_SYMBOL_GPL(regmap_bulk_read
);
447 * remap_update_bits: Perform a read/modify/write cycle on the register map
449 * @map: Register map to update
450 * @reg: Register to update
451 * @mask: Bitmask to change
452 * @val: New value for bitmask
454 * Returns zero for success, a negative number on error.
456 int regmap_update_bits(struct regmap
*map
, unsigned int reg
,
457 unsigned int mask
, unsigned int val
)
462 mutex_lock(&map
->lock
);
464 ret
= _regmap_read(map
, reg
, &tmp
);
471 ret
= _regmap_write(map
, reg
, tmp
);
474 mutex_unlock(&map
->lock
);
478 EXPORT_SYMBOL_GPL(regmap_update_bits
);
480 static int __init
regmap_initcall(void)
482 regmap_debugfs_initcall();
486 postcore_initcall(regmap_initcall
);
This page took 0.055956 seconds and 6 git commands to generate.