Loading...
1/*
2 * Register map access API
3 *
4 * Copyright 2011 Wolfson Microelectronics plc
5 *
6 * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
7 *
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.
11 */
12
13#include <linux/slab.h>
14#include <linux/module.h>
15#include <linux/mutex.h>
16#include <linux/err.h>
17
18#include <linux/regmap.h>
19
20struct regmap;
21
22struct regmap_format {
23 size_t buf_size;
24 size_t reg_bytes;
25 size_t val_bytes;
26 void (*format_write)(struct regmap *map,
27 unsigned int reg, unsigned int val);
28 void (*format_reg)(void *buf, unsigned int reg);
29 void (*format_val)(void *buf, unsigned int val);
30 unsigned int (*parse_val)(void *buf);
31};
32
33struct regmap {
34 struct mutex lock;
35
36 struct device *dev; /* Device we do I/O on */
37 void *work_buf; /* Scratch buffer used to format I/O */
38 struct regmap_format format; /* Buffer format */
39 const struct regmap_bus *bus;
40};
41
42static void regmap_format_4_12_write(struct regmap *map,
43 unsigned int reg, unsigned int val)
44{
45 __be16 *out = map->work_buf;
46 *out = cpu_to_be16((reg << 12) | val);
47}
48
49static void regmap_format_7_9_write(struct regmap *map,
50 unsigned int reg, unsigned int val)
51{
52 __be16 *out = map->work_buf;
53 *out = cpu_to_be16((reg << 9) | val);
54}
55
56static void regmap_format_8(void *buf, unsigned int val)
57{
58 u8 *b = buf;
59
60 b[0] = val;
61}
62
63static void regmap_format_16(void *buf, unsigned int val)
64{
65 __be16 *b = buf;
66
67 b[0] = cpu_to_be16(val);
68}
69
70static unsigned int regmap_parse_8(void *buf)
71{
72 u8 *b = buf;
73
74 return b[0];
75}
76
77static unsigned int regmap_parse_16(void *buf)
78{
79 __be16 *b = buf;
80
81 b[0] = be16_to_cpu(b[0]);
82
83 return b[0];
84}
85
86/**
87 * regmap_init(): Initialise register map
88 *
89 * @dev: Device that will be interacted with
90 * @bus: Bus-specific callbacks to use with device
91 * @config: Configuration for register map
92 *
93 * The return value will be an ERR_PTR() on error or a valid pointer to
94 * a struct regmap. This function should generally not be called
95 * directly, it should be called by bus-specific init functions.
96 */
97struct regmap *regmap_init(struct device *dev,
98 const struct regmap_bus *bus,
99 const struct regmap_config *config)
100{
101 struct regmap *map;
102 int ret = -EINVAL;
103
104 if (!bus || !config)
105 return NULL;
106
107 map = kzalloc(sizeof(*map), GFP_KERNEL);
108 if (map == NULL) {
109 ret = -ENOMEM;
110 goto err;
111 }
112
113 mutex_init(&map->lock);
114 map->format.buf_size = (config->reg_bits + config->val_bits) / 8;
115 map->format.reg_bytes = config->reg_bits / 8;
116 map->format.val_bytes = config->val_bits / 8;
117 map->dev = dev;
118 map->bus = bus;
119
120 switch (config->reg_bits) {
121 case 4:
122 switch (config->val_bits) {
123 case 12:
124 map->format.format_write = regmap_format_4_12_write;
125 break;
126 default:
127 goto err_map;
128 }
129 break;
130
131 case 7:
132 switch (config->val_bits) {
133 case 9:
134 map->format.format_write = regmap_format_7_9_write;
135 break;
136 default:
137 goto err_map;
138 }
139 break;
140
141 case 8:
142 map->format.format_reg = regmap_format_8;
143 break;
144
145 case 16:
146 map->format.format_reg = regmap_format_16;
147 break;
148
149 default:
150 goto err_map;
151 }
152
153 switch (config->val_bits) {
154 case 8:
155 map->format.format_val = regmap_format_8;
156 map->format.parse_val = regmap_parse_8;
157 break;
158 case 16:
159 map->format.format_val = regmap_format_16;
160 map->format.parse_val = regmap_parse_16;
161 break;
162 }
163
164 if (!map->format.format_write &&
165 !(map->format.format_reg && map->format.format_val))
166 goto err_map;
167
168 map->work_buf = kmalloc(map->format.buf_size, GFP_KERNEL);
169 if (map->work_buf == NULL) {
170 ret = -ENOMEM;
171 goto err_map;
172 }
173
174 return map;
175
176err_map:
177 kfree(map);
178err:
179 return ERR_PTR(ret);
180}
181EXPORT_SYMBOL_GPL(regmap_init);
182
183/**
184 * regmap_exit(): Free a previously allocated register map
185 */
186void regmap_exit(struct regmap *map)
187{
188 kfree(map->work_buf);
189 kfree(map);
190}
191EXPORT_SYMBOL_GPL(regmap_exit);
192
193static int _regmap_raw_write(struct regmap *map, unsigned int reg,
194 const void *val, size_t val_len)
195{
196 void *buf;
197 int ret = -ENOTSUPP;
198 size_t len;
199
200 map->format.format_reg(map->work_buf, reg);
201
202 /* Try to do a gather write if we can */
203 if (map->bus->gather_write)
204 ret = map->bus->gather_write(map->dev, map->work_buf,
205 map->format.reg_bytes,
206 val, val_len);
207
208 /* Otherwise fall back on linearising by hand. */
209 if (ret == -ENOTSUPP) {
210 len = map->format.reg_bytes + val_len;
211 buf = kmalloc(len, GFP_KERNEL);
212 if (!buf)
213 return -ENOMEM;
214
215 memcpy(buf, map->work_buf, map->format.reg_bytes);
216 memcpy(buf + map->format.reg_bytes, val, val_len);
217 ret = map->bus->write(map->dev, buf, len);
218
219 kfree(buf);
220 }
221
222 return ret;
223}
224
225static int _regmap_write(struct regmap *map, unsigned int reg,
226 unsigned int val)
227{
228 BUG_ON(!map->format.format_write && !map->format.format_val);
229
230 if (map->format.format_write) {
231 map->format.format_write(map, reg, val);
232
233 return map->bus->write(map->dev, map->work_buf,
234 map->format.buf_size);
235 } else {
236 map->format.format_val(map->work_buf + map->format.reg_bytes,
237 val);
238 return _regmap_raw_write(map, reg,
239 map->work_buf + map->format.reg_bytes,
240 map->format.val_bytes);
241 }
242}
243
244/**
245 * regmap_write(): Write a value to a single register
246 *
247 * @map: Register map to write to
248 * @reg: Register to write to
249 * @val: Value to be written
250 *
251 * A value of zero will be returned on success, a negative errno will
252 * be returned in error cases.
253 */
254int regmap_write(struct regmap *map, unsigned int reg, unsigned int val)
255{
256 int ret;
257
258 mutex_lock(&map->lock);
259
260 ret = _regmap_write(map, reg, val);
261
262 mutex_unlock(&map->lock);
263
264 return ret;
265}
266EXPORT_SYMBOL_GPL(regmap_write);
267
268/**
269 * regmap_raw_write(): Write raw values to one or more registers
270 *
271 * @map: Register map to write to
272 * @reg: Initial register to write to
273 * @val: Block of data to be written, laid out for direct transmission to the
274 * device
275 * @val_len: Length of data pointed to by val.
276 *
277 * This function is intended to be used for things like firmware
278 * download where a large block of data needs to be transferred to the
279 * device. No formatting will be done on the data provided.
280 *
281 * A value of zero will be returned on success, a negative errno will
282 * be returned in error cases.
283 */
284int regmap_raw_write(struct regmap *map, unsigned int reg,
285 const void *val, size_t val_len)
286{
287 int ret;
288
289 mutex_lock(&map->lock);
290
291 ret = _regmap_raw_write(map, reg, val, val_len);
292
293 mutex_unlock(&map->lock);
294
295 return ret;
296}
297EXPORT_SYMBOL_GPL(regmap_raw_write);
298
299static int _regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
300 unsigned int val_len)
301{
302 u8 *u8 = map->work_buf;
303 int ret;
304
305 map->format.format_reg(map->work_buf, reg);
306
307 /*
308 * Some buses flag reads by setting the high bits in the
309 * register addresss; since it's always the high bits for all
310 * current formats we can do this here rather than in
311 * formatting. This may break if we get interesting formats.
312 */
313 if (map->bus->read_flag_mask)
314 u8[0] |= map->bus->read_flag_mask;
315
316 ret = map->bus->read(map->dev, map->work_buf, map->format.reg_bytes,
317 val, val_len);
318 if (ret != 0)
319 return ret;
320
321 return 0;
322}
323
324static int _regmap_read(struct regmap *map, unsigned int reg,
325 unsigned int *val)
326{
327 int ret;
328
329 if (!map->format.parse_val)
330 return -EINVAL;
331
332 ret = _regmap_raw_read(map, reg, map->work_buf, map->format.val_bytes);
333 if (ret == 0)
334 *val = map->format.parse_val(map->work_buf);
335
336 return ret;
337}
338
339/**
340 * regmap_read(): Read a value from a single register
341 *
342 * @map: Register map to write to
343 * @reg: Register to be read from
344 * @val: Pointer to store read value
345 *
346 * A value of zero will be returned on success, a negative errno will
347 * be returned in error cases.
348 */
349int regmap_read(struct regmap *map, unsigned int reg, unsigned int *val)
350{
351 int ret;
352
353 mutex_lock(&map->lock);
354
355 ret = _regmap_read(map, reg, val);
356
357 mutex_unlock(&map->lock);
358
359 return ret;
360}
361EXPORT_SYMBOL_GPL(regmap_read);
362
363/**
364 * regmap_raw_read(): Read raw data from the device
365 *
366 * @map: Register map to write to
367 * @reg: First register to be read from
368 * @val: Pointer to store read value
369 * @val_len: Size of data to read
370 *
371 * A value of zero will be returned on success, a negative errno will
372 * be returned in error cases.
373 */
374int regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
375 size_t val_len)
376{
377 int ret;
378
379 mutex_lock(&map->lock);
380
381 ret = _regmap_raw_read(map, reg, val, val_len);
382
383 mutex_unlock(&map->lock);
384
385 return ret;
386}
387EXPORT_SYMBOL_GPL(regmap_raw_read);
388
389/**
390 * regmap_bulk_read(): Read multiple registers from the device
391 *
392 * @map: Register map to write to
393 * @reg: First register to be read from
394 * @val: Pointer to store read value, in native register size for device
395 * @val_count: Number of registers to read
396 *
397 * A value of zero will be returned on success, a negative errno will
398 * be returned in error cases.
399 */
400int regmap_bulk_read(struct regmap *map, unsigned int reg, void *val,
401 size_t val_count)
402{
403 int ret, i;
404 size_t val_bytes = map->format.val_bytes;
405
406 if (!map->format.parse_val)
407 return -EINVAL;
408
409 ret = regmap_raw_read(map, reg, val, val_bytes * val_count);
410 if (ret != 0)
411 return ret;
412
413 for (i = 0; i < val_count * val_bytes; i += val_bytes)
414 map->format.parse_val(val + i);
415
416 return 0;
417}
418EXPORT_SYMBOL_GPL(regmap_bulk_read);
419
420/**
421 * remap_update_bits: Perform a read/modify/write cycle on the register map
422 *
423 * @map: Register map to update
424 * @reg: Register to update
425 * @mask: Bitmask to change
426 * @val: New value for bitmask
427 *
428 * Returns zero for success, a negative number on error.
429 */
430int regmap_update_bits(struct regmap *map, unsigned int reg,
431 unsigned int mask, unsigned int val)
432{
433 int ret;
434 unsigned int tmp;
435
436 mutex_lock(&map->lock);
437
438 ret = _regmap_read(map, reg, &tmp);
439 if (ret != 0)
440 goto out;
441
442 tmp &= ~mask;
443 tmp |= val & mask;
444
445 ret = _regmap_write(map, reg, tmp);
446
447out:
448 mutex_unlock(&map->lock);
449
450 return ret;
451}
452EXPORT_SYMBOL_GPL(regmap_update_bits);
1/*
2 * Register map access API
3 *
4 * Copyright 2011 Wolfson Microelectronics plc
5 *
6 * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
7 *
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.
11 */
12
13#include <linux/device.h>
14#include <linux/slab.h>
15#include <linux/export.h>
16#include <linux/mutex.h>
17#include <linux/err.h>
18
19#define CREATE_TRACE_POINTS
20#include <trace/events/regmap.h>
21
22#include "internal.h"
23
24bool regmap_writeable(struct regmap *map, unsigned int reg)
25{
26 if (map->max_register && reg > map->max_register)
27 return false;
28
29 if (map->writeable_reg)
30 return map->writeable_reg(map->dev, reg);
31
32 return true;
33}
34
35bool regmap_readable(struct regmap *map, unsigned int reg)
36{
37 if (map->max_register && reg > map->max_register)
38 return false;
39
40 if (map->format.format_write)
41 return false;
42
43 if (map->readable_reg)
44 return map->readable_reg(map->dev, reg);
45
46 return true;
47}
48
49bool regmap_volatile(struct regmap *map, unsigned int reg)
50{
51 if (!regmap_readable(map, reg))
52 return false;
53
54 if (map->volatile_reg)
55 return map->volatile_reg(map->dev, reg);
56
57 return true;
58}
59
60bool regmap_precious(struct regmap *map, unsigned int reg)
61{
62 if (!regmap_readable(map, reg))
63 return false;
64
65 if (map->precious_reg)
66 return map->precious_reg(map->dev, reg);
67
68 return false;
69}
70
71static bool regmap_volatile_range(struct regmap *map, unsigned int reg,
72 unsigned int num)
73{
74 unsigned int i;
75
76 for (i = 0; i < num; i++)
77 if (!regmap_volatile(map, reg + i))
78 return false;
79
80 return true;
81}
82
83static void regmap_format_2_6_write(struct regmap *map,
84 unsigned int reg, unsigned int val)
85{
86 u8 *out = map->work_buf;
87
88 *out = (reg << 6) | val;
89}
90
91static void regmap_format_4_12_write(struct regmap *map,
92 unsigned int reg, unsigned int val)
93{
94 __be16 *out = map->work_buf;
95 *out = cpu_to_be16((reg << 12) | val);
96}
97
98static void regmap_format_7_9_write(struct regmap *map,
99 unsigned int reg, unsigned int val)
100{
101 __be16 *out = map->work_buf;
102 *out = cpu_to_be16((reg << 9) | val);
103}
104
105static void regmap_format_10_14_write(struct regmap *map,
106 unsigned int reg, unsigned int val)
107{
108 u8 *out = map->work_buf;
109
110 out[2] = val;
111 out[1] = (val >> 8) | (reg << 6);
112 out[0] = reg >> 2;
113}
114
115static void regmap_format_8(void *buf, unsigned int val, unsigned int shift)
116{
117 u8 *b = buf;
118
119 b[0] = val << shift;
120}
121
122static void regmap_format_16(void *buf, unsigned int val, unsigned int shift)
123{
124 __be16 *b = buf;
125
126 b[0] = cpu_to_be16(val << shift);
127}
128
129static void regmap_format_24(void *buf, unsigned int val, unsigned int shift)
130{
131 u8 *b = buf;
132
133 val <<= shift;
134
135 b[0] = val >> 16;
136 b[1] = val >> 8;
137 b[2] = val;
138}
139
140static void regmap_format_32(void *buf, unsigned int val, unsigned int shift)
141{
142 __be32 *b = buf;
143
144 b[0] = cpu_to_be32(val << shift);
145}
146
147static unsigned int regmap_parse_8(void *buf)
148{
149 u8 *b = buf;
150
151 return b[0];
152}
153
154static unsigned int regmap_parse_16(void *buf)
155{
156 __be16 *b = buf;
157
158 b[0] = be16_to_cpu(b[0]);
159
160 return b[0];
161}
162
163static unsigned int regmap_parse_24(void *buf)
164{
165 u8 *b = buf;
166 unsigned int ret = b[2];
167 ret |= ((unsigned int)b[1]) << 8;
168 ret |= ((unsigned int)b[0]) << 16;
169
170 return ret;
171}
172
173static unsigned int regmap_parse_32(void *buf)
174{
175 __be32 *b = buf;
176
177 b[0] = be32_to_cpu(b[0]);
178
179 return b[0];
180}
181
182static void regmap_lock_mutex(struct regmap *map)
183{
184 mutex_lock(&map->mutex);
185}
186
187static void regmap_unlock_mutex(struct regmap *map)
188{
189 mutex_unlock(&map->mutex);
190}
191
192static void regmap_lock_spinlock(struct regmap *map)
193{
194 spin_lock(&map->spinlock);
195}
196
197static void regmap_unlock_spinlock(struct regmap *map)
198{
199 spin_unlock(&map->spinlock);
200}
201
202static void dev_get_regmap_release(struct device *dev, void *res)
203{
204 /*
205 * We don't actually have anything to do here; the goal here
206 * is not to manage the regmap but to provide a simple way to
207 * get the regmap back given a struct device.
208 */
209}
210
211/**
212 * regmap_init(): Initialise register map
213 *
214 * @dev: Device that will be interacted with
215 * @bus: Bus-specific callbacks to use with device
216 * @bus_context: Data passed to bus-specific callbacks
217 * @config: Configuration for register map
218 *
219 * The return value will be an ERR_PTR() on error or a valid pointer to
220 * a struct regmap. This function should generally not be called
221 * directly, it should be called by bus-specific init functions.
222 */
223struct regmap *regmap_init(struct device *dev,
224 const struct regmap_bus *bus,
225 void *bus_context,
226 const struct regmap_config *config)
227{
228 struct regmap *map, **m;
229 int ret = -EINVAL;
230
231 if (!bus || !config)
232 goto err;
233
234 map = kzalloc(sizeof(*map), GFP_KERNEL);
235 if (map == NULL) {
236 ret = -ENOMEM;
237 goto err;
238 }
239
240 if (bus->fast_io) {
241 spin_lock_init(&map->spinlock);
242 map->lock = regmap_lock_spinlock;
243 map->unlock = regmap_unlock_spinlock;
244 } else {
245 mutex_init(&map->mutex);
246 map->lock = regmap_lock_mutex;
247 map->unlock = regmap_unlock_mutex;
248 }
249 map->format.reg_bytes = DIV_ROUND_UP(config->reg_bits, 8);
250 map->format.pad_bytes = config->pad_bits / 8;
251 map->format.val_bytes = DIV_ROUND_UP(config->val_bits, 8);
252 map->format.buf_size = DIV_ROUND_UP(config->reg_bits +
253 config->val_bits + config->pad_bits, 8);
254 map->reg_shift = config->pad_bits % 8;
255 if (config->reg_stride)
256 map->reg_stride = config->reg_stride;
257 else
258 map->reg_stride = 1;
259 map->use_single_rw = config->use_single_rw;
260 map->dev = dev;
261 map->bus = bus;
262 map->bus_context = bus_context;
263 map->max_register = config->max_register;
264 map->writeable_reg = config->writeable_reg;
265 map->readable_reg = config->readable_reg;
266 map->volatile_reg = config->volatile_reg;
267 map->precious_reg = config->precious_reg;
268 map->cache_type = config->cache_type;
269 map->name = config->name;
270
271 if (config->read_flag_mask || config->write_flag_mask) {
272 map->read_flag_mask = config->read_flag_mask;
273 map->write_flag_mask = config->write_flag_mask;
274 } else {
275 map->read_flag_mask = bus->read_flag_mask;
276 }
277
278 switch (config->reg_bits + map->reg_shift) {
279 case 2:
280 switch (config->val_bits) {
281 case 6:
282 map->format.format_write = regmap_format_2_6_write;
283 break;
284 default:
285 goto err_map;
286 }
287 break;
288
289 case 4:
290 switch (config->val_bits) {
291 case 12:
292 map->format.format_write = regmap_format_4_12_write;
293 break;
294 default:
295 goto err_map;
296 }
297 break;
298
299 case 7:
300 switch (config->val_bits) {
301 case 9:
302 map->format.format_write = regmap_format_7_9_write;
303 break;
304 default:
305 goto err_map;
306 }
307 break;
308
309 case 10:
310 switch (config->val_bits) {
311 case 14:
312 map->format.format_write = regmap_format_10_14_write;
313 break;
314 default:
315 goto err_map;
316 }
317 break;
318
319 case 8:
320 map->format.format_reg = regmap_format_8;
321 break;
322
323 case 16:
324 map->format.format_reg = regmap_format_16;
325 break;
326
327 case 32:
328 map->format.format_reg = regmap_format_32;
329 break;
330
331 default:
332 goto err_map;
333 }
334
335 switch (config->val_bits) {
336 case 8:
337 map->format.format_val = regmap_format_8;
338 map->format.parse_val = regmap_parse_8;
339 break;
340 case 16:
341 map->format.format_val = regmap_format_16;
342 map->format.parse_val = regmap_parse_16;
343 break;
344 case 24:
345 map->format.format_val = regmap_format_24;
346 map->format.parse_val = regmap_parse_24;
347 break;
348 case 32:
349 map->format.format_val = regmap_format_32;
350 map->format.parse_val = regmap_parse_32;
351 break;
352 }
353
354 if (map->format.format_write)
355 map->use_single_rw = true;
356
357 if (!map->format.format_write &&
358 !(map->format.format_reg && map->format.format_val))
359 goto err_map;
360
361 map->work_buf = kzalloc(map->format.buf_size, GFP_KERNEL);
362 if (map->work_buf == NULL) {
363 ret = -ENOMEM;
364 goto err_map;
365 }
366
367 regmap_debugfs_init(map, config->name);
368
369 ret = regcache_init(map, config);
370 if (ret < 0)
371 goto err_debugfs;
372
373 /* Add a devres resource for dev_get_regmap() */
374 m = devres_alloc(dev_get_regmap_release, sizeof(*m), GFP_KERNEL);
375 if (!m) {
376 ret = -ENOMEM;
377 goto err_cache;
378 }
379 *m = map;
380 devres_add(dev, m);
381
382 return map;
383
384err_cache:
385 regcache_exit(map);
386err_debugfs:
387 regmap_debugfs_exit(map);
388 kfree(map->work_buf);
389err_map:
390 kfree(map);
391err:
392 return ERR_PTR(ret);
393}
394EXPORT_SYMBOL_GPL(regmap_init);
395
396static void devm_regmap_release(struct device *dev, void *res)
397{
398 regmap_exit(*(struct regmap **)res);
399}
400
401/**
402 * devm_regmap_init(): Initialise managed register map
403 *
404 * @dev: Device that will be interacted with
405 * @bus: Bus-specific callbacks to use with device
406 * @bus_context: Data passed to bus-specific callbacks
407 * @config: Configuration for register map
408 *
409 * The return value will be an ERR_PTR() on error or a valid pointer
410 * to a struct regmap. This function should generally not be called
411 * directly, it should be called by bus-specific init functions. The
412 * map will be automatically freed by the device management code.
413 */
414struct regmap *devm_regmap_init(struct device *dev,
415 const struct regmap_bus *bus,
416 void *bus_context,
417 const struct regmap_config *config)
418{
419 struct regmap **ptr, *regmap;
420
421 ptr = devres_alloc(devm_regmap_release, sizeof(*ptr), GFP_KERNEL);
422 if (!ptr)
423 return ERR_PTR(-ENOMEM);
424
425 regmap = regmap_init(dev, bus, bus_context, config);
426 if (!IS_ERR(regmap)) {
427 *ptr = regmap;
428 devres_add(dev, ptr);
429 } else {
430 devres_free(ptr);
431 }
432
433 return regmap;
434}
435EXPORT_SYMBOL_GPL(devm_regmap_init);
436
437/**
438 * regmap_reinit_cache(): Reinitialise the current register cache
439 *
440 * @map: Register map to operate on.
441 * @config: New configuration. Only the cache data will be used.
442 *
443 * Discard any existing register cache for the map and initialize a
444 * new cache. This can be used to restore the cache to defaults or to
445 * update the cache configuration to reflect runtime discovery of the
446 * hardware.
447 */
448int regmap_reinit_cache(struct regmap *map, const struct regmap_config *config)
449{
450 int ret;
451
452 map->lock(map);
453
454 regcache_exit(map);
455 regmap_debugfs_exit(map);
456
457 map->max_register = config->max_register;
458 map->writeable_reg = config->writeable_reg;
459 map->readable_reg = config->readable_reg;
460 map->volatile_reg = config->volatile_reg;
461 map->precious_reg = config->precious_reg;
462 map->cache_type = config->cache_type;
463
464 regmap_debugfs_init(map, config->name);
465
466 map->cache_bypass = false;
467 map->cache_only = false;
468
469 ret = regcache_init(map, config);
470
471 map->unlock(map);
472
473 return ret;
474}
475EXPORT_SYMBOL_GPL(regmap_reinit_cache);
476
477/**
478 * regmap_exit(): Free a previously allocated register map
479 */
480void regmap_exit(struct regmap *map)
481{
482 regcache_exit(map);
483 regmap_debugfs_exit(map);
484 if (map->bus->free_context)
485 map->bus->free_context(map->bus_context);
486 kfree(map->work_buf);
487 kfree(map);
488}
489EXPORT_SYMBOL_GPL(regmap_exit);
490
491static int dev_get_regmap_match(struct device *dev, void *res, void *data)
492{
493 struct regmap **r = res;
494 if (!r || !*r) {
495 WARN_ON(!r || !*r);
496 return 0;
497 }
498
499 /* If the user didn't specify a name match any */
500 if (data)
501 return (*r)->name == data;
502 else
503 return 1;
504}
505
506/**
507 * dev_get_regmap(): Obtain the regmap (if any) for a device
508 *
509 * @dev: Device to retrieve the map for
510 * @name: Optional name for the register map, usually NULL.
511 *
512 * Returns the regmap for the device if one is present, or NULL. If
513 * name is specified then it must match the name specified when
514 * registering the device, if it is NULL then the first regmap found
515 * will be used. Devices with multiple register maps are very rare,
516 * generic code should normally not need to specify a name.
517 */
518struct regmap *dev_get_regmap(struct device *dev, const char *name)
519{
520 struct regmap **r = devres_find(dev, dev_get_regmap_release,
521 dev_get_regmap_match, (void *)name);
522
523 if (!r)
524 return NULL;
525 return *r;
526}
527EXPORT_SYMBOL_GPL(dev_get_regmap);
528
529static int _regmap_raw_write(struct regmap *map, unsigned int reg,
530 const void *val, size_t val_len)
531{
532 u8 *u8 = map->work_buf;
533 void *buf;
534 int ret = -ENOTSUPP;
535 size_t len;
536 int i;
537
538 /* Check for unwritable registers before we start */
539 if (map->writeable_reg)
540 for (i = 0; i < val_len / map->format.val_bytes; i++)
541 if (!map->writeable_reg(map->dev,
542 reg + (i * map->reg_stride)))
543 return -EINVAL;
544
545 if (!map->cache_bypass && map->format.parse_val) {
546 unsigned int ival;
547 int val_bytes = map->format.val_bytes;
548 for (i = 0; i < val_len / val_bytes; i++) {
549 memcpy(map->work_buf, val + (i * val_bytes), val_bytes);
550 ival = map->format.parse_val(map->work_buf);
551 ret = regcache_write(map, reg + (i * map->reg_stride),
552 ival);
553 if (ret) {
554 dev_err(map->dev,
555 "Error in caching of register: %u ret: %d\n",
556 reg + i, ret);
557 return ret;
558 }
559 }
560 if (map->cache_only) {
561 map->cache_dirty = true;
562 return 0;
563 }
564 }
565
566 map->format.format_reg(map->work_buf, reg, map->reg_shift);
567
568 u8[0] |= map->write_flag_mask;
569
570 trace_regmap_hw_write_start(map->dev, reg,
571 val_len / map->format.val_bytes);
572
573 /* If we're doing a single register write we can probably just
574 * send the work_buf directly, otherwise try to do a gather
575 * write.
576 */
577 if (val == (map->work_buf + map->format.pad_bytes +
578 map->format.reg_bytes))
579 ret = map->bus->write(map->bus_context, map->work_buf,
580 map->format.reg_bytes +
581 map->format.pad_bytes +
582 val_len);
583 else if (map->bus->gather_write)
584 ret = map->bus->gather_write(map->bus_context, map->work_buf,
585 map->format.reg_bytes +
586 map->format.pad_bytes,
587 val, val_len);
588
589 /* If that didn't work fall back on linearising by hand. */
590 if (ret == -ENOTSUPP) {
591 len = map->format.reg_bytes + map->format.pad_bytes + val_len;
592 buf = kzalloc(len, GFP_KERNEL);
593 if (!buf)
594 return -ENOMEM;
595
596 memcpy(buf, map->work_buf, map->format.reg_bytes);
597 memcpy(buf + map->format.reg_bytes + map->format.pad_bytes,
598 val, val_len);
599 ret = map->bus->write(map->bus_context, buf, len);
600
601 kfree(buf);
602 }
603
604 trace_regmap_hw_write_done(map->dev, reg,
605 val_len / map->format.val_bytes);
606
607 return ret;
608}
609
610int _regmap_write(struct regmap *map, unsigned int reg,
611 unsigned int val)
612{
613 int ret;
614 BUG_ON(!map->format.format_write && !map->format.format_val);
615
616 if (!map->cache_bypass && map->format.format_write) {
617 ret = regcache_write(map, reg, val);
618 if (ret != 0)
619 return ret;
620 if (map->cache_only) {
621 map->cache_dirty = true;
622 return 0;
623 }
624 }
625
626 trace_regmap_reg_write(map->dev, reg, val);
627
628 if (map->format.format_write) {
629 map->format.format_write(map, reg, val);
630
631 trace_regmap_hw_write_start(map->dev, reg, 1);
632
633 ret = map->bus->write(map->bus_context, map->work_buf,
634 map->format.buf_size);
635
636 trace_regmap_hw_write_done(map->dev, reg, 1);
637
638 return ret;
639 } else {
640 map->format.format_val(map->work_buf + map->format.reg_bytes
641 + map->format.pad_bytes, val, 0);
642 return _regmap_raw_write(map, reg,
643 map->work_buf +
644 map->format.reg_bytes +
645 map->format.pad_bytes,
646 map->format.val_bytes);
647 }
648}
649
650/**
651 * regmap_write(): Write a value to a single register
652 *
653 * @map: Register map to write to
654 * @reg: Register to write to
655 * @val: Value to be written
656 *
657 * A value of zero will be returned on success, a negative errno will
658 * be returned in error cases.
659 */
660int regmap_write(struct regmap *map, unsigned int reg, unsigned int val)
661{
662 int ret;
663
664 if (reg % map->reg_stride)
665 return -EINVAL;
666
667 map->lock(map);
668
669 ret = _regmap_write(map, reg, val);
670
671 map->unlock(map);
672
673 return ret;
674}
675EXPORT_SYMBOL_GPL(regmap_write);
676
677/**
678 * regmap_raw_write(): Write raw values to one or more registers
679 *
680 * @map: Register map to write to
681 * @reg: Initial register to write to
682 * @val: Block of data to be written, laid out for direct transmission to the
683 * device
684 * @val_len: Length of data pointed to by val.
685 *
686 * This function is intended to be used for things like firmware
687 * download where a large block of data needs to be transferred to the
688 * device. No formatting will be done on the data provided.
689 *
690 * A value of zero will be returned on success, a negative errno will
691 * be returned in error cases.
692 */
693int regmap_raw_write(struct regmap *map, unsigned int reg,
694 const void *val, size_t val_len)
695{
696 int ret;
697
698 if (val_len % map->format.val_bytes)
699 return -EINVAL;
700 if (reg % map->reg_stride)
701 return -EINVAL;
702
703 map->lock(map);
704
705 ret = _regmap_raw_write(map, reg, val, val_len);
706
707 map->unlock(map);
708
709 return ret;
710}
711EXPORT_SYMBOL_GPL(regmap_raw_write);
712
713/*
714 * regmap_bulk_write(): Write multiple registers to the device
715 *
716 * @map: Register map to write to
717 * @reg: First register to be write from
718 * @val: Block of data to be written, in native register size for device
719 * @val_count: Number of registers to write
720 *
721 * This function is intended to be used for writing a large block of
722 * data to be device either in single transfer or multiple transfer.
723 *
724 * A value of zero will be returned on success, a negative errno will
725 * be returned in error cases.
726 */
727int regmap_bulk_write(struct regmap *map, unsigned int reg, const void *val,
728 size_t val_count)
729{
730 int ret = 0, i;
731 size_t val_bytes = map->format.val_bytes;
732 void *wval;
733
734 if (!map->format.parse_val)
735 return -EINVAL;
736 if (reg % map->reg_stride)
737 return -EINVAL;
738
739 map->lock(map);
740
741 /* No formatting is require if val_byte is 1 */
742 if (val_bytes == 1) {
743 wval = (void *)val;
744 } else {
745 wval = kmemdup(val, val_count * val_bytes, GFP_KERNEL);
746 if (!wval) {
747 ret = -ENOMEM;
748 dev_err(map->dev, "Error in memory allocation\n");
749 goto out;
750 }
751 for (i = 0; i < val_count * val_bytes; i += val_bytes)
752 map->format.parse_val(wval + i);
753 }
754 /*
755 * Some devices does not support bulk write, for
756 * them we have a series of single write operations.
757 */
758 if (map->use_single_rw) {
759 for (i = 0; i < val_count; i++) {
760 ret = regmap_raw_write(map,
761 reg + (i * map->reg_stride),
762 val + (i * val_bytes),
763 val_bytes);
764 if (ret != 0)
765 return ret;
766 }
767 } else {
768 ret = _regmap_raw_write(map, reg, wval, val_bytes * val_count);
769 }
770
771 if (val_bytes != 1)
772 kfree(wval);
773
774out:
775 map->unlock(map);
776 return ret;
777}
778EXPORT_SYMBOL_GPL(regmap_bulk_write);
779
780static int _regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
781 unsigned int val_len)
782{
783 u8 *u8 = map->work_buf;
784 int ret;
785
786 map->format.format_reg(map->work_buf, reg, map->reg_shift);
787
788 /*
789 * Some buses or devices flag reads by setting the high bits in the
790 * register addresss; since it's always the high bits for all
791 * current formats we can do this here rather than in
792 * formatting. This may break if we get interesting formats.
793 */
794 u8[0] |= map->read_flag_mask;
795
796 trace_regmap_hw_read_start(map->dev, reg,
797 val_len / map->format.val_bytes);
798
799 ret = map->bus->read(map->bus_context, map->work_buf,
800 map->format.reg_bytes + map->format.pad_bytes,
801 val, val_len);
802
803 trace_regmap_hw_read_done(map->dev, reg,
804 val_len / map->format.val_bytes);
805
806 return ret;
807}
808
809static int _regmap_read(struct regmap *map, unsigned int reg,
810 unsigned int *val)
811{
812 int ret;
813
814 if (!map->cache_bypass) {
815 ret = regcache_read(map, reg, val);
816 if (ret == 0)
817 return 0;
818 }
819
820 if (!map->format.parse_val)
821 return -EINVAL;
822
823 if (map->cache_only)
824 return -EBUSY;
825
826 ret = _regmap_raw_read(map, reg, map->work_buf, map->format.val_bytes);
827 if (ret == 0) {
828 *val = map->format.parse_val(map->work_buf);
829 trace_regmap_reg_read(map->dev, reg, *val);
830 }
831
832 if (ret == 0 && !map->cache_bypass)
833 regcache_write(map, reg, *val);
834
835 return ret;
836}
837
838/**
839 * regmap_read(): Read a value from a single register
840 *
841 * @map: Register map to write to
842 * @reg: Register to be read from
843 * @val: Pointer to store read value
844 *
845 * A value of zero will be returned on success, a negative errno will
846 * be returned in error cases.
847 */
848int regmap_read(struct regmap *map, unsigned int reg, unsigned int *val)
849{
850 int ret;
851
852 if (reg % map->reg_stride)
853 return -EINVAL;
854
855 map->lock(map);
856
857 ret = _regmap_read(map, reg, val);
858
859 map->unlock(map);
860
861 return ret;
862}
863EXPORT_SYMBOL_GPL(regmap_read);
864
865/**
866 * regmap_raw_read(): Read raw data from the device
867 *
868 * @map: Register map to write to
869 * @reg: First register to be read from
870 * @val: Pointer to store read value
871 * @val_len: Size of data to read
872 *
873 * A value of zero will be returned on success, a negative errno will
874 * be returned in error cases.
875 */
876int regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
877 size_t val_len)
878{
879 size_t val_bytes = map->format.val_bytes;
880 size_t val_count = val_len / val_bytes;
881 unsigned int v;
882 int ret, i;
883
884 if (val_len % map->format.val_bytes)
885 return -EINVAL;
886 if (reg % map->reg_stride)
887 return -EINVAL;
888
889 map->lock(map);
890
891 if (regmap_volatile_range(map, reg, val_count) || map->cache_bypass ||
892 map->cache_type == REGCACHE_NONE) {
893 /* Physical block read if there's no cache involved */
894 ret = _regmap_raw_read(map, reg, val, val_len);
895
896 } else {
897 /* Otherwise go word by word for the cache; should be low
898 * cost as we expect to hit the cache.
899 */
900 for (i = 0; i < val_count; i++) {
901 ret = _regmap_read(map, reg + (i * map->reg_stride),
902 &v);
903 if (ret != 0)
904 goto out;
905
906 map->format.format_val(val + (i * val_bytes), v, 0);
907 }
908 }
909
910 out:
911 map->unlock(map);
912
913 return ret;
914}
915EXPORT_SYMBOL_GPL(regmap_raw_read);
916
917/**
918 * regmap_bulk_read(): Read multiple registers from the device
919 *
920 * @map: Register map to write to
921 * @reg: First register to be read from
922 * @val: Pointer to store read value, in native register size for device
923 * @val_count: Number of registers to read
924 *
925 * A value of zero will be returned on success, a negative errno will
926 * be returned in error cases.
927 */
928int regmap_bulk_read(struct regmap *map, unsigned int reg, void *val,
929 size_t val_count)
930{
931 int ret, i;
932 size_t val_bytes = map->format.val_bytes;
933 bool vol = regmap_volatile_range(map, reg, val_count);
934
935 if (!map->format.parse_val)
936 return -EINVAL;
937 if (reg % map->reg_stride)
938 return -EINVAL;
939
940 if (vol || map->cache_type == REGCACHE_NONE) {
941 /*
942 * Some devices does not support bulk read, for
943 * them we have a series of single read operations.
944 */
945 if (map->use_single_rw) {
946 for (i = 0; i < val_count; i++) {
947 ret = regmap_raw_read(map,
948 reg + (i * map->reg_stride),
949 val + (i * val_bytes),
950 val_bytes);
951 if (ret != 0)
952 return ret;
953 }
954 } else {
955 ret = regmap_raw_read(map, reg, val,
956 val_bytes * val_count);
957 if (ret != 0)
958 return ret;
959 }
960
961 for (i = 0; i < val_count * val_bytes; i += val_bytes)
962 map->format.parse_val(val + i);
963 } else {
964 for (i = 0; i < val_count; i++) {
965 unsigned int ival;
966 ret = regmap_read(map, reg + (i * map->reg_stride),
967 &ival);
968 if (ret != 0)
969 return ret;
970 memcpy(val + (i * val_bytes), &ival, val_bytes);
971 }
972 }
973
974 return 0;
975}
976EXPORT_SYMBOL_GPL(regmap_bulk_read);
977
978static int _regmap_update_bits(struct regmap *map, unsigned int reg,
979 unsigned int mask, unsigned int val,
980 bool *change)
981{
982 int ret;
983 unsigned int tmp, orig;
984
985 map->lock(map);
986
987 ret = _regmap_read(map, reg, &orig);
988 if (ret != 0)
989 goto out;
990
991 tmp = orig & ~mask;
992 tmp |= val & mask;
993
994 if (tmp != orig) {
995 ret = _regmap_write(map, reg, tmp);
996 *change = true;
997 } else {
998 *change = false;
999 }
1000
1001out:
1002 map->unlock(map);
1003
1004 return ret;
1005}
1006
1007/**
1008 * regmap_update_bits: Perform a read/modify/write cycle on the register map
1009 *
1010 * @map: Register map to update
1011 * @reg: Register to update
1012 * @mask: Bitmask to change
1013 * @val: New value for bitmask
1014 *
1015 * Returns zero for success, a negative number on error.
1016 */
1017int regmap_update_bits(struct regmap *map, unsigned int reg,
1018 unsigned int mask, unsigned int val)
1019{
1020 bool change;
1021 return _regmap_update_bits(map, reg, mask, val, &change);
1022}
1023EXPORT_SYMBOL_GPL(regmap_update_bits);
1024
1025/**
1026 * regmap_update_bits_check: Perform a read/modify/write cycle on the
1027 * register map and report if updated
1028 *
1029 * @map: Register map to update
1030 * @reg: Register to update
1031 * @mask: Bitmask to change
1032 * @val: New value for bitmask
1033 * @change: Boolean indicating if a write was done
1034 *
1035 * Returns zero for success, a negative number on error.
1036 */
1037int regmap_update_bits_check(struct regmap *map, unsigned int reg,
1038 unsigned int mask, unsigned int val,
1039 bool *change)
1040{
1041 return _regmap_update_bits(map, reg, mask, val, change);
1042}
1043EXPORT_SYMBOL_GPL(regmap_update_bits_check);
1044
1045/**
1046 * regmap_register_patch: Register and apply register updates to be applied
1047 * on device initialistion
1048 *
1049 * @map: Register map to apply updates to.
1050 * @regs: Values to update.
1051 * @num_regs: Number of entries in regs.
1052 *
1053 * Register a set of register updates to be applied to the device
1054 * whenever the device registers are synchronised with the cache and
1055 * apply them immediately. Typically this is used to apply
1056 * corrections to be applied to the device defaults on startup, such
1057 * as the updates some vendors provide to undocumented registers.
1058 */
1059int regmap_register_patch(struct regmap *map, const struct reg_default *regs,
1060 int num_regs)
1061{
1062 int i, ret;
1063 bool bypass;
1064
1065 /* If needed the implementation can be extended to support this */
1066 if (map->patch)
1067 return -EBUSY;
1068
1069 map->lock(map);
1070
1071 bypass = map->cache_bypass;
1072
1073 map->cache_bypass = true;
1074
1075 /* Write out first; it's useful to apply even if we fail later. */
1076 for (i = 0; i < num_regs; i++) {
1077 ret = _regmap_write(map, regs[i].reg, regs[i].def);
1078 if (ret != 0) {
1079 dev_err(map->dev, "Failed to write %x = %x: %d\n",
1080 regs[i].reg, regs[i].def, ret);
1081 goto out;
1082 }
1083 }
1084
1085 map->patch = kcalloc(num_regs, sizeof(struct reg_default), GFP_KERNEL);
1086 if (map->patch != NULL) {
1087 memcpy(map->patch, regs,
1088 num_regs * sizeof(struct reg_default));
1089 map->patch_regs = num_regs;
1090 } else {
1091 ret = -ENOMEM;
1092 }
1093
1094out:
1095 map->cache_bypass = bypass;
1096
1097 map->unlock(map);
1098
1099 return ret;
1100}
1101EXPORT_SYMBOL_GPL(regmap_register_patch);
1102
1103/*
1104 * regmap_get_val_bytes(): Report the size of a register value
1105 *
1106 * Report the size of a register value, mainly intended to for use by
1107 * generic infrastructure built on top of regmap.
1108 */
1109int regmap_get_val_bytes(struct regmap *map)
1110{
1111 if (map->format.format_write)
1112 return -EINVAL;
1113
1114 return map->format.val_bytes;
1115}
1116EXPORT_SYMBOL_GPL(regmap_get_val_bytes);
1117
1118static int __init regmap_initcall(void)
1119{
1120 regmap_debugfs_initcall();
1121
1122 return 0;
1123}
1124postcore_initcall(regmap_initcall);