~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/include/linux/regmap.h

Version: ~ [ linux-5.12-rc1 ] ~ [ linux-5.11.2 ] ~ [ linux-5.10.19 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.101 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.177 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.222 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.258 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.258 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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  */
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  */
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
679 static inline int regcache_sync(struct regmap *map)
680 {
681         WARN_ONCE(1, "regmap API is disabled");
682         return -EINVAL;
683 }
684 
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 
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 
699 static inline void regcache_cache_only(struct regmap *map, bool enable)
700 {
701         WARN_ONCE(1, "regmap API is disabled");
702 }
703 
704 static inline void regcache_cache_bypass(struct regmap *map, bool enable)
705 {
706         WARN_ONCE(1, "regmap API is disabled");
707 }
708 
709 static inline void regcache_mark_dirty(struct regmap *map)
710 {
711         WARN_ONCE(1, "regmap API is disabled");
712 }
713 
714 static inline void regmap_async_complete(struct regmap *map)
715 {
716         WARN_ONCE(1, "regmap API is disabled");
717 }
718 
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 
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 
734 static inline struct regmap *dev_get_regmap(struct device *dev,
735                                             const char *name)
736 {
737         return NULL;
738 }
739 
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 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp