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