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 21struct module; 22struct device; 23struct i2c_client; 24struct irq_domain; 25struct spi_device; 26struct spmi_device; 27struct regmap; 28struct regmap_range_cfg; 29struct regmap_field; 30struct snd_ac97; 31 32/* An enum of all the supported cache types */ 33enum 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 */ 48struct reg_default { 49 unsigned int reg; 50 unsigned int def; 51}; 52 53#ifdef CONFIG_REGMAP 54 55enum 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 */ 70struct 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 */ 88struct 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 95typedef void (*regmap_lock)(void *); 96typedef 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 */ 186struct 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 */ 249struct 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 266struct regmap_async; 267 268typedef int (*regmap_hw_write)(void *context, const void *data, 269 size_t count); 270typedef int (*regmap_hw_gather_write)(void *context, 271 const void *reg, size_t reg_len, 272 const void *val, size_t val_len); 273typedef 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); 277typedef int (*regmap_hw_read)(void *context, 278 const void *reg_buf, size_t reg_size, 279 void *val_buf, size_t val_size); 280typedef int (*regmap_hw_reg_read)(void *context, unsigned int reg, 281 unsigned int *val); 282typedef int (*regmap_hw_reg_write)(void *context, unsigned int reg, 283 unsigned int val); 284typedef struct regmap_async *(*regmap_hw_async_alloc)(void); 285typedef 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 */ 312struct 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 327struct regmap *regmap_init(struct device *dev, 328 const struct regmap_bus *bus, 329 void *bus_context, 330 const struct regmap_config *config); 331int regmap_attach_dev(struct device *dev, struct regmap *map, 332 const struct regmap_config *config); 333struct regmap *regmap_init_i2c(struct i2c_client *i2c, 334 const struct regmap_config *config); 335struct regmap *regmap_init_spi(struct spi_device *dev, 336 const struct regmap_config *config); 337struct regmap *regmap_init_spmi_base(struct spmi_device *dev, 338 const struct regmap_config *config); 339struct regmap *regmap_init_spmi_ext(struct spmi_device *dev, 340 const struct regmap_config *config); 341struct regmap *regmap_init_mmio_clk(struct device *dev, const char *clk_id, 342 void __iomem *regs, 343 const struct regmap_config *config); 344struct regmap *regmap_init_ac97(struct snd_ac97 *ac97, 345 const struct regmap_config *config); 346 347struct regmap *devm_regmap_init(struct device *dev, 348 const struct regmap_bus *bus, 349 void *bus_context, 350 const struct regmap_config *config); 351struct regmap *devm_regmap_init_i2c(struct i2c_client *i2c, 352 const struct regmap_config *config); 353struct regmap *devm_regmap_init_spi(struct spi_device *dev, 354 const struct regmap_config *config); 355struct regmap *devm_regmap_init_spmi_base(struct spmi_device *dev, 356 const struct regmap_config *config); 357struct regmap *devm_regmap_init_spmi_ext(struct spmi_device *dev, 358 const struct regmap_config *config); 359struct regmap *devm_regmap_init_mmio_clk(struct device *dev, const char *clk_id, 360 void __iomem *regs, 361 const struct regmap_config *config); 362struct regmap *devm_regmap_init_ac97(struct snd_ac97 *ac97, 363 const struct regmap_config *config); 364 365bool 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 */ 377static 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 */ 395static 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 402void regmap_exit(struct regmap *map); 403int regmap_reinit_cache(struct regmap *map, 404 const struct regmap_config *config); 405struct regmap *dev_get_regmap(struct device *dev, const char *name); 406struct device *regmap_get_device(struct regmap *map); 407int regmap_write(struct regmap *map, unsigned int reg, unsigned int val); 408int regmap_write_async(struct regmap *map, unsigned int reg, unsigned int val); 409int regmap_raw_write(struct regmap *map, unsigned int reg, 410 const void *val, size_t val_len); 411int regmap_bulk_write(struct regmap *map, unsigned int reg, const void *val, 412 size_t val_count); 413int regmap_multi_reg_write(struct regmap *map, const struct reg_default *regs, 414 int num_regs); 415int regmap_multi_reg_write_bypassed(struct regmap *map, 416 const struct reg_default *regs, 417 int num_regs); 418int regmap_raw_write_async(struct regmap *map, unsigned int reg, 419 const void *val, size_t val_len); 420int regmap_read(struct regmap *map, unsigned int reg, unsigned int *val); 421int regmap_raw_read(struct regmap *map, unsigned int reg, 422 void *val, size_t val_len); 423int regmap_bulk_read(struct regmap *map, unsigned int reg, void *val, 424 size_t val_count); 425int regmap_update_bits(struct regmap *map, unsigned int reg, 426 unsigned int mask, unsigned int val); 427int regmap_update_bits_async(struct regmap *map, unsigned int reg, 428 unsigned int mask, unsigned int val); 429int regmap_update_bits_check(struct regmap *map, unsigned int reg, 430 unsigned int mask, unsigned int val, 431 bool *change); 432int regmap_update_bits_check_async(struct regmap *map, unsigned int reg, 433 unsigned int mask, unsigned int val, 434 bool *change); 435int regmap_get_val_bytes(struct regmap *map); 436int regmap_async_complete(struct regmap *map); 437bool regmap_can_raw_write(struct regmap *map); 438 439int regcache_sync(struct regmap *map); 440int regcache_sync_region(struct regmap *map, unsigned int min, 441 unsigned int max); 442int regcache_drop_region(struct regmap *map, unsigned int min, 443 unsigned int max); 444void regcache_cache_only(struct regmap *map, bool enable); 445void regcache_cache_bypass(struct regmap *map, bool enable); 446void regcache_mark_dirty(struct regmap *map); 447 448bool regmap_check_range_table(struct regmap *map, unsigned int reg, 449 const struct regmap_access_table *table); 450 451int regmap_register_patch(struct regmap *map, const struct reg_default *regs, 452 int num_regs); 453int regmap_parse_val(struct regmap *map, const void *buf, 454 unsigned int *val); 455 456static 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 462bool 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 */ 475struct 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 489struct regmap_field *regmap_field_alloc(struct regmap *regmap, 490 struct reg_field reg_field); 491void regmap_field_free(struct regmap_field *field); 492 493struct regmap_field *devm_regmap_field_alloc(struct device *dev, 494 struct regmap *regmap, struct reg_field reg_field); 495void devm_regmap_field_free(struct device *dev, struct regmap_field *field); 496 497int regmap_field_read(struct regmap_field *field, unsigned int *val); 498int regmap_field_write(struct regmap_field *field, unsigned int val); 499int regmap_field_update_bits(struct regmap_field *field, 500 unsigned int mask, unsigned int val); 501 502int regmap_fields_write(struct regmap_field *field, unsigned int id, 503 unsigned int val); 504int regmap_fields_read(struct regmap_field *field, unsigned int id, 505 unsigned int *val); 506int 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 */ 515struct 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 */ 544struct 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 564struct regmap_irq_chip_data; 565 566int 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); 569void regmap_del_irq_chip(int irq, struct regmap_irq_chip_data *data); 570int regmap_irq_chip_get_base(struct regmap_irq_chip_data *data); 571int regmap_irq_get_virq(struct regmap_irq_chip_data *data, int irq); 572struct 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 583static 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 590static 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 597static 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 604static 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 611static 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 618static 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 625static 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 632static 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 639static 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 646static 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 654static 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 663static 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 673static inline int regmap_get_val_bytes(struct regmap *map) 674{ 675 WARN_ONCE(1, "regmap API is disabled"); 676 return -EINVAL; 677} 678 679static inline int regcache_sync(struct regmap *map) 680{ 681 WARN_ONCE(1, "regmap API is disabled"); 682 return -EINVAL; 683} 684 685static 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 692static 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 699static inline void regcache_cache_only(struct regmap *map, bool enable) 700{ 701 WARN_ONCE(1, "regmap API is disabled"); 702} 703 704static inline void regcache_cache_bypass(struct regmap *map, bool enable) 705{ 706 WARN_ONCE(1, "regmap API is disabled"); 707} 708 709static inline void regcache_mark_dirty(struct regmap *map) 710{ 711 WARN_ONCE(1, "regmap API is disabled"); 712} 713 714static inline void regmap_async_complete(struct regmap *map) 715{ 716 WARN_ONCE(1, "regmap API is disabled"); 717} 718 719static 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 727static 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 734static inline struct regmap *dev_get_regmap(struct device *dev, 735 const char *name) 736{ 737 return NULL; 738} 739 740static 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