“992f191f2c83f0d1184975a211070dff2a359d3b”上不存在“README.md”
regmap.h 35.8 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
#ifndef __LINUX_REGMAP_H
#define __LINUX_REGMAP_H

/*
 * Register map access API
 *
 * Copyright 2011 Wolfson Microelectronics plc
 *
 * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

#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

22
struct module;
23
struct device;
M
Mark Brown 已提交
24
struct i2c_client;
25
struct irq_domain;
M
Mark Brown 已提交
26
struct spi_device;
27
struct spmi_device;
28
struct regmap;
29
struct regmap_range_cfg;
30
struct regmap_field;
31
struct snd_ac97;
M
Mark Brown 已提交
32

33 34 35
/* An enum of all the supported cache types */
enum regcache_type {
	REGCACHE_NONE,
36
	REGCACHE_RBTREE,
37 38
	REGCACHE_COMPRESSED,
	REGCACHE_FLAT,
39 40
};

41 42 43 44 45 46 47 48 49 50 51 52 53
/**
 * Default value for a register.  We use an array of structs rather
 * than a simple array as many modern devices have very sparse
 * register maps.
 *
 * @reg: Register address.
 * @def: Register default value.
 */
struct reg_default {
	unsigned int reg;
	unsigned int def;
};

54
/**
55 56
 * Register/value pairs for sequences of writes with an optional delay in
 * microseconds to be applied after each write.
57 58 59
 *
 * @reg: Register address.
 * @def: Register value.
60
 * @delay_us: Delay to be applied after the register write in microseconds
61 62 63 64
 */
struct reg_sequence {
	unsigned int reg;
	unsigned int def;
65
	unsigned int delay_us;
66 67
};

68 69
#ifdef CONFIG_REGMAP

70 71 72 73 74 75 76 77
enum regmap_endian {
	/* Unspecified -> 0 -> Backwards compatible default */
	REGMAP_ENDIAN_DEFAULT = 0,
	REGMAP_ENDIAN_BIG,
	REGMAP_ENDIAN_LITTLE,
	REGMAP_ENDIAN_NATIVE,
};

78 79 80 81 82 83 84 85 86 87 88 89
/**
 * A register range, used for access related checks
 * (readable/writeable/volatile/precious checks)
 *
 * @range_min: address of first register
 * @range_max: address of last register
 */
struct regmap_range {
	unsigned int range_min;
	unsigned int range_max;
};

90 91
#define regmap_reg_range(low, high) { .range_min = low, .range_max = high, }

92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109
/*
 * A table of ranges including some yes ranges and some no ranges.
 * If a register belongs to a no_range, the corresponding check function
 * will return false. If a register belongs to a yes range, the corresponding
 * check function will return true. "no_ranges" are searched first.
 *
 * @yes_ranges : pointer to an array of regmap ranges used as "yes ranges"
 * @n_yes_ranges: size of the above array
 * @no_ranges: pointer to an array of regmap ranges used as "no ranges"
 * @n_no_ranges: size of the above array
 */
struct regmap_access_table {
	const struct regmap_range *yes_ranges;
	unsigned int n_yes_ranges;
	const struct regmap_range *no_ranges;
	unsigned int n_no_ranges;
};

110 111 112
typedef void (*regmap_lock)(void *);
typedef void (*regmap_unlock)(void *);

113 114 115
/**
 * Configuration for the register map of a device.
 *
116 117 118
 * @name: Optional name of the regmap. Useful when a device has multiple
 *        register regions.
 *
119
 * @reg_bits: Number of bits in a register address, mandatory.
120 121 122
 * @reg_stride: The register address stride. Valid register addresses are a
 *              multiple of this value. If set to 0, a value of 1 will be
 *              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 128 129 130
 *		   can be written to. If this field is NULL but wr_table
 *		   (see below) is not, the check is performed on such table
 *                 (a register is writeable if it belongs to one of the ranges
 *                  specified by wr_table).
131
 * @readable_reg: Optional callback returning true if the register
132 133 134 135
 *		  can be read from. If this field is NULL but rd_table
 *		   (see below) is not, the check is performed on such table
 *                 (a register is readable if it belongs to one of the ranges
 *                  specified by rd_table).
136
 * @volatile_reg: Optional callback returning true if the register
137 138 139 140
 *		  value can't be cached. If this field is NULL but
 *		  volatile_table (see below) is not, the check is performed on
 *                such table (a register is volatile if it belongs to one of
 *                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 145 146 147 148 149 150 151 152
 *                field is NULL but precious_table (see below) is not, the
 *                check is performed on such table (a register is precious if
 *                it belongs to one of the ranges specified by precious_table).
 * @lock:	  Optional lock callback (overrides regmap's default lock
 *		  function, based on spinlock or mutex).
 * @unlock:	  As above for unlocking.
 * @lock_arg:	  this field is passed as the only argument of lock/unlock
 *		  functions (ignored in case regular lock/unlock functions
 *		  are not overridden).
153 154
 * @reg_read:	  Optional callback that if filled will be used to perform
 *           	  all the reads from the registers. Should only be provided for
155 156 157
 *		  devices whose read operation cannot be represented as a simple
 *		  read operation on a bus such as SPI, I2C, etc. Most of the
 *		  devices do not need this.
158 159 160 161 162 163 164
 * @reg_write:	  Same as above for writing.
 * @fast_io:	  Register IO is fast. Use a spinlock instead of a mutex
 *	     	  to perform locking. This field is ignored if custom lock/unlock
 *	     	  functions are used (see fields lock/unlock of struct regmap_config).
 *		  This field is a duplicate of a similar file in
 *		  'struct regmap_bus' and serves exact same purpose.
 *		   Use it only for "no-bus" cases.
165
 * @max_register: Optional, specifies the maximum valid register address.
166 167 168 169 170
 * @wr_table:     Optional, points to a struct regmap_access_table specifying
 *                valid ranges for write access.
 * @rd_table:     As above, for read access.
 * @volatile_table: As above, for volatile registers.
 * @precious_table: As above, for precious registers.
171 172 173
 * @reg_defaults: Power on reset values for registers (for use with
 *                register cache support).
 * @num_reg_defaults: Number of elements in reg_defaults.
174 175 176 177 178 179
 *
 * @read_flag_mask: Mask to be set in the top byte of the register when doing
 *                  a read.
 * @write_flag_mask: Mask to be set in the top byte of the register when doing
 *                   a write. If both read_flag_mask and write_flag_mask are
 *                   empty the regmap_bus default masks are used.
180 181 182
 * @use_single_rw: If set, converts the bulk read and write operations into
 *		    a series of single read and write operations. This is useful
 *		    for device that does not support bulk read and write.
183 184 185
 * @can_multi_write: If set, the device supports the multi write mode of bulk
 *                   write operations, if clear multi write requests will be
 *                   split into individual write operations
186 187 188 189 190
 *
 * @cache_type: The actual cache type.
 * @reg_defaults_raw: Power on reset values for registers (for use with
 *                    register cache support).
 * @num_reg_defaults_raw: Number of elements in reg_defaults_raw.
191 192 193 194 195 196
 * @reg_format_endian: Endianness for formatted register addresses. If this is
 *                     DEFAULT, the @reg_format_endian_default value from the
 *                     regmap bus is used.
 * @val_format_endian: Endianness for formatted register values. If this is
 *                     DEFAULT, the @reg_format_endian_default value from the
 *                     regmap bus is used.
197 198 199
 *
 * @ranges: Array of configuration entries for virtual address ranges.
 * @num_ranges: Number of range configuration entries.
200
 */
201
struct regmap_config {
202 203
	const char *name;

204
	int reg_bits;
205
	int reg_stride;
206
	int pad_bits;
207
	int val_bits;
208 209 210 211

	bool (*writeable_reg)(struct device *dev, unsigned int reg);
	bool (*readable_reg)(struct device *dev, unsigned int reg);
	bool (*volatile_reg)(struct device *dev, unsigned int reg);
212
	bool (*precious_reg)(struct device *dev, unsigned int reg);
213 214 215
	regmap_lock lock;
	regmap_unlock unlock;
	void *lock_arg;
216

217 218 219 220 221
	int (*reg_read)(void *context, unsigned int reg, unsigned int *val);
	int (*reg_write)(void *context, unsigned int reg, unsigned int val);

	bool fast_io;

222
	unsigned int max_register;
223 224 225 226
	const struct regmap_access_table *wr_table;
	const struct regmap_access_table *rd_table;
	const struct regmap_access_table *volatile_table;
	const struct regmap_access_table *precious_table;
227
	const struct reg_default *reg_defaults;
228 229 230 231
	unsigned int num_reg_defaults;
	enum regcache_type cache_type;
	const void *reg_defaults_raw;
	unsigned int num_reg_defaults_raw;
232 233 234

	u8 read_flag_mask;
	u8 write_flag_mask;
235 236

	bool use_single_rw;
237
	bool can_multi_write;
238 239 240

	enum regmap_endian reg_format_endian;
	enum regmap_endian val_format_endian;
241

242
	const struct regmap_range_cfg *ranges;
243
	unsigned int num_ranges;
244 245 246 247 248 249 250 251
};

/**
 * Configuration for indirectly accessed or paged registers.
 * Registers, mapped to this virtual range, are accessed in two steps:
 *     1. page selector register update;
 *     2. access through data window registers.
 *
252 253
 * @name: Descriptive name for diagnostics
 *
254 255 256 257 258 259 260 261 262 263 264
 * @range_min: Address of the lowest register address in virtual range.
 * @range_max: Address of the highest register in virtual range.
 *
 * @page_sel_reg: Register with selector field.
 * @page_sel_mask: Bit shift for selector value.
 * @page_sel_shift: Bit mask for selector value.
 *
 * @window_start: Address of first (lowest) register in data window.
 * @window_len: Number of registers in data window.
 */
struct regmap_range_cfg {
265 266
	const char *name;

267 268 269 270 271 272 273 274 275 276 277 278
	/* Registers of virtual address range */
	unsigned int range_min;
	unsigned int range_max;

	/* Page selector for indirect addressing */
	unsigned int selector_reg;
	unsigned int selector_mask;
	int selector_shift;

	/* Data window (per each page) */
	unsigned int window_start;
	unsigned int window_len;
279 280
};

281 282
struct regmap_async;

283
typedef int (*regmap_hw_write)(void *context, const void *data,
284
			       size_t count);
285
typedef int (*regmap_hw_gather_write)(void *context,
286 287
				      const void *reg, size_t reg_len,
				      const void *val, size_t val_len);
288 289 290 291
typedef int (*regmap_hw_async_write)(void *context,
				     const void *reg, size_t reg_len,
				     const void *val, size_t val_len,
				     struct regmap_async *async);
292
typedef int (*regmap_hw_read)(void *context,
293 294
			      const void *reg_buf, size_t reg_size,
			      void *val_buf, size_t val_size);
295 296 297 298
typedef int (*regmap_hw_reg_read)(void *context, unsigned int reg,
				  unsigned int *val);
typedef int (*regmap_hw_reg_write)(void *context, unsigned int reg,
				   unsigned int val);
299 300
typedef int (*regmap_hw_reg_update_bits)(void *context, unsigned int reg,
					 unsigned int mask, unsigned int val);
301
typedef struct regmap_async *(*regmap_hw_async_alloc)(void);
302
typedef void (*regmap_hw_free_context)(void *context);
303 304 305 306

/**
 * Description of a hardware bus for the register map infrastructure.
 *
307
 * @fast_io: Register IO is fast. Use a spinlock instead of a mutex
308 309 310
 *	     to perform locking. This field is ignored if custom lock/unlock
 *	     functions are used (see fields lock/unlock of
 *	     struct regmap_config).
311 312 313
 * @write: Write operation.
 * @gather_write: Write operation with split register/value, return -ENOTSUPP
 *                if not implemented  on a given device.
314 315
 * @async_write: Write operation which completes asynchronously, optional and
 *               must serialise with respect to non-async I/O.
316 317
 * @reg_write: Write a single register value to the given register address. This
 *             write operation has to complete when returning from the function.
318 319
 * @read: Read operation.  Data is returned in the buffer used to transmit
 *         data.
320 321
 * @reg_read: Read a single register value from a given register address.
 * @free_context: Free context.
322
 * @async_alloc: Allocate a regmap_async() structure.
323 324
 * @read_flag_mask: Mask to be set in the top byte of the register when doing
 *                  a read.
325 326 327 328 329 330
 * @reg_format_endian_default: Default endianness for formatted register
 *     addresses. Used when the regmap_config specifies DEFAULT. If this is
 *     DEFAULT, BIG is assumed.
 * @val_format_endian_default: Default endianness for formatted register
 *     values. Used when the regmap_config specifies DEFAULT. If this is
 *     DEFAULT, BIG is assumed.
331 332
 * @max_raw_read: Max raw read size that can be used on the bus.
 * @max_raw_write: Max raw write size that can be used on the bus.
333 334
 */
struct regmap_bus {
335
	bool fast_io;
336 337
	regmap_hw_write write;
	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 347
	enum regmap_endian reg_format_endian_default;
	enum regmap_endian val_format_endian_default;
348 349
	size_t max_raw_read;
	size_t max_raw_write;
350 351
};

352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422
/*
 * __regmap_init functions.
 *
 * These functions take a lock key and name parameter, and should not be called
 * directly. Instead, use the regmap_init macros that generate a key and name
 * for each call.
 */
struct regmap *__regmap_init(struct device *dev,
			     const struct regmap_bus *bus,
			     void *bus_context,
			     const struct regmap_config *config,
			     struct lock_class_key *lock_key,
			     const char *lock_name);
struct regmap *__regmap_init_i2c(struct i2c_client *i2c,
				 const struct regmap_config *config,
				 struct lock_class_key *lock_key,
				 const char *lock_name);
struct regmap *__regmap_init_spi(struct spi_device *dev,
				 const struct regmap_config *config,
				 struct lock_class_key *lock_key,
				 const char *lock_name);
struct regmap *__regmap_init_spmi_base(struct spmi_device *dev,
				       const struct regmap_config *config,
				       struct lock_class_key *lock_key,
				       const char *lock_name);
struct regmap *__regmap_init_spmi_ext(struct spmi_device *dev,
				      const struct regmap_config *config,
				      struct lock_class_key *lock_key,
				      const char *lock_name);
struct regmap *__regmap_init_mmio_clk(struct device *dev, const char *clk_id,
				      void __iomem *regs,
				      const struct regmap_config *config,
				      struct lock_class_key *lock_key,
				      const char *lock_name);
struct regmap *__regmap_init_ac97(struct snd_ac97 *ac97,
				  const struct regmap_config *config,
				  struct lock_class_key *lock_key,
				  const char *lock_name);

struct regmap *__devm_regmap_init(struct device *dev,
				  const struct regmap_bus *bus,
				  void *bus_context,
				  const struct regmap_config *config,
				  struct lock_class_key *lock_key,
				  const char *lock_name);
struct regmap *__devm_regmap_init_i2c(struct i2c_client *i2c,
				      const struct regmap_config *config,
				      struct lock_class_key *lock_key,
				      const char *lock_name);
struct regmap *__devm_regmap_init_spi(struct spi_device *dev,
				      const struct regmap_config *config,
				      struct lock_class_key *lock_key,
				      const char *lock_name);
struct regmap *__devm_regmap_init_spmi_base(struct spmi_device *dev,
					    const struct regmap_config *config,
					    struct lock_class_key *lock_key,
					    const char *lock_name);
struct regmap *__devm_regmap_init_spmi_ext(struct spmi_device *dev,
					   const struct regmap_config *config,
					   struct lock_class_key *lock_key,
					   const char *lock_name);
struct regmap *__devm_regmap_init_mmio_clk(struct device *dev,
					   const char *clk_id,
					   void __iomem *regs,
					   const struct regmap_config *config,
					   struct lock_class_key *lock_key,
					   const char *lock_name);
struct regmap *__devm_regmap_init_ac97(struct snd_ac97 *ac97,
				       const struct regmap_config *config,
				       struct lock_class_key *lock_key,
				       const char *lock_name);
423

424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445
/*
 * Wrapper for regmap_init macros to include a unique lockdep key and name
 * for each call. No-op if CONFIG_LOCKDEP is not set.
 *
 * @fn: Real function to call (in the form __[*_]regmap_init[_*])
 * @name: Config variable name (#config in the calling macro)
 **/
#ifdef CONFIG_LOCKDEP
#define __regmap_lockdep_wrapper(fn, name, ...)				\
(									\
	({								\
		static struct lock_class_key _key;			\
		fn(__VA_ARGS__, &_key,					\
			KBUILD_BASENAME ":"				\
			__stringify(__LINE__) ":"			\
			"(" name ")->lock");				\
	})								\
)
#else
#define __regmap_lockdep_wrapper(fn, name, ...) fn(__VA_ARGS__, NULL, NULL)
#endif

446 447 448 449 450 451 452 453 454 455 456 457
/**
 * regmap_init(): Initialise register map
 *
 * @dev: Device that will be interacted with
 * @bus: Bus-specific callbacks to use with device
 * @bus_context: Data passed to bus-specific callbacks
 * @config: Configuration for register map
 *
 * The return value will be an ERR_PTR() on error or a valid pointer to
 * a struct regmap.  This function should generally not be called
 * directly, it should be called by bus-specific init functions.
 */
458 459 460
#define regmap_init(dev, bus, bus_context, config)			\
	__regmap_lockdep_wrapper(__regmap_init, #config,		\
				dev, bus, bus_context, config)
461
int regmap_attach_dev(struct device *dev, struct regmap *map,
462
		      const struct regmap_config *config);
463

464 465 466 467 468 469 470 471 472
/**
 * regmap_init_i2c(): Initialise register map
 *
 * @i2c: Device that will be interacted with
 * @config: Configuration for register map
 *
 * The return value will be an ERR_PTR() on error or a valid pointer to
 * a struct regmap.
 */
473 474 475
#define regmap_init_i2c(i2c, config)					\
	__regmap_lockdep_wrapper(__regmap_init_i2c, #config,		\
				i2c, config)
476 477 478 479 480 481 482 483 484 485

/**
 * regmap_init_spi(): Initialise register map
 *
 * @spi: Device that will be interacted with
 * @config: Configuration for register map
 *
 * The return value will be an ERR_PTR() on error or a valid pointer to
 * a struct regmap.
 */
486 487 488
#define regmap_init_spi(dev, config)					\
	__regmap_lockdep_wrapper(__regmap_init_spi, #config,		\
				dev, config)
489 490 491 492 493 494 495 496 497

/**
 * regmap_init_spmi_base(): Create regmap for the Base register space
 * @sdev:	SPMI device that will be interacted with
 * @config:	Configuration for register map
 *
 * The return value will be an ERR_PTR() on error or a valid pointer to
 * a struct regmap.
 */
498 499 500
#define regmap_init_spmi_base(dev, config)				\
	__regmap_lockdep_wrapper(__regmap_init_spmi_base, #config,	\
				dev, config)
501 502 503 504 505 506 507 508 509

/**
 * regmap_init_spmi_ext(): Create regmap for Ext register space
 * @sdev:	Device that will be interacted with
 * @config:	Configuration for register map
 *
 * The return value will be an ERR_PTR() on error or a valid pointer to
 * a struct regmap.
 */
510 511 512
#define regmap_init_spmi_ext(dev, config)				\
	__regmap_lockdep_wrapper(__regmap_init_spmi_ext, #config,	\
				dev, config)
513 514 515 516 517 518 519 520 521 522 523 524

/**
 * regmap_init_mmio_clk(): Initialise register map with register clock
 *
 * @dev: Device that will be interacted with
 * @clk_id: register clock consumer ID
 * @regs: Pointer to memory-mapped IO region
 * @config: Configuration for register map
 *
 * The return value will be an ERR_PTR() on error or a valid pointer to
 * a struct regmap.
 */
525 526 527
#define regmap_init_mmio_clk(dev, clk_id, regs, config)			\
	__regmap_lockdep_wrapper(__regmap_init_mmio_clk, #config,	\
				dev, clk_id, regs, config)
528 529 530 531 532 533 534 535 536 537 538

/**
 * regmap_init_mmio(): Initialise register map
 *
 * @dev: Device that will be interacted with
 * @regs: Pointer to memory-mapped IO region
 * @config: Configuration for register map
 *
 * The return value will be an ERR_PTR() on error or a valid pointer to
 * a struct regmap.
 */
539 540 541 542 543 544 545 546 547 548 549 550
#define regmap_init_mmio(dev, regs, config)		\
	regmap_init_mmio_clk(dev, NULL, regs, config)

/**
 * regmap_init_ac97(): Initialise AC'97 register map
 *
 * @ac97: Device that will be interacted with
 * @config: Configuration for register map
 *
 * The return value will be an ERR_PTR() on error or a valid pointer to
 * a struct regmap.
 */
551 552 553
#define regmap_init_ac97(ac97, config)					\
	__regmap_lockdep_wrapper(__regmap_init_ac97, #config,		\
				ac97, config)
554
bool regmap_ac97_default_volatile(struct device *dev, unsigned int reg);
555

556 557 558 559 560 561 562 563 564 565 566 567 568
/**
 * devm_regmap_init(): Initialise managed register map
 *
 * @dev: Device that will be interacted with
 * @bus: Bus-specific callbacks to use with device
 * @bus_context: Data passed to bus-specific callbacks
 * @config: Configuration for register map
 *
 * The return value will be an ERR_PTR() on error or a valid pointer
 * to a struct regmap.  This function should generally not be called
 * directly, it should be called by bus-specific init functions.  The
 * map will be automatically freed by the device management code.
 */
569 570 571
#define devm_regmap_init(dev, bus, bus_context, config)			\
	__regmap_lockdep_wrapper(__devm_regmap_init, #config,		\
				dev, bus, bus_context, config)
572 573 574 575 576 577 578 579 580 581 582

/**
 * devm_regmap_init_i2c(): Initialise managed register map
 *
 * @i2c: Device that will be interacted with
 * @config: Configuration for register map
 *
 * The return value will be an ERR_PTR() on error or a valid pointer
 * to a struct regmap.  The regmap will be automatically freed by the
 * device management code.
 */
583 584 585
#define devm_regmap_init_i2c(i2c, config)				\
	__regmap_lockdep_wrapper(__devm_regmap_init_i2c, #config,	\
				i2c, config)
586 587 588 589 590 591 592 593 594 595 596

/**
 * devm_regmap_init_spi(): Initialise register map
 *
 * @spi: Device that will be interacted with
 * @config: Configuration for register map
 *
 * The return value will be an ERR_PTR() on error or a valid pointer
 * to a struct regmap.  The map will be automatically freed by the
 * device management code.
 */
597 598 599
#define devm_regmap_init_spi(dev, config)				\
	__regmap_lockdep_wrapper(__devm_regmap_init_spi, #config,	\
				dev, config)
600 601 602 603 604 605 606 607 608 609

/**
 * devm_regmap_init_spmi_base(): Create managed regmap for Base register space
 * @sdev:	SPMI device that will be interacted with
 * @config:	Configuration for register map
 *
 * The return value will be an ERR_PTR() on error or a valid pointer
 * to a struct regmap.  The regmap will be automatically freed by the
 * device management code.
 */
610 611 612
#define devm_regmap_init_spmi_base(dev, config)				\
	__regmap_lockdep_wrapper(__devm_regmap_init_spmi_base, #config,	\
				dev, config)
613 614 615 616 617 618 619 620 621 622

/**
 * devm_regmap_init_spmi_ext(): Create managed regmap for Ext register space
 * @sdev:	SPMI device that will be interacted with
 * @config:	Configuration for register map
 *
 * The return value will be an ERR_PTR() on error or a valid pointer
 * to a struct regmap.  The regmap will be automatically freed by the
 * device management code.
 */
623 624 625 626
#define devm_regmap_init_spmi_ext(dev, config)				\
	__regmap_lockdep_wrapper(__devm_regmap_init_spmi_ext, #config,	\
				dev, config)

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 633 634
 * @regs: Pointer to memory-mapped IO region
 * @config: Configuration for register map
 *
635 636 637
 * The return value will be an ERR_PTR() on error or a valid pointer
 * to a struct regmap.  The regmap will be automatically freed by the
 * device management code.
638
 */
639 640 641
#define devm_regmap_init_mmio_clk(dev, clk_id, regs, config)		\
	__regmap_lockdep_wrapper(__devm_regmap_init_mmio_clk, #config,	\
				dev, clk_id, regs, config)
642 643 644 645 646 647 648 649 650 651 652 653

/**
 * devm_regmap_init_mmio(): Initialise managed register map
 *
 * @dev: Device that will be interacted with
 * @regs: Pointer to memory-mapped IO region
 * @config: Configuration for register map
 *
 * The return value will be an ERR_PTR() on error or a valid pointer
 * to a struct regmap.  The regmap will be automatically freed by the
 * device management code.
 */
654 655
#define devm_regmap_init_mmio(dev, regs, config)		\
	devm_regmap_init_mmio_clk(dev, NULL, regs, config)
656

657 658 659 660 661 662 663 664 665 666 667 668 669
/**
 * devm_regmap_init_ac97(): Initialise AC'97 register map
 *
 * @ac97: Device that will be interacted with
 * @config: Configuration for register map
 *
 * The return value will be an ERR_PTR() on error or a valid pointer
 * to a struct regmap.  The regmap will be automatically freed by the
 * device management code.
 */
#define devm_regmap_init_ac97(ac97, config)				\
	__regmap_lockdep_wrapper(__devm_regmap_init_ac97, #config,	\
				ac97, config)
670

671
void regmap_exit(struct regmap *map);
672 673
int regmap_reinit_cache(struct regmap *map,
			const struct regmap_config *config);
674
struct regmap *dev_get_regmap(struct device *dev, const char *name);
675
struct device *regmap_get_device(struct regmap *map);
676
int regmap_write(struct regmap *map, unsigned int reg, unsigned int val);
677
int regmap_write_async(struct regmap *map, unsigned int reg, unsigned int val);
678 679
int regmap_raw_write(struct regmap *map, unsigned int reg,
		     const void *val, size_t val_len);
680 681
int regmap_bulk_write(struct regmap *map, unsigned int reg, const void *val,
			size_t val_count);
682
int regmap_multi_reg_write(struct regmap *map, const struct reg_sequence *regs,
683
			int num_regs);
684
int regmap_multi_reg_write_bypassed(struct regmap *map,
685
				    const struct reg_sequence *regs,
686
				    int num_regs);
687 688
int regmap_raw_write_async(struct regmap *map, unsigned int reg,
			   const void *val, size_t val_len);
689 690 691 692 693 694 695
int regmap_read(struct regmap *map, unsigned int reg, unsigned int *val);
int regmap_raw_read(struct regmap *map, unsigned int reg,
		    void *val, size_t val_len);
int regmap_bulk_read(struct regmap *map, unsigned int reg, void *val,
		     size_t val_count);
int regmap_update_bits(struct regmap *map, unsigned int reg,
		       unsigned int mask, unsigned int val);
696 697
int regmap_write_bits(struct regmap *map, unsigned int reg,
		       unsigned int mask, unsigned int val);
698 699
int regmap_update_bits_async(struct regmap *map, unsigned int reg,
			     unsigned int mask, unsigned int val);
700 701 702
int regmap_update_bits_check(struct regmap *map, unsigned int reg,
			     unsigned int mask, unsigned int val,
			     bool *change);
703 704 705
int regmap_update_bits_check_async(struct regmap *map, unsigned int reg,
				   unsigned int mask, unsigned int val,
				   bool *change);
706
int regmap_get_val_bytes(struct regmap *map);
707
int regmap_get_max_register(struct regmap *map);
708
int regmap_get_reg_stride(struct regmap *map);
709
int regmap_async_complete(struct regmap *map);
710
bool regmap_can_raw_write(struct regmap *map);
711 712
size_t regmap_get_raw_read_max(struct regmap *map);
size_t regmap_get_raw_write_max(struct regmap *map);
713

714
int regcache_sync(struct regmap *map);
715 716
int regcache_sync_region(struct regmap *map, unsigned int min,
			 unsigned int max);
717 718
int regcache_drop_region(struct regmap *map, unsigned int min,
			 unsigned int max);
719
void regcache_cache_only(struct regmap *map, bool enable);
720
void regcache_cache_bypass(struct regmap *map, bool enable);
721
void regcache_mark_dirty(struct regmap *map);
722

723 724 725
bool regmap_check_range_table(struct regmap *map, unsigned int reg,
			      const struct regmap_access_table *table);

726
int regmap_register_patch(struct regmap *map, const struct reg_sequence *regs,
727
			  int num_regs);
728 729
int regmap_parse_val(struct regmap *map, const void *buf,
				unsigned int *val);
730

731 732 733 734 735 736 737 738 739 740
static inline bool regmap_reg_in_range(unsigned int reg,
				       const struct regmap_range *range)
{
	return reg >= range->range_min && reg <= range->range_max;
}

bool regmap_reg_in_ranges(unsigned int reg,
			  const struct regmap_range *ranges,
			  unsigned int nranges);

741 742 743 744 745
/**
 * Description of an register field
 *
 * @reg: Offset of the register within the regmap bank
 * @lsb: lsb of the register field.
746
 * @msb: msb of the register field.
747 748
 * @id_size: port size if it has some ports
 * @id_offset: address offset for each ports
749 750 751 752 753
 */
struct reg_field {
	unsigned int reg;
	unsigned int lsb;
	unsigned int msb;
754 755
	unsigned int id_size;
	unsigned int id_offset;
756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773
};

#define REG_FIELD(_reg, _lsb, _msb) {		\
				.reg = _reg,	\
				.lsb = _lsb,	\
				.msb = _msb,	\
				}

struct regmap_field *regmap_field_alloc(struct regmap *regmap,
		struct reg_field reg_field);
void regmap_field_free(struct regmap_field *field);

struct regmap_field *devm_regmap_field_alloc(struct device *dev,
		struct regmap *regmap, struct reg_field reg_field);
void devm_regmap_field_free(struct device *dev,	struct regmap_field *field);

int regmap_field_read(struct regmap_field *field, unsigned int *val);
int regmap_field_write(struct regmap_field *field, unsigned int val);
774 775
int regmap_field_update_bits(struct regmap_field *field,
			     unsigned int mask, unsigned int val);
776

777 778
int regmap_fields_write(struct regmap_field *field, unsigned int id,
			unsigned int val);
779 780
int regmap_fields_force_write(struct regmap_field *field, unsigned int id,
			unsigned int val);
781 782 783 784
int regmap_fields_read(struct regmap_field *field, unsigned int id,
		       unsigned int *val);
int regmap_fields_update_bits(struct regmap_field *field,  unsigned int id,
			      unsigned int mask, unsigned int val);
785

786 787 788 789 790
/**
 * Description of an IRQ for the generic regmap irq_chip.
 *
 * @reg_offset: Offset of the status/mask register within the bank
 * @mask:       Mask used to flag/control the register.
791 792 793
 * @type_reg_offset: Offset register for the irq type setting.
 * @type_rising_mask: Mask bit to configure RISING type irq.
 * @type_falling_mask: Mask bit to configure FALLING type irq.
794 795 796 797
 */
struct regmap_irq {
	unsigned int reg_offset;
	unsigned int mask;
798 799 800
	unsigned int type_reg_offset;
	unsigned int type_rising_mask;
	unsigned int type_falling_mask;
801 802
};

803 804 805
#define REGMAP_IRQ_REG(_irq, _off, _mask)		\
	[_irq] = { .reg_offset = (_off), .mask = (_mask) }

806 807 808 809 810 811 812 813 814
/**
 * Description of a generic regmap irq_chip.  This is not intended to
 * handle every possible interrupt controller, but it should handle a
 * substantial proportion of those that are found in the wild.
 *
 * @name:        Descriptive name for IRQ controller.
 *
 * @status_base: Base status register address.
 * @mask_base:   Base mask register address.
815 816
 * @unmask_base:  Base unmask register address. for chips who have
 *                separate mask and unmask registers
817 818
 * @ack_base:    Base ack address. If zero then the chip is clear on read.
 *               Using zero value is possible with @use_ack bit.
819
 * @wake_base:   Base address for wake enables.  If zero unsupported.
820
 * @type_base:   Base address for irq type.  If zero unsupported.
821
 * @irq_reg_stride:  Stride to use for chips where registers are not contiguous.
822
 * @init_ack_masked: Ack all masked interrupts once during initalization.
823
 * @mask_invert: Inverted mask register: cleared bits are masked out.
824
 * @use_ack:     Use @ack register even if it is zero.
825
 * @ack_invert:  Inverted ack register: cleared bits for ack.
826
 * @wake_invert: Inverted wake register: cleared bits are wake enabled.
827
 * @type_invert: Invert the type flags.
828
 * @runtime_pm:  Hold a runtime PM lock on the device when accessing it.
829 830 831 832 833
 *
 * @num_regs:    Number of registers in each control bank.
 * @irqs:        Descriptors for individual IRQs.  Interrupt numbers are
 *               assigned based on the index in the array of the interrupt.
 * @num_irqs:    Number of descriptors.
834 835 836
 * @num_type_reg:    Number of type registers.
 * @type_reg_stride: Stride to use for chips where type registers are not
 *			contiguous.
837 838 839 840 841 842
 */
struct regmap_irq_chip {
	const char *name;

	unsigned int status_base;
	unsigned int mask_base;
843
	unsigned int unmask_base;
844
	unsigned int ack_base;
845
	unsigned int wake_base;
846
	unsigned int type_base;
847
	unsigned int irq_reg_stride;
848 849
	bool init_ack_masked:1;
	bool mask_invert:1;
850
	bool use_ack:1;
851
	bool ack_invert:1;
852 853
	bool wake_invert:1;
	bool runtime_pm:1;
854
	bool type_invert:1;
855 856 857 858 859

	int num_regs;

	const struct regmap_irq *irqs;
	int num_irqs;
860 861 862

	int num_type_reg;
	unsigned int type_reg_stride;
863 864 865 866 867
};

struct regmap_irq_chip_data;

int regmap_add_irq_chip(struct regmap *map, int irq, int irq_flags,
868
			int irq_base, const struct regmap_irq_chip *chip,
869 870
			struct regmap_irq_chip_data **data);
void regmap_del_irq_chip(int irq, struct regmap_irq_chip_data *data);
871
int regmap_irq_chip_get_base(struct regmap_irq_chip_data *data);
872
int regmap_irq_get_virq(struct regmap_irq_chip_data *data, int irq);
873
struct irq_domain *regmap_irq_get_domain(struct regmap_irq_chip_data *data);
874

875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890
#else

/*
 * These stubs should only ever be called by generic code which has
 * regmap based facilities, if they ever get called at runtime
 * something is going wrong and something probably needs to select
 * REGMAP.
 */

static inline int regmap_write(struct regmap *map, unsigned int reg,
			       unsigned int val)
{
	WARN_ONCE(1, "regmap API is disabled");
	return -EINVAL;
}

891 892 893 894 895 896 897
static inline int regmap_write_async(struct regmap *map, unsigned int reg,
				     unsigned int val)
{
	WARN_ONCE(1, "regmap API is disabled");
	return -EINVAL;
}

898 899 900 901 902 903 904
static inline int regmap_raw_write(struct regmap *map, unsigned int reg,
				   const void *val, size_t val_len)
{
	WARN_ONCE(1, "regmap API is disabled");
	return -EINVAL;
}

905 906 907 908 909 910 911
static inline int regmap_raw_write_async(struct regmap *map, unsigned int reg,
					 const void *val, size_t val_len)
{
	WARN_ONCE(1, "regmap API is disabled");
	return -EINVAL;
}

912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946
static inline int regmap_bulk_write(struct regmap *map, unsigned int reg,
				    const void *val, size_t val_count)
{
	WARN_ONCE(1, "regmap API is disabled");
	return -EINVAL;
}

static inline int regmap_read(struct regmap *map, unsigned int reg,
			      unsigned int *val)
{
	WARN_ONCE(1, "regmap API is disabled");
	return -EINVAL;
}

static inline int regmap_raw_read(struct regmap *map, unsigned int reg,
				  void *val, size_t val_len)
{
	WARN_ONCE(1, "regmap API is disabled");
	return -EINVAL;
}

static inline int regmap_bulk_read(struct regmap *map, unsigned int reg,
				   void *val, size_t val_count)
{
	WARN_ONCE(1, "regmap API is disabled");
	return -EINVAL;
}

static inline int regmap_update_bits(struct regmap *map, unsigned int reg,
				     unsigned int mask, unsigned int val)
{
	WARN_ONCE(1, "regmap API is disabled");
	return -EINVAL;
}

947 948 949 950 951 952 953
static inline int regmap_write_bits(struct regmap *map, unsigned int reg,
				     unsigned int mask, unsigned int val)
{
	WARN_ONCE(1, "regmap API is disabled");
	return -EINVAL;
}

954 955 956 957 958 959 960 961
static inline int regmap_update_bits_async(struct regmap *map,
					   unsigned int reg,
					   unsigned int mask, unsigned int val)
{
	WARN_ONCE(1, "regmap API is disabled");
	return -EINVAL;
}

962 963 964 965 966 967 968 969 970
static inline int regmap_update_bits_check(struct regmap *map,
					   unsigned int reg,
					   unsigned int mask, unsigned int val,
					   bool *change)
{
	WARN_ONCE(1, "regmap API is disabled");
	return -EINVAL;
}

971 972 973 974 975 976 977 978 979 980
static inline int regmap_update_bits_check_async(struct regmap *map,
						 unsigned int reg,
						 unsigned int mask,
						 unsigned int val,
						 bool *change)
{
	WARN_ONCE(1, "regmap API is disabled");
	return -EINVAL;
}

981 982 983 984 985 986
static inline int regmap_get_val_bytes(struct regmap *map)
{
	WARN_ONCE(1, "regmap API is disabled");
	return -EINVAL;
}

987 988 989 990 991 992
static inline int regmap_get_max_register(struct regmap *map)
{
	WARN_ONCE(1, "regmap API is disabled");
	return -EINVAL;
}

993 994 995 996 997 998
static inline int regmap_get_reg_stride(struct regmap *map)
{
	WARN_ONCE(1, "regmap API is disabled");
	return -EINVAL;
}

999 1000 1001 1002 1003 1004
static inline int regcache_sync(struct regmap *map)
{
	WARN_ONCE(1, "regmap API is disabled");
	return -EINVAL;
}

1005 1006 1007 1008 1009 1010 1011
static inline int regcache_sync_region(struct regmap *map, unsigned int min,
				       unsigned int max)
{
	WARN_ONCE(1, "regmap API is disabled");
	return -EINVAL;
}

1012 1013 1014 1015 1016 1017 1018
static inline int regcache_drop_region(struct regmap *map, unsigned int min,
				       unsigned int max)
{
	WARN_ONCE(1, "regmap API is disabled");
	return -EINVAL;
}

1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033
static inline void regcache_cache_only(struct regmap *map, bool enable)
{
	WARN_ONCE(1, "regmap API is disabled");
}

static inline void regcache_cache_bypass(struct regmap *map, bool enable)
{
	WARN_ONCE(1, "regmap API is disabled");
}

static inline void regcache_mark_dirty(struct regmap *map)
{
	WARN_ONCE(1, "regmap API is disabled");
}

1034 1035 1036 1037 1038
static inline void regmap_async_complete(struct regmap *map)
{
	WARN_ONCE(1, "regmap API is disabled");
}

1039
static inline int regmap_register_patch(struct regmap *map,
1040
					const struct reg_sequence *regs,
1041 1042 1043 1044 1045 1046
					int num_regs)
{
	WARN_ONCE(1, "regmap API is disabled");
	return -EINVAL;
}

1047 1048 1049 1050 1051 1052 1053
static inline int regmap_parse_val(struct regmap *map, const void *buf,
				unsigned int *val)
{
	WARN_ONCE(1, "regmap API is disabled");
	return -EINVAL;
}

1054 1055 1056 1057 1058 1059
static inline struct regmap *dev_get_regmap(struct device *dev,
					    const char *name)
{
	return NULL;
}

1060 1061 1062
static inline struct device *regmap_get_device(struct regmap *map)
{
	WARN_ONCE(1, "regmap API is disabled");
1063
	return NULL;
1064 1065
}

1066 1067
#endif

1068
#endif
新手
引导
客服 返回
顶部