regmap: Apply optional delay in multi_reg_write/register_patch (2de9d600) · Commits · 戴 / test

drivers/base/regmap/regmap.c

+48 −6

Original line number	Diff line number	Diff line
		@@ -18,6 +18,7 @@
		#include <linux/of.h>
		#include <linux/rbtree.h>
		#include <linux/sched.h>
		#include <linux/delay.h>

		#define CREATE_TRACE_POINTS
		#include "trace.h"
		@@ -1807,10 +1808,12 @@ static int _regmap_range_multi_paged_reg_write(struct regmap *map,
		int i, n;
		struct reg_sequence *base;
		unsigned int this_page = 0;
		unsigned int page_change = 0;
		/*
		* the set of registers are not neccessarily in order, but
		* since the order of write must be preserved this algorithm
		* chops the set each time the page changes
		* chops the set each time the page changes. This also applies
		* if there is a delay required at any point in the sequence.
		*/
		base = regs;
		for (i = 0, n = 0; i < num_regs; i++, n++) {
		@@ -1826,16 +1829,48 @@ static int _regmap_range_multi_paged_reg_write(struct regmap *map,
		this_page = win_page;
		if (win_page != this_page) {
		this_page = win_page;
		page_change = 1;
		}
		}

		/* If we have both a page change and a delay make sure to
		* write the regs and apply the delay before we change the
		* page.
		*/

		if (page_change \|\| regs[i].delay_us) {

		/* For situations where the first write requires
		* a delay we need to make sure we don't call
		* raw_multi_reg_write with n=0
		* This can't occur with page breaks as we
		* never write on the first iteration
		*/
		if (regs[i].delay_us && i == 0)
		n = 1;

		ret = _regmap_raw_multi_reg_write(map, base, n);
		if (ret != 0)
		return ret;

		if (regs[i].delay_us)
		udelay(regs[i].delay_us);

		base += n;
		n = 0;
		}
		ret = _regmap_select_page(map, &base[n].reg, range, 1);

		if (page_change) {
		ret = _regmap_select_page(map,
		&base[n].reg,
		range, 1);
		if (ret != 0)
		return ret;

		page_change = 0;
		}

		}

		}
		if (n > 0)
		return _regmap_raw_multi_reg_write(map, base, n);
		@@ -1854,6 +1889,9 @@ static int _regmap_multi_reg_write(struct regmap *map,
		ret = _regmap_write(map, regs[i].reg, regs[i].def);
		if (ret != 0)
		return ret;

		if (regs[i].delay_us)
		udelay(regs[i].delay_us);
		}
		return 0;
		}
		@@ -1893,8 +1931,12 @@ static int _regmap_multi_reg_write(struct regmap *map,
		for (i = 0; i < num_regs; i++) {
		unsigned int reg = regs[i].reg;
		struct regmap_range_node *range;

		/* Coalesce all the writes between a page break or a delay
		* in a sequence
		*/
		range = _regmap_range_lookup(map, reg);
		if (range) {
		if (range \|\| regs[i].delay_us) {
		size_t len = sizeof(struct reg_sequence)*num_regs;
		struct reg_sequence *base = kmemdup(regs, len,
		GFP_KERNEL);

include/linux/regmap.h

+4 −1

Original line number	Diff line number	Diff line
		@@ -51,14 +51,17 @@ struct reg_default {
		};

		/**
		* Register/value pairs for sequences of writes
		* Register/value pairs for sequences of writes with an optional delay in
		* microseconds to be applied after each write.
		*
		* @reg: Register address.
		* @def: Register value.
		* @delay_us: Delay to be applied after the register write in microseconds
		*/
		struct reg_sequence {
		unsigned int reg;
		unsigned int def;
		unsigned int delay_us;
		};

		#ifdef CONFIG_REGMAP

Admin message