mirrors/linux-stable
1
0
Fork 0
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git synced 2024-09-29 22:02:02 +00:00
Code Issues Releases Wiki Activity

regmap: Support accelerated noinc operations

Browse source 
Several architectures have accelerated operations for MMIO
operations writing to a single register, such as writesb, writesw,
writesl, writesq, readsb, readsw, readsl and readsq but regmap
currently cannot use them because we have no hooks for providing
an accelerated noinc back-end for MMIO.

Solve this by providing reg_[read/write]_noinc callbacks for
the bus abstraction, so that the regmap-mmio bus can use this.

Currently I do not see a need to support this for custom regmaps
so it is only added to the bus.

Callbacks are passed a void * with the array of values and a
count which is the number of items of the byte chunk size for
the specific register width.

Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
Link: https://lore.kernel.org/r/20220816204832.265837-1-linus.walleij@linaro.org
Signed-off-by: Mark Brown <broonie@kernel.org>
This commit is contained in:
Linus Walleij 2022-08-16 22:48:31 +02:00 committed by Mark Brown
parent 77672e0387
commit c20cc099b3
No known key found for this signature in database
GPG key ID: 24D68B725D5487D0
2 changed files with 128 additions and 3 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

123
drivers/base/regmap/regmap.c
View file

@ -2129,6 +2129,99 @@ int regmap_raw_write(struct regmap *map, unsigned int reg,
}
EXPORT_SYMBOL_GPL(regmap_raw_write);
static int regmap_noinc_readwrite(struct regmap *map, unsigned int reg,
void *val, unsigned int val_len, bool write)
{
size_t val_bytes = map->format.val_bytes;
size_t val_count = val_len / val_bytes;
unsigned int lastval;
u8 *u8p;
u16 *u16p;
u32 *u32p;
#ifdef CONFIG_64BIT
u64 *u64p;
#endif
int ret;
int i;
switch (val_bytes) {
case 1:
u8p = val;
if (write)
lastval = (unsigned int)u8p[val_count - 1];
break;
case 2:
u16p = val;
if (write)
lastval = (unsigned int)u16p[val_count - 1];
break;
case 4:
u32p = val;
if (write)
lastval = (unsigned int)u32p[val_count - 1];
break;
#ifdef CONFIG_64BIT
case 8:
u64p = val;
if (write)
lastval = (unsigned int)u64p[val_count - 1];
break;
#endif
default:
return -EINVAL;
}
/*
* Update the cache with the last value we write, the rest is just
* gone down in the hardware FIFO. We can't cache FIFOs. This makes
* sure a single read from the cache will work.
*/
if (write) {
if (!map->cache_bypass && !map->defer_caching) {
ret = regcache_write(map, reg, lastval);
if (ret != 0)
return ret;
if (map->cache_only) {
map->cache_dirty = true;
return 0;
}
}
ret = map->bus->reg_noinc_write(map->bus_context, reg, val, val_count);
} else {
ret = map->bus->reg_noinc_read(map->bus_context, reg, val, val_count);
}
if (!ret && regmap_should_log(map)) {
dev_info(map->dev, "%x %s [", reg, write ? "<=" : "=>");
for (i = 0; i < val_len; i++) {
switch (val_bytes) {
case 1:
pr_cont("%x", u8p[i]);
break;
case 2:
pr_cont("%x", u16p[i]);
break;
case 4:
pr_cont("%x", u32p[i]);
break;
#ifdef CONFIG_64BIT
case 8:
pr_cont("%llx", u64p[i]);
break;
#endif
default:
break;
}
if (i == (val_len - 1))
pr_cont("]\n");
else
pr_cont(",");
}
}
return 0;
}
/**
* regmap_noinc_write(): Write data from a register without incrementing the
* register number
@ -2156,9 +2249,8 @@ int regmap_noinc_write(struct regmap *map, unsigned int reg,
size_t write_len;
int ret;
if (!map->write)
return -ENOTSUPP;
if (!map->write && !(map->bus && map->bus->reg_noinc_write))
return -EINVAL;
if (val_len % map->format.val_bytes)
return -EINVAL;
if (!IS_ALIGNED(reg, map->reg_stride))
@ -2173,6 +2265,15 @@ int regmap_noinc_write(struct regmap *map, unsigned int reg,
goto out_unlock;
}
/*
* Use the accelerated operation if we can. The val drops the const
* typing in order to facilitate code reuse in regmap_noinc_readwrite().
*/
if (map->bus->reg_noinc_write) {
ret = regmap_noinc_readwrite(map, reg, (void *)val, val_len, true);
goto out_unlock;
}
while (val_len) {
if (map->max_raw_write && map->max_raw_write < val_len)
write_len = map->max_raw_write;
@ -2943,6 +3044,22 @@ int regmap_noinc_read(struct regmap *map, unsigned int reg,
goto out_unlock;
}
/* Use the accelerated operation if we can */
if (map->bus->reg_noinc_read) {
/*
* We have not defined the FIFO semantics for cache, as the
* cache is just one value deep. Should we return the last
* written value? Just avoid this by always reading the FIFO
* even when using cache. Cache only will not work.
*/
if (map->cache_only) {
ret = -EBUSY;
goto out_unlock;
}
ret = regmap_noinc_readwrite(map, reg, val, val_len, false);
goto out_unlock;
}
while (val_len) {
if (map->max_raw_read && map->max_raw_read < val_len)
read_len = map->max_raw_read;

8
include/linux/regmap.h
View file

@ -492,8 +492,12 @@ typedef int (*regmap_hw_read)(void *context,
void *val_buf, size_t val_size);
typedef int (*regmap_hw_reg_read)(void *context, unsigned int reg,
unsigned int *val);
typedef int (*regmap_hw_reg_noinc_read)(void *context, unsigned int reg,
void *val, size_t val_count);
typedef int (*regmap_hw_reg_write)(void *context, unsigned int reg,
unsigned int val);
typedef int (*regmap_hw_reg_noinc_write)(void *context, unsigned int reg,
const void *val, size_t val_count);
typedef int (*regmap_hw_reg_update_bits)(void *context, unsigned int reg,
unsigned int mask, unsigned int val);
typedef struct regmap_async *(*regmap_hw_async_alloc)(void);
@ -514,6 +518,8 @@ typedef void (*regmap_hw_free_context)(void *context);
* must serialise with respect to non-async I/O.
* @reg_write: Write a single register value to the given register address. This
* write operation has to complete when returning from the function.
* @reg_write_noinc: Write multiple register value to the same register. This
* write operation has to complete when returning from the function.
* @reg_update_bits: Update bits operation to be used against volatile
* registers, intended for devices supporting some mechanism
* for setting clearing bits without having to
@ -541,9 +547,11 @@ struct regmap_bus {
regmap_hw_gather_write gather_write;
regmap_hw_async_write async_write;
regmap_hw_reg_write reg_write;
regmap_hw_reg_noinc_write reg_noinc_write;
regmap_hw_reg_update_bits reg_update_bits;
regmap_hw_read read;
regmap_hw_reg_read reg_read;
regmap_hw_reg_noinc_read reg_noinc_read;
regmap_hw_free_context free_context;
regmap_hw_async_alloc async_alloc;
u8 read_flag_mask;