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