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#include <linux/lockdep.h> 21 22struct module; 23struct device; 24struct i2c_client; 25struct irq_domain; 26struct spi_device; 27struct spmi_device; 28struct regmap; 29struct regmap_range_cfg; 30struct regmap_field; 31struct snd_ac97; 32 33/* An enum of all the supported cache types */ 34enum regcache_type { 35 REGCACHE_NONE, 36 REGCACHE_RBTREE, 37 REGCACHE_COMPRESSED, 38 REGCACHE_FLAT, 39}; 40 41/** 42 * Default value for a register. We use an array of structs rather 43 * than a simple array as many modern devices have very sparse 44 * register maps. 45 * 46 * @reg: Register address. 47 * @def: Register default value. 48 */ 49struct reg_default { 50 unsigned int reg; 51 unsigned int def; 52}; 53 54/** 55 * Register/value pairs for sequences of writes with an optional delay in 56 * microseconds to be applied after each write. 57 * 58 * @reg: Register address. 59 * @def: Register value. 60 * @delay_us: Delay to be applied after the register write in microseconds 61 */ 62struct reg_sequence { 63 unsigned int reg; 64 unsigned int def; 65 unsigned int delay_us; 66}; 67 68#ifdef CONFIG_REGMAP 69 70enum regmap_endian { 71 /* Unspecified -> 0 -> Backwards compatible default */ 72 REGMAP_ENDIAN_DEFAULT = 0, 73 REGMAP_ENDIAN_BIG, 74 REGMAP_ENDIAN_LITTLE, 75 REGMAP_ENDIAN_NATIVE, 76}; 77 78/** 79 * A register range, used for access related checks 80 * (readable/writeable/volatile/precious checks) 81 * 82 * @range_min: address of first register 83 * @range_max: address of last register 84 */ 85struct regmap_range { 86 unsigned int range_min; 87 unsigned int range_max; 88}; 89 90#define regmap_reg_range(low, high) { .range_min = low, .range_max = high, } 91 92/* 93 * A table of ranges including some yes ranges and some no ranges. 94 * If a register belongs to a no_range, the corresponding check function 95 * will return false. If a register belongs to a yes range, the corresponding 96 * check function will return true. "no_ranges" are searched first. 97 * 98 * @yes_ranges : pointer to an array of regmap ranges used as "yes ranges" 99 * @n_yes_ranges: size of the above array 100 * @no_ranges: pointer to an array of regmap ranges used as "no ranges" 101 * @n_no_ranges: size of the above array 102 */ 103struct regmap_access_table { 104 const struct regmap_range *yes_ranges; 105 unsigned int n_yes_ranges; 106 const struct regmap_range *no_ranges; 107 unsigned int n_no_ranges; 108}; 109 110typedef void (*regmap_lock)(void *); 111typedef void (*regmap_unlock)(void *); 112 113/** 114 * Configuration for the register map of a device. 115 * 116 * @name: Optional name of the regmap. Useful when a device has multiple 117 * register regions. 118 * 119 * @reg_bits: Number of bits in a register address, mandatory. 120 * @reg_stride: The register address stride. Valid register addresses are a 121 * multiple of this value. If set to 0, a value of 1 will be 122 * used. 123 * @pad_bits: Number of bits of padding between register and value. 124 * @val_bits: Number of bits in a register value, mandatory. 125 * 126 * @writeable_reg: Optional callback returning true if the register 127 * can be written to. If this field is NULL but wr_table 128 * (see below) is not, the check is performed on such table 129 * (a register is writeable if it belongs to one of the ranges 130 * specified by wr_table). 131 * @readable_reg: Optional callback returning true if the register 132 * can be read from. If this field is NULL but rd_table 133 * (see below) is not, the check is performed on such table 134 * (a register is readable if it belongs to one of the ranges 135 * specified by rd_table). 136 * @volatile_reg: Optional callback returning true if the register 137 * value can't be cached. If this field is NULL but 138 * volatile_table (see below) is not, the check is performed on 139 * such table (a register is volatile if it belongs to one of 140 * the ranges specified by volatile_table). 141 * @precious_reg: Optional callback returning true if the register 142 * should not be read outside of a call from the driver 143 * (e.g., a clear on read interrupt status register). If this 144 * field is NULL but precious_table (see below) is not, the 145 * check is performed on such table (a register is precious if 146 * it belongs to one of the ranges specified by precious_table). 147 * @lock: Optional lock callback (overrides regmap's default lock 148 * function, based on spinlock or mutex). 149 * @unlock: As above for unlocking. 150 * @lock_arg: this field is passed as the only argument of lock/unlock 151 * functions (ignored in case regular lock/unlock functions 152 * are not overridden). 153 * @reg_read: Optional callback that if filled will be used to perform 154 * all the reads from the registers. Should only be provided for 155 * devices whose read operation cannot be represented as a simple 156 * read operation on a bus such as SPI, I2C, etc. Most of the 157 * devices do not need this. 158 * @reg_write: Same as above for writing. 159 * @fast_io: Register IO is fast. Use a spinlock instead of a mutex 160 * to perform locking. This field is ignored if custom lock/unlock 161 * functions are used (see fields lock/unlock of struct regmap_config). 162 * This field is a duplicate of a similar file in 163 * 'struct regmap_bus' and serves exact same purpose. 164 * Use it only for "no-bus" cases. 165 * @max_register: Optional, specifies the maximum valid register index. 166 * @wr_table: Optional, points to a struct regmap_access_table specifying 167 * valid ranges for write access. 168 * @rd_table: As above, for read access. 169 * @volatile_table: As above, for volatile registers. 170 * @precious_table: As above, for precious registers. 171 * @reg_defaults: Power on reset values for registers (for use with 172 * register cache support). 173 * @num_reg_defaults: Number of elements in reg_defaults. 174 * 175 * @read_flag_mask: Mask to be set in the top byte of the register when doing 176 * a read. 177 * @write_flag_mask: Mask to be set in the top byte of the register when doing 178 * a write. If both read_flag_mask and write_flag_mask are 179 * empty the regmap_bus default masks are used. 180 * @use_single_rw: If set, converts the bulk read and write operations into 181 * a series of single read and write operations. This is useful 182 * for device that does not support bulk read and write. 183 * @can_multi_write: If set, the device supports the multi write mode of bulk 184 * write operations, if clear multi write requests will be 185 * split into individual write operations 186 * 187 * @cache_type: The actual cache type. 188 * @reg_defaults_raw: Power on reset values for registers (for use with 189 * register cache support). 190 * @num_reg_defaults_raw: Number of elements in reg_defaults_raw. 191 * @reg_format_endian: Endianness for formatted register addresses. If this is 192 * DEFAULT, the @reg_format_endian_default value from the 193 * regmap bus is used. 194 * @val_format_endian: Endianness for formatted register values. If this is 195 * DEFAULT, the @reg_format_endian_default value from the 196 * regmap bus is used. 197 * 198 * @ranges: Array of configuration entries for virtual address ranges. 199 * @num_ranges: Number of range configuration entries. 200 */ 201struct regmap_config { 202 const char *name; 203 204 int reg_bits; 205 int reg_stride; 206 int pad_bits; 207 int val_bits; 208 209 bool (*writeable_reg)(struct device *dev, unsigned int reg); 210 bool (*readable_reg)(struct device *dev, unsigned int reg); 211 bool (*volatile_reg)(struct device *dev, unsigned int reg); 212 bool (*precious_reg)(struct device *dev, unsigned int reg); 213 regmap_lock lock; 214 regmap_unlock unlock; 215 void *lock_arg; 216 217 int (*reg_read)(void *context, unsigned int reg, unsigned int *val); 218 int (*reg_write)(void *context, unsigned int reg, unsigned int val); 219 220 bool fast_io; 221 222 unsigned int max_register; 223 const struct regmap_access_table *wr_table; 224 const struct regmap_access_table *rd_table; 225 const struct regmap_access_table *volatile_table; 226 const struct regmap_access_table *precious_table; 227 const struct reg_default *reg_defaults; 228 unsigned int num_reg_defaults; 229 enum regcache_type cache_type; 230 const void *reg_defaults_raw; 231 unsigned int num_reg_defaults_raw; 232 233 u8 read_flag_mask; 234 u8 write_flag_mask; 235 236 bool use_single_rw; 237 bool can_multi_write; 238 239 enum regmap_endian reg_format_endian; 240 enum regmap_endian val_format_endian; 241 242 const struct regmap_range_cfg *ranges; 243 unsigned int num_ranges; 244}; 245 246/** 247 * Configuration for indirectly accessed or paged registers. 248 * Registers, mapped to this virtual range, are accessed in two steps: 249 * 1. page selector register update; 250 * 2. access through data window registers. 251 * 252 * @name: Descriptive name for diagnostics 253 * 254 * @range_min: Address of the lowest register address in virtual range. 255 * @range_max: Address of the highest register in virtual range. 256 * 257 * @page_sel_reg: Register with selector field. 258 * @page_sel_mask: Bit shift for selector value. 259 * @page_sel_shift: Bit mask for selector value. 260 * 261 * @window_start: Address of first (lowest) register in data window. 262 * @window_len: Number of registers in data window. 263 */ 264struct regmap_range_cfg { 265 const char *name; 266 267 /* Registers of virtual address range */ 268 unsigned int range_min; 269 unsigned int range_max; 270 271 /* Page selector for indirect addressing */ 272 unsigned int selector_reg; 273 unsigned int selector_mask; 274 int selector_shift; 275 276 /* Data window (per each page) */ 277 unsigned int window_start; 278 unsigned int window_len; 279}; 280 281struct regmap_async; 282 283typedef int (*regmap_hw_write)(void *context, const void *data, 284 size_t count); 285typedef int (*regmap_hw_gather_write)(void *context, 286 const void *reg, size_t reg_len, 287 const void *val, size_t val_len); 288typedef int (*regmap_hw_async_write)(void *context, 289 const void *reg, size_t reg_len, 290 const void *val, size_t val_len, 291 struct regmap_async *async); 292typedef int (*regmap_hw_read)(void *context, 293 const void *reg_buf, size_t reg_size, 294 void *val_buf, size_t val_size); 295typedef int (*regmap_hw_reg_read)(void *context, unsigned int reg, 296 unsigned int *val); 297typedef int (*regmap_hw_reg_write)(void *context, unsigned int reg, 298 unsigned int val); 299typedef int (*regmap_hw_reg_update_bits)(void *context, unsigned int reg, 300 unsigned int mask, unsigned int val); 301typedef struct regmap_async *(*regmap_hw_async_alloc)(void); 302typedef void (*regmap_hw_free_context)(void *context); 303 304/** 305 * Description of a hardware bus for the register map infrastructure. 306 * 307 * @fast_io: Register IO is fast. Use a spinlock instead of a mutex 308 * to perform locking. This field is ignored if custom lock/unlock 309 * functions are used (see fields lock/unlock of 310 * struct regmap_config). 311 * @write: Write operation. 312 * @gather_write: Write operation with split register/value, return -ENOTSUPP 313 * if not implemented on a given device. 314 * @async_write: Write operation which completes asynchronously, optional and 315 * must serialise with respect to non-async I/O. 316 * @reg_write: Write a single register value to the given register address. This 317 * write operation has to complete when returning from the function. 318 * @read: Read operation. Data is returned in the buffer used to transmit 319 * data. 320 * @reg_read: Read a single register value from a given register address. 321 * @free_context: Free context. 322 * @async_alloc: Allocate a regmap_async() structure. 323 * @read_flag_mask: Mask to be set in the top byte of the register when doing 324 * a read. 325 * @reg_format_endian_default: Default endianness for formatted register 326 * addresses. Used when the regmap_config specifies DEFAULT. If this is 327 * DEFAULT, BIG is assumed. 328 * @val_format_endian_default: Default endianness for formatted register 329 * values. Used when the regmap_config specifies DEFAULT. If this is 330 * DEFAULT, BIG is assumed. 331 * @max_raw_read: Max raw read size that can be used on the bus. 332 * @max_raw_write: Max raw write size that can be used on the bus. 333 */ 334struct regmap_bus { 335 bool fast_io; 336 regmap_hw_write write; 337 regmap_hw_gather_write gather_write; 338 regmap_hw_async_write async_write; 339 regmap_hw_reg_write reg_write; 340 regmap_hw_reg_update_bits reg_update_bits; 341 regmap_hw_read read; 342 regmap_hw_reg_read reg_read; 343 regmap_hw_free_context free_context; 344 regmap_hw_async_alloc async_alloc; 345 u8 read_flag_mask; 346 enum regmap_endian reg_format_endian_default; 347 enum regmap_endian val_format_endian_default; 348 size_t max_raw_read; 349 size_t max_raw_write; 350}; 351 352/* 353 * __regmap_init functions. 354 * 355 * These functions take a lock key and name parameter, and should not be called 356 * directly. Instead, use the regmap_init macros that generate a key and name 357 * for each call. 358 */ 359struct regmap *__regmap_init(struct device *dev, 360 const struct regmap_bus *bus, 361 void *bus_context, 362 const struct regmap_config *config, 363 struct lock_class_key *lock_key, 364 const char *lock_name); 365struct regmap *__regmap_init_i2c(struct i2c_client *i2c, 366 const struct regmap_config *config, 367 struct lock_class_key *lock_key, 368 const char *lock_name); 369struct regmap *__regmap_init_spi(struct spi_device *dev, 370 const struct regmap_config *config, 371 struct lock_class_key *lock_key, 372 const char *lock_name); 373struct regmap *__regmap_init_spmi_base(struct spmi_device *dev, 374 const struct regmap_config *config, 375 struct lock_class_key *lock_key, 376 const char *lock_name); 377struct regmap *__regmap_init_spmi_ext(struct spmi_device *dev, 378 const struct regmap_config *config, 379 struct lock_class_key *lock_key, 380 const char *lock_name); 381struct regmap *__regmap_init_mmio_clk(struct device *dev, const char *clk_id, 382 void __iomem *regs, 383 const struct regmap_config *config, 384 struct lock_class_key *lock_key, 385 const char *lock_name); 386struct regmap *__regmap_init_ac97(struct snd_ac97 *ac97, 387 const struct regmap_config *config, 388 struct lock_class_key *lock_key, 389 const char *lock_name); 390 391struct regmap *__devm_regmap_init(struct device *dev, 392 const struct regmap_bus *bus, 393 void *bus_context, 394 const struct regmap_config *config, 395 struct lock_class_key *lock_key, 396 const char *lock_name); 397struct regmap *__devm_regmap_init_i2c(struct i2c_client *i2c, 398 const struct regmap_config *config, 399 struct lock_class_key *lock_key, 400 const char *lock_name); 401struct regmap *__devm_regmap_init_spi(struct spi_device *dev, 402 const struct regmap_config *config, 403 struct lock_class_key *lock_key, 404 const char *lock_name); 405struct regmap *__devm_regmap_init_spmi_base(struct spmi_device *dev, 406 const struct regmap_config *config, 407 struct lock_class_key *lock_key, 408 const char *lock_name); 409struct regmap *__devm_regmap_init_spmi_ext(struct spmi_device *dev, 410 const struct regmap_config *config, 411 struct lock_class_key *lock_key, 412 const char *lock_name); 413struct regmap *__devm_regmap_init_mmio_clk(struct device *dev, 414 const char *clk_id, 415 void __iomem *regs, 416 const struct regmap_config *config, 417 struct lock_class_key *lock_key, 418 const char *lock_name); 419struct regmap *__devm_regmap_init_ac97(struct snd_ac97 *ac97, 420 const struct regmap_config *config, 421 struct lock_class_key *lock_key, 422 const char *lock_name); 423 424/* 425 * Wrapper for regmap_init macros to include a unique lockdep key and name 426 * for each call. No-op if CONFIG_LOCKDEP is not set. 427 * 428 * @fn: Real function to call (in the form __[*_]regmap_init[_*]) 429 * @name: Config variable name (#config in the calling macro) 430 **/ 431#ifdef CONFIG_LOCKDEP 432#define __regmap_lockdep_wrapper(fn, name, ...) \ 433( \ 434 ({ \ 435 static struct lock_class_key _key; \ 436 fn(__VA_ARGS__, &_key, \ 437 KBUILD_BASENAME ":" \ 438 __stringify(__LINE__) ":" \ 439 "(" name ")->lock"); \ 440 }) \ 441) 442#else 443#define __regmap_lockdep_wrapper(fn, name, ...) fn(__VA_ARGS__, NULL, NULL) 444#endif 445 446/** 447 * regmap_init(): Initialise register map 448 * 449 * @dev: Device that will be interacted with 450 * @bus: Bus-specific callbacks to use with device 451 * @bus_context: Data passed to bus-specific callbacks 452 * @config: Configuration for register map 453 * 454 * The return value will be an ERR_PTR() on error or a valid pointer to 455 * a struct regmap. This function should generally not be called 456 * directly, it should be called by bus-specific init functions. 457 */ 458#define regmap_init(dev, bus, bus_context, config) \ 459 __regmap_lockdep_wrapper(__regmap_init, #config, \ 460 dev, bus, bus_context, config) 461int regmap_attach_dev(struct device *dev, struct regmap *map, 462 const struct regmap_config *config); 463 464/** 465 * regmap_init_i2c(): Initialise register map 466 * 467 * @i2c: Device that will be interacted with 468 * @config: Configuration for register map 469 * 470 * The return value will be an ERR_PTR() on error or a valid pointer to 471 * a struct regmap. 472 */ 473#define regmap_init_i2c(i2c, config) \ 474 __regmap_lockdep_wrapper(__regmap_init_i2c, #config, \ 475 i2c, config) 476 477/** 478 * regmap_init_spi(): Initialise register map 479 * 480 * @spi: Device that will be interacted with 481 * @config: Configuration for register map 482 * 483 * The return value will be an ERR_PTR() on error or a valid pointer to 484 * a struct regmap. 485 */ 486#define regmap_init_spi(dev, config) \ 487 __regmap_lockdep_wrapper(__regmap_init_spi, #config, \ 488 dev, config) 489 490/** 491 * regmap_init_spmi_base(): Create regmap for the Base register space 492 * @sdev: SPMI device that will be interacted with 493 * @config: Configuration for register map 494 * 495 * The return value will be an ERR_PTR() on error or a valid pointer to 496 * a struct regmap. 497 */ 498#define regmap_init_spmi_base(dev, config) \ 499 __regmap_lockdep_wrapper(__regmap_init_spmi_base, #config, \ 500 dev, config) 501 502/** 503 * regmap_init_spmi_ext(): Create regmap for Ext register space 504 * @sdev: Device that will be interacted with 505 * @config: Configuration for register map 506 * 507 * The return value will be an ERR_PTR() on error or a valid pointer to 508 * a struct regmap. 509 */ 510#define regmap_init_spmi_ext(dev, config) \ 511 __regmap_lockdep_wrapper(__regmap_init_spmi_ext, #config, \ 512 dev, config) 513 514/** 515 * regmap_init_mmio_clk(): Initialise register map with register clock 516 * 517 * @dev: Device that will be interacted with 518 * @clk_id: register clock consumer ID 519 * @regs: Pointer to memory-mapped IO region 520 * @config: Configuration for register map 521 * 522 * The return value will be an ERR_PTR() on error or a valid pointer to 523 * a struct regmap. 524 */ 525#define regmap_init_mmio_clk(dev, clk_id, regs, config) \ 526 __regmap_lockdep_wrapper(__regmap_init_mmio_clk, #config, \ 527 dev, clk_id, regs, config) 528 529/** 530 * regmap_init_mmio(): Initialise register map 531 * 532 * @dev: Device that will be interacted with 533 * @regs: Pointer to memory-mapped IO region 534 * @config: Configuration for register map 535 * 536 * The return value will be an ERR_PTR() on error or a valid pointer to 537 * a struct regmap. 538 */ 539#define regmap_init_mmio(dev, regs, config) \ 540 regmap_init_mmio_clk(dev, NULL, regs, config) 541 542/** 543 * regmap_init_ac97(): Initialise AC'97 register map 544 * 545 * @ac97: Device that will be interacted with 546 * @config: Configuration for register map 547 * 548 * The return value will be an ERR_PTR() on error or a valid pointer to 549 * a struct regmap. 550 */ 551#define regmap_init_ac97(ac97, config) \ 552 __regmap_lockdep_wrapper(__regmap_init_ac97, #config, \ 553 ac97, config) 554bool regmap_ac97_default_volatile(struct device *dev, unsigned int reg); 555 556/** 557 * devm_regmap_init(): Initialise managed register map 558 * 559 * @dev: Device that will be interacted with 560 * @bus: Bus-specific callbacks to use with device 561 * @bus_context: Data passed to bus-specific callbacks 562 * @config: Configuration for register map 563 * 564 * The return value will be an ERR_PTR() on error or a valid pointer 565 * to a struct regmap. This function should generally not be called 566 * directly, it should be called by bus-specific init functions. The 567 * map will be automatically freed by the device management code. 568 */ 569#define devm_regmap_init(dev, bus, bus_context, config) \ 570 __regmap_lockdep_wrapper(__devm_regmap_init, #config, \ 571 dev, bus, bus_context, config) 572 573/** 574 * devm_regmap_init_i2c(): Initialise managed register map 575 * 576 * @i2c: Device that will be interacted with 577 * @config: Configuration for register map 578 * 579 * The return value will be an ERR_PTR() on error or a valid pointer 580 * to a struct regmap. The regmap will be automatically freed by the 581 * device management code. 582 */ 583#define devm_regmap_init_i2c(i2c, config) \ 584 __regmap_lockdep_wrapper(__devm_regmap_init_i2c, #config, \ 585 i2c, config) 586 587/** 588 * devm_regmap_init_spi(): Initialise register map 589 * 590 * @spi: Device that will be interacted with 591 * @config: Configuration for register map 592 * 593 * The return value will be an ERR_PTR() on error or a valid pointer 594 * to a struct regmap. The map will be automatically freed by the 595 * device management code. 596 */ 597#define devm_regmap_init_spi(dev, config) \ 598 __regmap_lockdep_wrapper(__devm_regmap_init_spi, #config, \ 599 dev, config) 600 601/** 602 * devm_regmap_init_spmi_base(): Create managed regmap for Base register space 603 * @sdev: SPMI device that will be interacted with 604 * @config: Configuration for register map 605 * 606 * The return value will be an ERR_PTR() on error or a valid pointer 607 * to a struct regmap. The regmap will be automatically freed by the 608 * device management code. 609 */ 610#define devm_regmap_init_spmi_base(dev, config) \ 611 __regmap_lockdep_wrapper(__devm_regmap_init_spmi_base, #config, \ 612 dev, config) 613 614/** 615 * devm_regmap_init_spmi_ext(): Create managed regmap for Ext register space 616 * @sdev: SPMI device that will be interacted with 617 * @config: Configuration for register map 618 * 619 * The return value will be an ERR_PTR() on error or a valid pointer 620 * to a struct regmap. The regmap will be automatically freed by the 621 * device management code. 622 */ 623#define devm_regmap_init_spmi_ext(dev, config) \ 624 __regmap_lockdep_wrapper(__devm_regmap_init_spmi_ext, #config, \ 625 dev, config) 626 627/** 628 * devm_regmap_init_mmio_clk(): Initialise managed register map with clock 629 * 630 * @dev: Device that will be interacted with 631 * @clk_id: register clock consumer ID 632 * @regs: Pointer to memory-mapped IO region 633 * @config: Configuration for register map 634 * 635 * The return value will be an ERR_PTR() on error or a valid pointer 636 * to a struct regmap. The regmap will be automatically freed by the 637 * device management code. 638 */ 639#define devm_regmap_init_mmio_clk(dev, clk_id, regs, config) \ 640 __regmap_lockdep_wrapper(__devm_regmap_init_mmio_clk, #config, \ 641 dev, clk_id, regs, config) 642 643/** 644 * devm_regmap_init_mmio(): Initialise managed register map 645 * 646 * @dev: Device that will be interacted with 647 * @regs: Pointer to memory-mapped IO region 648 * @config: Configuration for register map 649 * 650 * The return value will be an ERR_PTR() on error or a valid pointer 651 * to a struct regmap. The regmap will be automatically freed by the 652 * device management code. 653 */ 654#define devm_regmap_init_mmio(dev, regs, config) \ 655 devm_regmap_init_mmio_clk(dev, NULL, regs, config) 656 657/** 658 * devm_regmap_init_ac97(): Initialise AC'97 register map 659 * 660 * @ac97: Device that will be interacted with 661 * @config: Configuration for register map 662 * 663 * The return value will be an ERR_PTR() on error or a valid pointer 664 * to a struct regmap. The regmap will be automatically freed by the 665 * device management code. 666 */ 667#define devm_regmap_init_ac97(ac97, config) \ 668 __regmap_lockdep_wrapper(__devm_regmap_init_ac97, #config, \ 669 ac97, config) 670 671void regmap_exit(struct regmap *map); 672int regmap_reinit_cache(struct regmap *map, 673 const struct regmap_config *config); 674struct regmap *dev_get_regmap(struct device *dev, const char *name); 675struct device *regmap_get_device(struct regmap *map); 676int regmap_write(struct regmap *map, unsigned int reg, unsigned int val); 677int regmap_write_async(struct regmap *map, unsigned int reg, unsigned int val); 678int regmap_raw_write(struct regmap *map, unsigned int reg, 679 const void *val, size_t val_len); 680int regmap_bulk_write(struct regmap *map, unsigned int reg, const void *val, 681 size_t val_count); 682int regmap_multi_reg_write(struct regmap *map, const struct reg_sequence *regs, 683 int num_regs); 684int regmap_multi_reg_write_bypassed(struct regmap *map, 685 const struct reg_sequence *regs, 686 int num_regs); 687int regmap_raw_write_async(struct regmap *map, unsigned int reg, 688 const void *val, size_t val_len); 689int regmap_read(struct regmap *map, unsigned int reg, unsigned int *val); 690int regmap_raw_read(struct regmap *map, unsigned int reg, 691 void *val, size_t val_len); 692int regmap_bulk_read(struct regmap *map, unsigned int reg, void *val, 693 size_t val_count); 694int regmap_update_bits(struct regmap *map, unsigned int reg, 695 unsigned int mask, unsigned int val); 696int regmap_write_bits(struct regmap *map, unsigned int reg, 697 unsigned int mask, unsigned int val); 698int regmap_update_bits_async(struct regmap *map, unsigned int reg, 699 unsigned int mask, unsigned int val); 700int regmap_update_bits_check(struct regmap *map, unsigned int reg, 701 unsigned int mask, unsigned int val, 702 bool *change); 703int regmap_update_bits_check_async(struct regmap *map, unsigned int reg, 704 unsigned int mask, unsigned int val, 705 bool *change); 706int regmap_get_val_bytes(struct regmap *map); 707int regmap_get_max_register(struct regmap *map); 708int regmap_get_reg_stride(struct regmap *map); 709int regmap_async_complete(struct regmap *map); 710bool regmap_can_raw_write(struct regmap *map); 711size_t regmap_get_raw_read_max(struct regmap *map); 712size_t regmap_get_raw_write_max(struct regmap *map); 713 714int regcache_sync(struct regmap *map); 715int regcache_sync_region(struct regmap *map, unsigned int min, 716 unsigned int max); 717int regcache_drop_region(struct regmap *map, unsigned int min, 718 unsigned int max); 719void regcache_cache_only(struct regmap *map, bool enable); 720void regcache_cache_bypass(struct regmap *map, bool enable); 721void regcache_mark_dirty(struct regmap *map); 722 723bool regmap_check_range_table(struct regmap *map, unsigned int reg, 724 const struct regmap_access_table *table); 725 726int regmap_register_patch(struct regmap *map, const struct reg_sequence *regs, 727 int num_regs); 728int regmap_parse_val(struct regmap *map, const void *buf, 729 unsigned int *val); 730 731static inline bool regmap_reg_in_range(unsigned int reg, 732 const struct regmap_range *range) 733{ 734 return reg >= range->range_min && reg <= range->range_max; 735} 736 737bool regmap_reg_in_ranges(unsigned int reg, 738 const struct regmap_range *ranges, 739 unsigned int nranges); 740 741/** 742 * Description of an register field 743 * 744 * @reg: Offset of the register within the regmap bank 745 * @lsb: lsb of the register field. 746 * @msb: msb of the register field. 747 * @id_size: port size if it has some ports 748 * @id_offset: address offset for each ports 749 */ 750struct reg_field { 751 unsigned int reg; 752 unsigned int lsb; 753 unsigned int msb; 754 unsigned int id_size; 755 unsigned int id_offset; 756}; 757 758#define REG_FIELD(_reg, _lsb, _msb) { \ 759 .reg = _reg, \ 760 .lsb = _lsb, \ 761 .msb = _msb, \ 762 } 763 764struct regmap_field *regmap_field_alloc(struct regmap *regmap, 765 struct reg_field reg_field); 766void regmap_field_free(struct regmap_field *field); 767 768struct regmap_field *devm_regmap_field_alloc(struct device *dev, 769 struct regmap *regmap, struct reg_field reg_field); 770void devm_regmap_field_free(struct device *dev, struct regmap_field *field); 771 772int regmap_field_read(struct regmap_field *field, unsigned int *val); 773int regmap_field_write(struct regmap_field *field, unsigned int val); 774int regmap_field_update_bits(struct regmap_field *field, 775 unsigned int mask, unsigned int val); 776 777int regmap_fields_write(struct regmap_field *field, unsigned int id, 778 unsigned int val); 779int regmap_fields_force_write(struct regmap_field *field, unsigned int id, 780 unsigned int val); 781int regmap_fields_read(struct regmap_field *field, unsigned int id, 782 unsigned int *val); 783int regmap_fields_update_bits(struct regmap_field *field, unsigned int id, 784 unsigned int mask, unsigned int val); 785 786/** 787 * Description of an IRQ for the generic regmap irq_chip. 788 * 789 * @reg_offset: Offset of the status/mask register within the bank 790 * @mask: Mask used to flag/control the register. 791 */ 792struct regmap_irq { 793 unsigned int reg_offset; 794 unsigned int mask; 795}; 796 797#define REGMAP_IRQ_REG(_irq, _off, _mask) \ 798 [_irq] = { .reg_offset = (_off), .mask = (_mask) } 799 800/** 801 * Description of a generic regmap irq_chip. This is not intended to 802 * handle every possible interrupt controller, but it should handle a 803 * substantial proportion of those that are found in the wild. 804 * 805 * @name: Descriptive name for IRQ controller. 806 * 807 * @status_base: Base status register address. 808 * @mask_base: Base mask register address. 809 * @unmask_base: Base unmask register address. for chips who have 810 * separate mask and unmask registers 811 * @ack_base: Base ack address. If zero then the chip is clear on read. 812 * Using zero value is possible with @use_ack bit. 813 * @wake_base: Base address for wake enables. If zero unsupported. 814 * @irq_reg_stride: Stride to use for chips where registers are not contiguous. 815 * @init_ack_masked: Ack all masked interrupts once during initalization. 816 * @mask_invert: Inverted mask register: cleared bits are masked out. 817 * @use_ack: Use @ack register even if it is zero. 818 * @ack_invert: Inverted ack register: cleared bits for ack. 819 * @wake_invert: Inverted wake register: cleared bits are wake enabled. 820 * @runtime_pm: Hold a runtime PM lock on the device when accessing it. 821 * 822 * @num_regs: Number of registers in each control bank. 823 * @irqs: Descriptors for individual IRQs. Interrupt numbers are 824 * assigned based on the index in the array of the interrupt. 825 * @num_irqs: Number of descriptors. 826 */ 827struct regmap_irq_chip { 828 const char *name; 829 830 unsigned int status_base; 831 unsigned int mask_base; 832 unsigned int unmask_base; 833 unsigned int ack_base; 834 unsigned int wake_base; 835 unsigned int irq_reg_stride; 836 bool init_ack_masked:1; 837 bool mask_invert:1; 838 bool use_ack:1; 839 bool ack_invert:1; 840 bool wake_invert:1; 841 bool runtime_pm:1; 842 843 int num_regs; 844 845 const struct regmap_irq *irqs; 846 int num_irqs; 847}; 848 849struct regmap_irq_chip_data; 850 851int regmap_add_irq_chip(struct regmap *map, int irq, int irq_flags, 852 int irq_base, const struct regmap_irq_chip *chip, 853 struct regmap_irq_chip_data **data); 854void regmap_del_irq_chip(int irq, struct regmap_irq_chip_data *data); 855int regmap_irq_chip_get_base(struct regmap_irq_chip_data *data); 856int regmap_irq_get_virq(struct regmap_irq_chip_data *data, int irq); 857struct irq_domain *regmap_irq_get_domain(struct regmap_irq_chip_data *data); 858 859#else 860 861/* 862 * These stubs should only ever be called by generic code which has 863 * regmap based facilities, if they ever get called at runtime 864 * something is going wrong and something probably needs to select 865 * REGMAP. 866 */ 867 868static inline int regmap_write(struct regmap *map, unsigned int reg, 869 unsigned int val) 870{ 871 WARN_ONCE(1, "regmap API is disabled"); 872 return -EINVAL; 873} 874 875static inline int regmap_write_async(struct regmap *map, unsigned int reg, 876 unsigned int val) 877{ 878 WARN_ONCE(1, "regmap API is disabled"); 879 return -EINVAL; 880} 881 882static inline int regmap_raw_write(struct regmap *map, unsigned int reg, 883 const void *val, size_t val_len) 884{ 885 WARN_ONCE(1, "regmap API is disabled"); 886 return -EINVAL; 887} 888 889static inline int regmap_raw_write_async(struct regmap *map, unsigned int reg, 890 const void *val, size_t val_len) 891{ 892 WARN_ONCE(1, "regmap API is disabled"); 893 return -EINVAL; 894} 895 896static inline int regmap_bulk_write(struct regmap *map, unsigned int reg, 897 const void *val, size_t val_count) 898{ 899 WARN_ONCE(1, "regmap API is disabled"); 900 return -EINVAL; 901} 902 903static inline int regmap_read(struct regmap *map, unsigned int reg, 904 unsigned int *val) 905{ 906 WARN_ONCE(1, "regmap API is disabled"); 907 return -EINVAL; 908} 909 910static inline int regmap_raw_read(struct regmap *map, unsigned int reg, 911 void *val, size_t val_len) 912{ 913 WARN_ONCE(1, "regmap API is disabled"); 914 return -EINVAL; 915} 916 917static inline int regmap_bulk_read(struct regmap *map, unsigned int reg, 918 void *val, size_t val_count) 919{ 920 WARN_ONCE(1, "regmap API is disabled"); 921 return -EINVAL; 922} 923 924static inline int regmap_update_bits(struct regmap *map, unsigned int reg, 925 unsigned int mask, unsigned int val) 926{ 927 WARN_ONCE(1, "regmap API is disabled"); 928 return -EINVAL; 929} 930 931static inline int regmap_write_bits(struct regmap *map, unsigned int reg, 932 unsigned int mask, unsigned int val) 933{ 934 WARN_ONCE(1, "regmap API is disabled"); 935 return -EINVAL; 936} 937 938static inline int regmap_update_bits_async(struct regmap *map, 939 unsigned int reg, 940 unsigned int mask, unsigned int val) 941{ 942 WARN_ONCE(1, "regmap API is disabled"); 943 return -EINVAL; 944} 945 946static inline int regmap_update_bits_check(struct regmap *map, 947 unsigned int reg, 948 unsigned int mask, unsigned int val, 949 bool *change) 950{ 951 WARN_ONCE(1, "regmap API is disabled"); 952 return -EINVAL; 953} 954 955static inline int regmap_update_bits_check_async(struct regmap *map, 956 unsigned int reg, 957 unsigned int mask, 958 unsigned int val, 959 bool *change) 960{ 961 WARN_ONCE(1, "regmap API is disabled"); 962 return -EINVAL; 963} 964 965static inline int regmap_get_val_bytes(struct regmap *map) 966{ 967 WARN_ONCE(1, "regmap API is disabled"); 968 return -EINVAL; 969} 970 971static inline int regmap_get_max_register(struct regmap *map) 972{ 973 WARN_ONCE(1, "regmap API is disabled"); 974 return -EINVAL; 975} 976 977static inline int regmap_get_reg_stride(struct regmap *map) 978{ 979 WARN_ONCE(1, "regmap API is disabled"); 980 return -EINVAL; 981} 982 983static inline int regcache_sync(struct regmap *map) 984{ 985 WARN_ONCE(1, "regmap API is disabled"); 986 return -EINVAL; 987} 988 989static inline int regcache_sync_region(struct regmap *map, unsigned int min, 990 unsigned int max) 991{ 992 WARN_ONCE(1, "regmap API is disabled"); 993 return -EINVAL; 994} 995 996static inline int regcache_drop_region(struct regmap *map, unsigned int min, 997 unsigned int max) 998{ 999 WARN_ONCE(1, "regmap API is disabled"); 1000 return -EINVAL; 1001} 1002 1003static inline void regcache_cache_only(struct regmap *map, bool enable) 1004{ 1005 WARN_ONCE(1, "regmap API is disabled"); 1006} 1007 1008static inline void regcache_cache_bypass(struct regmap *map, bool enable) 1009{ 1010 WARN_ONCE(1, "regmap API is disabled"); 1011} 1012 1013static inline void regcache_mark_dirty(struct regmap *map) 1014{ 1015 WARN_ONCE(1, "regmap API is disabled"); 1016} 1017 1018static inline void regmap_async_complete(struct regmap *map) 1019{ 1020 WARN_ONCE(1, "regmap API is disabled"); 1021} 1022 1023static inline int regmap_register_patch(struct regmap *map, 1024 const struct reg_default *regs, 1025 int num_regs) 1026{ 1027 WARN_ONCE(1, "regmap API is disabled"); 1028 return -EINVAL; 1029} 1030 1031static inline int regmap_parse_val(struct regmap *map, const void *buf, 1032 unsigned int *val) 1033{ 1034 WARN_ONCE(1, "regmap API is disabled"); 1035 return -EINVAL; 1036} 1037 1038static inline struct regmap *dev_get_regmap(struct device *dev, 1039 const char *name) 1040{ 1041 return NULL; 1042} 1043 1044static inline struct device *regmap_get_device(struct regmap *map) 1045{ 1046 WARN_ONCE(1, "regmap API is disabled"); 1047 return NULL; 1048} 1049 1050#endif 1051 1052#endif 1053