regmap: core: Split out in place value parsing
Subsystems (2)
PATCH 1/2 regmap: core: Split out in place value parsing
Currently the value parsing operations both return the parsed value and modify the passed buffer. This precludes their use in places like the cache code so split out the in place modification into a new parse_inplace() operation.
--- drivers/base/regmap/internal.h | 3 ++- drivers/base/regmap/regmap.c | 52 +++++++++++++++++++++++++++------------- 2 files changed, 38 insertions(+), 17 deletions(-)
drivers/base/regmap/internal.h +2 -1
@@ -38,7 +38,8 @@ struct regmap_format { unsigned int reg, unsigned int val);void (*format_reg)(void *buf,unsigned int reg,unsigned int shift);void (*format_val)(void *buf,unsigned int val,unsigned int shift); -unsigned int (*parse_val)(void *buf); +unsigned int (*parse_val)(const void *buf); +void (*parse_inplace)(void *buf); };struct regmap_async {
drivers/base/regmap/regmap.c +36 -16
132 lines not on this page · raw message
Signature · 1 line
1.7.10.4
PATCH 2/2 regmap: cache: Store caches in native register format where possible
This allows the cached data to be sent directly to the device when we sync it.
--- drivers/base/regmap/regcache.c | 16 ++++++++++++++-- 1 file changed, 14 insertions(+), 2 deletions(-)
drivers/base/regmap/regcache.c +14 -2
@@ -45,8 +45,8 @@ static int regcache_hw_init(struct regmap *map) tmp_buf =kmalloc (map->cache_size_raw,GFP_KERNEL );if (!tmp_buf)return -EINVAL ; - ret =regmap_bulk_read (map,0 , tmp_buf, - map->num_reg_defaults_raw); + ret =regmap_raw_read (map,0 , tmp_buf, + map->num_reg_defaults_raw); map->cache_bypass = cache_bypass;if (ret <0 ) {kfree (tmp_buf);
@@ -421,6 +421,13 @@ bool regcache_set_val(struct regmap *map, void *base, unsigned int idx,if (regcache_get_val (map, base, idx) == val)return true; +/* Use device native format if possible */ +if (map->format.format_val) { + map->format.format_val (base + (map->cache_word_size * idx), + val,0 ); +return false; + } +switch (map->cache_word_size) {case 1 : {u8 *cache = base;
@@ -449,6 +456,11 @@ unsigned int regcache_get_val(struct regmap *map, const void *base,if (!base)return -EINVAL ; +/* Use device native format if possible */ +if (map->format.parse_val) +return map->format.parse_val (base + + (map->cache_word_size * idx)); +switch (map->cache_word_size) {case 1 : {const u8 *cache = base;
Signature · 1 line
1.7.10.4
Quoted 4 lines · Mark Brown
Currently the value parsing operations both return the parsed value and modify the passed buffer. This precludes their use in places like the cache code so split out the in place modification into a new
parse_inplace()operation.
Mark,
This change seems to break audio on my Tegra system with a WM8903 CODEC. In next-20130318, reverting this plus "regmap: cache: Store caches in native register format where possible" which depends on it does solve the problem.
Looking at the raw WM8903 registers using i2cdump shows that for example without these patches, register 39h is set to 0x0020, but with them it's set to 0x0021, so the headphones are muted. In both cases, the regmap debugfs file thinks the value last written is 0xa1 (the 0x80 bit isn't actually state stored in HW, so the only relevant difference is in the LSB). There are numerous other differences in i2cdump output.
It took a very quick look at the patch and couldn't see anything actively wrong. I wonder if one of the existing unconverted users of .parse_val() relies on the in-place modification of the buffer as well as getting the result back, and so should have been converted to calling both .parse_inplace() and then .parse_val()?
A message that is not in the archive (sent off-list or not yet received): [email protected]
Quoted 9 lines · Mark Brown
Quoted 6 lines · Stephen Warren
It took a very quick look at the patch and couldn't see anything actively wrong. I wonder if one of the existing unconverted users of .parse_val() relies on the in-place modification of the buffer as well as getting the result back, and so should have been converted to calling both .parse_inplace() and then .parse_val()?
Quoted 8 lines
Possibly, though you'd have thought that if it were just that one of the other users would have noticed - my primary development board uses regmap extensively for example. Does seem the most likely option though. Can't test anything again until Friday sadly.
Might also be some unusual code path WM8903 exercises, though again it's pretty simple.
I haven't thought through why the patch in question causes/exposes the issue yet, but I have found out what the problem is.
_regmap_bus_raw_write() formats the value into work_buf + reg_bytes + pad_bytes, i.e. work_buf + 1.
For the first regmap_write() that the WM8903 driver does, work_buf is now xx 89 03.
_regmap_raw_write() then memcpy()s from val (i.e. work_buf + 1) to workbuf, and parses the value to send to the caching code:
Quoted 5 lines
if (!map->cache_bypass &&
map->format.parse_val) { unsigned int ival; intval_bytes=map->format.val_bytes; for (i = 0; i <val_len/val_bytes; i++) {memcpy(map->work_buf, val + (i * val_bytes), val_bytes); ival =map->format.parse_val(map->work_buf);
This corrupts that value at work_buf + 1 since it overlaps the copy destination at work_buf. work_buf is now 89 03 03.
_regmap_raw_write() then formats the register address into work_buf, yielding 00 03 03.
That data stream is then sent over I2C, causing a write to register 0 (correct) of value 03 03 (rather than 89 03).
If I comment out the memcpy, and instead pass the value address directly to .parse_val(), everything works again.
Quoted 31 lines · Stephen Warren
Quoted 9 lines · Mark Brown
Quoted 6 lines · Stephen Warren
It took a very quick look at the patch and couldn't see anything actively wrong. I wonder if one of the existing unconverted users of .parse_val() relies on the in-place modification of the buffer as well as getting the result back, and so should have been converted to calling both .parse_inplace() and then .parse_val()?
Quoted 8 lines
Possibly, though you'd have thought that if it were just that one of the other users would have noticed - my primary development board uses regmap extensively for example. Does seem the most likely option though. Can't test anything again until Friday sadly.
Might also be some unusual code path WM8903 exercises, though again it's pretty simple.
I haven't thought through why the patch in question causes/exposes the issue yet, but I have found out what the problem is.
_regmap_bus_raw_write()formats the value intowork_buf+reg_bytes+pad_bytes, i.e.work_buf+ 1.For the first
regmap_write()that the WM8903 driver does,work_bufis now xx 89 03.
_regmap_raw_write()then memcpy()s from val (i.e.work_buf+ 1) to workbuf, and parses the value to send to the caching code:
Quoted 8 lines
Quoted 5 lines
if (!map->cache_bypass &&
map->format.parse_val) { unsigned int ival; intval_bytes=map->format.val_bytes; for (i = 0; i <val_len/val_bytes; i++) {memcpy(map->work_buf, val + (i * val_bytes), val_bytes); ival =map->format.parse_val(map->work_buf);This corrupts that value at
work_buf+ 1 since it overlaps the copy destination atwork_buf.work_bufis now 89 03 03.
Ah, here's why it used to work:
When parse_val used to both return the value and modify the buffer in place, parse_val used to re-write the buffer from 89 03 03 to 03 89 03, which is the same content that it originally had before the memcpy, at least for the region that holds the value rather than the address, which is all that's relevant since the address gets over-written later. The combination of the memcpy-down-by-1-byte followed by swap-first-2-bytes, just accidentally happened to leave the buffer in a valid state. Of course, this only works for certain combinations of register address and value sizes, I think...
So, I think that the fix I mentioned below really is valid, and what's more is technically needed irrespective of whether "regmap: core: Split out in place value parsing" is applied. I'll assume so and send out that patch.
Quoted 8 lines
_regmap_raw_write()then formats the register address intowork_buf, yielding 00 03 03.That data stream is then sent over I2C, causing a write to register 0 (correct) of value 03 03 (rather than 89 03).
If I comment out the memcpy, and instead pass the value address directly to .parse_val(), everything works again.