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 rgister 126 * should not be read outside of a call from the driver 127 * (eg, 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 whos read operation cannot be represented as a simple read 140 * operation on a bus such as SPI, I2C, etc. Most of the devices do 141 * 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 * @wake_base: Base address for wake enables. If zero unsupported. 502 * @irq_reg_stride: Stride to use for chips where registers are not contiguous. 503 * @init_ack_masked: Ack all masked interrupts once during initalization. 504 * @mask_invert: Inverted mask register: cleared bits are masked out. 505 * @wake_invert: Inverted wake register: cleared bits are wake enabled. 506 * @runtime_pm: Hold a runtime PM lock on the device when accessing it. 507 * 508 * @num_regs: Number of registers in each control bank. 509 * @irqs: Descriptors for individual IRQs. Interrupt numbers are 510 * assigned based on the index in the array of the interrupt. 511 * @num_irqs: Number of descriptors. 512 */ 513 struct regmap_irq_chip { 514 const char *name; 515 516 unsigned int status_base; 517 unsigned int mask_base; 518 unsigned int ack_base; 519 unsigned int wake_base; 520 unsigned int irq_reg_stride; 521 bool init_ack_masked:1; 522 bool mask_invert:1; 523 bool wake_invert:1; 524 bool runtime_pm:1; 525 526 int num_regs; 527 528 const struct regmap_irq *irqs; 529 int num_irqs; 530 }; 531 532 struct regmap_irq_chip_data; 533 534 int regmap_add_irq_chip(struct regmap *map, int irq, int irq_flags, 535 int irq_base, const struct regmap_irq_chip *chip, 536 struct regmap_irq_chip_data **data); 537 void regmap_del_irq_chip(int irq, struct regmap_irq_chip_data *data); 538 int regmap_irq_chip_get_base(struct regmap_irq_chip_data *data); 539 int regmap_irq_get_virq(struct regmap_irq_chip_data *data, int irq); 540 struct irq_domain *regmap_irq_get_domain(struct regmap_irq_chip_data *data); 541 542 #else 543 544 /* 545 * These stubs should only ever be called by generic code which has 546 * regmap based facilities, if they ever get called at runtime 547 * something is going wrong and something probably needs to select 548 * REGMAP. 549 */ 550 551 static inline int regmap_write(struct regmap *map, unsigned int reg, 552 unsigned int val) 553 { 554 WARN_ONCE(1, "regmap API is disabled"); 555 return -EINVAL; 556 } 557 558 static inline int regmap_write_async(struct regmap *map, unsigned int reg, 559 unsigned int val) 560 { 561 WARN_ONCE(1, "regmap API is disabled"); 562 return -EINVAL; 563 } 564 565 static inline int regmap_raw_write(struct regmap *map, unsigned int reg, 566 const void *val, size_t val_len) 567 { 568 WARN_ONCE(1, "regmap API is disabled"); 569 return -EINVAL; 570 } 571 572 static inline int regmap_raw_write_async(struct regmap *map, unsigned int reg, 573 const void *val, size_t val_len) 574 { 575 WARN_ONCE(1, "regmap API is disabled"); 576 return -EINVAL; 577 } 578 579 static inline int regmap_bulk_write(struct regmap *map, unsigned int reg, 580 const void *val, size_t val_count) 581 { 582 WARN_ONCE(1, "regmap API is disabled"); 583 return -EINVAL; 584 } 585 586 static inline int regmap_read(struct regmap *map, unsigned int reg, 587 unsigned int *val) 588 { 589 WARN_ONCE(1, "regmap API is disabled"); 590 return -EINVAL; 591 } 592 593 static inline int regmap_raw_read(struct regmap *map, unsigned int reg, 594 void *val, size_t val_len) 595 { 596 WARN_ONCE(1, "regmap API is disabled"); 597 return -EINVAL; 598 } 599 600 static inline int regmap_bulk_read(struct regmap *map, unsigned int reg, 601 void *val, size_t val_count) 602 { 603 WARN_ONCE(1, "regmap API is disabled"); 604 return -EINVAL; 605 } 606 607 static inline int regmap_update_bits(struct regmap *map, unsigned int reg, 608 unsigned int mask, unsigned int val) 609 { 610 WARN_ONCE(1, "regmap API is disabled"); 611 return -EINVAL; 612 } 613 614 static inline int regmap_update_bits_async(struct regmap *map, 615 unsigned int reg, 616 unsigned int mask, unsigned int val) 617 { 618 WARN_ONCE(1, "regmap API is disabled"); 619 return -EINVAL; 620 } 621 622 static inline int regmap_update_bits_check(struct regmap *map, 623 unsigned int reg, 624 unsigned int mask, unsigned int val, 625 bool *change) 626 { 627 WARN_ONCE(1, "regmap API is disabled"); 628 return -EINVAL; 629 } 630 631 static inline int regmap_update_bits_check_async(struct regmap *map, 632 unsigned int reg, 633 unsigned int mask, 634 unsigned int val, 635 bool *change) 636 { 637 WARN_ONCE(1, "regmap API is disabled"); 638 return -EINVAL; 639 } 640 641 static inline int regmap_get_val_bytes(struct regmap *map) 642 { 643 WARN_ONCE(1, "regmap API is disabled"); 644 return -EINVAL; 645 } 646 647 static inline int regcache_sync(struct regmap *map) 648 { 649 WARN_ONCE(1, "regmap API is disabled"); 650 return -EINVAL; 651 } 652 653 static inline int regcache_sync_region(struct regmap *map, unsigned int min, 654 unsigned int max) 655 { 656 WARN_ONCE(1, "regmap API is disabled"); 657 return -EINVAL; 658 } 659 660 static inline int regcache_drop_region(struct regmap *map, unsigned int min, 661 unsigned int max) 662 { 663 WARN_ONCE(1, "regmap API is disabled"); 664 return -EINVAL; 665 } 666 667 static inline void regcache_cache_only(struct regmap *map, bool enable) 668 { 669 WARN_ONCE(1, "regmap API is disabled"); 670 } 671 672 static inline void regcache_cache_bypass(struct regmap *map, bool enable) 673 { 674 WARN_ONCE(1, "regmap API is disabled"); 675 } 676 677 static inline void regcache_mark_dirty(struct regmap *map) 678 { 679 WARN_ONCE(1, "regmap API is disabled"); 680 } 681 682 static inline void regmap_async_complete(struct regmap *map) 683 { 684 WARN_ONCE(1, "regmap API is disabled"); 685 } 686 687 static inline int regmap_register_patch(struct regmap *map, 688 const struct reg_default *regs, 689 int num_regs) 690 { 691 WARN_ONCE(1, "regmap API is disabled"); 692 return -EINVAL; 693 } 694 695 static inline struct regmap *dev_get_regmap(struct device *dev, 696 const char *name) 697 { 698 return NULL; 699 } 700 701 #endif 702 703 #endif 704