github-mirror/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux.git synced 2026-07-28 18:21:24 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity Graph

ASoC: cs35l56: Replace open-coded SoundWire regmap with generic regmap-sdw

Browse Source 
Richard Fitzgerald <rf@opensource.cirrus.com> says:

This series replaces the entirely custom SoundWire regmap with the generic
regmap-sdw. The reasons for doing this are:

- Avoid code duplication
- Avoid effort of keeping custom implementation up-to-date
- Prepare for supporting BRA

Link: https://patch.msgid.link/20260519135435.479949-1-rf@opensource.cirrus.com
This commit is contained in:
Mark Brown 2026-05-19 14:59:56 +01:00
commit b7b0f9bb1a
No known key found for this signature in database
GPG Key ID: 24D68B725D5487D0
5 changed files with 59 additions and 89 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
sound/soc/codecs/Kconfig
View File

@ -887,7 +887,7 @@ config SND_SOC_CS35L56_SPI
config SND_SOC_CS35L56_SDW
tristate "Cirrus Logic CS35L56 CODEC (SDW)"
depends on SOUNDWIRE
select REGMAP
select REGMAP_SOUNDWIRE
select SND_SOC_CS35L56
select SND_SOC_CS35L56_SHARED
help

137
sound/soc/codecs/cs35l56-sdw.c
View File

@ -17,6 +17,7 @@
#include <linux/string_choices.h>
#include <linux/swab.h>
#include <linux/types.h>
#include <linux/unaligned.h>
#include <linux/workqueue.h>
#include "cs35l56.h"
@ -59,8 +60,6 @@ static int cs35l56_sdw_slow_read(struct sdw_slave *peripheral, unsigned int reg,
{
int ret, i;
reg += CS35L56_SDW_ADDR_OFFSET;
for (i = 0; i < val_size; i += sizeof(u32)) {
/* Poll for bus bridge idle */
ret = cs35l56_sdw_poll_mem_status(peripheral,
@ -97,57 +96,23 @@ static int cs35l56_sdw_slow_read(struct sdw_slave *peripheral, unsigned int reg,
return 0;
}
static int cs35l56_sdw_read_one(struct sdw_slave *peripheral, unsigned int reg, void *buf)
{
int ret;
ret = sdw_nread_no_pm(peripheral, reg, 4, (u8 *)buf);
if (ret != 0) {
dev_err(&peripheral->dev, "Read failed @%#x:%d\n", reg, ret);
return ret;
}
swab32s((u32 *)buf);
return 0;
}
static int cs35l56_sdw_read(void *context, const void *reg_buf,
const size_t reg_size, void *val_buf,
size_t val_size)
{
struct sdw_slave *peripheral = context;
u8 *buf8 = val_buf;
unsigned int reg, bytes;
struct cs35l56_private *cs35l56 = dev_get_drvdata(&peripheral->dev);
unsigned int reg_addr = get_unaligned_le32(reg_buf);
int ret;
reg = le32_to_cpu(*(const __le32 *)reg_buf);
if (cs35l56_is_otp_register(reg_addr - CS35L56_SDW_ADDR_OFFSET))
return cs35l56_sdw_slow_read(peripheral, reg_addr, (u8 *)val_buf, val_size);
if (cs35l56_is_otp_register(reg))
return cs35l56_sdw_slow_read(peripheral, reg, buf8, val_size);
ret = regmap_raw_read(cs35l56->sdw_bus_regmap, reg_addr, val_buf, val_size);
if (ret)
return ret;
reg += CS35L56_SDW_ADDR_OFFSET;
if (val_size == 4)
return cs35l56_sdw_read_one(peripheral, reg, val_buf);
while (val_size) {
bytes = SDW_REG_NO_PAGE - (reg & SDW_REGADDR); /* to end of page */
if (bytes > val_size)
bytes = val_size;
ret = sdw_nread_no_pm(peripheral, reg, bytes, buf8);
if (ret != 0) {
dev_err(&peripheral->dev, "Read failed @%#x..%#x:%d\n",
reg, reg + bytes - 1, ret);
return ret;
}
swab32_array((u32 *)buf8, bytes / 4);
val_size -= bytes;
reg += bytes;
buf8 += bytes;
}
swab32_array((u32 *)val_buf, val_size / sizeof(u32));
return 0;
}
@ -161,58 +126,34 @@ static inline void cs35l56_swab_copy(void *dest, const void *src, size_t nbytes)
*dest32++ = swab32(*src32++);
}
static int cs35l56_sdw_write_one(struct sdw_slave *peripheral, unsigned int reg, const void *buf)
{
u32 val_le = swab32(*(u32 *)buf);
int ret;
ret = sdw_nwrite_no_pm(peripheral, reg, 4, (u8 *)&val_le);
if (ret != 0) {
dev_err(&peripheral->dev, "Write failed @%#x:%d\n", reg, ret);
return ret;
}
return 0;
}
static int cs35l56_sdw_gather_write(void *context,
const void *reg_buf, size_t reg_size,
const void *val_buf, size_t val_size)
{
struct sdw_slave *peripheral = context;
const u8 *src_be = val_buf;
u32 val_le_buf[64]; /* Define u32 so it is 32-bit aligned */
unsigned int reg, bytes;
struct cs35l56_private *cs35l56 = dev_get_drvdata(&peripheral->dev);
unsigned int reg_addr = get_unaligned_le32(reg_buf);
u32 swab_buf[64]; /* Define u32 so it is 32-bit aligned */
int ret;
reg = le32_to_cpu(*(const __le32 *)reg_buf);
reg += CS35L56_SDW_ADDR_OFFSET;
if (val_size == 4)
return cs35l56_sdw_write_one(peripheral, reg, src_be);
while (val_size) {
bytes = SDW_REG_NO_PAGE - (reg & SDW_REGADDR); /* to end of page */
if (bytes > val_size)
bytes = val_size;
if (bytes > sizeof(val_le_buf))
bytes = sizeof(val_le_buf);
cs35l56_swab_copy(val_le_buf, src_be, bytes);
ret = sdw_nwrite_no_pm(peripheral, reg, bytes, (u8 *)val_le_buf);
if (ret != 0) {
dev_err(&peripheral->dev, "Write failed @%#x..%#x:%d\n",
reg, reg + bytes - 1, ret);
while (val_size > sizeof(swab_buf)) {
cs35l56_swab_copy(swab_buf, val_buf, sizeof(swab_buf));
ret = regmap_raw_write(cs35l56->sdw_bus_regmap, reg_addr,
swab_buf, sizeof(swab_buf));
if (ret)
return ret;
}
val_size -= bytes;
reg += bytes;
src_be += bytes;
val_size -= sizeof(swab_buf);
reg_addr += sizeof(swab_buf);
val_buf += sizeof(swab_buf);
}
return 0;
if (val_size == 0)
return 0;
cs35l56_swab_copy(swab_buf, val_buf, val_size);
return regmap_raw_write(cs35l56->sdw_bus_regmap, reg_addr, swab_buf, val_size);
}
static int cs35l56_sdw_write(void *context, const void *val_buf, size_t val_size)
@ -231,7 +172,7 @@ static int cs35l56_sdw_write(void *context, const void *val_buf, size_t val_size
* byte controls always have the same byte order, and firmware file blobs
* can be written verbatim.
*/
static const struct regmap_bus cs35l56_regmap_bus_sdw = {
static const struct regmap_bus cs35l56_regmap_swab_bus_sdw = {
.read = cs35l56_sdw_read,
.write = cs35l56_sdw_write,
.gather_write = cs35l56_sdw_gather_write,
@ -239,6 +180,18 @@ static const struct regmap_bus cs35l56_regmap_bus_sdw = {
.val_format_endian_default = REGMAP_ENDIAN_BIG,
};
/* Low-level SoundWire regmap to transfer the data over the bus */
static const struct regmap_config cs35l56_sdw_bus_regmap = {
.name = "sdw-le32",
.reg_bits = 32,
.val_bits = 32,
.reg_stride = 4,
.reg_format_endian = REGMAP_ENDIAN_LITTLE,
.val_format_endian = REGMAP_ENDIAN_LITTLE,
.max_register = CS35L56_DSP1_PMEM_5114 + 0x8000,
.cache_type = REGCACHE_NONE,
};
static int cs35l56_sdw_get_unique_id(struct cs35l56_private *cs35l56)
{
int ret;
@ -560,8 +513,16 @@ static int cs35l56_sdw_probe(struct sdw_slave *peripheral, const struct sdw_devi
cs35l56->base.type = ((unsigned int)id->driver_data) & 0xff;
cs35l56->base.regmap = devm_regmap_init(dev, &cs35l56_regmap_bus_sdw,
peripheral, regmap_config);
/* Low-level regmap to transfer read/writes over SoundWire bus */
cs35l56->sdw_bus_regmap = devm_regmap_init_sdw(peripheral, &cs35l56_sdw_bus_regmap);
if (IS_ERR(cs35l56->sdw_bus_regmap)) {
ret = PTR_ERR(cs35l56->sdw_bus_regmap);
return dev_err_probe(dev, ret, "Failed to allocate bus register map\n");
}
/* Wrapper regmap to simulate big-endian ordering */
cs35l56->base.regmap = devm_regmap_init(dev, &cs35l56_regmap_swab_bus_sdw,
peripheral, regmap_config);
if (IS_ERR(cs35l56->base.regmap)) {
ret = PTR_ERR(cs35l56->base.regmap);
return dev_err_probe(dev, ret, "Failed to allocate register map\n");

6
sound/soc/codecs/cs35l56-shared-test.c
View File

@ -29,6 +29,7 @@ struct cs35l56_shared_test_priv {
struct faux_device *gpio_dev;
struct cs35l56_shared_test_mock_gpio *gpio_priv;
struct regmap *registers;
unsigned int reg_offset;
struct cs35l56_base *cs35l56_base;
u8 applied_pad_pull_state[CS35L56_MAX_GPIO];
};
@ -194,6 +195,8 @@ static int cs35l56_shared_test_reg_read(void *context, unsigned int reg, unsigne
{
struct cs35l56_shared_test_priv *priv = context;
reg -= priv->reg_offset;
switch (reg) {
case CS35L56_SYNC_GPIO1_CFG ... CS35L56_ASP2_DIO_GPIO13_CFG:
case CS35L56_GPIO1_CTRL1 ... CS35L56_GPIO13_CTRL1:
@ -214,6 +217,8 @@ static int cs35l56_shared_test_reg_write(void *context, unsigned int reg, unsign
{
struct cs35l56_shared_test_priv *priv = context;
reg -= priv->reg_offset;
switch (reg) {
case CS35L56_UPDATE_REGS:
return cs35l56_shared_test_updt_gpio_pres(priv, reg, val);
@ -657,6 +662,7 @@ static int cs35l56_shared_test_case_base_init(struct kunit *test, u8 type, u8 re
test->priv = priv;
priv->test = test;
priv->reg_offset = regmap_config->reg_base;
/* Create dummy amp driver dev */
priv->amp_dev = faux_device_create("cs35l56_shared_test_drv", NULL, NULL);

2
sound/soc/codecs/cs35l56-shared.c
View File

@ -1880,6 +1880,7 @@ EXPORT_SYMBOL_NS_GPL(cs35l56_regmap_spi, "SND_SOC_CS35L56_SHARED");
const struct regmap_config cs35l56_regmap_sdw = {
.reg_bits = 32,
.reg_base = 0x8000,
.val_bits = 32,
.reg_stride = 4,
.reg_format_endian = REGMAP_ENDIAN_LITTLE,
@ -1915,6 +1916,7 @@ const struct regmap_config cs35l63_regmap_sdw = {
.reg_bits = 32,
.val_bits = 32,
.reg_stride = 4,
.reg_base = 0x8000,
.reg_format_endian = REGMAP_ENDIAN_LITTLE,
.val_format_endian = REGMAP_ENDIAN_BIG,
.max_register = CS35L56_DSP1_PMEM_5114,

1
sound/soc/codecs/cs35l56.h
View File

@ -37,6 +37,7 @@ struct cs35l56_private {
struct snd_soc_component *component;
struct regulator_bulk_data supplies[CS35L56_NUM_BULK_SUPPLIES];
struct sdw_slave *sdw_peripheral;
struct regmap *sdw_bus_regmap;
const char *fallback_fw_suffix;
struct work_struct sdw_irq_work;
bool sdw_irq_no_unmask;