iv/linux
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

ASoC: cs35l56: Move shared data into a common data structure

Browse Source 
The ASoC and HDA drivers have structures that contain some of the same
information - instead of maintaining two locations for this data the
drivers should share a common data structure as this will enable common
utility functions to be created.

The first step is to move the location of these members in the ASoC
driver.

Signed-off-by: Simon Trimmer <simont@opensource.cirrus.com>
Signed-off-by: Richard Fitzgerald <rf@opensource.cirrus.com>
Acked-by: Mark Brown <broonie@kernel.org>
Link: https://lore.kernel.org/r/20230721132120.5523-2-rf@opensource.cirrus.com
Signed-off-by: Mark Brown <broonie@kernel.org>
This commit is contained in:
Simon Trimmer 2023-07-21 14:21:10 +01:00 committed by Mark Brown
parent de1b43a57a
commit 898673b905
No known key found for this signature in database
GPG Key ID: 24D68B725D5487D0
7 changed files with 270 additions and 259 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
include/sound/cs35l56.h
View File

@ -252,6 +252,19 @@
#define CS35L56_NUM_BULK_SUPPLIES 3 #define CS35L56_NUM_BULK_SUPPLIES 3
#define CS35L56_NUM_DSP_REGIONS 5 #define CS35L56_NUM_DSP_REGIONS 5
struct cs35l56_base {
struct device *dev;
struct regmap *regmap;
int irq;
struct mutex irq_lock;
u8 rev;
bool init_done;
bool fw_patched;
bool secured;
bool can_hibernate;
struct gpio_desc *reset_gpio;
};
extern struct regmap_config cs35l56_regmap_i2c; extern struct regmap_config cs35l56_regmap_i2c;
extern struct regmap_config cs35l56_regmap_spi; extern struct regmap_config cs35l56_regmap_spi;
extern struct regmap_config cs35l56_regmap_sdw; extern struct regmap_config cs35l56_regmap_sdw;
@ -260,7 +273,7 @@ extern const struct cs_dsp_region cs35l56_dsp1_regions[CS35L56_NUM_DSP_REGIONS];
extern const char * const cs35l56_tx_input_texts[CS35L56_NUM_INPUT_SRC]; extern const char * const cs35l56_tx_input_texts[CS35L56_NUM_INPUT_SRC];
extern const unsigned int cs35l56_tx_input_values[CS35L56_NUM_INPUT_SRC]; extern const unsigned int cs35l56_tx_input_values[CS35L56_NUM_INPUT_SRC];
int cs35l56_set_patch(struct regmap *regmap); int cs35l56_set_patch(struct cs35l56_base *cs35l56_base);
int cs35l56_get_bclk_freq_id(unsigned int freq); int cs35l56_get_bclk_freq_id(unsigned int freq);
void cs35l56_fill_supply_names(struct regulator_bulk_data *data); void cs35l56_fill_supply_names(struct regulator_bulk_data *data);

14
sound/soc/codecs/cs35l56-i2c.c
View File

@ -26,14 +26,14 @@ static int cs35l56_i2c_probe(struct i2c_client *client)
if (!cs35l56) if (!cs35l56)
return -ENOMEM; return -ENOMEM;
cs35l56->dev = dev; cs35l56->base.dev = dev;
cs35l56->can_hibernate = true; cs35l56->base.can_hibernate = true;
i2c_set_clientdata(client, cs35l56); i2c_set_clientdata(client, cs35l56);
cs35l56->regmap = devm_regmap_init_i2c(client, regmap_config); cs35l56->base.regmap = devm_regmap_init_i2c(client, regmap_config);
if (IS_ERR(cs35l56->regmap)) { if (IS_ERR(cs35l56->base.regmap)) {
ret = PTR_ERR(cs35l56->regmap); ret = PTR_ERR(cs35l56->base.regmap);
return dev_err_probe(cs35l56->dev, ret, "Failed to allocate register map\n"); return dev_err_probe(cs35l56->base.dev, ret, "Failed to allocate register map\n");
} }
ret = cs35l56_common_probe(cs35l56); ret = cs35l56_common_probe(cs35l56);
@ -42,7 +42,7 @@ static int cs35l56_i2c_probe(struct i2c_client *client)
ret = cs35l56_init(cs35l56); ret = cs35l56_init(cs35l56);
if (ret == 0) if (ret == 0)
ret = cs35l56_irq_request(cs35l56, client->irq); ret = cs35l56_irq_request(&cs35l56->base, client->irq);
if (ret < 0) if (ret < 0)
cs35l56_remove(cs35l56); cs35l56_remove(cs35l56);

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

@ -166,13 +166,13 @@ static void cs35l56_sdw_init(struct sdw_slave *peripheral)
struct cs35l56_private *cs35l56 = dev_get_drvdata(&peripheral->dev); struct cs35l56_private *cs35l56 = dev_get_drvdata(&peripheral->dev);
int ret; int ret;
pm_runtime_get_noresume(cs35l56->dev); pm_runtime_get_noresume(cs35l56->base.dev);
regcache_cache_only(cs35l56->regmap, false); regcache_cache_only(cs35l56->base.regmap, false);
ret = cs35l56_init(cs35l56); ret = cs35l56_init(cs35l56);
if (ret < 0) { if (ret < 0) {
regcache_cache_only(cs35l56->regmap, true); regcache_cache_only(cs35l56->base.regmap, true);
goto out; goto out;
} }
@ -180,15 +180,15 @@ static void cs35l56_sdw_init(struct sdw_slave *peripheral)
* cs35l56_init can return with !init_done if it triggered * cs35l56_init can return with !init_done if it triggered
* a soft reset. * a soft reset.
*/ */
if (cs35l56->init_done) { if (cs35l56->base.init_done) {
/* Enable SoundWire interrupts */ /* Enable SoundWire interrupts */
sdw_write_no_pm(peripheral, CS35L56_SDW_GEN_INT_MASK_1, sdw_write_no_pm(peripheral, CS35L56_SDW_GEN_INT_MASK_1,
CS35L56_SDW_INT_MASK_CODEC_IRQ); CS35L56_SDW_INT_MASK_CODEC_IRQ);
} }
out: out:
pm_runtime_mark_last_busy(cs35l56->dev); pm_runtime_mark_last_busy(cs35l56->base.dev);
pm_runtime_put_autosuspend(cs35l56->dev); pm_runtime_put_autosuspend(cs35l56->base.dev);
} }
static int cs35l56_sdw_interrupt(struct sdw_slave *peripheral, static int cs35l56_sdw_interrupt(struct sdw_slave *peripheral,
@ -198,7 +198,7 @@ static int cs35l56_sdw_interrupt(struct sdw_slave *peripheral,
/* SoundWire core holds our pm_runtime when calling this function. */ /* SoundWire core holds our pm_runtime when calling this function. */
dev_dbg(cs35l56->dev, "int control_port=%#x\n", status->control_port); dev_dbg(cs35l56->base.dev, "int control_port=%#x\n", status->control_port);
if ((status->control_port & SDW_SCP_INT1_IMPL_DEF) == 0) if ((status->control_port & SDW_SCP_INT1_IMPL_DEF) == 0)
return 0; return 0;
@ -207,7 +207,7 @@ static int cs35l56_sdw_interrupt(struct sdw_slave *peripheral,
* Prevent bus manager suspending and possibly issuing a * Prevent bus manager suspending and possibly issuing a
* bus-reset before the queued work has run. * bus-reset before the queued work has run.
*/ */
pm_runtime_get_noresume(cs35l56->dev); pm_runtime_get_noresume(cs35l56->base.dev);
/* /*
* Mask and clear until it has been handled. The read of GEN_INT_STAT_1 * Mask and clear until it has been handled. The read of GEN_INT_STAT_1
@ -230,14 +230,14 @@ static void cs35l56_sdw_irq_work(struct work_struct *work)
struct cs35l56_private, struct cs35l56_private,
sdw_irq_work); sdw_irq_work);
cs35l56_irq(-1, cs35l56); cs35l56_irq(-1, &cs35l56->base);
/* unmask interrupts */ /* unmask interrupts */
if (!cs35l56->sdw_irq_no_unmask) if (!cs35l56->sdw_irq_no_unmask)
sdw_write_no_pm(cs35l56->sdw_peripheral, CS35L56_SDW_GEN_INT_MASK_1, sdw_write_no_pm(cs35l56->sdw_peripheral, CS35L56_SDW_GEN_INT_MASK_1,
CS35L56_SDW_INT_MASK_CODEC_IRQ); CS35L56_SDW_INT_MASK_CODEC_IRQ);
pm_runtime_put_autosuspend(cs35l56->dev); pm_runtime_put_autosuspend(cs35l56->base.dev);
} }
static int cs35l56_sdw_read_prop(struct sdw_slave *peripheral) static int cs35l56_sdw_read_prop(struct sdw_slave *peripheral)
@ -246,7 +246,7 @@ static int cs35l56_sdw_read_prop(struct sdw_slave *peripheral)
struct sdw_slave_prop *prop = &peripheral->prop; struct sdw_slave_prop *prop = &peripheral->prop;
struct sdw_dpn_prop *ports; struct sdw_dpn_prop *ports;
ports = devm_kcalloc(cs35l56->dev, 2, sizeof(*ports), GFP_KERNEL); ports = devm_kcalloc(cs35l56->base.dev, 2, sizeof(*ports), GFP_KERNEL);
if (!ports) if (!ports)
return -ENOMEM; return -ENOMEM;
@ -279,17 +279,17 @@ static int cs35l56_sdw_update_status(struct sdw_slave *peripheral,
switch (status) { switch (status) {
case SDW_SLAVE_ATTACHED: case SDW_SLAVE_ATTACHED:
dev_dbg(cs35l56->dev, "%s: ATTACHED\n", __func__); dev_dbg(cs35l56->base.dev, "%s: ATTACHED\n", __func__);
if (cs35l56->sdw_attached) if (cs35l56->sdw_attached)
break; break;
if (!cs35l56->init_done || cs35l56->soft_resetting) if (!cs35l56->base.init_done || cs35l56->soft_resetting)
cs35l56_sdw_init(peripheral); cs35l56_sdw_init(peripheral);
cs35l56->sdw_attached = true; cs35l56->sdw_attached = true;
break; break;
case SDW_SLAVE_UNATTACHED: case SDW_SLAVE_UNATTACHED:
dev_dbg(cs35l56->dev, "%s: UNATTACHED\n", __func__); dev_dbg(cs35l56->base.dev, "%s: UNATTACHED\n", __func__);
cs35l56->sdw_attached = false; cs35l56->sdw_attached = false;
break; break;
default: default:
@ -305,7 +305,7 @@ static int cs35l56_a1_kick_divider(struct cs35l56_private *cs35l56,
unsigned int curr_scale_reg, next_scale_reg; unsigned int curr_scale_reg, next_scale_reg;
int curr_scale, next_scale, ret; int curr_scale, next_scale, ret;
if (!cs35l56->init_done) if (!cs35l56->base.init_done)
return 0; return 0;
if (peripheral->bus->params.curr_bank) { if (peripheral->bus->params.curr_bank) {
@ -324,13 +324,13 @@ static int cs35l56_a1_kick_divider(struct cs35l56_private *cs35l56,
*/ */
curr_scale = sdw_read_no_pm(peripheral, curr_scale_reg); curr_scale = sdw_read_no_pm(peripheral, curr_scale_reg);
if (curr_scale < 0) { if (curr_scale < 0) {
dev_err(cs35l56->dev, "Failed to read current clock scale: %d\n", curr_scale); dev_err(cs35l56->base.dev, "Failed to read current clock scale: %d\n", curr_scale);
return curr_scale; return curr_scale;
} }
next_scale = sdw_read_no_pm(peripheral, next_scale_reg); next_scale = sdw_read_no_pm(peripheral, next_scale_reg);
if (next_scale < 0) { if (next_scale < 0) {
dev_err(cs35l56->dev, "Failed to read next clock scale: %d\n", next_scale); dev_err(cs35l56->base.dev, "Failed to read next clock scale: %d\n", next_scale);
return next_scale; return next_scale;
} }
@ -338,7 +338,8 @@ static int cs35l56_a1_kick_divider(struct cs35l56_private *cs35l56,
next_scale = cs35l56->old_sdw_clock_scale; next_scale = cs35l56->old_sdw_clock_scale;
ret = sdw_write_no_pm(peripheral, next_scale_reg, next_scale); ret = sdw_write_no_pm(peripheral, next_scale_reg, next_scale);
if (ret < 0) { if (ret < 0) {
dev_err(cs35l56->dev, "Failed to modify current clock scale: %d\n", ret); dev_err(cs35l56->base.dev, "Failed to modify current clock scale: %d\n",
ret);
return ret; return ret;
} }
} }
@ -346,11 +347,11 @@ static int cs35l56_a1_kick_divider(struct cs35l56_private *cs35l56,
cs35l56->old_sdw_clock_scale = curr_scale; cs35l56->old_sdw_clock_scale = curr_scale;
ret = sdw_write_no_pm(peripheral, curr_scale_reg, CS35L56_SDW_INVALID_BUS_SCALE); ret = sdw_write_no_pm(peripheral, curr_scale_reg, CS35L56_SDW_INVALID_BUS_SCALE);
if (ret < 0) { if (ret < 0) {
dev_err(cs35l56->dev, "Failed to modify current clock scale: %d\n", ret); dev_err(cs35l56->base.dev, "Failed to modify current clock scale: %d\n", ret);
return ret; return ret;
} }
dev_dbg(cs35l56->dev, "Next bus scale: %#x\n", next_scale); dev_dbg(cs35l56->base.dev, "Next bus scale: %#x\n", next_scale);
return 0; return 0;
} }
@ -362,9 +363,10 @@ static int cs35l56_sdw_bus_config(struct sdw_slave *peripheral,
int sclk; int sclk;
sclk = params->curr_dr_freq / 2; sclk = params->curr_dr_freq / 2;
dev_dbg(cs35l56->dev, "%s: sclk=%u c=%u r=%u\n", __func__, sclk, params->col, params->row); dev_dbg(cs35l56->base.dev, "%s: sclk=%u c=%u r=%u\n",
__func__, sclk, params->col, params->row);
if (cs35l56->rev < 0xb0) if (cs35l56->base.rev < 0xb0)
return cs35l56_a1_kick_divider(cs35l56, peripheral); return cs35l56_a1_kick_divider(cs35l56, peripheral);
return 0; return 0;
@ -376,7 +378,7 @@ static int __maybe_unused cs35l56_sdw_clk_stop(struct sdw_slave *peripheral,
{ {
struct cs35l56_private *cs35l56 = dev_get_drvdata(&peripheral->dev); struct cs35l56_private *cs35l56 = dev_get_drvdata(&peripheral->dev);
dev_dbg(cs35l56->dev, "%s: mode:%d type:%d\n", __func__, mode, type); dev_dbg(cs35l56->base.dev, "%s: mode:%d type:%d\n", __func__, mode, type);
return 0; return 0;
} }
@ -397,10 +399,10 @@ static int __maybe_unused cs35l56_sdw_handle_unattach(struct cs35l56_private *cs
if (peripheral->unattach_request) { if (peripheral->unattach_request) {
/* Cannot access registers until bus is re-initialized. */ /* Cannot access registers until bus is re-initialized. */
dev_dbg(cs35l56->dev, "Wait for initialization_complete\n"); dev_dbg(cs35l56->base.dev, "Wait for initialization_complete\n");
if (!wait_for_completion_timeout(&peripheral->initialization_complete, if (!wait_for_completion_timeout(&peripheral->initialization_complete,
msecs_to_jiffies(5000))) { msecs_to_jiffies(5000))) {
dev_err(cs35l56->dev, "initialization_complete timed out\n"); dev_err(cs35l56->base.dev, "initialization_complete timed out\n");
return -ETIMEDOUT; return -ETIMEDOUT;
} }
@ -419,7 +421,7 @@ static int __maybe_unused cs35l56_sdw_runtime_suspend(struct device *dev)
{ {
struct cs35l56_private *cs35l56 = dev_get_drvdata(dev); struct cs35l56_private *cs35l56 = dev_get_drvdata(dev);
if (!cs35l56->init_done) if (!cs35l56->base.init_done)
return 0; return 0;
return cs35l56_runtime_suspend(dev); return cs35l56_runtime_suspend(dev);
@ -432,7 +434,7 @@ static int __maybe_unused cs35l56_sdw_runtime_resume(struct device *dev)
dev_dbg(dev, "Runtime resume\n"); dev_dbg(dev, "Runtime resume\n");
if (!cs35l56->init_done) if (!cs35l56->base.init_done)
return 0; return 0;
ret = cs35l56_sdw_handle_unattach(cs35l56); ret = cs35l56_sdw_handle_unattach(cs35l56);
@ -454,7 +456,7 @@ static int __maybe_unused cs35l56_sdw_system_suspend(struct device *dev)
{ {
struct cs35l56_private *cs35l56 = dev_get_drvdata(dev); struct cs35l56_private *cs35l56 = dev_get_drvdata(dev);
if (!cs35l56->init_done) if (!cs35l56->base.init_done)
return 0; return 0;
/* /*
@ -493,21 +495,21 @@ static int cs35l56_sdw_probe(struct sdw_slave *peripheral, const struct sdw_devi
if (!cs35l56) if (!cs35l56)
return -ENOMEM; return -ENOMEM;
cs35l56->dev = dev; cs35l56->base.dev = dev;
cs35l56->sdw_peripheral = peripheral; cs35l56->sdw_peripheral = peripheral;
INIT_WORK(&cs35l56->sdw_irq_work, cs35l56_sdw_irq_work); INIT_WORK(&cs35l56->sdw_irq_work, cs35l56_sdw_irq_work);
dev_set_drvdata(dev, cs35l56); dev_set_drvdata(dev, cs35l56);
cs35l56->regmap = devm_regmap_init(dev, &cs35l56_regmap_bus_sdw, cs35l56->base.regmap = devm_regmap_init(dev, &cs35l56_regmap_bus_sdw,
peripheral, &cs35l56_regmap_sdw); peripheral, &cs35l56_regmap_sdw);
if (IS_ERR(cs35l56->regmap)) { if (IS_ERR(cs35l56->base.regmap)) {
ret = PTR_ERR(cs35l56->regmap); ret = PTR_ERR(cs35l56->base.regmap);
return dev_err_probe(dev, ret, "Failed to allocate register map\n"); return dev_err_probe(dev, ret, "Failed to allocate register map\n");
} }
/* Start in cache-only until device is enumerated */ /* Start in cache-only until device is enumerated */
regcache_cache_only(cs35l56->regmap, true); regcache_cache_only(cs35l56->base.regmap, true);
ret = cs35l56_common_probe(cs35l56); ret = cs35l56_common_probe(cs35l56);
if (ret != 0) if (ret != 0)

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

@ -18,9 +18,10 @@ static const struct reg_sequence cs35l56_patch[] = {
{ CS35L56_MAIN_POSTURE_NUMBER, 0x00000000 }, { CS35L56_MAIN_POSTURE_NUMBER, 0x00000000 },
}; };
int cs35l56_set_patch(struct regmap *regmap) int cs35l56_set_patch(struct cs35l56_base *cs35l56_base)
{ {
return regmap_register_patch(regmap, cs35l56_patch, ARRAY_SIZE(cs35l56_patch)); return regmap_register_patch(cs35l56_base->regmap, cs35l56_patch,
ARRAY_SIZE(cs35l56_patch));
} }
EXPORT_SYMBOL_NS_GPL(cs35l56_set_patch, SND_SOC_CS35L56_SHARED); EXPORT_SYMBOL_NS_GPL(cs35l56_set_patch, SND_SOC_CS35L56_SHARED);

10
sound/soc/codecs/cs35l56-spi.c
View File

@ -25,13 +25,13 @@ static int cs35l56_spi_probe(struct spi_device *spi)
return -ENOMEM; return -ENOMEM;
spi_set_drvdata(spi, cs35l56); spi_set_drvdata(spi, cs35l56);
cs35l56->regmap = devm_regmap_init_spi(spi, regmap_config); cs35l56->base.regmap = devm_regmap_init_spi(spi, regmap_config);
if (IS_ERR(cs35l56->regmap)) { if (IS_ERR(cs35l56->base.regmap)) {
ret = PTR_ERR(cs35l56->regmap); ret = PTR_ERR(cs35l56->base.regmap);
return dev_err_probe(&spi->dev, ret, "Failed to allocate register map\n"); return dev_err_probe(&spi->dev, ret, "Failed to allocate register map\n");
} }
cs35l56->dev = &spi->dev; cs35l56->base.dev = &spi->dev;
ret = cs35l56_common_probe(cs35l56); ret = cs35l56_common_probe(cs35l56);
if (ret != 0) if (ret != 0)
@ -39,7 +39,7 @@ static int cs35l56_spi_probe(struct spi_device *spi)
ret = cs35l56_init(cs35l56); ret = cs35l56_init(cs35l56);
if (ret == 0) if (ret == 0)
ret = cs35l56_irq_request(cs35l56, spi->irq); ret = cs35l56_irq_request(&cs35l56->base, spi->irq);
if (ret < 0) if (ret < 0)
cs35l56_remove(cs35l56); cs35l56_remove(cs35l56);

404
sound/soc/codecs/cs35l56.c
View File

File diff suppressed because it is too large Load Diff

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

@ -32,26 +32,17 @@ struct sdw_slave;
struct cs35l56_private { struct cs35l56_private {
struct wm_adsp dsp; /* must be first member */ struct wm_adsp dsp; /* must be first member */
struct cs35l56_base base;
struct work_struct dsp_work; struct work_struct dsp_work;
struct workqueue_struct *dsp_wq; struct workqueue_struct *dsp_wq;
struct mutex irq_lock;
struct snd_soc_component *component; struct snd_soc_component *component;
struct device *dev;
struct regmap *regmap;
struct regulator_bulk_data supplies[CS35L56_NUM_BULK_SUPPLIES]; struct regulator_bulk_data supplies[CS35L56_NUM_BULK_SUPPLIES];
int irq;
struct sdw_slave *sdw_peripheral; struct sdw_slave *sdw_peripheral;
u8 rev;
struct work_struct sdw_irq_work; struct work_struct sdw_irq_work;
bool secured;
bool sdw_irq_no_unmask; bool sdw_irq_no_unmask;
bool soft_resetting; bool soft_resetting;
bool init_done;
bool sdw_attached; bool sdw_attached;
bool fw_patched;
bool can_hibernate;
struct completion init_completion; struct completion init_completion;
struct gpio_desc *reset_gpio;
u32 rx_mask; u32 rx_mask;
u32 tx_mask; u32 tx_mask;
@ -73,7 +64,7 @@ int cs35l56_system_resume_no_irq(struct device *dev);
int cs35l56_system_resume_early(struct device *dev); int cs35l56_system_resume_early(struct device *dev);
int cs35l56_system_resume(struct device *dev); int cs35l56_system_resume(struct device *dev);
irqreturn_t cs35l56_irq(int irq, void *data); irqreturn_t cs35l56_irq(int irq, void *data);
int cs35l56_irq_request(struct cs35l56_private *cs35l56, int irq); int cs35l56_irq_request(struct cs35l56_base *cs35l56_base, int irq);
int cs35l56_common_probe(struct cs35l56_private *cs35l56); int cs35l56_common_probe(struct cs35l56_private *cs35l56);
int cs35l56_init(struct cs35l56_private *cs35l56); int cs35l56_init(struct cs35l56_private *cs35l56);
void cs35l56_remove(struct cs35l56_private *cs35l56); void cs35l56_remove(struct cs35l56_private *cs35l56);