1#ifndef __LINUX_REGMAP_H
2#define __LINUX_REGMAP_H
3
4
5
6
7
8
9
10
11
12
13
14
15
16#include <linux/list.h>
17#include <linux/rbtree.h>
18#include <linux/delay.h>
19#include <linux/err.h>
20#include <linux/bug.h>
21#include <linux/lockdep.h>
22
23struct module;
24struct device;
25struct i2c_client;
26struct irq_domain;
27struct spi_device;
28struct spmi_device;
29struct regmap;
30struct regmap_range_cfg;
31struct regmap_field;
32struct snd_ac97;
33
34
35enum regcache_type {
36 REGCACHE_NONE,
37 REGCACHE_RBTREE,
38 REGCACHE_COMPRESSED,
39 REGCACHE_FLAT,
40};
41
42
43
44
45
46
47
48
49
50
51struct reg_default {
52 unsigned int reg;
53 unsigned int def;
54};
55
56
57
58
59
60
61
62
63
64
65
66struct reg_sequence {
67 unsigned int reg;
68 unsigned int def;
69 unsigned int delay_us;
70};
71
72#define regmap_update_bits(map, reg, mask, val) \
73 regmap_update_bits_base(map, reg, mask, val, NULL, false, false)
74#define regmap_update_bits_async(map, reg, mask, val)\
75 regmap_update_bits_base(map, reg, mask, val, NULL, true, false)
76#define regmap_update_bits_check(map, reg, mask, val, change)\
77 regmap_update_bits_base(map, reg, mask, val, change, false, false)
78#define regmap_update_bits_check_async(map, reg, mask, val, change)\
79 regmap_update_bits_base(map, reg, mask, val, change, true, false)
80
81#define regmap_write_bits(map, reg, mask, val) \
82 regmap_update_bits_base(map, reg, mask, val, NULL, false, true)
83
84#define regmap_field_write(field, val) \
85 regmap_field_update_bits_base(field, ~0, val, NULL, false, false)
86#define regmap_field_force_write(field, val) \
87 regmap_field_update_bits_base(field, ~0, val, NULL, false, true)
88#define regmap_field_update_bits(field, mask, val)\
89 regmap_field_update_bits_base(field, mask, val, NULL, false, false)
90#define regmap_field_force_update_bits(field, mask, val) \
91 regmap_field_update_bits_base(field, mask, val, NULL, false, true)
92
93#define regmap_fields_write(field, id, val) \
94 regmap_fields_update_bits_base(field, id, ~0, val, NULL, false, false)
95#define regmap_fields_force_write(field, id, val) \
96 regmap_fields_update_bits_base(field, id, ~0, val, NULL, false, true)
97#define regmap_fields_update_bits(field, id, mask, val)\
98 regmap_fields_update_bits_base(field, id, mask, val, NULL, false, false)
99#define regmap_fields_force_update_bits(field, id, mask, val) \
100 regmap_fields_update_bits_base(field, id, mask, val, NULL, false, true)
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121#define regmap_read_poll_timeout(map, addr, val, cond, sleep_us, timeout_us) \
122({ \
123 ktime_t timeout = ktime_add_us(ktime_get(), timeout_us); \
124 int pollret; \
125 might_sleep_if(sleep_us); \
126 for (;;) { \
127 pollret = regmap_read((map), (addr), &(val)); \
128 if (pollret) \
129 break; \
130 if (cond) \
131 break; \
132 if (timeout_us && ktime_compare(ktime_get(), timeout) > 0) { \
133 pollret = regmap_read((map), (addr), &(val)); \
134 break; \
135 } \
136 if (sleep_us) \
137 usleep_range((sleep_us >> 2) + 1, sleep_us); \
138 } \
139 pollret ?: ((cond) ? 0 : -ETIMEDOUT); \
140})
141
142#ifdef CONFIG_REGMAP
143
144enum regmap_endian {
145
146 REGMAP_ENDIAN_DEFAULT = 0,
147 REGMAP_ENDIAN_BIG,
148 REGMAP_ENDIAN_LITTLE,
149 REGMAP_ENDIAN_NATIVE,
150};
151
152
153
154
155
156
157
158
159struct regmap_range {
160 unsigned int range_min;
161 unsigned int range_max;
162};
163
164#define regmap_reg_range(low, high) { .range_min = low, .range_max = high, }
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179struct regmap_access_table {
180 const struct regmap_range *yes_ranges;
181 unsigned int n_yes_ranges;
182 const struct regmap_range *no_ranges;
183 unsigned int n_no_ranges;
184};
185
186typedef void (*regmap_lock)(void *);
187typedef void (*regmap_unlock)(void *);
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277struct regmap_config {
278 const char *name;
279
280 int reg_bits;
281 int reg_stride;
282 int pad_bits;
283 int val_bits;
284
285 bool (*writeable_reg)(struct device *dev, unsigned int reg);
286 bool (*readable_reg)(struct device *dev, unsigned int reg);
287 bool (*volatile_reg)(struct device *dev, unsigned int reg);
288 bool (*precious_reg)(struct device *dev, unsigned int reg);
289 regmap_lock lock;
290 regmap_unlock unlock;
291 void *lock_arg;
292
293 int (*reg_read)(void *context, unsigned int reg, unsigned int *val);
294 int (*reg_write)(void *context, unsigned int reg, unsigned int val);
295
296 bool fast_io;
297
298 unsigned int max_register;
299 const struct regmap_access_table *wr_table;
300 const struct regmap_access_table *rd_table;
301 const struct regmap_access_table *volatile_table;
302 const struct regmap_access_table *precious_table;
303 const struct reg_default *reg_defaults;
304 unsigned int num_reg_defaults;
305 enum regcache_type cache_type;
306 const void *reg_defaults_raw;
307 unsigned int num_reg_defaults_raw;
308
309 unsigned long read_flag_mask;
310 unsigned long write_flag_mask;
311
312 bool use_single_rw;
313 bool can_multi_write;
314
315 enum regmap_endian reg_format_endian;
316 enum regmap_endian val_format_endian;
317
318 const struct regmap_range_cfg *ranges;
319 unsigned int num_ranges;
320};
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342struct regmap_range_cfg {
343 const char *name;
344
345
346 unsigned int range_min;
347 unsigned int range_max;
348
349
350 unsigned int selector_reg;
351 unsigned int selector_mask;
352 int selector_shift;
353
354
355 unsigned int window_start;
356 unsigned int window_len;
357};
358
359struct regmap_async;
360
361typedef int (*regmap_hw_write)(void *context, const void *data,
362 size_t count);
363typedef int (*regmap_hw_gather_write)(void *context,
364 const void *reg, size_t reg_len,
365 const void *val, size_t val_len);
366typedef int (*regmap_hw_async_write)(void *context,
367 const void *reg, size_t reg_len,
368 const void *val, size_t val_len,
369 struct regmap_async *async);
370typedef int (*regmap_hw_read)(void *context,
371 const void *reg_buf, size_t reg_size,
372 void *val_buf, size_t val_size);
373typedef int (*regmap_hw_reg_read)(void *context, unsigned int reg,
374 unsigned int *val);
375typedef int (*regmap_hw_reg_write)(void *context, unsigned int reg,
376 unsigned int val);
377typedef int (*regmap_hw_reg_update_bits)(void *context, unsigned int reg,
378 unsigned int mask, unsigned int val);
379typedef struct regmap_async *(*regmap_hw_async_alloc)(void);
380typedef void (*regmap_hw_free_context)(void *context);
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417struct regmap_bus {
418 bool fast_io;
419 regmap_hw_write write;
420 regmap_hw_gather_write gather_write;
421 regmap_hw_async_write async_write;
422 regmap_hw_reg_write reg_write;
423 regmap_hw_reg_update_bits reg_update_bits;
424 regmap_hw_read read;
425 regmap_hw_reg_read reg_read;
426 regmap_hw_free_context free_context;
427 regmap_hw_async_alloc async_alloc;
428 u8 read_flag_mask;
429 enum regmap_endian reg_format_endian_default;
430 enum regmap_endian val_format_endian_default;
431 size_t max_raw_read;
432 size_t max_raw_write;
433};
434
435
436
437
438
439
440
441
442struct regmap *__regmap_init(struct device *dev,
443 const struct regmap_bus *bus,
444 void *bus_context,
445 const struct regmap_config *config,
446 struct lock_class_key *lock_key,
447 const char *lock_name);
448struct regmap *__regmap_init_i2c(struct i2c_client *i2c,
449 const struct regmap_config *config,
450 struct lock_class_key *lock_key,
451 const char *lock_name);
452struct regmap *__regmap_init_spi(struct spi_device *dev,
453 const struct regmap_config *config,
454 struct lock_class_key *lock_key,
455 const char *lock_name);
456struct regmap *__regmap_init_spmi_base(struct spmi_device *dev,
457 const struct regmap_config *config,
458 struct lock_class_key *lock_key,
459 const char *lock_name);
460struct regmap *__regmap_init_spmi_ext(struct spmi_device *dev,
461 const struct regmap_config *config,
462 struct lock_class_key *lock_key,
463 const char *lock_name);
464struct regmap *__regmap_init_w1(struct device *w1_dev,
465 const struct regmap_config *config,
466 struct lock_class_key *lock_key,
467 const char *lock_name);
468struct regmap *__regmap_init_mmio_clk(struct device *dev, const char *clk_id,
469 void __iomem *regs,
470 const struct regmap_config *config,
471 struct lock_class_key *lock_key,
472 const char *lock_name);
473struct regmap *__regmap_init_ac97(struct snd_ac97 *ac97,
474 const struct regmap_config *config,
475 struct lock_class_key *lock_key,
476 const char *lock_name);
477
478struct regmap *__devm_regmap_init(struct device *dev,
479 const struct regmap_bus *bus,
480 void *bus_context,
481 const struct regmap_config *config,
482 struct lock_class_key *lock_key,
483 const char *lock_name);
484struct regmap *__devm_regmap_init_i2c(struct i2c_client *i2c,
485 const struct regmap_config *config,
486 struct lock_class_key *lock_key,
487 const char *lock_name);
488struct regmap *__devm_regmap_init_spi(struct spi_device *dev,
489 const struct regmap_config *config,
490 struct lock_class_key *lock_key,
491 const char *lock_name);
492struct regmap *__devm_regmap_init_spmi_base(struct spmi_device *dev,
493 const struct regmap_config *config,
494 struct lock_class_key *lock_key,
495 const char *lock_name);
496struct regmap *__devm_regmap_init_spmi_ext(struct spmi_device *dev,
497 const struct regmap_config *config,
498 struct lock_class_key *lock_key,
499 const char *lock_name);
500struct regmap *__devm_regmap_init_w1(struct device *w1_dev,
501 const struct regmap_config *config,
502 struct lock_class_key *lock_key,
503 const char *lock_name);
504struct regmap *__devm_regmap_init_mmio_clk(struct device *dev,
505 const char *clk_id,
506 void __iomem *regs,
507 const struct regmap_config *config,
508 struct lock_class_key *lock_key,
509 const char *lock_name);
510struct regmap *__devm_regmap_init_ac97(struct snd_ac97 *ac97,
511 const struct regmap_config *config,
512 struct lock_class_key *lock_key,
513 const char *lock_name);
514
515
516
517
518
519
520
521
522#ifdef CONFIG_LOCKDEP
523#define __regmap_lockdep_wrapper(fn, name, ...) \
524( \
525 ({ \
526 static struct lock_class_key _key; \
527 fn(__VA_ARGS__, &_key, \
528 KBUILD_BASENAME ":" \
529 __stringify(__LINE__) ":" \
530 "(" name ")->lock"); \
531 }) \
532)
533#else
534#define __regmap_lockdep_wrapper(fn, name, ...) fn(__VA_ARGS__, NULL, NULL)
535#endif
536
537
538
539
540
541
542
543
544
545
546
547
548
549#define regmap_init(dev, bus, bus_context, config) \
550 __regmap_lockdep_wrapper(__regmap_init, #config, \
551 dev, bus, bus_context, config)
552int regmap_attach_dev(struct device *dev, struct regmap *map,
553 const struct regmap_config *config);
554
555
556
557
558
559
560
561
562
563
564#define regmap_init_i2c(i2c, config) \
565 __regmap_lockdep_wrapper(__regmap_init_i2c, #config, \
566 i2c, config)
567
568
569
570
571
572
573
574
575
576
577#define regmap_init_spi(dev, config) \
578 __regmap_lockdep_wrapper(__regmap_init_spi, #config, \
579 dev, config)
580
581
582
583
584
585
586
587
588
589
590#define regmap_init_spmi_base(dev, config) \
591 __regmap_lockdep_wrapper(__regmap_init_spmi_base, #config, \
592 dev, config)
593
594
595
596
597
598
599
600
601
602
603#define regmap_init_spmi_ext(dev, config) \
604 __regmap_lockdep_wrapper(__regmap_init_spmi_ext, #config, \
605 dev, config)
606
607
608
609
610
611
612
613
614
615
616#define regmap_init_w1(w1_dev, config) \
617 __regmap_lockdep_wrapper(__regmap_init_w1, #config, \
618 w1_dev, config)
619
620
621
622
623
624
625
626
627
628
629
630
631#define regmap_init_mmio_clk(dev, clk_id, regs, config) \
632 __regmap_lockdep_wrapper(__regmap_init_mmio_clk, #config, \
633 dev, clk_id, regs, config)
634
635
636
637
638
639
640
641
642
643
644
645#define regmap_init_mmio(dev, regs, config) \
646 regmap_init_mmio_clk(dev, NULL, regs, config)
647
648
649
650
651
652
653
654
655
656
657#define regmap_init_ac97(ac97, config) \
658 __regmap_lockdep_wrapper(__regmap_init_ac97, #config, \
659 ac97, config)
660bool regmap_ac97_default_volatile(struct device *dev, unsigned int reg);
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675#define devm_regmap_init(dev, bus, bus_context, config) \
676 __regmap_lockdep_wrapper(__devm_regmap_init, #config, \
677 dev, bus, bus_context, config)
678
679
680
681
682
683
684
685
686
687
688
689#define devm_regmap_init_i2c(i2c, config) \
690 __regmap_lockdep_wrapper(__devm_regmap_init_i2c, #config, \
691 i2c, config)
692
693
694
695
696
697
698
699
700
701
702
703#define devm_regmap_init_spi(dev, config) \
704 __regmap_lockdep_wrapper(__devm_regmap_init_spi, #config, \
705 dev, config)
706
707
708
709
710
711
712
713
714
715
716
717#define devm_regmap_init_spmi_base(dev, config) \
718 __regmap_lockdep_wrapper(__devm_regmap_init_spmi_base, #config, \
719 dev, config)
720
721
722
723
724
725
726
727
728
729
730
731#define devm_regmap_init_spmi_ext(dev, config) \
732 __regmap_lockdep_wrapper(__devm_regmap_init_spmi_ext, #config, \
733 dev, config)
734
735
736
737
738
739
740
741
742
743
744
745#define devm_regmap_init_w1(w1_dev, config) \
746 __regmap_lockdep_wrapper(__devm_regmap_init_w1, #config, \
747 w1_dev, config)
748
749
750
751
752
753
754
755
756
757
758
759
760#define devm_regmap_init_mmio_clk(dev, clk_id, regs, config) \
761 __regmap_lockdep_wrapper(__devm_regmap_init_mmio_clk, #config, \
762 dev, clk_id, regs, config)
763
764
765
766
767
768
769
770
771
772
773
774
775#define devm_regmap_init_mmio(dev, regs, config) \
776 devm_regmap_init_mmio_clk(dev, NULL, regs, config)
777
778
779
780
781
782
783
784
785
786
787
788#define devm_regmap_init_ac97(ac97, config) \
789 __regmap_lockdep_wrapper(__devm_regmap_init_ac97, #config, \
790 ac97, config)
791
792void regmap_exit(struct regmap *map);
793int regmap_reinit_cache(struct regmap *map,
794 const struct regmap_config *config);
795struct regmap *dev_get_regmap(struct device *dev, const char *name);
796struct device *regmap_get_device(struct regmap *map);
797int regmap_write(struct regmap *map, unsigned int reg, unsigned int val);
798int regmap_write_async(struct regmap *map, unsigned int reg, unsigned int val);
799int regmap_raw_write(struct regmap *map, unsigned int reg,
800 const void *val, size_t val_len);
801int regmap_bulk_write(struct regmap *map, unsigned int reg, const void *val,
802 size_t val_count);
803int regmap_multi_reg_write(struct regmap *map, const struct reg_sequence *regs,
804 int num_regs);
805int regmap_multi_reg_write_bypassed(struct regmap *map,
806 const struct reg_sequence *regs,
807 int num_regs);
808int regmap_raw_write_async(struct regmap *map, unsigned int reg,
809 const void *val, size_t val_len);
810int regmap_read(struct regmap *map, unsigned int reg, unsigned int *val);
811int regmap_raw_read(struct regmap *map, unsigned int reg,
812 void *val, size_t val_len);
813int regmap_bulk_read(struct regmap *map, unsigned int reg, void *val,
814 size_t val_count);
815int regmap_update_bits_base(struct regmap *map, unsigned int reg,
816 unsigned int mask, unsigned int val,
817 bool *change, bool async, bool force);
818int regmap_get_val_bytes(struct regmap *map);
819int regmap_get_max_register(struct regmap *map);
820int regmap_get_reg_stride(struct regmap *map);
821int regmap_async_complete(struct regmap *map);
822bool regmap_can_raw_write(struct regmap *map);
823size_t regmap_get_raw_read_max(struct regmap *map);
824size_t regmap_get_raw_write_max(struct regmap *map);
825
826int regcache_sync(struct regmap *map);
827int regcache_sync_region(struct regmap *map, unsigned int min,
828 unsigned int max);
829int regcache_drop_region(struct regmap *map, unsigned int min,
830 unsigned int max);
831void regcache_cache_only(struct regmap *map, bool enable);
832void regcache_cache_bypass(struct regmap *map, bool enable);
833void regcache_mark_dirty(struct regmap *map);
834
835bool regmap_check_range_table(struct regmap *map, unsigned int reg,
836 const struct regmap_access_table *table);
837
838int regmap_register_patch(struct regmap *map, const struct reg_sequence *regs,
839 int num_regs);
840int regmap_parse_val(struct regmap *map, const void *buf,
841 unsigned int *val);
842
843static inline bool regmap_reg_in_range(unsigned int reg,
844 const struct regmap_range *range)
845{
846 return reg >= range->range_min && reg <= range->range_max;
847}
848
849bool regmap_reg_in_ranges(unsigned int reg,
850 const struct regmap_range *ranges,
851 unsigned int nranges);
852
853
854
855
856
857
858
859
860
861
862struct reg_field {
863 unsigned int reg;
864 unsigned int lsb;
865 unsigned int msb;
866 unsigned int id_size;
867 unsigned int id_offset;
868};
869
870#define REG_FIELD(_reg, _lsb, _msb) { \
871 .reg = _reg, \
872 .lsb = _lsb, \
873 .msb = _msb, \
874 }
875
876struct regmap_field *regmap_field_alloc(struct regmap *regmap,
877 struct reg_field reg_field);
878void regmap_field_free(struct regmap_field *field);
879
880struct regmap_field *devm_regmap_field_alloc(struct device *dev,
881 struct regmap *regmap, struct reg_field reg_field);
882void devm_regmap_field_free(struct device *dev, struct regmap_field *field);
883
884int regmap_field_read(struct regmap_field *field, unsigned int *val);
885int regmap_field_update_bits_base(struct regmap_field *field,
886 unsigned int mask, unsigned int val,
887 bool *change, bool async, bool force);
888int regmap_fields_read(struct regmap_field *field, unsigned int id,
889 unsigned int *val);
890int regmap_fields_update_bits_base(struct regmap_field *field, unsigned int id,
891 unsigned int mask, unsigned int val,
892 bool *change, bool async, bool force);
893
894
895
896
897
898
899
900
901
902
903struct regmap_irq {
904 unsigned int reg_offset;
905 unsigned int mask;
906 unsigned int type_reg_offset;
907 unsigned int type_rising_mask;
908 unsigned int type_falling_mask;
909};
910
911#define REGMAP_IRQ_REG(_irq, _off, _mask) \
912 [_irq] = { .reg_offset = (_off), .mask = (_mask) }
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955struct regmap_irq_chip {
956 const char *name;
957
958 unsigned int status_base;
959 unsigned int mask_base;
960 unsigned int unmask_base;
961 unsigned int ack_base;
962 unsigned int wake_base;
963 unsigned int type_base;
964 unsigned int irq_reg_stride;
965 bool mask_writeonly:1;
966 bool init_ack_masked:1;
967 bool mask_invert:1;
968 bool use_ack:1;
969 bool ack_invert:1;
970 bool wake_invert:1;
971 bool runtime_pm:1;
972 bool type_invert:1;
973
974 int num_regs;
975
976 const struct regmap_irq *irqs;
977 int num_irqs;
978
979 int num_type_reg;
980 unsigned int type_reg_stride;
981
982 int (*handle_pre_irq)(void *irq_drv_data);
983 int (*handle_post_irq)(void *irq_drv_data);
984 void *irq_drv_data;
985};
986
987struct regmap_irq_chip_data;
988
989int regmap_add_irq_chip(struct regmap *map, int irq, int irq_flags,
990 int irq_base, const struct regmap_irq_chip *chip,
991 struct regmap_irq_chip_data **data);
992void regmap_del_irq_chip(int irq, struct regmap_irq_chip_data *data);
993
994int devm_regmap_add_irq_chip(struct device *dev, struct regmap *map, int irq,
995 int irq_flags, int irq_base,
996 const struct regmap_irq_chip *chip,
997 struct regmap_irq_chip_data **data);
998void devm_regmap_del_irq_chip(struct device *dev, int irq,
999 struct regmap_irq_chip_data *data);
1000
1001int regmap_irq_chip_get_base(struct regmap_irq_chip_data *data);
1002int regmap_irq_get_virq(struct regmap_irq_chip_data *data, int irq);
1003struct irq_domain *regmap_irq_get_domain(struct regmap_irq_chip_data *data);
1004
1005#else
1006
1007
1008
1009
1010
1011
1012
1013
1014static inline int regmap_write(struct regmap *map, unsigned int reg,
1015 unsigned int val)
1016{
1017 WARN_ONCE(1, "regmap API is disabled");
1018 return -EINVAL;
1019}
1020
1021static inline int regmap_write_async(struct regmap *map, unsigned int reg,
1022 unsigned int val)
1023{
1024 WARN_ONCE(1, "regmap API is disabled");
1025 return -EINVAL;
1026}
1027
1028static inline int regmap_raw_write(struct regmap *map, unsigned int reg,
1029 const void *val, size_t val_len)
1030{
1031 WARN_ONCE(1, "regmap API is disabled");
1032 return -EINVAL;
1033}
1034
1035static inline int regmap_raw_write_async(struct regmap *map, unsigned int reg,
1036 const void *val, size_t val_len)
1037{
1038 WARN_ONCE(1, "regmap API is disabled");
1039 return -EINVAL;
1040}
1041
1042static inline int regmap_bulk_write(struct regmap *map, unsigned int reg,
1043 const void *val, size_t val_count)
1044{
1045 WARN_ONCE(1, "regmap API is disabled");
1046 return -EINVAL;
1047}
1048
1049static inline int regmap_read(struct regmap *map, unsigned int reg,
1050 unsigned int *val)
1051{
1052 WARN_ONCE(1, "regmap API is disabled");
1053 return -EINVAL;
1054}
1055
1056static inline int regmap_raw_read(struct regmap *map, unsigned int reg,
1057 void *val, size_t val_len)
1058{
1059 WARN_ONCE(1, "regmap API is disabled");
1060 return -EINVAL;
1061}
1062
1063static inline int regmap_bulk_read(struct regmap *map, unsigned int reg,
1064 void *val, size_t val_count)
1065{
1066 WARN_ONCE(1, "regmap API is disabled");
1067 return -EINVAL;
1068}
1069
1070static inline int regmap_update_bits_base(struct regmap *map, unsigned int reg,
1071 unsigned int mask, unsigned int val,
1072 bool *change, bool async, bool force)
1073{
1074 WARN_ONCE(1, "regmap API is disabled");
1075 return -EINVAL;
1076}
1077
1078static inline int regmap_field_update_bits_base(struct regmap_field *field,
1079 unsigned int mask, unsigned int val,
1080 bool *change, bool async, bool force)
1081{
1082 WARN_ONCE(1, "regmap API is disabled");
1083 return -EINVAL;
1084}
1085
1086static inline int regmap_fields_update_bits_base(struct regmap_field *field,
1087 unsigned int id,
1088 unsigned int mask, unsigned int val,
1089 bool *change, bool async, bool force)
1090{
1091 WARN_ONCE(1, "regmap API is disabled");
1092 return -EINVAL;
1093}
1094
1095static inline int regmap_get_val_bytes(struct regmap *map)
1096{
1097 WARN_ONCE(1, "regmap API is disabled");
1098 return -EINVAL;
1099}
1100
1101static inline int regmap_get_max_register(struct regmap *map)
1102{
1103 WARN_ONCE(1, "regmap API is disabled");
1104 return -EINVAL;
1105}
1106
1107static inline int regmap_get_reg_stride(struct regmap *map)
1108{
1109 WARN_ONCE(1, "regmap API is disabled");
1110 return -EINVAL;
1111}
1112
1113static inline int regcache_sync(struct regmap *map)
1114{
1115 WARN_ONCE(1, "regmap API is disabled");
1116 return -EINVAL;
1117}
1118
1119static inline int regcache_sync_region(struct regmap *map, unsigned int min,
1120 unsigned int max)
1121{
1122 WARN_ONCE(1, "regmap API is disabled");
1123 return -EINVAL;
1124}
1125
1126static inline int regcache_drop_region(struct regmap *map, unsigned int min,
1127 unsigned int max)
1128{
1129 WARN_ONCE(1, "regmap API is disabled");
1130 return -EINVAL;
1131}
1132
1133static inline void regcache_cache_only(struct regmap *map, bool enable)
1134{
1135 WARN_ONCE(1, "regmap API is disabled");
1136}
1137
1138static inline void regcache_cache_bypass(struct regmap *map, bool enable)
1139{
1140 WARN_ONCE(1, "regmap API is disabled");
1141}
1142
1143static inline void regcache_mark_dirty(struct regmap *map)
1144{
1145 WARN_ONCE(1, "regmap API is disabled");
1146}
1147
1148static inline void regmap_async_complete(struct regmap *map)
1149{
1150 WARN_ONCE(1, "regmap API is disabled");
1151}
1152
1153static inline int regmap_register_patch(struct regmap *map,
1154 const struct reg_sequence *regs,
1155 int num_regs)
1156{
1157 WARN_ONCE(1, "regmap API is disabled");
1158 return -EINVAL;
1159}
1160
1161static inline int regmap_parse_val(struct regmap *map, const void *buf,
1162 unsigned int *val)
1163{
1164 WARN_ONCE(1, "regmap API is disabled");
1165 return -EINVAL;
1166}
1167
1168static inline struct regmap *dev_get_regmap(struct device *dev,
1169 const char *name)
1170{
1171 return NULL;
1172}
1173
1174static inline struct device *regmap_get_device(struct regmap *map)
1175{
1176 WARN_ONCE(1, "regmap API is disabled");
1177 return NULL;
1178}
1179
1180#endif
1181
1182#endif
1183