redonkable
/
alistair23-linux
1
0
Fork 0
Code Releases Activity

regmap: Apply optional delay in multi_reg_write/register_patch 

Add an optional delay_us field in reg_sequence to allow the client to
specify a delay (in microseconds) to be applied after any given write
in a sequence of writes.

We treat a delay in a sequence the same way we treat a page change as
they are logically similar in that you can coalesce all write before
a delay (in the same way you can coalesce all writes before a page
change is needed)

Signed-off-by: Nariman Poushin <nariman@opensource.wolfsonmicro.com>
Signed-off-by: Mark Brown <broonie@kernel.org>
hifive-unleashed-5.1
Nariman Poushin 2015-07-16 16:36:22 +01:00 committed by Mark Brown
parent 8019ff6cfc
commit 2de9d6006c
2 changed files with 52 additions and 7 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

54
drivers/base/regmap/regmap.c
View File

@ -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 (ret != 0)
return ret;
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);

5
include/linux/regmap.h
View File

@ -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