Branch data Line data Source code
1 : : #ifndef __LINUX_REGMAP_H
2 : : #define __LINUX_REGMAP_H
3 : :
4 : : /*
5 : : * Register map access API
6 : : *
7 : : * Copyright 2011 Wolfson Microelectronics plc
8 : : *
9 : : * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
10 : : *
11 : : * This program is free software; you can redistribute it and/or modify
12 : : * it under the terms of the GNU General Public License version 2 as
13 : : * published by the Free Software Foundation.
14 : : */
15 : :
16 : : #include <linux/list.h>
17 : : #include <linux/rbtree.h>
18 : : #include <linux/err.h>
19 : : #include <linux/bug.h>
20 : :
21 : : struct module;
22 : : struct device;
23 : : struct i2c_client;
24 : : struct irq_domain;
25 : : struct spi_device;
26 : : struct spmi_device;
27 : : struct regmap;
28 : : struct regmap_range_cfg;
29 : : struct regmap_field;
30 : :
31 : : /* An enum of all the supported cache types */
32 : : enum regcache_type {
33 : : REGCACHE_NONE,
34 : : REGCACHE_RBTREE,
35 : : REGCACHE_COMPRESSED,
36 : : REGCACHE_FLAT,
37 : : };
38 : :
39 : : /**
40 : : * Default value for a register. We use an array of structs rather
41 : : * than a simple array as many modern devices have very sparse
42 : : * register maps.
43 : : *
44 : : * @reg: Register address.
45 : : * @def: Register default value.
46 : : */
47 : : struct reg_default {
48 : : unsigned int reg;
49 : : unsigned int def;
50 : : };
51 : :
52 : : #ifdef CONFIG_REGMAP
53 : :
54 : : enum regmap_endian {
55 : : /* Unspecified -> 0 -> Backwards compatible default */
56 : : REGMAP_ENDIAN_DEFAULT = 0,
57 : : REGMAP_ENDIAN_BIG,
58 : : REGMAP_ENDIAN_LITTLE,
59 : : REGMAP_ENDIAN_NATIVE,
60 : : };
61 : :
62 : : /**
63 : : * A register range, used for access related checks
64 : : * (readable/writeable/volatile/precious checks)
65 : : *
66 : : * @range_min: address of first register
67 : : * @range_max: address of last register
68 : : */
69 : : struct regmap_range {
70 : : unsigned int range_min;
71 : : unsigned int range_max;
72 : : };
73 : :
74 : : #define regmap_reg_range(low, high) { .range_min = low, .range_max = high, }
75 : :
76 : : /*
77 : : * A table of ranges including some yes ranges and some no ranges.
78 : : * If a register belongs to a no_range, the corresponding check function
79 : : * will return false. If a register belongs to a yes range, the corresponding
80 : : * check function will return true. "no_ranges" are searched first.
81 : : *
82 : : * @yes_ranges : pointer to an array of regmap ranges used as "yes ranges"
83 : : * @n_yes_ranges: size of the above array
84 : : * @no_ranges: pointer to an array of regmap ranges used as "no ranges"
85 : : * @n_no_ranges: size of the above array
86 : : */
87 : : struct regmap_access_table {
88 : : const struct regmap_range *yes_ranges;
89 : : unsigned int n_yes_ranges;
90 : : const struct regmap_range *no_ranges;
91 : : unsigned int n_no_ranges;
92 : : };
93 : :
94 : : typedef void (*regmap_lock)(void *);
95 : : typedef void (*regmap_unlock)(void *);
96 : :
97 : : /**
98 : : * Configuration for the register map of a device.
99 : : *
100 : : * @name: Optional name of the regmap. Useful when a device has multiple
101 : : * register regions.
102 : : *
103 : : * @reg_bits: Number of bits in a register address, mandatory.
104 : : * @reg_stride: The register address stride. Valid register addresses are a
105 : : * multiple of this value. If set to 0, a value of 1 will be
106 : : * used.
107 : : * @pad_bits: Number of bits of padding between register and value.
108 : : * @val_bits: Number of bits in a register value, mandatory.
109 : : *
110 : : * @writeable_reg: Optional callback returning true if the register
111 : : * can be written to. If this field is NULL but wr_table
112 : : * (see below) is not, the check is performed on such table
113 : : * (a register is writeable if it belongs to one of the ranges
114 : : * specified by wr_table).
115 : : * @readable_reg: Optional callback returning true if the register
116 : : * can be read from. If this field is NULL but rd_table
117 : : * (see below) is not, the check is performed on such table
118 : : * (a register is readable if it belongs to one of the ranges
119 : : * specified by rd_table).
120 : : * @volatile_reg: Optional callback returning true if the register
121 : : * value can't be cached. If this field is NULL but
122 : : * volatile_table (see below) is not, the check is performed on
123 : : * such table (a register is volatile if it belongs to one of
124 : : * the ranges specified by volatile_table).
125 : : * @precious_reg: Optional callback returning true if the rgister
126 : : * should not be read outside of a call from the driver
127 : : * (eg, a clear on read interrupt status register). If this
128 : : * field is NULL but precious_table (see below) is not, the
129 : : * check is performed on such table (a register is precious if
130 : : * it belongs to one of the ranges specified by precious_table).
131 : : * @lock: Optional lock callback (overrides regmap's default lock
132 : : * function, based on spinlock or mutex).
133 : : * @unlock: As above for unlocking.
134 : : * @lock_arg: this field is passed as the only argument of lock/unlock
135 : : * functions (ignored in case regular lock/unlock functions
136 : : * are not overridden).
137 : : * @reg_read: Optional callback that if filled will be used to perform
138 : : * all the reads from the registers. Should only be provided for
139 : : * devices whos read operation cannot be represented as a simple read
140 : : * operation on a bus such as SPI, I2C, etc. Most of the devices do
141 : : * not need this.
142 : : * @reg_write: Same as above for writing.
143 : : * @fast_io: Register IO is fast. Use a spinlock instead of a mutex
144 : : * to perform locking. This field is ignored if custom lock/unlock
145 : : * functions are used (see fields lock/unlock of struct regmap_config).
146 : : * This field is a duplicate of a similar file in
147 : : * 'struct regmap_bus' and serves exact same purpose.
148 : : * Use it only for "no-bus" cases.
149 : : * @max_register: Optional, specifies the maximum valid register index.
150 : : * @wr_table: Optional, points to a struct regmap_access_table specifying
151 : : * valid ranges for write access.
152 : : * @rd_table: As above, for read access.
153 : : * @volatile_table: As above, for volatile registers.
154 : : * @precious_table: As above, for precious registers.
155 : : * @reg_defaults: Power on reset values for registers (for use with
156 : : * register cache support).
157 : : * @num_reg_defaults: Number of elements in reg_defaults.
158 : : *
159 : : * @read_flag_mask: Mask to be set in the top byte of the register when doing
160 : : * a read.
161 : : * @write_flag_mask: Mask to be set in the top byte of the register when doing
162 : : * a write. If both read_flag_mask and write_flag_mask are
163 : : * empty the regmap_bus default masks are used.
164 : : * @use_single_rw: If set, converts the bulk read and write operations into
165 : : * a series of single read and write operations. This is useful
166 : : * for device that does not support bulk read and write.
167 : : *
168 : : * @cache_type: The actual cache type.
169 : : * @reg_defaults_raw: Power on reset values for registers (for use with
170 : : * register cache support).
171 : : * @num_reg_defaults_raw: Number of elements in reg_defaults_raw.
172 : : * @reg_format_endian: Endianness for formatted register addresses. If this is
173 : : * DEFAULT, the @reg_format_endian_default value from the
174 : : * regmap bus is used.
175 : : * @val_format_endian: Endianness for formatted register values. If this is
176 : : * DEFAULT, the @reg_format_endian_default value from the
177 : : * regmap bus is used.
178 : : *
179 : : * @ranges: Array of configuration entries for virtual address ranges.
180 : : * @num_ranges: Number of range configuration entries.
181 : : */
182 : : struct regmap_config {
183 : : const char *name;
184 : :
185 : : int reg_bits;
186 : : int reg_stride;
187 : : int pad_bits;
188 : : int val_bits;
189 : :
190 : : bool (*writeable_reg)(struct device *dev, unsigned int reg);
191 : : bool (*readable_reg)(struct device *dev, unsigned int reg);
192 : : bool (*volatile_reg)(struct device *dev, unsigned int reg);
193 : : bool (*precious_reg)(struct device *dev, unsigned int reg);
194 : : regmap_lock lock;
195 : : regmap_unlock unlock;
196 : : void *lock_arg;
197 : :
198 : : int (*reg_read)(void *context, unsigned int reg, unsigned int *val);
199 : : int (*reg_write)(void *context, unsigned int reg, unsigned int val);
200 : :
201 : : bool fast_io;
202 : :
203 : : unsigned int max_register;
204 : : const struct regmap_access_table *wr_table;
205 : : const struct regmap_access_table *rd_table;
206 : : const struct regmap_access_table *volatile_table;
207 : : const struct regmap_access_table *precious_table;
208 : : const struct reg_default *reg_defaults;
209 : : unsigned int num_reg_defaults;
210 : : enum regcache_type cache_type;
211 : : const void *reg_defaults_raw;
212 : : unsigned int num_reg_defaults_raw;
213 : :
214 : : u8 read_flag_mask;
215 : : u8 write_flag_mask;
216 : :
217 : : bool use_single_rw;
218 : :
219 : : enum regmap_endian reg_format_endian;
220 : : enum regmap_endian val_format_endian;
221 : :
222 : : const struct regmap_range_cfg *ranges;
223 : : unsigned int num_ranges;
224 : : };
225 : :
226 : : /**
227 : : * Configuration for indirectly accessed or paged registers.
228 : : * Registers, mapped to this virtual range, are accessed in two steps:
229 : : * 1. page selector register update;
230 : : * 2. access through data window registers.
231 : : *
232 : : * @name: Descriptive name for diagnostics
233 : : *
234 : : * @range_min: Address of the lowest register address in virtual range.
235 : : * @range_max: Address of the highest register in virtual range.
236 : : *
237 : : * @page_sel_reg: Register with selector field.
238 : : * @page_sel_mask: Bit shift for selector value.
239 : : * @page_sel_shift: Bit mask for selector value.
240 : : *
241 : : * @window_start: Address of first (lowest) register in data window.
242 : : * @window_len: Number of registers in data window.
243 : : */
244 : : struct regmap_range_cfg {
245 : : const char *name;
246 : :
247 : : /* Registers of virtual address range */
248 : : unsigned int range_min;
249 : : unsigned int range_max;
250 : :
251 : : /* Page selector for indirect addressing */
252 : : unsigned int selector_reg;
253 : : unsigned int selector_mask;
254 : : int selector_shift;
255 : :
256 : : /* Data window (per each page) */
257 : : unsigned int window_start;
258 : : unsigned int window_len;
259 : : };
260 : :
261 : : struct regmap_async;
262 : :
263 : : typedef int (*regmap_hw_write)(void *context, const void *data,
264 : : size_t count);
265 : : typedef int (*regmap_hw_gather_write)(void *context,
266 : : const void *reg, size_t reg_len,
267 : : const void *val, size_t val_len);
268 : : typedef int (*regmap_hw_async_write)(void *context,
269 : : const void *reg, size_t reg_len,
270 : : const void *val, size_t val_len,
271 : : struct regmap_async *async);
272 : : typedef int (*regmap_hw_read)(void *context,
273 : : const void *reg_buf, size_t reg_size,
274 : : void *val_buf, size_t val_size);
275 : : typedef struct regmap_async *(*regmap_hw_async_alloc)(void);
276 : : typedef void (*regmap_hw_free_context)(void *context);
277 : :
278 : : /**
279 : : * Description of a hardware bus for the register map infrastructure.
280 : : *
281 : : * @fast_io: Register IO is fast. Use a spinlock instead of a mutex
282 : : * to perform locking. This field is ignored if custom lock/unlock
283 : : * functions are used (see fields lock/unlock of
284 : : * struct regmap_config).
285 : : * @write: Write operation.
286 : : * @gather_write: Write operation with split register/value, return -ENOTSUPP
287 : : * if not implemented on a given device.
288 : : * @async_write: Write operation which completes asynchronously, optional and
289 : : * must serialise with respect to non-async I/O.
290 : : * @read: Read operation. Data is returned in the buffer used to transmit
291 : : * data.
292 : : * @async_alloc: Allocate a regmap_async() structure.
293 : : * @read_flag_mask: Mask to be set in the top byte of the register when doing
294 : : * a read.
295 : : * @reg_format_endian_default: Default endianness for formatted register
296 : : * addresses. Used when the regmap_config specifies DEFAULT. If this is
297 : : * DEFAULT, BIG is assumed.
298 : : * @val_format_endian_default: Default endianness for formatted register
299 : : * values. Used when the regmap_config specifies DEFAULT. If this is
300 : : * DEFAULT, BIG is assumed.
301 : : * @async_size: Size of struct used for async work.
302 : : */
303 : : struct regmap_bus {
304 : : bool fast_io;
305 : : regmap_hw_write write;
306 : : regmap_hw_gather_write gather_write;
307 : : regmap_hw_async_write async_write;
308 : : regmap_hw_read read;
309 : : regmap_hw_free_context free_context;
310 : : regmap_hw_async_alloc async_alloc;
311 : : u8 read_flag_mask;
312 : : enum regmap_endian reg_format_endian_default;
313 : : enum regmap_endian val_format_endian_default;
314 : : };
315 : :
316 : : struct regmap *regmap_init(struct device *dev,
317 : : const struct regmap_bus *bus,
318 : : void *bus_context,
319 : : const struct regmap_config *config);
320 : : struct regmap *regmap_init_i2c(struct i2c_client *i2c,
321 : : const struct regmap_config *config);
322 : : struct regmap *regmap_init_spi(struct spi_device *dev,
323 : : const struct regmap_config *config);
324 : : struct regmap *regmap_init_spmi(struct spmi_device *dev,
325 : : const struct regmap_config *config);
326 : : struct regmap *regmap_init_mmio_clk(struct device *dev, const char *clk_id,
327 : : void __iomem *regs,
328 : : const struct regmap_config *config);
329 : :
330 : : struct regmap *devm_regmap_init(struct device *dev,
331 : : const struct regmap_bus *bus,
332 : : void *bus_context,
333 : : const struct regmap_config *config);
334 : : struct regmap *devm_regmap_init_i2c(struct i2c_client *i2c,
335 : : const struct regmap_config *config);
336 : : struct regmap *devm_regmap_init_spi(struct spi_device *dev,
337 : : const struct regmap_config *config);
338 : : struct regmap *devm_regmap_init_spmi(struct spmi_device *dev,
339 : : const struct regmap_config *config);
340 : : struct regmap *devm_regmap_init_mmio_clk(struct device *dev, const char *clk_id,
341 : : void __iomem *regs,
342 : : const struct regmap_config *config);
343 : :
344 : : /**
345 : : * regmap_init_mmio(): Initialise register map
346 : : *
347 : : * @dev: Device that will be interacted with
348 : : * @regs: Pointer to memory-mapped IO region
349 : : * @config: Configuration for register map
350 : : *
351 : : * The return value will be an ERR_PTR() on error or a valid pointer to
352 : : * a struct regmap.
353 : : */
354 : : static inline struct regmap *regmap_init_mmio(struct device *dev,
355 : : void __iomem *regs,
356 : : const struct regmap_config *config)
357 : : {
358 : : return regmap_init_mmio_clk(dev, NULL, regs, config);
359 : : }
360 : :
361 : : /**
362 : : * devm_regmap_init_mmio(): Initialise managed register map
363 : : *
364 : : * @dev: Device that will be interacted with
365 : : * @regs: Pointer to memory-mapped IO region
366 : : * @config: Configuration for register map
367 : : *
368 : : * The return value will be an ERR_PTR() on error or a valid pointer
369 : : * to a struct regmap. The regmap will be automatically freed by the
370 : : * device management code.
371 : : */
372 : : static inline struct regmap *devm_regmap_init_mmio(struct device *dev,
373 : : void __iomem *regs,
374 : : const struct regmap_config *config)
375 : : {
376 : : return devm_regmap_init_mmio_clk(dev, NULL, regs, config);
377 : : }
378 : :
379 : : void regmap_exit(struct regmap *map);
380 : : int regmap_reinit_cache(struct regmap *map,
381 : : const struct regmap_config *config);
382 : : struct regmap *dev_get_regmap(struct device *dev, const char *name);
383 : : int regmap_write(struct regmap *map, unsigned int reg, unsigned int val);
384 : : int regmap_write_async(struct regmap *map, unsigned int reg, unsigned int val);
385 : : int regmap_raw_write(struct regmap *map, unsigned int reg,
386 : : const void *val, size_t val_len);
387 : : int regmap_bulk_write(struct regmap *map, unsigned int reg, const void *val,
388 : : size_t val_count);
389 : : int regmap_multi_reg_write(struct regmap *map, struct reg_default *regs,
390 : : int num_regs);
391 : : int regmap_raw_write_async(struct regmap *map, unsigned int reg,
392 : : const void *val, size_t val_len);
393 : : int regmap_read(struct regmap *map, unsigned int reg, unsigned int *val);
394 : : int regmap_raw_read(struct regmap *map, unsigned int reg,
395 : : void *val, size_t val_len);
396 : : int regmap_bulk_read(struct regmap *map, unsigned int reg, void *val,
397 : : size_t val_count);
398 : : int regmap_update_bits(struct regmap *map, unsigned int reg,
399 : : unsigned int mask, unsigned int val);
400 : : int regmap_update_bits_async(struct regmap *map, unsigned int reg,
401 : : unsigned int mask, unsigned int val);
402 : : int regmap_update_bits_check(struct regmap *map, unsigned int reg,
403 : : unsigned int mask, unsigned int val,
404 : : bool *change);
405 : : int regmap_update_bits_check_async(struct regmap *map, unsigned int reg,
406 : : unsigned int mask, unsigned int val,
407 : : bool *change);
408 : : int regmap_get_val_bytes(struct regmap *map);
409 : : int regmap_async_complete(struct regmap *map);
410 : : bool regmap_can_raw_write(struct regmap *map);
411 : :
412 : : int regcache_sync(struct regmap *map);
413 : : int regcache_sync_region(struct regmap *map, unsigned int min,
414 : : unsigned int max);
415 : : int regcache_drop_region(struct regmap *map, unsigned int min,
416 : : unsigned int max);
417 : : void regcache_cache_only(struct regmap *map, bool enable);
418 : : void regcache_cache_bypass(struct regmap *map, bool enable);
419 : : void regcache_mark_dirty(struct regmap *map);
420 : :
421 : : bool regmap_check_range_table(struct regmap *map, unsigned int reg,
422 : : const struct regmap_access_table *table);
423 : :
424 : : int regmap_register_patch(struct regmap *map, const struct reg_default *regs,
425 : : int num_regs);
426 : :
427 : : static inline bool regmap_reg_in_range(unsigned int reg,
428 : : const struct regmap_range *range)
429 : : {
430 : : return reg >= range->range_min && reg <= range->range_max;
431 : : }
432 : :
433 : : bool regmap_reg_in_ranges(unsigned int reg,
434 : : const struct regmap_range *ranges,
435 : : unsigned int nranges);
436 : :
437 : : /**
438 : : * Description of an register field
439 : : *
440 : : * @reg: Offset of the register within the regmap bank
441 : : * @lsb: lsb of the register field.
442 : : * @reg: msb of the register field.
443 : : * @id_size: port size if it has some ports
444 : : * @id_offset: address offset for each ports
445 : : */
446 : : struct reg_field {
447 : : unsigned int reg;
448 : : unsigned int lsb;
449 : : unsigned int msb;
450 : : unsigned int id_size;
451 : : unsigned int id_offset;
452 : : };
453 : :
454 : : #define REG_FIELD(_reg, _lsb, _msb) { \
455 : : .reg = _reg, \
456 : : .lsb = _lsb, \
457 : : .msb = _msb, \
458 : : }
459 : :
460 : : struct regmap_field *regmap_field_alloc(struct regmap *regmap,
461 : : struct reg_field reg_field);
462 : : void regmap_field_free(struct regmap_field *field);
463 : :
464 : : struct regmap_field *devm_regmap_field_alloc(struct device *dev,
465 : : struct regmap *regmap, struct reg_field reg_field);
466 : : void devm_regmap_field_free(struct device *dev, struct regmap_field *field);
467 : :
468 : : int regmap_field_read(struct regmap_field *field, unsigned int *val);
469 : : int regmap_field_write(struct regmap_field *field, unsigned int val);
470 : : int regmap_field_update_bits(struct regmap_field *field,
471 : : unsigned int mask, unsigned int val);
472 : :
473 : : int regmap_fields_write(struct regmap_field *field, unsigned int id,
474 : : unsigned int val);
475 : : int regmap_fields_read(struct regmap_field *field, unsigned int id,
476 : : unsigned int *val);
477 : : int regmap_fields_update_bits(struct regmap_field *field, unsigned int id,
478 : : unsigned int mask, unsigned int val);
479 : :
480 : : /**
481 : : * Description of an IRQ for the generic regmap irq_chip.
482 : : *
483 : : * @reg_offset: Offset of the status/mask register within the bank
484 : : * @mask: Mask used to flag/control the register.
485 : : */
486 : : struct regmap_irq {
487 : : unsigned int reg_offset;
488 : : unsigned int mask;
489 : : };
490 : :
491 : : /**
492 : : * Description of a generic regmap irq_chip. This is not intended to
493 : : * handle every possible interrupt controller, but it should handle a
494 : : * substantial proportion of those that are found in the wild.
495 : : *
496 : : * @name: Descriptive name for IRQ controller.
497 : : *
498 : : * @status_base: Base status register address.
499 : : * @mask_base: Base mask register address.
500 : : * @ack_base: Base ack address. If zero then the chip is clear on read.
501 : : * @wake_base: Base address for wake enables. If zero unsupported.
502 : : * @irq_reg_stride: Stride to use for chips where registers are not contiguous.
503 : : * @init_ack_masked: Ack all masked interrupts once during initalization.
504 : : * @mask_invert: Inverted mask register: cleared bits are masked out.
505 : : * @wake_invert: Inverted wake register: cleared bits are wake enabled.
506 : : * @runtime_pm: Hold a runtime PM lock on the device when accessing it.
507 : : *
508 : : * @num_regs: Number of registers in each control bank.
509 : : * @irqs: Descriptors for individual IRQs. Interrupt numbers are
510 : : * assigned based on the index in the array of the interrupt.
511 : : * @num_irqs: Number of descriptors.
512 : : */
513 : : struct regmap_irq_chip {
514 : : const char *name;
515 : :
516 : : unsigned int status_base;
517 : : unsigned int mask_base;
518 : : unsigned int ack_base;
519 : : unsigned int wake_base;
520 : : unsigned int irq_reg_stride;
521 : : bool init_ack_masked:1;
522 : : bool mask_invert:1;
523 : : bool wake_invert:1;
524 : : bool runtime_pm:1;
525 : :
526 : : int num_regs;
527 : :
528 : : const struct regmap_irq *irqs;
529 : : int num_irqs;
530 : : };
531 : :
532 : : struct regmap_irq_chip_data;
533 : :
534 : : int regmap_add_irq_chip(struct regmap *map, int irq, int irq_flags,
535 : : int irq_base, const struct regmap_irq_chip *chip,
536 : : struct regmap_irq_chip_data **data);
537 : : void regmap_del_irq_chip(int irq, struct regmap_irq_chip_data *data);
538 : : int regmap_irq_chip_get_base(struct regmap_irq_chip_data *data);
539 : : int regmap_irq_get_virq(struct regmap_irq_chip_data *data, int irq);
540 : : struct irq_domain *regmap_irq_get_domain(struct regmap_irq_chip_data *data);
541 : :
542 : : #else
543 : :
544 : : /*
545 : : * These stubs should only ever be called by generic code which has
546 : : * regmap based facilities, if they ever get called at runtime
547 : : * something is going wrong and something probably needs to select
548 : : * REGMAP.
549 : : */
550 : :
551 : : static inline int regmap_write(struct regmap *map, unsigned int reg,
552 : : unsigned int val)
553 : : {
554 : : WARN_ONCE(1, "regmap API is disabled");
555 : : return -EINVAL;
556 : : }
557 : :
558 : : static inline int regmap_write_async(struct regmap *map, unsigned int reg,
559 : : unsigned int val)
560 : : {
561 : : WARN_ONCE(1, "regmap API is disabled");
562 : : return -EINVAL;
563 : : }
564 : :
565 : : static inline int regmap_raw_write(struct regmap *map, unsigned int reg,
566 : : const void *val, size_t val_len)
567 : : {
568 : : WARN_ONCE(1, "regmap API is disabled");
569 : : return -EINVAL;
570 : : }
571 : :
572 : : static inline int regmap_raw_write_async(struct regmap *map, unsigned int reg,
573 : : const void *val, size_t val_len)
574 : : {
575 : : WARN_ONCE(1, "regmap API is disabled");
576 : : return -EINVAL;
577 : : }
578 : :
579 : : static inline int regmap_bulk_write(struct regmap *map, unsigned int reg,
580 : : const void *val, size_t val_count)
581 : : {
582 : : WARN_ONCE(1, "regmap API is disabled");
583 : : return -EINVAL;
584 : : }
585 : :
586 : : static inline int regmap_read(struct regmap *map, unsigned int reg,
587 : : unsigned int *val)
588 : : {
589 [ # # ][ # # ]: 0 : WARN_ONCE(1, "regmap API is disabled");
[ # # ][ # # ]
[ # # ][ # # ]
590 : : return -EINVAL;
591 : : }
592 : :
593 : : static inline int regmap_raw_read(struct regmap *map, unsigned int reg,
594 : : void *val, size_t val_len)
595 : : {
596 : : WARN_ONCE(1, "regmap API is disabled");
597 : : return -EINVAL;
598 : : }
599 : :
600 : : static inline int regmap_bulk_read(struct regmap *map, unsigned int reg,
601 : : void *val, size_t val_count)
602 : : {
603 : : WARN_ONCE(1, "regmap API is disabled");
604 : : return -EINVAL;
605 : : }
606 : :
607 : : static inline int regmap_update_bits(struct regmap *map, unsigned int reg,
608 : : unsigned int mask, unsigned int val)
609 : : {
610 [ # # ][ # # ]: 0 : WARN_ONCE(1, "regmap API is disabled");
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
611 : : return -EINVAL;
612 : : }
613 : :
614 : : static inline int regmap_update_bits_async(struct regmap *map,
615 : : unsigned int reg,
616 : : unsigned int mask, unsigned int val)
617 : : {
618 : : WARN_ONCE(1, "regmap API is disabled");
619 : : return -EINVAL;
620 : : }
621 : :
622 : : static inline int regmap_update_bits_check(struct regmap *map,
623 : : unsigned int reg,
624 : : unsigned int mask, unsigned int val,
625 : : bool *change)
626 : : {
627 : : WARN_ONCE(1, "regmap API is disabled");
628 : : return -EINVAL;
629 : : }
630 : :
631 : : static inline int regmap_update_bits_check_async(struct regmap *map,
632 : : unsigned int reg,
633 : : unsigned int mask,
634 : : unsigned int val,
635 : : bool *change)
636 : : {
637 : : WARN_ONCE(1, "regmap API is disabled");
638 : : return -EINVAL;
639 : : }
640 : :
641 : : static inline int regmap_get_val_bytes(struct regmap *map)
642 : : {
643 : : WARN_ONCE(1, "regmap API is disabled");
644 : : return -EINVAL;
645 : : }
646 : :
647 : : static inline int regcache_sync(struct regmap *map)
648 : : {
649 : : WARN_ONCE(1, "regmap API is disabled");
650 : : return -EINVAL;
651 : : }
652 : :
653 : : static inline int regcache_sync_region(struct regmap *map, unsigned int min,
654 : : unsigned int max)
655 : : {
656 : : WARN_ONCE(1, "regmap API is disabled");
657 : : return -EINVAL;
658 : : }
659 : :
660 : : static inline int regcache_drop_region(struct regmap *map, unsigned int min,
661 : : unsigned int max)
662 : : {
663 : : WARN_ONCE(1, "regmap API is disabled");
664 : : return -EINVAL;
665 : : }
666 : :
667 : : static inline void regcache_cache_only(struct regmap *map, bool enable)
668 : : {
669 : : WARN_ONCE(1, "regmap API is disabled");
670 : : }
671 : :
672 : : static inline void regcache_cache_bypass(struct regmap *map, bool enable)
673 : : {
674 : : WARN_ONCE(1, "regmap API is disabled");
675 : : }
676 : :
677 : : static inline void regcache_mark_dirty(struct regmap *map)
678 : : {
679 : : WARN_ONCE(1, "regmap API is disabled");
680 : : }
681 : :
682 : : static inline void regmap_async_complete(struct regmap *map)
683 : : {
684 : : WARN_ONCE(1, "regmap API is disabled");
685 : : }
686 : :
687 : : static inline int regmap_register_patch(struct regmap *map,
688 : : const struct reg_default *regs,
689 : : int num_regs)
690 : : {
691 : : WARN_ONCE(1, "regmap API is disabled");
692 : : return -EINVAL;
693 : : }
694 : :
695 : : static inline struct regmap *dev_get_regmap(struct device *dev,
696 : : const char *name)
697 : : {
698 : : return NULL;
699 : : }
700 : :
701 : : #endif
702 : :
703 : : #endif
|
