regmap: Fixup the kernel-doc comments on functions/structures

}

/**

 * regcache_read: Fetch the value of a given register from the cache.

 * regcache_read - Fetch the value of a given register from the cache.

 *

 * @map: map to configure.

 * @reg: The register index.

}

/**

 * regcache_write: Set the value of a given register in the cache.

 * regcache_write - Set the value of a given register in the cache.

 *

 * @map: map to configure.

 * @reg: The register index.

}

/**

 * regcache_sync: Sync the register cache with the hardware.

 * regcache_sync - Sync the register cache with the hardware.

 *

 * @map: map to configure.

 *

EXPORT_SYMBOL_GPL(regcache_sync);

/**

 * regcache_sync_region: Sync part  of the register cache with the hardware.

 * regcache_sync_region - Sync part  of the register cache with the hardware.

 *

 * @map: map to sync.

 * @min: first register to sync

EXPORT_SYMBOL_GPL(regcache_sync_region);

/**

 * regcache_drop_region: Discard part of the register cache

 * regcache_drop_region - Discard part of the register cache

 *

 * @map: map to operate on

 * @min: first register to discard

EXPORT_SYMBOL_GPL(regcache_drop_region);

/**

 * regcache_cache_only: Put a register map into cache only mode

 * regcache_cache_only - Put a register map into cache only mode

 *

 * @map: map to configure

 * @cache_only: flag if changes should be written to the hardware

 * @enable: flag if changes should be written to the hardware

 *

 * When a register map is marked as cache only writes to the register

 * map API will only update the register cache, they will not cause

EXPORT_SYMBOL_GPL(regcache_cache_only);

/**

 * regcache_mark_dirty: Indicate that HW registers were reset to default values

 * regcache_mark_dirty - Indicate that HW registers were reset to default values

 *

 * @map: map to mark

 *

EXPORT_SYMBOL_GPL(regcache_mark_dirty);

/**

 * regcache_cache_bypass: Put a register map into cache bypass mode

 * regcache_cache_bypass - Put a register map into cache bypass mode

 *

 * @map: map to configure

 * @cache_bypass: flag if changes should not be written to the cache

 * @enable: flag if changes should not be written to the cache

 *

 * When a register map is marked with the cache bypass option, writes

 * to the register map API will only update the hardware and not the

};

/**

 * regmap_add_irq_chip(): Use standard regmap IRQ controller handling

 * regmap_add_irq_chip() - Use standard regmap IRQ controller handling

 *

 * map:       The regmap for the device.

 * irq:       The IRQ the device uses to signal interrupts

 * irq_flags: The IRQF_ flags to use for the primary interrupt.

 * chip:      Configuration for the interrupt controller.

 * data:      Runtime data structure for the controller, allocated on success

 * @map: The regmap for the device.

 * @irq: The IRQ the device uses to signal interrupts.

 * @irq_flags: The IRQF_ flags to use for the primary interrupt.

 * @irq_base: Allocate at specific IRQ number if irq_base > 0.

 * @chip: Configuration for the interrupt controller.

 * @data: Runtime data structure for the controller, allocated on success.

 *

 * Returns 0 on success or an errno on failure.

 *

EXPORT_SYMBOL_GPL(regmap_add_irq_chip);

/**

 * regmap_del_irq_chip(): Stop interrupt handling for a regmap IRQ chip

 * regmap_del_irq_chip() - Stop interrupt handling for a regmap IRQ chip

 *

 * @irq: Primary IRQ for the device

 * @d:   regmap_irq_chip_data allocated by regmap_add_irq_chip()

 * @d: &regmap_irq_chip_data allocated by regmap_add_irq_chip()

 *

 * This function also dispose all mapped irq on chip.

 * This function also disposes of all mapped IRQs on the chip.

 */

void regmap_del_irq_chip(int irq, struct regmap_irq_chip_data *d)

{

}

/**

 * devm_regmap_add_irq_chip(): Resource manager regmap_add_irq_chip()

 * devm_regmap_add_irq_chip() - Resource manager regmap_add_irq_chip()

 *

 * @dev: The device pointer on which irq_chip belongs to.

 * @map: The regmap for the device.

 * @irq: The IRQ the device uses to signal interrupts

 * @irq_flags: The IRQF_ flags to use for the primary interrupt.

 * @irq_base: Allocate at specific IRQ number if irq_base > 0.

 * @chip: Configuration for the interrupt controller.

 * @data: Runtime data structure for the controller, allocated on success

 *

 * Returns 0 on success or an errno on failure.

 *

 * The regmap_irq_chip data automatically be released when the device is

 * The &regmap_irq_chip_data will be automatically released when the device is

 * unbound.

 */

int devm_regmap_add_irq_chip(struct device *dev, struct regmap *map, int irq,

EXPORT_SYMBOL_GPL(devm_regmap_add_irq_chip);

/**

 * devm_regmap_del_irq_chip(): Resource managed regmap_del_irq_chip()

 * devm_regmap_del_irq_chip() - Resource managed regmap_del_irq_chip()

 *

 * @dev: Device for which which resource was allocated.

 * @irq: Primary IRQ for the device

 * @d:   regmap_irq_chip_data allocated by regmap_add_irq_chip()

 * @irq: Primary IRQ for the device.

 * @data: &regmap_irq_chip_data allocated by regmap_add_irq_chip().

 *

 * A resource managed version of regmap_del_irq_chip().

 */

void devm_regmap_del_irq_chip(struct device *dev, int irq,

			      struct regmap_irq_chip_data *data)

EXPORT_SYMBOL_GPL(devm_regmap_del_irq_chip);

/**

 * regmap_irq_chip_get_base(): Retrieve interrupt base for a regmap IRQ chip

 * regmap_irq_chip_get_base() - Retrieve interrupt base for a regmap IRQ chip

 *

 * Useful for drivers to request their own IRQs.

 * @data: regmap irq controller to operate on.

 *

 * @data: regmap_irq controller to operate on.

 * Useful for drivers to request their own IRQs.

 */

int regmap_irq_chip_get_base(struct regmap_irq_chip_data *data)

{

EXPORT_SYMBOL_GPL(regmap_irq_chip_get_base);

/**

 * regmap_irq_get_virq(): Map an interrupt on a chip to a virtual IRQ

 * regmap_irq_get_virq() - Map an interrupt on a chip to a virtual IRQ

 *

 * Useful for drivers to request their own IRQs.

 * @data: regmap irq controller to operate on.

 * @irq: index of the interrupt requested in the chip IRQs.

 *

 * @data: regmap_irq controller to operate on.

 * @irq: index of the interrupt requested in the chip IRQs

 * Useful for drivers to request their own IRQs.

 */

int regmap_irq_get_virq(struct regmap_irq_chip_data *data, int irq)

{

EXPORT_SYMBOL_GPL(regmap_irq_get_virq);

/**

 * regmap_irq_get_domain(): Retrieve the irq_domain for the chip

 * regmap_irq_get_domain() - Retrieve the irq_domain for the chip

 *

 * @data: regmap_irq controller to operate on.

 *

 * Useful for drivers to request their own IRQs and for integration

 * with subsystems.  For ease of integration NULL is accepted as a

 * domain, allowing devices to just call this even if no domain is

 * allocated.

 *

 * @data: regmap_irq controller to operate on.

 */

struct irq_domain *regmap_irq_get_domain(struct regmap_irq_chip_data *data)

{

}

/**

 * devm_regmap_field_alloc(): Allocate and initialise a register field

 * in a register map.

 * devm_regmap_field_alloc() - Allocate and initialise a register field.

 *

 * @dev: Device that will be interacted with

 * @regmap: regmap bank in which this register field is located.

EXPORT_SYMBOL_GPL(devm_regmap_field_alloc);

/**

 * devm_regmap_field_free(): Free register field allocated using

 * devm_regmap_field_alloc. Usally drivers need not call this function,

 * as the memory allocated via devm will be freed as per device-driver

 * life-cyle.

 * devm_regmap_field_free() - Free a register field allocated using

 *                            devm_regmap_field_alloc.

 *

 * @dev: Device that will be interacted with

 * @field: regmap field which should be freed.

 *

 * Free register field allocated using devm_regmap_field_alloc(). Usually

 * drivers need not call this function, as the memory allocated via devm

 * will be freed as per device-driver life-cyle.

 */

void devm_regmap_field_free(struct device *dev,

	struct regmap_field *field)

EXPORT_SYMBOL_GPL(devm_regmap_field_free);

/**

 * regmap_field_alloc(): Allocate and initialise a register field

 * in a register map.

 * regmap_field_alloc() - Allocate and initialise a register field.

 *

 * @regmap: regmap bank in which this register field is located.

 * @reg_field: Register field with in the bank.

EXPORT_SYMBOL_GPL(regmap_field_alloc);

/**

 * regmap_field_free(): Free register field allocated using regmap_field_alloc

 * regmap_field_free() - Free register field allocated using

 *                       regmap_field_alloc.

 *

 * @field: regmap field which should be freed.

 */

EXPORT_SYMBOL_GPL(regmap_field_free);

/**

 * regmap_reinit_cache(): Reinitialise the current register cache

 * regmap_reinit_cache() - Reinitialise the current register cache

 *

 * @map: Register map to operate on.

 * @config: New configuration.  Only the cache data will be used.

EXPORT_SYMBOL_GPL(regmap_reinit_cache);

/**

 * regmap_exit(): Free a previously allocated register map

 * regmap_exit() - Free a previously allocated register map

 *

 * @map: Register map to operate on.

 */

void regmap_exit(struct regmap *map)

{

}

/**

 * dev_get_regmap(): Obtain the regmap (if any) for a device

 * dev_get_regmap() - Obtain the regmap (if any) for a device

 *

 * @dev: Device to retrieve the map for

 * @name: Optional name for the register map, usually NULL.

EXPORT_SYMBOL_GPL(dev_get_regmap);

/**

 * regmap_get_device(): Obtain the device from a regmap

 * regmap_get_device() - Obtain the device from a regmap

 *

 * @map: Register map to operate on.

 *

}

/**

 * regmap_write(): Write a value to a single register

 * regmap_write() - Write a value to a single register

 *

 * @map: Register map to write to

 * @reg: Register to write to

EXPORT_SYMBOL_GPL(regmap_write);

/**

 * regmap_write_async(): Write a value to a single register asynchronously

 * regmap_write_async() - Write a value to a single register asynchronously

 *

 * @map: Register map to write to

 * @reg: Register to write to

EXPORT_SYMBOL_GPL(regmap_write_async);

/**

 * regmap_raw_write(): Write raw values to one or more registers

 * regmap_raw_write() - Write raw values to one or more registers

 *

 * @map: Register map to write to

 * @reg: Initial register to write to

EXPORT_SYMBOL_GPL(regmap_raw_write);

/**

 * regmap_field_update_bits_base():

 *	Perform a read/modify/write cycle on the register field

 *	with change, async, force option

 * regmap_field_update_bits_base() - Perform a read/modify/write cycle a

 *                                   register field.

 *

 * @field: Register field to write to

 * @mask: Bitmask to change

 * @async: Boolean indicating asynchronously

 * @force: Boolean indicating use force update

 *

 * Perform a read/modify/write cycle on the register field with change,

 * async, force option.

 *

 * A value of zero will be returned on success, a negative errno will

 * be returned in error cases.

 */

EXPORT_SYMBOL_GPL(regmap_field_update_bits_base);

/**

 * regmap_fields_update_bits_base():

 *	Perform a read/modify/write cycle on the register field

 *	with change, async, force option

 * regmap_fields_update_bits_base() - Perform a read/modify/write cycle a

 *                                    register field with port ID

 *

 * @field: Register field to write to

 * @id: port ID

}

EXPORT_SYMBOL_GPL(regmap_fields_update_bits_base);

/*

 * regmap_bulk_write(): Write multiple registers to the device

/**

 * regmap_bulk_write() - Write multiple registers to the device

 *

 * @map: Register map to write to

 * @reg: First register to be write from

	return _regmap_raw_multi_reg_write(map, regs, num_regs);

}

/*

 * regmap_multi_reg_write(): Write multiple registers to the device

 *

 * where the set of register,value pairs are supplied in any order,

 * possibly not all in a single range.

/**

 * regmap_multi_reg_write() - Write multiple registers to the device

 *

 * @map: Register map to write to

 * @regs: Array of structures containing register,value to be written

 * @num_regs: Number of registers to write

 *

 * Write multiple registers to the device where the set of register, value

 * pairs are supplied in any order, possibly not all in a single range.

 *

 * The 'normal' block write mode will send ultimately send data on the

 * target bus as R,V1,V2,V3,..,Vn where successively higer registers are

 * target bus as R,V1,V2,V3,..,Vn where successively higher registers are

 * addressed. However, this alternative block multi write mode will send

 * the data as R1,V1,R2,V2,..,Rn,Vn on the target bus. The target device

 * must of course support the mode.

}

EXPORT_SYMBOL_GPL(regmap_multi_reg_write);

/*

 * regmap_multi_reg_write_bypassed(): Write multiple registers to the

/**

 * regmap_multi_reg_write_bypassed() - Write multiple registers to the

 *                                     device but not the cache

 *

 * where the set of register are supplied in any order

 *

 * @map: Register map to write to

 * @regs: Array of structures containing register,value to be written

 * @num_regs: Number of registers to write

 *

 * Write multiple registers to the device but not the cache where the set

 * of register are supplied in any order.

 *

 * This function is intended to be used for writing a large block of data

 * atomically to the device in single transfer for those I2C client devices

 * that implement this alternative block write mode.

EXPORT_SYMBOL_GPL(regmap_multi_reg_write_bypassed);

/**

 * regmap_raw_write_async(): Write raw values to one or more registers

 * regmap_raw_write_async() - Write raw values to one or more registers

 *                            asynchronously

 *

 * @map: Register map to write to

}

/**

 * regmap_read(): Read a value from a single register

 * regmap_read() - Read a value from a single register

 *

 * @map: Register map to read from

 * @reg: Register to be read from

EXPORT_SYMBOL_GPL(regmap_read);

/**

 * regmap_raw_read(): Read raw data from the device

 * regmap_raw_read() - Read raw data from the device

 *

 * @map: Register map to read from

 * @reg: First register to be read from

EXPORT_SYMBOL_GPL(regmap_raw_read);

/**

 * regmap_field_read(): Read a value to a single register field

 * regmap_field_read() - Read a value to a single register field

 *

 * @field: Register field to read from

 * @val: Pointer to store read value

EXPORT_SYMBOL_GPL(regmap_field_read);

/**

 * regmap_fields_read(): Read a value to a single register field with port ID

 * regmap_fields_read() - Read a value to a single register field with port ID

 *

 * @field: Register field to read from

 * @id: port ID

EXPORT_SYMBOL_GPL(regmap_fields_read);

/**

 * regmap_bulk_read(): Read multiple registers from the device

 * regmap_bulk_read() - Read multiple registers from the device

 *

 * @map: Register map to read from

 * @reg: First register to be read from

}

/**

 * regmap_update_bits_base:

 *	Perform a read/modify/write cycle on the

 *	register map with change, async, force option

 * regmap_update_bits_base() - Perform a read/modify/write cycle on a register

 *

 * @map: Register map to update

 * @reg: Register to update

 * @async: Boolean indicating asynchronously

 * @force: Boolean indicating use force update

 *

 * if async was true,

 * With most buses the read must be done synchronously so this is most

 * useful for devices with a cache which do not need to interact with

 * the hardware to determine the current register value.

 * Perform a read/modify/write cycle on a register map with change, async, force

 * options.

 *

 * If async is true:

 *

 * With most buses the read must be done synchronously so this is most useful

 * for devices with a cache which do not need to interact with the hardware to

 * determine the current register value.

 *

 * Returns zero for success, a negative number on error.

 */

}

/**

 * regmap_async_complete: Ensure all asynchronous I/O has completed.

 * regmap_async_complete - Ensure all asynchronous I/O has completed.

 *

 * @map: Map to operate on.

 *

EXPORT_SYMBOL_GPL(regmap_async_complete);

/**

 * regmap_register_patch: Register and apply register updates to be applied

 * regmap_register_patch - Register and apply register updates to be applied

 *                         on device initialistion

 *

 * @map: Register map to apply updates to.

}

EXPORT_SYMBOL_GPL(regmap_register_patch);

/*

 * regmap_get_val_bytes(): Report the size of a register value

/**

 * regmap_get_val_bytes() - Report the size of a register value

 *

 * @map: Register map to operate on.

 *

 * Report the size of a register value, mainly intended to for use by

 * generic infrastructure built on top of regmap.

EXPORT_SYMBOL_GPL(regmap_get_val_bytes);

/**

 * regmap_get_max_register(): Report the max register value

 * regmap_get_max_register() - Report the max register value

 *

 * @map: Register map to operate on.

 *

 * Report the max register value, mainly intended to for use by

 * generic infrastructure built on top of regmap.

EXPORT_SYMBOL_GPL(regmap_get_max_register);

/**

 * regmap_get_reg_stride(): Report the register address stride

 * regmap_get_reg_stride() - Report the register address stride

 *

 * @map: Register map to operate on.

 *

 * Report the register address stride, mainly intended to for use by

 * generic infrastructure built on top of regmap.