From: Kuninori Morimoto kuninori.morimoto.gx@renesas.com

Now we can replace Codec to Component. Let's do it.

Note: xxx_codec_xxx() -> xxx_component_xxx() .idle_bias_off = 0 -> .idle_bias_on = 1 .ignore_pmdown_time = 0 -> .pmdown_time = 1 - -> .endianness = 1 - -> .non_legacy_dai_naming = 1

Signed-off-by: Kuninori Morimoto kuninori.morimoto.gx@renesas.com --- sound/soc/soc-utils.c | 22 ++++++++-------------- 1 file changed, 8 insertions(+), 14 deletions(-)

diff --git a/sound/soc/soc-utils.c b/sound/soc/soc-utils.c index e237858..1e0f802 100644 --- a/sound/soc/soc-utils.c +++ b/sound/soc/soc-utils.c @@ -288,7 +288,12 @@ static int dummy_dma_open(struct snd_pcm_substream *substream) .ops = &dummy_dma_ops, };

-static const struct snd_soc_codec_driver dummy_codec; +static const struct snd_soc_component_driver dummy_codec = { + .idle_bias_on = 1, + .pmdown_time = 1, + .endianness = 1, + .non_legacy_dai_naming = 1, +};

#define STUB_RATES SNDRV_PCM_RATE_8000_192000 #define STUB_FORMATS (SNDRV_PCM_FMTBIT_S8 | \ @@ -338,33 +343,22 @@ static int snd_soc_dummy_probe(struct platform_device *pdev) { int ret;

- ret = snd_soc_register_codec(&pdev->dev, &dummy_codec, &dummy_dai, 1); + ret = devm_snd_soc_register_component(&pdev->dev, + &dummy_codec, &dummy_dai, 1); if (ret < 0) return ret;

ret = devm_snd_soc_register_component(&pdev->dev, &dummy_platform, NULL, 0); - if (ret < 0) { - snd_soc_unregister_codec(&pdev->dev); - return ret; - }

return ret; }

-static int snd_soc_dummy_remove(struct platform_device *pdev) -{ - snd_soc_unregister_codec(&pdev->dev); - - return 0; -} - static struct platform_driver soc_dummy_driver = { .driver = { .name = "snd-soc-dummy", }, .probe = snd_soc_dummy_probe, - .remove = snd_soc_dummy_remove, };

static struct platform_device *soc_dummy_dev;

From: Kuninori Morimoto kuninori.morimoto.gx@renesas.com

Now we can replace Codec to Component. Let's do it.

Note: xxx_codec_xxx() -> xxx_component_xxx() .idle_bias_off = 1 -> .idle_bias_on = 0 .ignore_pmdown_time = 0 -> .pmdown_time = 1 - -> .endianness = 1 - -> .non_legacy_dai_naming = 1

Signed-off-by: Kuninori Morimoto kuninori.morimoto.gx@renesas.com --- sound/soc/codecs/wm0010.c | 181 +++++++++++++++++++++++----------------------- 1 file changed, 89 insertions(+), 92 deletions(-)

diff --git a/sound/soc/codecs/wm0010.c b/sound/soc/codecs/wm0010.c index 0147d2f..ab1ad33 100644 --- a/sound/soc/codecs/wm0010.c +++ b/sound/soc/codecs/wm0010.c @@ -90,7 +90,7 @@ enum wm0010_state { };

struct wm0010_priv { - struct snd_soc_codec *codec; + struct snd_soc_component *component;

struct mutex lock; struct device *dev; @@ -157,9 +157,9 @@ static const char *wm0010_state_to_str(enum wm0010_state state) }

/* Called with wm0010->lock held */ -static void wm0010_halt(struct snd_soc_codec *codec) +static void wm0010_halt(struct snd_soc_component *component) { - struct wm0010_priv *wm0010 = snd_soc_codec_get_drvdata(codec); + struct wm0010_priv *wm0010 = snd_soc_component_get_drvdata(component); unsigned long flags; enum wm0010_state state;

@@ -193,7 +193,7 @@ static void wm0010_halt(struct snd_soc_codec *codec)

struct wm0010_boot_xfer { struct list_head list; - struct snd_soc_codec *codec; + struct snd_soc_component *component; struct completion *done; struct spi_message m; struct spi_transfer t; @@ -218,13 +218,13 @@ static void wm0010_mark_boot_failure(struct wm0010_priv *wm0010) static void wm0010_boot_xfer_complete(void *data) { struct wm0010_boot_xfer *xfer = data; - struct snd_soc_codec *codec = xfer->codec; - struct wm0010_priv *wm0010 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = xfer->component; + struct wm0010_priv *wm0010 = snd_soc_component_get_drvdata(component); u32 *out32 = xfer->t.rx_buf; int i;

if (xfer->m.status != 0) { - dev_err(codec->dev, "SPI transfer failed: %d\n", + dev_err(component->dev, "SPI transfer failed: %d\n", xfer->m.status); wm0010_mark_boot_failure(wm0010); if (xfer->done) @@ -233,11 +233,11 @@ static void wm0010_boot_xfer_complete(void *data) }

for (i = 0; i < xfer->t.len / 4; i++) { - dev_dbg(codec->dev, "%d: %04x\n", i, out32[i]); + dev_dbg(component->dev, "%d: %04x\n", i, out32[i]);

switch (be32_to_cpu(out32[i])) { case 0xe0e0e0e0: - dev_err(codec->dev, + dev_err(component->dev, "%d: ROM error reported in stage 2\n", i); wm0010_mark_boot_failure(wm0010); break; @@ -245,82 +245,82 @@ static void wm0010_boot_xfer_complete(void *data) case 0x55555555: if (wm0010->state < WM0010_STAGE2) break; - dev_err(codec->dev, + dev_err(component->dev, "%d: ROM bootloader running in stage 2\n", i); wm0010_mark_boot_failure(wm0010); break;

case 0x0fed0000: - dev_dbg(codec->dev, "Stage2 loader running\n"); + dev_dbg(component->dev, "Stage2 loader running\n"); break;

case 0x0fed0007: - dev_dbg(codec->dev, "CODE_HDR packet received\n"); + dev_dbg(component->dev, "CODE_HDR packet received\n"); break;

case 0x0fed0008: - dev_dbg(codec->dev, "CODE_DATA packet received\n"); + dev_dbg(component->dev, "CODE_DATA packet received\n"); break;

case 0x0fed0009: - dev_dbg(codec->dev, "Download complete\n"); + dev_dbg(component->dev, "Download complete\n"); break;

case 0x0fed000c: - dev_dbg(codec->dev, "Application start\n"); + dev_dbg(component->dev, "Application start\n"); break;

case 0x0fed000e: - dev_dbg(codec->dev, "PLL packet received\n"); + dev_dbg(component->dev, "PLL packet received\n"); wm0010->pll_running = true; break;

case 0x0fed0025: - dev_err(codec->dev, "Device reports image too long\n"); + dev_err(component->dev, "Device reports image too long\n"); wm0010_mark_boot_failure(wm0010); break;

case 0x0fed002c: - dev_err(codec->dev, "Device reports bad SPI packet\n"); + dev_err(component->dev, "Device reports bad SPI packet\n"); wm0010_mark_boot_failure(wm0010); break;

case 0x0fed0031: - dev_err(codec->dev, "Device reports SPI read overflow\n"); + dev_err(component->dev, "Device reports SPI read overflow\n"); wm0010_mark_boot_failure(wm0010); break;

case 0x0fed0032: - dev_err(codec->dev, "Device reports SPI underclock\n"); + dev_err(component->dev, "Device reports SPI underclock\n"); wm0010_mark_boot_failure(wm0010); break;

case 0x0fed0033: - dev_err(codec->dev, "Device reports bad header packet\n"); + dev_err(component->dev, "Device reports bad header packet\n"); wm0010_mark_boot_failure(wm0010); break;

case 0x0fed0034: - dev_err(codec->dev, "Device reports invalid packet type\n"); + dev_err(component->dev, "Device reports invalid packet type\n"); wm0010_mark_boot_failure(wm0010); break;

case 0x0fed0035: - dev_err(codec->dev, "Device reports data before header error\n"); + dev_err(component->dev, "Device reports data before header error\n"); wm0010_mark_boot_failure(wm0010); break;

case 0x0fed0038: - dev_err(codec->dev, "Device reports invalid PLL packet\n"); + dev_err(component->dev, "Device reports invalid PLL packet\n"); break;

case 0x0fed003a: - dev_err(codec->dev, "Device reports packet alignment error\n"); + dev_err(component->dev, "Device reports packet alignment error\n"); wm0010_mark_boot_failure(wm0010); break;

default: - dev_err(codec->dev, "Unrecognised return 0x%x\n", + dev_err(component->dev, "Unrecognised return 0x%x\n", be32_to_cpu(out32[i])); wm0010_mark_boot_failure(wm0010); break; @@ -342,10 +342,10 @@ static void byte_swap_64(u64 *data_in, u64 *data_out, u32 len) data_out[i] = cpu_to_be64(le64_to_cpu(data_in[i])); }

-static int wm0010_firmware_load(const char *name, struct snd_soc_codec *codec) +static int wm0010_firmware_load(const char *name, struct snd_soc_component *component) { - struct spi_device *spi = to_spi_device(codec->dev); - struct wm0010_priv *wm0010 = snd_soc_codec_get_drvdata(codec); + struct spi_device *spi = to_spi_device(component->dev); + struct wm0010_priv *wm0010 = snd_soc_component_get_drvdata(component); struct list_head xfer_list; struct wm0010_boot_xfer *xfer; int ret; @@ -359,9 +359,9 @@ static int wm0010_firmware_load(const char *name, struct snd_soc_codec *codec)

INIT_LIST_HEAD(&xfer_list);

- ret = request_firmware(&fw, name, codec->dev); + ret = request_firmware(&fw, name, component->dev); if (ret != 0) { - dev_err(codec->dev, "Failed to request application(%s): %d\n", + dev_err(component->dev, "Failed to request application(%s): %d\n", name, ret); return ret; } @@ -377,25 +377,25 @@ static int wm0010_firmware_load(const char *name, struct snd_soc_codec *codec)

/* First record should be INFO */ if (rec->command != DFW_CMD_INFO) { - dev_err(codec->dev, "First record not INFO\r\n"); + dev_err(component->dev, "First record not INFO\r\n"); ret = -EINVAL; goto abort; }

if (inforec->info_version != INFO_VERSION) { - dev_err(codec->dev, + dev_err(component->dev, "Unsupported version (%02d) of INFO record\r\n", inforec->info_version); ret = -EINVAL; goto abort; }

- dev_dbg(codec->dev, "Version v%02d INFO record found\r\n", + dev_dbg(component->dev, "Version v%02d INFO record found\r\n", inforec->info_version);

/* Check it's a DSP file */ if (dsp != DEVICE_ID_WM0010) { - dev_err(codec->dev, "Not a WM0010 firmware file.\r\n"); + dev_err(component->dev, "Not a WM0010 firmware file.\r\n"); ret = -EINVAL; goto abort; } @@ -405,7 +405,7 @@ static int wm0010_firmware_load(const char *name, struct snd_soc_codec *codec) rec = (void *)&rec->data[rec->length];

while (offset < fw->size) { - dev_dbg(codec->dev, + dev_dbg(component->dev, "Packet: command %d, data length = 0x%x\r\n", rec->command, rec->length); len = rec->length + 8; @@ -416,7 +416,7 @@ static int wm0010_firmware_load(const char *name, struct snd_soc_codec *codec) goto abort; }

- xfer->codec = codec; + xfer->component = component; list_add_tail(&xfer->list, &xfer_list);

out = kzalloc(len, GFP_KERNEL | GFP_DMA); @@ -460,18 +460,18 @@ static int wm0010_firmware_load(const char *name, struct snd_soc_codec *codec) rec = (void *)&rec->data[rec->length];

if (offset >= fw->size) { - dev_dbg(codec->dev, "All transfers scheduled\n"); + dev_dbg(component->dev, "All transfers scheduled\n"); xfer->done = &done; }

ret = spi_async(spi, &xfer->m); if (ret != 0) { - dev_err(codec->dev, "Write failed: %d\n", ret); + dev_err(component->dev, "Write failed: %d\n", ret); goto abort1; }

if (wm0010->boot_failed) { - dev_dbg(codec->dev, "Boot fail!\n"); + dev_dbg(component->dev, "Boot fail!\n"); ret = -EINVAL; goto abort1; } @@ -496,10 +496,10 @@ static int wm0010_firmware_load(const char *name, struct snd_soc_codec *codec) return ret; }

-static int wm0010_stage2_load(struct snd_soc_codec *codec) +static int wm0010_stage2_load(struct snd_soc_component *component) { - struct spi_device *spi = to_spi_device(codec->dev); - struct wm0010_priv *wm0010 = snd_soc_codec_get_drvdata(codec); + struct spi_device *spi = to_spi_device(component->dev); + struct wm0010_priv *wm0010 = snd_soc_component_get_drvdata(component); const struct firmware *fw; struct spi_message m; struct spi_transfer t; @@ -508,14 +508,14 @@ static int wm0010_stage2_load(struct snd_soc_codec *codec) int i; int ret = 0;

- ret = request_firmware(&fw, "wm0010_stage2.bin", codec->dev); + ret = request_firmware(&fw, "wm0010_stage2.bin", component->dev); if (ret != 0) { - dev_err(codec->dev, "Failed to request stage2 loader: %d\n", + dev_err(component->dev, "Failed to request stage2 loader: %d\n", ret); return ret; }

- dev_dbg(codec->dev, "Downloading %zu byte stage 2 loader\n", fw->size); + dev_dbg(component->dev, "Downloading %zu byte stage 2 loader\n", fw->size);

/* Copy to local buffer first as vmalloc causes problems for dma */ img = kzalloc(fw->size, GFP_KERNEL | GFP_DMA); @@ -541,19 +541,19 @@ static int wm0010_stage2_load(struct snd_soc_codec *codec) t.speed_hz = wm0010->sysclk / 10; spi_message_add_tail(&t, &m);

- dev_dbg(codec->dev, "Starting initial download at %dHz\n", + dev_dbg(component->dev, "Starting initial download at %dHz\n", t.speed_hz);

ret = spi_sync(spi, &m); if (ret != 0) { - dev_err(codec->dev, "Initial download failed: %d\n", ret); + dev_err(component->dev, "Initial download failed: %d\n", ret); goto abort; }

/* Look for errors from the boot ROM */ for (i = 0; i < fw->size; i++) { if (out[i] != 0x55) { - dev_err(codec->dev, "Boot ROM error: %x in %d\n", + dev_err(component->dev, "Boot ROM error: %x in %d\n", out[i], i); wm0010_mark_boot_failure(wm0010); ret = -EBUSY; @@ -570,10 +570,10 @@ static int wm0010_stage2_load(struct snd_soc_codec *codec) return ret; }

-static int wm0010_boot(struct snd_soc_codec *codec) +static int wm0010_boot(struct snd_soc_component *component) { - struct spi_device *spi = to_spi_device(codec->dev); - struct wm0010_priv *wm0010 = snd_soc_codec_get_drvdata(codec); + struct spi_device *spi = to_spi_device(component->dev); + struct wm0010_priv *wm0010 = snd_soc_component_get_drvdata(component); unsigned long flags; int ret; struct spi_message m; @@ -590,7 +590,7 @@ static int wm0010_boot(struct snd_soc_codec *codec) spin_unlock_irqrestore(&wm0010->irq_lock, flags);

if (wm0010->sysclk > 26000000) { - dev_err(codec->dev, "Max DSP clock frequency is 26MHz\n"); + dev_err(component->dev, "Max DSP clock frequency is 26MHz\n"); ret = -ECANCELED; goto err; } @@ -598,7 +598,7 @@ static int wm0010_boot(struct snd_soc_codec *codec) mutex_lock(&wm0010->lock); wm0010->pll_running = false;

- dev_dbg(codec->dev, "max_spi_freq: %d\n", wm0010->max_spi_freq); + dev_dbg(component->dev, "max_spi_freq: %d\n", wm0010->max_spi_freq);

ret = regulator_bulk_enable(ARRAY_SIZE(wm0010->core_supplies), wm0010->core_supplies); @@ -623,19 +623,19 @@ static int wm0010_boot(struct snd_soc_codec *codec)

if (!wait_for_completion_timeout(&wm0010->boot_completion, msecs_to_jiffies(20))) - dev_err(codec->dev, "Failed to get interrupt from DSP\n"); + dev_err(component->dev, "Failed to get interrupt from DSP\n");

spin_lock_irqsave(&wm0010->irq_lock, flags); wm0010->state = WM0010_BOOTROM; spin_unlock_irqrestore(&wm0010->irq_lock, flags);

- ret = wm0010_stage2_load(codec); + ret = wm0010_stage2_load(component); if (ret) goto abort;

if (!wait_for_completion_timeout(&wm0010->boot_completion, msecs_to_jiffies(20))) - dev_err(codec->dev, "Failed to get interrupt from DSP loader.\n"); + dev_err(component->dev, "Failed to get interrupt from DSP loader.\n");

spin_lock_irqsave(&wm0010->irq_lock, flags); wm0010->state = WM0010_STAGE2; @@ -676,14 +676,14 @@ static int wm0010_boot(struct snd_soc_codec *codec)

ret = spi_sync(spi, &m); if (ret) { - dev_err(codec->dev, "First PLL write failed: %d\n", ret); + dev_err(component->dev, "First PLL write failed: %d\n", ret); goto abort_swap; }

/* Use a second send of the message to get the return status */ ret = spi_sync(spi, &m); if (ret) { - dev_err(codec->dev, "Second PLL write failed: %d\n", ret); + dev_err(component->dev, "Second PLL write failed: %d\n", ret); goto abort_swap; }

@@ -692,7 +692,7 @@ static int wm0010_boot(struct snd_soc_codec *codec) /* Look for PLL active code from the DSP */ for (i = 0; i < len / 4; i++) { if (*p == 0x0e00ed0f) { - dev_dbg(codec->dev, "PLL packet received\n"); + dev_dbg(component->dev, "PLL packet received\n"); wm0010->pll_running = true; break; } @@ -702,9 +702,9 @@ static int wm0010_boot(struct snd_soc_codec *codec) kfree(img_swap); kfree(out); } else - dev_dbg(codec->dev, "Not enabling DSP PLL."); + dev_dbg(component->dev, "Not enabling DSP PLL.");

- ret = wm0010_firmware_load("wm0010.dfw", codec); + ret = wm0010_firmware_load("wm0010.dfw", component);

if (ret != 0) goto abort; @@ -723,7 +723,7 @@ static int wm0010_boot(struct snd_soc_codec *codec) kfree(out); abort: /* Put the chip back into reset */ - wm0010_halt(codec); + wm0010_halt(component); mutex_unlock(&wm0010->lock); return ret;

@@ -735,22 +735,22 @@ static int wm0010_boot(struct snd_soc_codec *codec) return ret; }

-static int wm0010_set_bias_level(struct snd_soc_codec *codec, +static int wm0010_set_bias_level(struct snd_soc_component *component, enum snd_soc_bias_level level) { - struct wm0010_priv *wm0010 = snd_soc_codec_get_drvdata(codec); + struct wm0010_priv *wm0010 = snd_soc_component_get_drvdata(component);

switch (level) { case SND_SOC_BIAS_ON: - if (snd_soc_codec_get_bias_level(codec) == SND_SOC_BIAS_PREPARE) - wm0010_boot(codec); + if (snd_soc_component_get_bias_level(component) == SND_SOC_BIAS_PREPARE) + wm0010_boot(component); break; case SND_SOC_BIAS_PREPARE: break; case SND_SOC_BIAS_STANDBY: - if (snd_soc_codec_get_bias_level(codec) == SND_SOC_BIAS_PREPARE) { + if (snd_soc_component_get_bias_level(component) == SND_SOC_BIAS_PREPARE) { mutex_lock(&wm0010->lock); - wm0010_halt(codec); + wm0010_halt(component); mutex_unlock(&wm0010->lock); } break; @@ -761,10 +761,10 @@ static int wm0010_set_bias_level(struct snd_soc_codec *codec, return 0; }

-static int wm0010_set_sysclk(struct snd_soc_codec *codec, int source, +static int wm0010_set_sysclk(struct snd_soc_component *component, int source, int clk_id, unsigned int freq, int dir) { - struct wm0010_priv *wm0010 = snd_soc_codec_get_drvdata(codec); + struct wm0010_priv *wm0010 = snd_soc_component_get_drvdata(component); unsigned int i;

wm0010->sysclk = freq; @@ -783,20 +783,19 @@ static int wm0010_set_sysclk(struct snd_soc_codec *codec, int source, return 0; }

-static int wm0010_probe(struct snd_soc_codec *codec); - -static const struct snd_soc_codec_driver soc_codec_dev_wm0010 = { - .probe = wm0010_probe, - .set_bias_level = wm0010_set_bias_level, - .set_sysclk = wm0010_set_sysclk, - .idle_bias_off = true, - - .component_driver = { - .dapm_widgets = wm0010_dapm_widgets, - .num_dapm_widgets = ARRAY_SIZE(wm0010_dapm_widgets), - .dapm_routes = wm0010_dapm_routes, - .num_dapm_routes = ARRAY_SIZE(wm0010_dapm_routes), - }, +static int wm0010_probe(struct snd_soc_component *component); + +static const struct snd_soc_component_driver soc_component_dev_wm0010 = { + .probe = wm0010_probe, + .set_bias_level = wm0010_set_bias_level, + .set_sysclk = wm0010_set_sysclk, + .dapm_widgets = wm0010_dapm_widgets, + .num_dapm_widgets = ARRAY_SIZE(wm0010_dapm_widgets), + .dapm_routes = wm0010_dapm_routes, + .num_dapm_routes = ARRAY_SIZE(wm0010_dapm_routes), + .pmdown_time = 1, + .endianness = 1, + .non_legacy_dai_naming = 1, };

#define WM0010_RATES (SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000) @@ -860,11 +859,11 @@ static irqreturn_t wm0010_irq(int irq, void *data) return IRQ_NONE; }

-static int wm0010_probe(struct snd_soc_codec *codec) +static int wm0010_probe(struct snd_soc_component *component) { - struct wm0010_priv *wm0010 = snd_soc_codec_get_drvdata(codec); + struct wm0010_priv *wm0010 = snd_soc_component_get_drvdata(component);

- wm0010->codec = codec; + wm0010->component = component;

return 0; } @@ -967,8 +966,8 @@ static int wm0010_spi_probe(struct spi_device *spi) else wm0010->board_max_spi_speed = 0;

- ret = snd_soc_register_codec(&spi->dev, - &soc_codec_dev_wm0010, wm0010_dai, + ret = devm_snd_soc_register_component(&spi->dev, + &soc_component_dev_wm0010, wm0010_dai, ARRAY_SIZE(wm0010_dai)); if (ret < 0) return ret; @@ -980,8 +979,6 @@ static int wm0010_spi_remove(struct spi_device *spi) { struct wm0010_priv *wm0010 = spi_get_drvdata(spi);

- snd_soc_unregister_codec(&spi->dev); - gpio_set_value_cansleep(wm0010->gpio_reset, wm0010->gpio_reset_value);

From: Kuninori Morimoto kuninori.morimoto.gx@renesas.com

Now we can replace Codec to Component. Let's do it.

Note: xxx_codec_xxx() -> xxx_component_xxx() .idle_bias_off = 1 -> .idle_bias_on = 0 .ignore_pmdown_time = 1 -> .pmdown_time = 0 - -> .endianness = 1 - -> .non_legacy_dai_naming = 1

Signed-off-by: Kuninori Morimoto kuninori.morimoto.gx@renesas.com --- sound/soc/codecs/wm2200.c | 157 ++++++++++++++++++++++------------------------ 1 file changed, 76 insertions(+), 81 deletions(-)

diff --git a/sound/soc/codecs/wm2200.c b/sound/soc/codecs/wm2200.c index 5c2f572..d5f4bbf 100644 --- a/sound/soc/codecs/wm2200.c +++ b/sound/soc/codecs/wm2200.c @@ -87,7 +87,7 @@ struct wm2200_priv { struct wm_adsp dsp[2]; struct regmap *regmap; struct device *dev; - struct snd_soc_codec *codec; + struct snd_soc_component *component; struct wm2200_pdata pdata; struct regulator_bulk_data core_supplies[WM2200_NUM_CORE_SUPPLIES];

@@ -1550,14 +1550,14 @@ static SOC_ENUM_SINGLE_DECL(wm2200_aec_loopback, WM2200_MIXER_ROUTES("LHPF2", "LHPF2"), };

-static int wm2200_probe(struct snd_soc_codec *codec) +static int wm2200_probe(struct snd_soc_component *component) { - struct wm2200_priv *wm2200 = snd_soc_codec_get_drvdata(codec); + struct wm2200_priv *wm2200 = snd_soc_component_get_drvdata(component); int ret;

- wm2200->codec = codec; + wm2200->component = component;

- ret = snd_soc_add_codec_controls(codec, wm_adsp_fw_controls, 2); + ret = snd_soc_add_component_controls(component, wm_adsp_fw_controls, 2); if (ret != 0) return ret;

@@ -1566,7 +1566,7 @@ static int wm2200_probe(struct snd_soc_codec *codec)

static int wm2200_set_fmt(struct snd_soc_dai *dai, unsigned int fmt) { - struct snd_soc_codec *codec = dai->codec; + struct snd_soc_component *component = dai->component; int lrclk, bclk, fmt_val;

lrclk = 0; @@ -1580,7 +1580,7 @@ static int wm2200_set_fmt(struct snd_soc_dai *dai, unsigned int fmt) fmt_val = 2; break; default: - dev_err(codec->dev, "Unsupported DAI format %d\n", + dev_err(component->dev, "Unsupported DAI format %d\n", fmt & SND_SOC_DAIFMT_FORMAT_MASK); return -EINVAL; } @@ -1599,7 +1599,7 @@ static int wm2200_set_fmt(struct snd_soc_dai *dai, unsigned int fmt) bclk |= WM2200_AIF1_BCLK_MSTR; break; default: - dev_err(codec->dev, "Unsupported master mode %d\n", + dev_err(component->dev, "Unsupported master mode %d\n", fmt & SND_SOC_DAIFMT_MASTER_MASK); return -EINVAL; } @@ -1621,15 +1621,15 @@ static int wm2200_set_fmt(struct snd_soc_dai *dai, unsigned int fmt) return -EINVAL; }

- snd_soc_update_bits(codec, WM2200_AUDIO_IF_1_1, WM2200_AIF1_BCLK_MSTR | + snd_soc_component_update_bits(component, WM2200_AUDIO_IF_1_1, WM2200_AIF1_BCLK_MSTR | WM2200_AIF1_BCLK_INV, bclk); - snd_soc_update_bits(codec, WM2200_AUDIO_IF_1_2, + snd_soc_component_update_bits(component, WM2200_AUDIO_IF_1_2, WM2200_AIF1TX_LRCLK_MSTR | WM2200_AIF1TX_LRCLK_INV, lrclk); - snd_soc_update_bits(codec, WM2200_AUDIO_IF_1_3, + snd_soc_component_update_bits(component, WM2200_AUDIO_IF_1_3, WM2200_AIF1TX_LRCLK_MSTR | WM2200_AIF1TX_LRCLK_INV, lrclk); - snd_soc_update_bits(codec, WM2200_AUDIO_IF_1_5, + snd_soc_component_update_bits(component, WM2200_AUDIO_IF_1_5, WM2200_AIF1_FMT_MASK, fmt_val);

return 0; @@ -1698,8 +1698,8 @@ static int wm2200_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params, struct snd_soc_dai *dai) { - struct snd_soc_codec *codec = dai->codec; - struct wm2200_priv *wm2200 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = dai->component; + struct wm2200_priv *wm2200 = snd_soc_component_get_drvdata(component); int i, bclk, lrclk, wl, fl, sr_code; int *bclk_rates;

@@ -1711,7 +1711,7 @@ static int wm2200_hw_params(struct snd_pcm_substream *substream, if (fl < 0) return fl;

- dev_dbg(codec->dev, "Word length %d bits, frame length %d bits\n", + dev_dbg(component->dev, "Word length %d bits, frame length %d bits\n", wl, fl);

/* Target BCLK rate */ @@ -1720,7 +1720,7 @@ static int wm2200_hw_params(struct snd_pcm_substream *substream, return bclk;

if (!wm2200->sysclk) { - dev_err(codec->dev, "SYSCLK has no rate set\n"); + dev_err(component->dev, "SYSCLK has no rate set\n"); return -EINVAL; }

@@ -1728,13 +1728,13 @@ static int wm2200_hw_params(struct snd_pcm_substream *substream, if (wm2200_sr_code[i] == params_rate(params)) break; if (i == ARRAY_SIZE(wm2200_sr_code)) { - dev_err(codec->dev, "Unsupported sample rate: %dHz\n", + dev_err(component->dev, "Unsupported sample rate: %dHz\n", params_rate(params)); return -EINVAL; } sr_code = i;

- dev_dbg(codec->dev, "Target BCLK is %dHz, using %dHz SYSCLK\n", + dev_dbg(component->dev, "Target BCLK is %dHz, using %dHz SYSCLK\n", bclk, wm2200->sysclk);

if (wm2200->sysclk % 4000) @@ -1746,38 +1746,38 @@ static int wm2200_hw_params(struct snd_pcm_substream *substream, if (bclk_rates[i] >= bclk && (bclk_rates[i] % bclk == 0)) break; if (i == WM2200_NUM_BCLK_RATES) { - dev_err(codec->dev, + dev_err(component->dev, "No valid BCLK for %dHz found from %dHz SYSCLK\n", bclk, wm2200->sysclk); return -EINVAL; }

bclk = i; - dev_dbg(codec->dev, "Setting %dHz BCLK\n", bclk_rates[bclk]); - snd_soc_update_bits(codec, WM2200_AUDIO_IF_1_1, + dev_dbg(component->dev, "Setting %dHz BCLK\n", bclk_rates[bclk]); + snd_soc_component_update_bits(component, WM2200_AUDIO_IF_1_1, WM2200_AIF1_BCLK_DIV_MASK, bclk);

lrclk = bclk_rates[bclk] / params_rate(params); - dev_dbg(codec->dev, "Setting %dHz LRCLK\n", bclk_rates[bclk] / lrclk); + dev_dbg(component->dev, "Setting %dHz LRCLK\n", bclk_rates[bclk] / lrclk); if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK || wm2200->symmetric_rates) - snd_soc_update_bits(codec, WM2200_AUDIO_IF_1_7, + snd_soc_component_update_bits(component, WM2200_AUDIO_IF_1_7, WM2200_AIF1RX_BCPF_MASK, lrclk); else - snd_soc_update_bits(codec, WM2200_AUDIO_IF_1_6, + snd_soc_component_update_bits(component, WM2200_AUDIO_IF_1_6, WM2200_AIF1TX_BCPF_MASK, lrclk);

i = (wl << WM2200_AIF1TX_WL_SHIFT) | wl; if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) - snd_soc_update_bits(codec, WM2200_AUDIO_IF_1_9, + snd_soc_component_update_bits(component, WM2200_AUDIO_IF_1_9, WM2200_AIF1RX_WL_MASK | WM2200_AIF1RX_SLOT_LEN_MASK, i); else - snd_soc_update_bits(codec, WM2200_AUDIO_IF_1_8, + snd_soc_component_update_bits(component, WM2200_AUDIO_IF_1_8, WM2200_AIF1TX_WL_MASK | WM2200_AIF1TX_SLOT_LEN_MASK, i);

- snd_soc_update_bits(codec, WM2200_CLOCKING_4, + snd_soc_component_update_bits(component, WM2200_CLOCKING_4, WM2200_SAMPLE_RATE_1_MASK, sr_code);

return 0; @@ -1788,10 +1788,10 @@ static int wm2200_hw_params(struct snd_pcm_substream *substream, .hw_params = wm2200_hw_params, };

-static int wm2200_set_sysclk(struct snd_soc_codec *codec, int clk_id, +static int wm2200_set_sysclk(struct snd_soc_component *component, int clk_id, int source, unsigned int freq, int dir) { - struct wm2200_priv *wm2200 = snd_soc_codec_get_drvdata(codec); + struct wm2200_priv *wm2200 = snd_soc_component_get_drvdata(component); int fval;

switch (clk_id) { @@ -1799,7 +1799,7 @@ static int wm2200_set_sysclk(struct snd_soc_codec *codec, int clk_id, break;

default: - dev_err(codec->dev, "Unknown clock %d\n", clk_id); + dev_err(component->dev, "Unknown clock %d\n", clk_id); return -EINVAL; }

@@ -1810,7 +1810,7 @@ static int wm2200_set_sysclk(struct snd_soc_codec *codec, int clk_id, case WM2200_CLKSRC_BCLK1: break; default: - dev_err(codec->dev, "Invalid source %d\n", source); + dev_err(component->dev, "Invalid source %d\n", source); return -EINVAL; }

@@ -1820,7 +1820,7 @@ static int wm2200_set_sysclk(struct snd_soc_codec *codec, int clk_id, fval = 2; break; default: - dev_err(codec->dev, "Invalid clock rate: %d\n", freq); + dev_err(component->dev, "Invalid clock rate: %d\n", freq); return -EINVAL; }

@@ -1828,7 +1828,7 @@ static int wm2200_set_sysclk(struct snd_soc_codec *codec, int clk_id, * match. */

- snd_soc_update_bits(codec, WM2200_CLOCKING_3, WM2200_SYSCLK_FREQ_MASK | + snd_soc_component_update_bits(component, WM2200_CLOCKING_3, WM2200_SYSCLK_FREQ_MASK | WM2200_SYSCLK_SRC_MASK, fval << WM2200_SYSCLK_FREQ_SHIFT | source);

@@ -1936,23 +1936,23 @@ static int fll_factors(struct _fll_div *fll_div, unsigned int Fref, return 0; }

-static int wm2200_set_fll(struct snd_soc_codec *codec, int fll_id, int source, +static int wm2200_set_fll(struct snd_soc_component *component, int fll_id, int source, unsigned int Fref, unsigned int Fout) { - struct i2c_client *i2c = to_i2c_client(codec->dev); - struct wm2200_priv *wm2200 = snd_soc_codec_get_drvdata(codec); + struct i2c_client *i2c = to_i2c_client(component->dev); + struct wm2200_priv *wm2200 = snd_soc_component_get_drvdata(component); struct _fll_div factors; int ret, i, timeout; unsigned long time_left;

if (!Fout) { - dev_dbg(codec->dev, "FLL disabled"); + dev_dbg(component->dev, "FLL disabled");

if (wm2200->fll_fout) - pm_runtime_put(codec->dev); + pm_runtime_put(component->dev);

wm2200->fll_fout = 0; - snd_soc_update_bits(codec, WM2200_FLL_CONTROL_1, + snd_soc_component_update_bits(component, WM2200_FLL_CONTROL_1, WM2200_FLL_ENA, 0); return 0; } @@ -1963,7 +1963,7 @@ static int wm2200_set_fll(struct snd_soc_codec *codec, int fll_id, int source, case WM2200_FLL_SRC_BCLK: break; default: - dev_err(codec->dev, "Invalid FLL source %d\n", source); + dev_err(component->dev, "Invalid FLL source %d\n", source); return -EINVAL; }

@@ -1972,44 +1972,44 @@ static int wm2200_set_fll(struct snd_soc_codec *codec, int fll_id, int source, return ret;

/* Disable the FLL while we reconfigure */ - snd_soc_update_bits(codec, WM2200_FLL_CONTROL_1, WM2200_FLL_ENA, 0); + snd_soc_component_update_bits(component, WM2200_FLL_CONTROL_1, WM2200_FLL_ENA, 0);

- snd_soc_update_bits(codec, WM2200_FLL_CONTROL_2, + snd_soc_component_update_bits(component, WM2200_FLL_CONTROL_2, WM2200_FLL_OUTDIV_MASK | WM2200_FLL_FRATIO_MASK, (factors.fll_outdiv << WM2200_FLL_OUTDIV_SHIFT) | factors.fll_fratio); if (factors.theta) { - snd_soc_update_bits(codec, WM2200_FLL_CONTROL_3, + snd_soc_component_update_bits(component, WM2200_FLL_CONTROL_3, WM2200_FLL_FRACN_ENA, WM2200_FLL_FRACN_ENA); - snd_soc_update_bits(codec, WM2200_FLL_EFS_2, + snd_soc_component_update_bits(component, WM2200_FLL_EFS_2, WM2200_FLL_EFS_ENA, WM2200_FLL_EFS_ENA); } else { - snd_soc_update_bits(codec, WM2200_FLL_CONTROL_3, + snd_soc_component_update_bits(component, WM2200_FLL_CONTROL_3, WM2200_FLL_FRACN_ENA, 0); - snd_soc_update_bits(codec, WM2200_FLL_EFS_2, + snd_soc_component_update_bits(component, WM2200_FLL_EFS_2, WM2200_FLL_EFS_ENA, 0); }

- snd_soc_update_bits(codec, WM2200_FLL_CONTROL_4, WM2200_FLL_THETA_MASK, + snd_soc_component_update_bits(component, WM2200_FLL_CONTROL_4, WM2200_FLL_THETA_MASK, factors.theta); - snd_soc_update_bits(codec, WM2200_FLL_CONTROL_6, WM2200_FLL_N_MASK, + snd_soc_component_update_bits(component, WM2200_FLL_CONTROL_6, WM2200_FLL_N_MASK, factors.n); - snd_soc_update_bits(codec, WM2200_FLL_CONTROL_7, + snd_soc_component_update_bits(component, WM2200_FLL_CONTROL_7, WM2200_FLL_CLK_REF_DIV_MASK | WM2200_FLL_CLK_REF_SRC_MASK, (factors.fll_refclk_div << WM2200_FLL_CLK_REF_DIV_SHIFT) | source); - snd_soc_update_bits(codec, WM2200_FLL_EFS_1, + snd_soc_component_update_bits(component, WM2200_FLL_EFS_1, WM2200_FLL_LAMBDA_MASK, factors.lambda);

/* Clear any pending completions */ try_wait_for_completion(&wm2200->fll_lock);

- pm_runtime_get_sync(codec->dev); + pm_runtime_get_sync(component->dev);

- snd_soc_update_bits(codec, WM2200_FLL_CONTROL_1, + snd_soc_component_update_bits(component, WM2200_FLL_CONTROL_1, WM2200_FLL_ENA, WM2200_FLL_ENA);

if (i2c->irq) @@ -2017,7 +2017,7 @@ static int wm2200_set_fll(struct snd_soc_codec *codec, int fll_id, int source, else timeout = 50;

- snd_soc_update_bits(codec, WM2200_CLOCKING_3, WM2200_SYSCLK_ENA, + snd_soc_component_update_bits(component, WM2200_CLOCKING_3, WM2200_SYSCLK_ENA, WM2200_SYSCLK_ENA);

/* Poll for the lock; will use the interrupt to exit quickly */ @@ -2032,10 +2032,10 @@ static int wm2200_set_fll(struct snd_soc_codec *codec, int fll_id, int source, msleep(1); }

- ret = snd_soc_read(codec, + ret = snd_soc_component_read32(component, WM2200_INTERRUPT_RAW_STATUS_2); if (ret < 0) { - dev_err(codec->dev, + dev_err(component->dev, "Failed to read FLL status: %d\n", ret); continue; @@ -2044,8 +2044,8 @@ static int wm2200_set_fll(struct snd_soc_codec *codec, int fll_id, int source, break; } if (i == timeout) { - dev_err(codec->dev, "FLL lock timed out\n"); - pm_runtime_put(codec->dev); + dev_err(component->dev, "FLL lock timed out\n"); + pm_runtime_put(component->dev); return -ETIMEDOUT; }

@@ -2053,29 +2053,29 @@ static int wm2200_set_fll(struct snd_soc_codec *codec, int fll_id, int source, wm2200->fll_fref = Fref; wm2200->fll_fout = Fout;

- dev_dbg(codec->dev, "FLL running %dHz->%dHz\n", Fref, Fout); + dev_dbg(component->dev, "FLL running %dHz->%dHz\n", Fref, Fout);

return 0; }

static int wm2200_dai_probe(struct snd_soc_dai *dai) { - struct snd_soc_codec *codec = dai->codec; - struct wm2200_priv *wm2200 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = dai->component; + struct wm2200_priv *wm2200 = snd_soc_component_get_drvdata(component); unsigned int val = 0; int ret;

- ret = snd_soc_read(codec, WM2200_GPIO_CTRL_1); + ret = snd_soc_component_read32(component, WM2200_GPIO_CTRL_1); if (ret >= 0) { if ((ret & WM2200_GP1_FN_MASK) != 0) { wm2200->symmetric_rates = true; val = WM2200_AIF1TX_LRCLK_SRC; } } else { - dev_err(codec->dev, "Failed to read GPIO 1 config: %d\n", ret); + dev_err(component->dev, "Failed to read GPIO 1 config: %d\n", ret); }

- snd_soc_update_bits(codec, WM2200_AUDIO_IF_1_2, + snd_soc_component_update_bits(component, WM2200_AUDIO_IF_1_2, WM2200_AIF1TX_LRCLK_SRC, val);

return 0; @@ -2106,22 +2106,18 @@ static int wm2200_dai_probe(struct snd_soc_dai *dai) .ops = &wm2200_dai_ops, };

-static const struct snd_soc_codec_driver soc_codec_wm2200 = { - .probe = wm2200_probe, - - .idle_bias_off = true, - .ignore_pmdown_time = true, - .set_sysclk = wm2200_set_sysclk, - .set_pll = wm2200_set_fll, - - .component_driver = { - .controls = wm2200_snd_controls, - .num_controls = ARRAY_SIZE(wm2200_snd_controls), - .dapm_widgets = wm2200_dapm_widgets, - .num_dapm_widgets = ARRAY_SIZE(wm2200_dapm_widgets), - .dapm_routes = wm2200_dapm_routes, - .num_dapm_routes = ARRAY_SIZE(wm2200_dapm_routes), - }, +static const struct snd_soc_component_driver soc_component_wm2200 = { + .probe = wm2200_probe, + .set_sysclk = wm2200_set_sysclk, + .set_pll = wm2200_set_fll, + .controls = wm2200_snd_controls, + .num_controls = ARRAY_SIZE(wm2200_snd_controls), + .dapm_widgets = wm2200_dapm_widgets, + .num_dapm_widgets = ARRAY_SIZE(wm2200_dapm_widgets), + .dapm_routes = wm2200_dapm_routes, + .num_dapm_routes = ARRAY_SIZE(wm2200_dapm_routes), + .endianness = 1, + .non_legacy_dai_naming = 1, };

static irqreturn_t wm2200_irq(int irq, void *data) @@ -2408,7 +2404,7 @@ static int wm2200_i2c_probe(struct i2c_client *i2c, pm_runtime_enable(&i2c->dev); pm_request_idle(&i2c->dev);

- ret = snd_soc_register_codec(&i2c->dev, &soc_codec_wm2200, + ret = devm_snd_soc_register_component(&i2c->dev, &soc_component_wm2200, &wm2200_dai, 1); if (ret != 0) { dev_err(&i2c->dev, "Failed to register CODEC: %d\n", ret); @@ -2435,7 +2431,6 @@ static int wm2200_i2c_remove(struct i2c_client *i2c) { struct wm2200_priv *wm2200 = i2c_get_clientdata(i2c);

- snd_soc_unregister_codec(&i2c->dev); if (i2c->irq) free_irq(i2c->irq, wm2200); if (wm2200->pdata.reset)

From: Kuninori Morimoto kuninori.morimoto.gx@renesas.com

Now we can replace Codec to Component. Let's do it.

Note: xxx_codec_xxx() -> xxx_component_xxx() .idle_bias_off = 0 -> .idle_bias_on = 1 .ignore_pmdown_time = 0 -> .pmdown_time = 1 - -> .endianness = 1 - -> .non_legacy_dai_naming = 1

Signed-off-by: Kuninori Morimoto kuninori.morimoto.gx@renesas.com --- sound/soc/codecs/wm8350.c | 183 ++++++++++++++++++++++----------------------- sound/soc/codecs/wm8350.h | 4 +- sound/soc/fsl/wm1133-ev1.c | 6 +- 3 files changed, 93 insertions(+), 100 deletions(-)

diff --git a/sound/soc/codecs/wm8350.c b/sound/soc/codecs/wm8350.c index fc79c67..6b3b768 100644 --- a/sound/soc/codecs/wm8350.c +++ b/sound/soc/codecs/wm8350.c @@ -256,8 +256,8 @@ static void wm8350_pga_work(struct work_struct *work) static int pga_event(struct snd_soc_dapm_widget *w, struct snd_kcontrol *kcontrol, int event) { - struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm); - struct wm8350_data *wm8350_data = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm); + struct wm8350_data *wm8350_data = snd_soc_component_get_drvdata(component); struct wm8350_output *out;

switch (w->shift) { @@ -299,8 +299,8 @@ static int pga_event(struct snd_soc_dapm_widget *w, static int wm8350_put_volsw_2r_vu(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { - struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol); - struct wm8350_data *wm8350_priv = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol); + struct wm8350_data *wm8350_priv = snd_soc_component_get_drvdata(component); struct wm8350_output *out = NULL; struct soc_mixer_control *mc = (struct soc_mixer_control *)kcontrol->private_value; @@ -334,16 +334,16 @@ static int wm8350_put_volsw_2r_vu(struct snd_kcontrol *kcontrol, return ret;

/* now hit the volume update bits (always bit 8) */ - val = snd_soc_read(codec, reg); - snd_soc_write(codec, reg, val | WM8350_OUT1_VU); + val = snd_soc_component_read32(component, reg); + snd_soc_component_write(component, reg, val | WM8350_OUT1_VU); return 1; }

static int wm8350_get_volsw_2r(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { - struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol); - struct wm8350_data *wm8350_priv = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol); + struct wm8350_data *wm8350_priv = snd_soc_component_get_drvdata(component); struct wm8350_output *out1 = &wm8350_priv->out1; struct wm8350_output *out2 = &wm8350_priv->out2; struct soc_mixer_control *mc = @@ -753,8 +753,8 @@ static const DECLARE_TLV_DB_RANGE(capture_sd_tlv, static int wm8350_set_dai_sysclk(struct snd_soc_dai *codec_dai, int clk_id, unsigned int freq, int dir) { - struct snd_soc_codec *codec = codec_dai->codec; - struct wm8350_data *wm8350_data = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = codec_dai->component; + struct wm8350_data *wm8350_data = snd_soc_component_get_drvdata(component); struct wm8350 *wm8350 = wm8350_data->wm8350; u16 fll_4;

@@ -769,9 +769,9 @@ static int wm8350_set_dai_sysclk(struct snd_soc_dai *codec_dai, case WM8350_MCLK_SEL_PLL_32K: wm8350_set_bits(wm8350, WM8350_CLOCK_CONTROL_1, WM8350_MCLK_SEL); - fll_4 = snd_soc_read(codec, WM8350_FLL_CONTROL_4) & + fll_4 = snd_soc_component_read32(component, WM8350_FLL_CONTROL_4) & ~WM8350_FLL_CLK_SRC_MASK; - snd_soc_write(codec, WM8350_FLL_CONTROL_4, fll_4 | clk_id); + snd_soc_component_write(component, WM8350_FLL_CONTROL_4, fll_4 | clk_id); break; }

@@ -788,44 +788,44 @@ static int wm8350_set_dai_sysclk(struct snd_soc_dai *codec_dai,

static int wm8350_set_clkdiv(struct snd_soc_dai *codec_dai, int div_id, int div) { - struct snd_soc_codec *codec = codec_dai->codec; + struct snd_soc_component *component = codec_dai->component; u16 val;

switch (div_id) { case WM8350_ADC_CLKDIV: - val = snd_soc_read(codec, WM8350_ADC_DIVIDER) & + val = snd_soc_component_read32(component, WM8350_ADC_DIVIDER) & ~WM8350_ADC_CLKDIV_MASK; - snd_soc_write(codec, WM8350_ADC_DIVIDER, val | div); + snd_soc_component_write(component, WM8350_ADC_DIVIDER, val | div); break; case WM8350_DAC_CLKDIV: - val = snd_soc_read(codec, WM8350_DAC_CLOCK_CONTROL) & + val = snd_soc_component_read32(component, WM8350_DAC_CLOCK_CONTROL) & ~WM8350_DAC_CLKDIV_MASK; - snd_soc_write(codec, WM8350_DAC_CLOCK_CONTROL, val | div); + snd_soc_component_write(component, WM8350_DAC_CLOCK_CONTROL, val | div); break; case WM8350_BCLK_CLKDIV: - val = snd_soc_read(codec, WM8350_CLOCK_CONTROL_1) & + val = snd_soc_component_read32(component, WM8350_CLOCK_CONTROL_1) & ~WM8350_BCLK_DIV_MASK; - snd_soc_write(codec, WM8350_CLOCK_CONTROL_1, val | div); + snd_soc_component_write(component, WM8350_CLOCK_CONTROL_1, val | div); break; case WM8350_OPCLK_CLKDIV: - val = snd_soc_read(codec, WM8350_CLOCK_CONTROL_1) & + val = snd_soc_component_read32(component, WM8350_CLOCK_CONTROL_1) & ~WM8350_OPCLK_DIV_MASK; - snd_soc_write(codec, WM8350_CLOCK_CONTROL_1, val | div); + snd_soc_component_write(component, WM8350_CLOCK_CONTROL_1, val | div); break; case WM8350_SYS_CLKDIV: - val = snd_soc_read(codec, WM8350_CLOCK_CONTROL_1) & + val = snd_soc_component_read32(component, WM8350_CLOCK_CONTROL_1) & ~WM8350_MCLK_DIV_MASK; - snd_soc_write(codec, WM8350_CLOCK_CONTROL_1, val | div); + snd_soc_component_write(component, WM8350_CLOCK_CONTROL_1, val | div); break; case WM8350_DACLR_CLKDIV: - val = snd_soc_read(codec, WM8350_DAC_LR_RATE) & + val = snd_soc_component_read32(component, WM8350_DAC_LR_RATE) & ~WM8350_DACLRC_RATE_MASK; - snd_soc_write(codec, WM8350_DAC_LR_RATE, val | div); + snd_soc_component_write(component, WM8350_DAC_LR_RATE, val | div); break; case WM8350_ADCLR_CLKDIV: - val = snd_soc_read(codec, WM8350_ADC_LR_RATE) & + val = snd_soc_component_read32(component, WM8350_ADC_LR_RATE) & ~WM8350_ADCLRC_RATE_MASK; - snd_soc_write(codec, WM8350_ADC_LR_RATE, val | div); + snd_soc_component_write(component, WM8350_ADC_LR_RATE, val | div); break; default: return -EINVAL; @@ -836,14 +836,14 @@ static int wm8350_set_clkdiv(struct snd_soc_dai *codec_dai, int div_id, int div)

static int wm8350_set_dai_fmt(struct snd_soc_dai *codec_dai, unsigned int fmt) { - struct snd_soc_codec *codec = codec_dai->codec; - u16 iface = snd_soc_read(codec, WM8350_AI_FORMATING) & + struct snd_soc_component *component = codec_dai->component; + u16 iface = snd_soc_component_read32(component, WM8350_AI_FORMATING) & ~(WM8350_AIF_BCLK_INV | WM8350_AIF_LRCLK_INV | WM8350_AIF_FMT_MASK); - u16 master = snd_soc_read(codec, WM8350_AI_DAC_CONTROL) & + u16 master = snd_soc_component_read32(component, WM8350_AI_DAC_CONTROL) & ~WM8350_BCLK_MSTR; - u16 dac_lrc = snd_soc_read(codec, WM8350_DAC_LR_RATE) & + u16 dac_lrc = snd_soc_component_read32(component, WM8350_DAC_LR_RATE) & ~WM8350_DACLRC_ENA; - u16 adc_lrc = snd_soc_read(codec, WM8350_ADC_LR_RATE) & + u16 adc_lrc = snd_soc_component_read32(component, WM8350_ADC_LR_RATE) & ~WM8350_ADCLRC_ENA;

/* set master/slave audio interface */ @@ -896,10 +896,10 @@ static int wm8350_set_dai_fmt(struct snd_soc_dai *codec_dai, unsigned int fmt) return -EINVAL; }

- snd_soc_write(codec, WM8350_AI_FORMATING, iface); - snd_soc_write(codec, WM8350_AI_DAC_CONTROL, master); - snd_soc_write(codec, WM8350_DAC_LR_RATE, dac_lrc); - snd_soc_write(codec, WM8350_ADC_LR_RATE, adc_lrc); + snd_soc_component_write(component, WM8350_AI_FORMATING, iface); + snd_soc_component_write(component, WM8350_AI_DAC_CONTROL, master); + snd_soc_component_write(component, WM8350_DAC_LR_RATE, dac_lrc); + snd_soc_component_write(component, WM8350_ADC_LR_RATE, adc_lrc); return 0; }

@@ -907,10 +907,10 @@ static int wm8350_pcm_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params, struct snd_soc_dai *codec_dai) { - struct snd_soc_codec *codec = codec_dai->codec; - struct wm8350_data *wm8350_data = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = codec_dai->component; + struct wm8350_data *wm8350_data = snd_soc_component_get_drvdata(component); struct wm8350 *wm8350 = wm8350_data->wm8350; - u16 iface = snd_soc_read(codec, WM8350_AI_FORMATING) & + u16 iface = snd_soc_component_read32(component, WM8350_AI_FORMATING) & ~WM8350_AIF_WL_MASK;

/* bit size */ @@ -928,7 +928,7 @@ static int wm8350_pcm_hw_params(struct snd_pcm_substream *substream, break; }

- snd_soc_write(codec, WM8350_AI_FORMATING, iface); + snd_soc_component_write(component, WM8350_AI_FORMATING, iface);

/* The sloping stopband filter is recommended for use with * lower sample rates to improve performance. @@ -947,7 +947,7 @@ static int wm8350_pcm_hw_params(struct snd_pcm_substream *substream,

static int wm8350_mute(struct snd_soc_dai *dai, int mute) { - struct snd_soc_codec *codec = dai->codec; + struct snd_soc_component *component = dai->component; unsigned int val;

if (mute) @@ -955,7 +955,7 @@ static int wm8350_mute(struct snd_soc_dai *dai, int mute) else val = 0;

- snd_soc_update_bits(codec, WM8350_DAC_MUTE, WM8350_DAC_MUTE_ENA, val); + snd_soc_component_update_bits(component, WM8350_DAC_MUTE, WM8350_DAC_MUTE_ENA, val);

return 0; } @@ -1024,8 +1024,8 @@ static int wm8350_set_fll(struct snd_soc_dai *codec_dai, int pll_id, int source, unsigned int freq_in, unsigned int freq_out) { - struct snd_soc_codec *codec = codec_dai->codec; - struct wm8350_data *priv = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = codec_dai->component; + struct wm8350_data *priv = snd_soc_component_get_drvdata(component); struct wm8350 *wm8350 = priv->wm8350; struct _fll_div fll_div; int ret = 0; @@ -1050,17 +1050,17 @@ static int wm8350_set_fll(struct snd_soc_dai *codec_dai, fll_div.ratio);

/* set up N.K & dividers */ - fll_1 = snd_soc_read(codec, WM8350_FLL_CONTROL_1) & + fll_1 = snd_soc_component_read32(component, WM8350_FLL_CONTROL_1) & ~(WM8350_FLL_OUTDIV_MASK | WM8350_FLL_RSP_RATE_MASK | 0xc000); - snd_soc_write(codec, WM8350_FLL_CONTROL_1, + snd_soc_component_write(component, WM8350_FLL_CONTROL_1, fll_1 | (fll_div.div << 8) | 0x50); - snd_soc_write(codec, WM8350_FLL_CONTROL_2, + snd_soc_component_write(component, WM8350_FLL_CONTROL_2, (fll_div.ratio << 11) | (fll_div. n & WM8350_FLL_N_MASK)); - snd_soc_write(codec, WM8350_FLL_CONTROL_3, fll_div.k); - fll_4 = snd_soc_read(codec, WM8350_FLL_CONTROL_4) & + snd_soc_component_write(component, WM8350_FLL_CONTROL_3, fll_div.k); + fll_4 = snd_soc_component_read32(component, WM8350_FLL_CONTROL_4) & ~(WM8350_FLL_FRAC | WM8350_FLL_SLOW_LOCK_REF); - snd_soc_write(codec, WM8350_FLL_CONTROL_4, + snd_soc_component_write(component, WM8350_FLL_CONTROL_4, fll_4 | (fll_div.k ? WM8350_FLL_FRAC : 0) | (fll_div.ratio == 8 ? WM8350_FLL_SLOW_LOCK_REF : 0));

@@ -1074,10 +1074,10 @@ static int wm8350_set_fll(struct snd_soc_dai *codec_dai, return 0; }

-static int wm8350_set_bias_level(struct snd_soc_codec *codec, +static int wm8350_set_bias_level(struct snd_soc_component *component, enum snd_soc_bias_level level) { - struct wm8350_data *priv = snd_soc_codec_get_drvdata(codec); + struct wm8350_data *priv = snd_soc_component_get_drvdata(component); struct wm8350 *wm8350 = priv->wm8350; struct wm8350_audio_platform_data *platform = wm8350->codec.platform_data; @@ -1101,7 +1101,7 @@ static int wm8350_set_bias_level(struct snd_soc_codec *codec, break;

case SND_SOC_BIAS_STANDBY: - if (snd_soc_codec_get_bias_level(codec) == SND_SOC_BIAS_OFF) { + if (snd_soc_component_get_bias_level(component) == SND_SOC_BIAS_OFF) { ret = regulator_bulk_enable(ARRAY_SIZE(priv->supplies), priv->supplies); if (ret != 0) @@ -1310,7 +1310,7 @@ static irqreturn_t wm8350_hpr_jack_handler(int irq, void *data) /** * wm8350_hp_jack_detect - Enable headphone jack detection. * - * @codec: WM8350 codec + * @component: WM8350 component * @which: left or right jack detect signal * @jack: jack to report detection events on * @report: value to report @@ -1318,10 +1318,10 @@ static irqreturn_t wm8350_hpr_jack_handler(int irq, void *data) * Enables the headphone jack detection of the WM8350. If no report * is specified then detection is disabled. */ -int wm8350_hp_jack_detect(struct snd_soc_codec *codec, enum wm8350_jack which, +int wm8350_hp_jack_detect(struct snd_soc_component *component, enum wm8350_jack which, struct snd_soc_jack *jack, int report) { - struct wm8350_data *priv = snd_soc_codec_get_drvdata(codec); + struct wm8350_data *priv = snd_soc_component_get_drvdata(component); struct wm8350 *wm8350 = priv->wm8350; int ena;

@@ -1389,7 +1389,7 @@ static irqreturn_t wm8350_mic_handler(int irq, void *data) /** * wm8350_mic_jack_detect - Enable microphone jack detection. * - * @codec: WM8350 codec + * @component: WM8350 component * @jack: jack to report detection events on * @detect_report: value to report when presence detected * @short_report: value to report when microphone short detected @@ -1397,11 +1397,11 @@ static irqreturn_t wm8350_mic_handler(int irq, void *data) * Enables the microphone jack detection of the WM8350. If both reports * are specified as zero then detection is disabled. */ -int wm8350_mic_jack_detect(struct snd_soc_codec *codec, +int wm8350_mic_jack_detect(struct snd_soc_component *component, struct snd_soc_jack *jack, int detect_report, int short_report) { - struct wm8350_data *priv = snd_soc_codec_get_drvdata(codec); + struct wm8350_data *priv = snd_soc_component_get_drvdata(component); struct wm8350 *wm8350 = priv->wm8350;

priv->mic.jack = jack; @@ -1455,26 +1455,26 @@ int wm8350_mic_jack_detect(struct snd_soc_codec *codec, .ops = &wm8350_dai_ops, };

-static int wm8350_codec_probe(struct snd_soc_codec *codec) +static int wm8350_component_probe(struct snd_soc_component *component) { - struct wm8350 *wm8350 = dev_get_platdata(codec->dev); + struct wm8350 *wm8350 = dev_get_platdata(component->dev); struct wm8350_data *priv; struct wm8350_output *out1; struct wm8350_output *out2; int ret, i;

if (wm8350->codec.platform_data == NULL) { - dev_err(codec->dev, "No audio platform data supplied\n"); + dev_err(component->dev, "No audio platform data supplied\n"); return -EINVAL; }

- priv = devm_kzalloc(codec->dev, sizeof(struct wm8350_data), + priv = devm_kzalloc(component->dev, sizeof(struct wm8350_data), GFP_KERNEL); if (priv == NULL) return -ENOMEM;

- snd_soc_codec_init_regmap(codec, wm8350->regmap); - snd_soc_codec_set_drvdata(codec, priv); + snd_soc_component_init_regmap(component, wm8350->regmap); + snd_soc_component_set_drvdata(component, priv);

priv->wm8350 = wm8350;

@@ -1497,9 +1497,9 @@ static int wm8350_codec_probe(struct snd_soc_codec *codec) wm8350_set_bits(wm8350, WM8350_POWER_MGMT_5, WM8350_CODEC_ENA);

/* Enable robust clocking mode in ADC */ - snd_soc_write(codec, WM8350_SECURITY, 0xa7); - snd_soc_write(codec, 0xde, 0x13); - snd_soc_write(codec, WM8350_SECURITY, 0); + snd_soc_component_write(component, WM8350_SECURITY, 0xa7); + snd_soc_component_write(component, 0xde, 0x13); + snd_soc_component_write(component, WM8350_SECURITY, 0);

/* read OUT1 & OUT2 volumes */ out1 = &priv->out1; @@ -1552,10 +1552,10 @@ static int wm8350_codec_probe(struct snd_soc_codec *codec) return 0; }

-static int wm8350_codec_remove(struct snd_soc_codec *codec) +static void wm8350_component_remove(struct snd_soc_component *component) { - struct wm8350_data *priv = snd_soc_codec_get_drvdata(codec); - struct wm8350 *wm8350 = dev_get_platdata(codec->dev); + struct wm8350_data *priv = snd_soc_component_get_drvdata(component); + struct wm8350 *wm8350 = dev_get_platdata(component->dev);

wm8350_clear_bits(wm8350, WM8350_JACK_DETECT, WM8350_JDL_ENA | WM8350_JDR_ENA); @@ -1578,44 +1578,37 @@ static int wm8350_codec_remove(struct snd_soc_codec *codec) flush_delayed_work(&priv->pga_work);

wm8350_clear_bits(wm8350, WM8350_POWER_MGMT_5, WM8350_CODEC_ENA); - - return 0; }

-static const struct snd_soc_codec_driver soc_codec_dev_wm8350 = { - .probe = wm8350_codec_probe, - .remove = wm8350_codec_remove, - .set_bias_level = wm8350_set_bias_level, - .suspend_bias_off = true, - - .component_driver = { - .controls = wm8350_snd_controls, - .num_controls = ARRAY_SIZE(wm8350_snd_controls), - .dapm_widgets = wm8350_dapm_widgets, - .num_dapm_widgets = ARRAY_SIZE(wm8350_dapm_widgets), - .dapm_routes = wm8350_dapm_routes, - .num_dapm_routes = ARRAY_SIZE(wm8350_dapm_routes), - }, +static const struct snd_soc_component_driver soc_component_dev_wm8350 = { + .probe = wm8350_component_probe, + .remove = wm8350_component_remove, + .set_bias_level = wm8350_set_bias_level, + .controls = wm8350_snd_controls, + .num_controls = ARRAY_SIZE(wm8350_snd_controls), + .dapm_widgets = wm8350_dapm_widgets, + .num_dapm_widgets = ARRAY_SIZE(wm8350_dapm_widgets), + .dapm_routes = wm8350_dapm_routes, + .num_dapm_routes = ARRAY_SIZE(wm8350_dapm_routes), + .suspend_bias_off = 1, + .idle_bias_on = 1, + .pmdown_time = 1, + .endianness = 1, + .non_legacy_dai_naming = 1, };

static int wm8350_probe(struct platform_device *pdev) { - return snd_soc_register_codec(&pdev->dev, &soc_codec_dev_wm8350, + return devm_snd_soc_register_component(&pdev->dev, + &soc_component_dev_wm8350, &wm8350_dai, 1); }

-static int wm8350_remove(struct platform_device *pdev) -{ - snd_soc_unregister_codec(&pdev->dev); - return 0; -} - static struct platform_driver wm8350_codec_driver = { .driver = { .name = "wm8350-codec", }, .probe = wm8350_probe, - .remove = wm8350_remove, };

module_platform_driver(wm8350_codec_driver); diff --git a/sound/soc/codecs/wm8350.h b/sound/soc/codecs/wm8350.h index 74108eb..1191326 100644 --- a/sound/soc/codecs/wm8350.h +++ b/sound/soc/codecs/wm8350.h @@ -20,9 +20,9 @@ enum wm8350_jack { WM8350_JDR = 2, };

-int wm8350_hp_jack_detect(struct snd_soc_codec *codec, enum wm8350_jack which, +int wm8350_hp_jack_detect(struct snd_soc_component *component, enum wm8350_jack which, struct snd_soc_jack *jack, int report); -int wm8350_mic_jack_detect(struct snd_soc_codec *codec, +int wm8350_mic_jack_detect(struct snd_soc_component *component, struct snd_soc_jack *jack, int detect_report, int short_report);

diff --git a/sound/soc/fsl/wm1133-ev1.c b/sound/soc/fsl/wm1133-ev1.c index cdaf163..2f80b21 100644 --- a/sound/soc/fsl/wm1133-ev1.c +++ b/sound/soc/fsl/wm1133-ev1.c @@ -201,18 +201,18 @@ static int wm1133_ev1_hw_params(struct snd_pcm_substream *substream,

static int wm1133_ev1_init(struct snd_soc_pcm_runtime *rtd) { - struct snd_soc_codec *codec = rtd->codec; + struct snd_soc_component *component = rtd->codec_dai->component;

/* Headphone jack detection */ snd_soc_card_jack_new(rtd->card, "Headphone", SND_JACK_HEADPHONE, &hp_jack, hp_jack_pins, ARRAY_SIZE(hp_jack_pins)); - wm8350_hp_jack_detect(codec, WM8350_JDR, &hp_jack, SND_JACK_HEADPHONE); + wm8350_hp_jack_detect(component, WM8350_JDR, &hp_jack, SND_JACK_HEADPHONE);

/* Microphone jack detection */ snd_soc_card_jack_new(rtd->card, "Microphone", SND_JACK_MICROPHONE | SND_JACK_BTN_0, &mic_jack, mic_jack_pins, ARRAY_SIZE(mic_jack_pins)); - wm8350_mic_jack_detect(codec, &mic_jack, SND_JACK_MICROPHONE, + wm8350_mic_jack_detect(component, &mic_jack, SND_JACK_MICROPHONE, SND_JACK_BTN_0);

snd_soc_dapm_force_enable_pin(&rtd->card->dapm, "Mic Bias");

From: Kuninori Morimoto kuninori.morimoto.gx@renesas.com

Now we can replace Codec to Component. Let's do it.

Note: xxx_codec_xxx() -> xxx_component_xxx() .idle_bias_off = 0 -> .idle_bias_on = 1 .ignore_pmdown_time = 0 -> .pmdown_time = 1 - -> .endianness = 1 - -> .non_legacy_dai_naming = 1

Signed-off-by: Kuninori Morimoto kuninori.morimoto.gx@renesas.com --- sound/soc/codecs/wm8580.c | 150 ++++++++++++++++++++++------------------------ 1 file changed, 71 insertions(+), 79 deletions(-)

diff --git a/sound/soc/codecs/wm8580.c b/sound/soc/codecs/wm8580.c index 910801d..37b141e 100644 --- a/sound/soc/codecs/wm8580.c +++ b/sound/soc/codecs/wm8580.c @@ -262,8 +262,8 @@ static int wm8580_out_vu(struct snd_kcontrol *kcontrol, { struct soc_mixer_control *mc = (struct soc_mixer_control *)kcontrol->private_value; - struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol); - struct wm8580_priv *wm8580 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol); + struct wm8580_priv *wm8580 = snd_soc_component_get_drvdata(component); unsigned int reg = mc->reg; unsigned int reg2 = mc->rreg; int ret; @@ -279,8 +279,8 @@ static int wm8580_out_vu(struct snd_kcontrol *kcontrol, return ret;

/* Now write again with the volume update bit set */ - snd_soc_update_bits(codec, reg, 0x100, 0x100); - snd_soc_update_bits(codec, reg2, 0x100, 0x100); + snd_soc_component_update_bits(component, reg, 0x100, 0x100); + snd_soc_component_update_bits(component, reg2, 0x100, 0x100);

return 0; } @@ -465,8 +465,8 @@ static int wm8580_set_dai_pll(struct snd_soc_dai *codec_dai, int pll_id, int source, unsigned int freq_in, unsigned int freq_out) { int offset; - struct snd_soc_codec *codec = codec_dai->codec; - struct wm8580_priv *wm8580 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = codec_dai->component; + struct wm8580_priv *wm8580 = snd_soc_component_get_drvdata(component); struct pll_state *state; struct _pll_div pll_div; unsigned int reg; @@ -505,25 +505,25 @@ static int wm8580_set_dai_pll(struct snd_soc_dai *codec_dai, int pll_id, /* Always disable the PLL - it is not safe to leave it running * while reprogramming it. */ - snd_soc_update_bits(codec, WM8580_PWRDN2, pwr_mask, pwr_mask); + snd_soc_component_update_bits(component, WM8580_PWRDN2, pwr_mask, pwr_mask);

if (!freq_in || !freq_out) return 0;

- snd_soc_write(codec, WM8580_PLLA1 + offset, pll_div.k & 0x1ff); - snd_soc_write(codec, WM8580_PLLA2 + offset, (pll_div.k >> 9) & 0x1ff); - snd_soc_write(codec, WM8580_PLLA3 + offset, + snd_soc_component_write(component, WM8580_PLLA1 + offset, pll_div.k & 0x1ff); + snd_soc_component_write(component, WM8580_PLLA2 + offset, (pll_div.k >> 9) & 0x1ff); + snd_soc_component_write(component, WM8580_PLLA3 + offset, (pll_div.k >> 18 & 0xf) | (pll_div.n << 4));

- reg = snd_soc_read(codec, WM8580_PLLA4 + offset); + reg = snd_soc_component_read32(component, WM8580_PLLA4 + offset); reg &= ~0x1b; reg |= pll_div.prescale | pll_div.postscale << 1 | pll_div.freqmode << 3;

- snd_soc_write(codec, WM8580_PLLA4 + offset, reg); + snd_soc_component_write(component, WM8580_PLLA4 + offset, reg);

/* All done, turn it on */ - snd_soc_update_bits(codec, WM8580_PWRDN2, pwr_mask, 0); + snd_soc_component_update_bits(component, WM8580_PWRDN2, pwr_mask, 0);

return 0; } @@ -539,8 +539,8 @@ static int wm8580_paif_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params, struct snd_soc_dai *dai) { - struct snd_soc_codec *codec = dai->codec; - struct wm8580_priv *wm8580 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = dai->component; + struct wm8580_priv *wm8580 = snd_soc_component_get_drvdata(component); u16 paifa = 0; u16 paifb = 0; int i, ratio, osr; @@ -572,12 +572,12 @@ static int wm8580_paif_hw_params(struct snd_pcm_substream *substream, if (ratio == wm8580_sysclk_ratios[i]) break; if (i == ARRAY_SIZE(wm8580_sysclk_ratios)) { - dev_err(codec->dev, "Invalid clock ratio %d/%d\n", + dev_err(component->dev, "Invalid clock ratio %d/%d\n", wm8580->sysclk[dai->driver->id], params_rate(params)); return -EINVAL; } paifa |= i; - dev_dbg(codec->dev, "Running at %dfs with %dHz clock\n", + dev_dbg(component->dev, "Running at %dfs with %dHz clock\n", wm8580_sysclk_ratios[i], wm8580->sysclk[dai->driver->id]);

if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { @@ -585,21 +585,21 @@ static int wm8580_paif_hw_params(struct snd_pcm_substream *substream, case 128: case 192: osr = WM8580_DACOSR; - dev_dbg(codec->dev, "Selecting 64x OSR\n"); + dev_dbg(component->dev, "Selecting 64x OSR\n"); break; default: osr = 0; - dev_dbg(codec->dev, "Selecting 128x OSR\n"); + dev_dbg(component->dev, "Selecting 128x OSR\n"); break; }

- snd_soc_update_bits(codec, WM8580_PAIF3, WM8580_DACOSR, osr); + snd_soc_component_update_bits(component, WM8580_PAIF3, WM8580_DACOSR, osr); }

- snd_soc_update_bits(codec, WM8580_PAIF1 + dai->driver->id, + snd_soc_component_update_bits(component, WM8580_PAIF1 + dai->driver->id, WM8580_AIF_RATE_MASK | WM8580_AIF_BCLKSEL_MASK, paifa); - snd_soc_update_bits(codec, WM8580_PAIF3 + dai->driver->id, + snd_soc_component_update_bits(component, WM8580_PAIF3 + dai->driver->id, WM8580_AIF_LENGTH_MASK, paifb); return 0; } @@ -607,13 +607,13 @@ static int wm8580_paif_hw_params(struct snd_pcm_substream *substream, static int wm8580_set_paif_dai_fmt(struct snd_soc_dai *codec_dai, unsigned int fmt) { - struct snd_soc_codec *codec = codec_dai->codec; + struct snd_soc_component *component = codec_dai->component; unsigned int aifa; unsigned int aifb; int can_invert_lrclk;

- aifa = snd_soc_read(codec, WM8580_PAIF1 + codec_dai->driver->id); - aifb = snd_soc_read(codec, WM8580_PAIF3 + codec_dai->driver->id); + aifa = snd_soc_component_read32(component, WM8580_PAIF1 + codec_dai->driver->id); + aifb = snd_soc_component_read32(component, WM8580_PAIF3 + codec_dai->driver->id);

aifb &= ~(WM8580_AIF_FMT_MASK | WM8580_AIF_LRP | WM8580_AIF_BCP);

@@ -679,8 +679,8 @@ static int wm8580_set_paif_dai_fmt(struct snd_soc_dai *codec_dai, return -EINVAL; }

- snd_soc_write(codec, WM8580_PAIF1 + codec_dai->driver->id, aifa); - snd_soc_write(codec, WM8580_PAIF3 + codec_dai->driver->id, aifb); + snd_soc_component_write(component, WM8580_PAIF1 + codec_dai->driver->id, aifa); + snd_soc_component_write(component, WM8580_PAIF3 + codec_dai->driver->id, aifb);

return 0; } @@ -688,12 +688,12 @@ static int wm8580_set_paif_dai_fmt(struct snd_soc_dai *codec_dai, static int wm8580_set_dai_clkdiv(struct snd_soc_dai *codec_dai, int div_id, int div) { - struct snd_soc_codec *codec = codec_dai->codec; + struct snd_soc_component *component = codec_dai->component; unsigned int reg;

switch (div_id) { case WM8580_MCLK: - reg = snd_soc_read(codec, WM8580_PLLB4); + reg = snd_soc_component_read32(component, WM8580_PLLB4); reg &= ~WM8580_PLLB4_MCLKOUTSRC_MASK;

switch (div) { @@ -715,11 +715,11 @@ static int wm8580_set_dai_clkdiv(struct snd_soc_dai *codec_dai, default: return -EINVAL; } - snd_soc_write(codec, WM8580_PLLB4, reg); + snd_soc_component_write(component, WM8580_PLLB4, reg); break;

case WM8580_CLKOUTSRC: - reg = snd_soc_read(codec, WM8580_PLLB4); + reg = snd_soc_component_read32(component, WM8580_PLLB4); reg &= ~WM8580_PLLB4_CLKOUTSRC_MASK;

switch (div) { @@ -741,7 +741,7 @@ static int wm8580_set_dai_clkdiv(struct snd_soc_dai *codec_dai, default: return -EINVAL; } - snd_soc_write(codec, WM8580_PLLB4, reg); + snd_soc_component_write(component, WM8580_PLLB4, reg); break;

default: @@ -754,8 +754,8 @@ static int wm8580_set_dai_clkdiv(struct snd_soc_dai *codec_dai, static int wm8580_set_sysclk(struct snd_soc_dai *dai, int clk_id, unsigned int freq, int dir) { - struct snd_soc_codec *codec = dai->codec; - struct wm8580_priv *wm8580 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = dai->component; + struct wm8580_priv *wm8580 = snd_soc_component_get_drvdata(component); int ret, sel, sel_mask, sel_shift;

switch (dai->driver->id) { @@ -790,14 +790,14 @@ static int wm8580_set_sysclk(struct snd_soc_dai *dai, int clk_id, sel = 3 << sel_shift; break; default: - dev_err(codec->dev, "Unknown clock %d\n", clk_id); + dev_err(component->dev, "Unknown clock %d\n", clk_id); return -EINVAL; }

/* We really should validate PLL settings but not yet */ wm8580->sysclk[dai->driver->id] = freq;

- ret = snd_soc_update_bits(codec, WM8580_CLKSEL, sel_mask, sel); + ret = snd_soc_component_update_bits(component, WM8580_CLKSEL, sel_mask, sel); if (ret < 0) return ret;

@@ -806,22 +806,22 @@ static int wm8580_set_sysclk(struct snd_soc_dai *dai, int clk_id,

static int wm8580_digital_mute(struct snd_soc_dai *codec_dai, int mute) { - struct snd_soc_codec *codec = codec_dai->codec; + struct snd_soc_component *component = codec_dai->component; unsigned int reg;

- reg = snd_soc_read(codec, WM8580_DAC_CONTROL5); + reg = snd_soc_component_read32(component, WM8580_DAC_CONTROL5);

if (mute) reg |= WM8580_DAC_CONTROL5_MUTEALL; else reg &= ~WM8580_DAC_CONTROL5_MUTEALL;

- snd_soc_write(codec, WM8580_DAC_CONTROL5, reg); + snd_soc_component_write(component, WM8580_DAC_CONTROL5, reg);

return 0; }

-static int wm8580_set_bias_level(struct snd_soc_codec *codec, +static int wm8580_set_bias_level(struct snd_soc_component *component, enum snd_soc_bias_level level) { switch (level) { @@ -830,20 +830,20 @@ static int wm8580_set_bias_level(struct snd_soc_codec *codec, break;

case SND_SOC_BIAS_STANDBY: - if (snd_soc_codec_get_bias_level(codec) == SND_SOC_BIAS_OFF) { + if (snd_soc_component_get_bias_level(component) == SND_SOC_BIAS_OFF) { /* Power up and get individual control of the DACs */ - snd_soc_update_bits(codec, WM8580_PWRDN1, + snd_soc_component_update_bits(component, WM8580_PWRDN1, WM8580_PWRDN1_PWDN | WM8580_PWRDN1_ALLDACPD, 0);

/* Make VMID high impedance */ - snd_soc_update_bits(codec, WM8580_ADC_CONTROL1, + snd_soc_component_update_bits(component, WM8580_ADC_CONTROL1, 0x100, 0); } break;

case SND_SOC_BIAS_OFF: - snd_soc_update_bits(codec, WM8580_PWRDN1, + snd_soc_component_update_bits(component, WM8580_PWRDN1, WM8580_PWRDN1_PWDN, WM8580_PWRDN1_PWDN); break; } @@ -853,8 +853,8 @@ static int wm8580_set_bias_level(struct snd_soc_codec *codec, static int wm8580_playback_startup(struct snd_pcm_substream *substream, struct snd_soc_dai *dai) { - struct snd_soc_codec *codec = dai->codec; - struct wm8580_priv *wm8580 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = dai->component; + struct wm8580_priv *wm8580 = snd_soc_component_get_drvdata(component);

return snd_pcm_hw_constraint_minmax(substream->runtime, SNDRV_PCM_HW_PARAM_CHANNELS, 1, wm8580->drvdata->num_dacs * 2); @@ -907,15 +907,15 @@ static int wm8580_playback_startup(struct snd_pcm_substream *substream, }, };

-static int wm8580_probe(struct snd_soc_codec *codec) +static int wm8580_probe(struct snd_soc_component *component) { - struct wm8580_priv *wm8580 = snd_soc_codec_get_drvdata(codec); - struct snd_soc_dapm_context *dapm = snd_soc_codec_get_dapm(codec); + struct wm8580_priv *wm8580 = snd_soc_component_get_drvdata(component); + struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(component); int ret = 0;

switch (wm8580->drvdata->num_dacs) { case 4: - snd_soc_add_codec_controls(codec, wm8581_snd_controls, + snd_soc_add_component_controls(component, wm8581_snd_controls, ARRAY_SIZE(wm8581_snd_controls)); snd_soc_dapm_new_controls(dapm, wm8581_dapm_widgets, ARRAY_SIZE(wm8581_dapm_widgets)); @@ -929,14 +929,14 @@ static int wm8580_probe(struct snd_soc_codec *codec) ret = regulator_bulk_enable(ARRAY_SIZE(wm8580->supplies), wm8580->supplies); if (ret != 0) { - dev_err(codec->dev, "Failed to enable supplies: %d\n", ret); + dev_err(component->dev, "Failed to enable supplies: %d\n", ret); goto err_regulator_get; }

/* Get the codec into a known state */ - ret = snd_soc_write(codec, WM8580_RESET, 0); + ret = snd_soc_component_write(component, WM8580_RESET, 0); if (ret != 0) { - dev_err(codec->dev, "Failed to reset codec: %d\n", ret); + dev_err(component->dev, "Failed to reset component: %d\n", ret); goto err_regulator_enable; }

@@ -949,28 +949,27 @@ static int wm8580_probe(struct snd_soc_codec *codec) }

/* power down chip */ -static int wm8580_remove(struct snd_soc_codec *codec) +static void wm8580_remove(struct snd_soc_component *component) { - struct wm8580_priv *wm8580 = snd_soc_codec_get_drvdata(codec); + struct wm8580_priv *wm8580 = snd_soc_component_get_drvdata(component);

regulator_bulk_disable(ARRAY_SIZE(wm8580->supplies), wm8580->supplies); - - return 0; }

-static const struct snd_soc_codec_driver soc_codec_dev_wm8580 = { - .probe = wm8580_probe, - .remove = wm8580_remove, - .set_bias_level = wm8580_set_bias_level, - - .component_driver = { - .controls = wm8580_snd_controls, - .num_controls = ARRAY_SIZE(wm8580_snd_controls), - .dapm_widgets = wm8580_dapm_widgets, - .num_dapm_widgets = ARRAY_SIZE(wm8580_dapm_widgets), - .dapm_routes = wm8580_dapm_routes, - .num_dapm_routes = ARRAY_SIZE(wm8580_dapm_routes), - }, +static const struct snd_soc_component_driver soc_component_dev_wm8580 = { + .probe = wm8580_probe, + .remove = wm8580_remove, + .set_bias_level = wm8580_set_bias_level, + .controls = wm8580_snd_controls, + .num_controls = ARRAY_SIZE(wm8580_snd_controls), + .dapm_widgets = wm8580_dapm_widgets, + .num_dapm_widgets = ARRAY_SIZE(wm8580_dapm_widgets), + .dapm_routes = wm8580_dapm_routes, + .num_dapm_routes = ARRAY_SIZE(wm8580_dapm_routes), + .idle_bias_on = 1, + .pmdown_time = 1, + .endianness = 1, + .non_legacy_dai_naming = 1, };

static const struct regmap_config wm8580_regmap = { @@ -1037,18 +1036,12 @@ static int wm8580_i2c_probe(struct i2c_client *i2c, return -EINVAL; }

- ret = snd_soc_register_codec(&i2c->dev, - &soc_codec_dev_wm8580, wm8580_dai, ARRAY_SIZE(wm8580_dai)); + ret = devm_snd_soc_register_component(&i2c->dev, + &soc_component_dev_wm8580, wm8580_dai, ARRAY_SIZE(wm8580_dai));

return ret; }

-static int wm8580_i2c_remove(struct i2c_client *client) -{ - snd_soc_unregister_codec(&client->dev); - return 0; -} - static const struct i2c_device_id wm8580_i2c_id[] = { { "wm8580", (kernel_ulong_t)&wm8580_data }, { "wm8581", (kernel_ulong_t)&wm8581_data }, @@ -1062,7 +1055,6 @@ static int wm8580_i2c_remove(struct i2c_client *client) .of_match_table = wm8580_of_match, }, .probe = wm8580_i2c_probe, - .remove = wm8580_i2c_remove, .id_table = wm8580_i2c_id, };

From: Kuninori Morimoto kuninori.morimoto.gx@renesas.com

Now we can replace Codec to Component. Let's do it.

Note: xxx_codec_xxx() -> xxx_component_xxx() .idle_bias_off = 0 -> .idle_bias_on = 1 .ignore_pmdown_time = 0 -> .pmdown_time = 1 - -> .endianness = 1 - -> .non_legacy_dai_naming = 1

Signed-off-by: Kuninori Morimoto kuninori.morimoto.gx@renesas.com --- sound/soc/codecs/wm8510.c | 149 +++++++++++++++++++++------------------------- 1 file changed, 68 insertions(+), 81 deletions(-)

diff --git a/sound/soc/codecs/wm8510.c b/sound/soc/codecs/wm8510.c index 119ceac..1675599 100644 --- a/sound/soc/codecs/wm8510.c +++ b/sound/soc/codecs/wm8510.c @@ -106,7 +106,7 @@ static bool wm8510_volatile(struct device *dev, unsigned int reg) #define WM8510_POWER1_BIASEN 0x08 #define WM8510_POWER1_BUFIOEN 0x10

-#define wm8510_reset(c) snd_soc_write(c, WM8510_RESET, 0) +#define wm8510_reset(c) snd_soc_component_write(c, WM8510_RESET, 0)

/* codec private data */ struct wm8510_priv { @@ -316,32 +316,32 @@ static void pll_factors(unsigned int target, unsigned int source) static int wm8510_set_dai_pll(struct snd_soc_dai *codec_dai, int pll_id, int source, unsigned int freq_in, unsigned int freq_out) { - struct snd_soc_codec *codec = codec_dai->codec; + struct snd_soc_component *component = codec_dai->component; u16 reg;

if (freq_in == 0 || freq_out == 0) { /* Clock CODEC directly from MCLK */ - reg = snd_soc_read(codec, WM8510_CLOCK); - snd_soc_write(codec, WM8510_CLOCK, reg & 0x0ff); + reg = snd_soc_component_read32(component, WM8510_CLOCK); + snd_soc_component_write(component, WM8510_CLOCK, reg & 0x0ff);

/* Turn off PLL */ - reg = snd_soc_read(codec, WM8510_POWER1); - snd_soc_write(codec, WM8510_POWER1, reg & 0x1df); + reg = snd_soc_component_read32(component, WM8510_POWER1); + snd_soc_component_write(component, WM8510_POWER1, reg & 0x1df); return 0; }

pll_factors(freq_out*4, freq_in);

- snd_soc_write(codec, WM8510_PLLN, (pll_div.pre_div << 4) | pll_div.n); - snd_soc_write(codec, WM8510_PLLK1, pll_div.k >> 18); - snd_soc_write(codec, WM8510_PLLK2, (pll_div.k >> 9) & 0x1ff); - snd_soc_write(codec, WM8510_PLLK3, pll_div.k & 0x1ff); - reg = snd_soc_read(codec, WM8510_POWER1); - snd_soc_write(codec, WM8510_POWER1, reg | 0x020); + snd_soc_component_write(component, WM8510_PLLN, (pll_div.pre_div << 4) | pll_div.n); + snd_soc_component_write(component, WM8510_PLLK1, pll_div.k >> 18); + snd_soc_component_write(component, WM8510_PLLK2, (pll_div.k >> 9) & 0x1ff); + snd_soc_component_write(component, WM8510_PLLK3, pll_div.k & 0x1ff); + reg = snd_soc_component_read32(component, WM8510_POWER1); + snd_soc_component_write(component, WM8510_POWER1, reg | 0x020);

/* Run CODEC from PLL instead of MCLK */ - reg = snd_soc_read(codec, WM8510_CLOCK); - snd_soc_write(codec, WM8510_CLOCK, reg | 0x100); + reg = snd_soc_component_read32(component, WM8510_CLOCK); + snd_soc_component_write(component, WM8510_CLOCK, reg | 0x100);

return 0; } @@ -352,29 +352,29 @@ static int wm8510_set_dai_pll(struct snd_soc_dai *codec_dai, int pll_id, static int wm8510_set_dai_clkdiv(struct snd_soc_dai *codec_dai, int div_id, int div) { - struct snd_soc_codec *codec = codec_dai->codec; + struct snd_soc_component *component = codec_dai->component; u16 reg;

switch (div_id) { case WM8510_OPCLKDIV: - reg = snd_soc_read(codec, WM8510_GPIO) & 0x1cf; - snd_soc_write(codec, WM8510_GPIO, reg | div); + reg = snd_soc_component_read32(component, WM8510_GPIO) & 0x1cf; + snd_soc_component_write(component, WM8510_GPIO, reg | div); break; case WM8510_MCLKDIV: - reg = snd_soc_read(codec, WM8510_CLOCK) & 0x11f; - snd_soc_write(codec, WM8510_CLOCK, reg | div); + reg = snd_soc_component_read32(component, WM8510_CLOCK) & 0x11f; + snd_soc_component_write(component, WM8510_CLOCK, reg | div); break; case WM8510_ADCCLK: - reg = snd_soc_read(codec, WM8510_ADC) & 0x1f7; - snd_soc_write(codec, WM8510_ADC, reg | div); + reg = snd_soc_component_read32(component, WM8510_ADC) & 0x1f7; + snd_soc_component_write(component, WM8510_ADC, reg | div); break; case WM8510_DACCLK: - reg = snd_soc_read(codec, WM8510_DAC) & 0x1f7; - snd_soc_write(codec, WM8510_DAC, reg | div); + reg = snd_soc_component_read32(component, WM8510_DAC) & 0x1f7; + snd_soc_component_write(component, WM8510_DAC, reg | div); break; case WM8510_BCLKDIV: - reg = snd_soc_read(codec, WM8510_CLOCK) & 0x1e3; - snd_soc_write(codec, WM8510_CLOCK, reg | div); + reg = snd_soc_component_read32(component, WM8510_CLOCK) & 0x1e3; + snd_soc_component_write(component, WM8510_CLOCK, reg | div); break; default: return -EINVAL; @@ -386,9 +386,9 @@ static int wm8510_set_dai_clkdiv(struct snd_soc_dai *codec_dai, static int wm8510_set_dai_fmt(struct snd_soc_dai *codec_dai, unsigned int fmt) { - struct snd_soc_codec *codec = codec_dai->codec; + struct snd_soc_component *component = codec_dai->component; u16 iface = 0; - u16 clk = snd_soc_read(codec, WM8510_CLOCK) & 0x1fe; + u16 clk = snd_soc_component_read32(component, WM8510_CLOCK) & 0x1fe;

/* set master/slave audio interface */ switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) { @@ -435,8 +435,8 @@ static int wm8510_set_dai_fmt(struct snd_soc_dai *codec_dai, return -EINVAL; }

- snd_soc_write(codec, WM8510_IFACE, iface); - snd_soc_write(codec, WM8510_CLOCK, clk); + snd_soc_component_write(component, WM8510_IFACE, iface); + snd_soc_component_write(component, WM8510_CLOCK, clk); return 0; }

@@ -444,9 +444,9 @@ static int wm8510_pcm_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params, struct snd_soc_dai *dai) { - struct snd_soc_codec *codec = dai->codec; - u16 iface = snd_soc_read(codec, WM8510_IFACE) & 0x19f; - u16 adn = snd_soc_read(codec, WM8510_ADD) & 0x1f1; + struct snd_soc_component *component = dai->component; + u16 iface = snd_soc_component_read32(component, WM8510_IFACE) & 0x19f; + u16 adn = snd_soc_component_read32(component, WM8510_ADD) & 0x1f1;

/* bit size */ switch (params_width(params)) { @@ -485,56 +485,56 @@ static int wm8510_pcm_hw_params(struct snd_pcm_substream *substream, break; }

- snd_soc_write(codec, WM8510_IFACE, iface); - snd_soc_write(codec, WM8510_ADD, adn); + snd_soc_component_write(component, WM8510_IFACE, iface); + snd_soc_component_write(component, WM8510_ADD, adn); return 0; }

static int wm8510_mute(struct snd_soc_dai *dai, int mute) { - struct snd_soc_codec *codec = dai->codec; - u16 mute_reg = snd_soc_read(codec, WM8510_DAC) & 0xffbf; + struct snd_soc_component *component = dai->component; + u16 mute_reg = snd_soc_component_read32(component, WM8510_DAC) & 0xffbf;

if (mute) - snd_soc_write(codec, WM8510_DAC, mute_reg | 0x40); + snd_soc_component_write(component, WM8510_DAC, mute_reg | 0x40); else - snd_soc_write(codec, WM8510_DAC, mute_reg); + snd_soc_component_write(component, WM8510_DAC, mute_reg); return 0; }

/* liam need to make this lower power with dapm */ -static int wm8510_set_bias_level(struct snd_soc_codec *codec, +static int wm8510_set_bias_level(struct snd_soc_component *component, enum snd_soc_bias_level level) { - struct wm8510_priv *wm8510 = snd_soc_codec_get_drvdata(codec); - u16 power1 = snd_soc_read(codec, WM8510_POWER1) & ~0x3; + struct wm8510_priv *wm8510 = snd_soc_component_get_drvdata(component); + u16 power1 = snd_soc_component_read32(component, WM8510_POWER1) & ~0x3;

switch (level) { case SND_SOC_BIAS_ON: case SND_SOC_BIAS_PREPARE: power1 |= 0x1; /* VMID 50k */ - snd_soc_write(codec, WM8510_POWER1, power1); + snd_soc_component_write(component, WM8510_POWER1, power1); break;

case SND_SOC_BIAS_STANDBY: power1 |= WM8510_POWER1_BIASEN | WM8510_POWER1_BUFIOEN;

- if (snd_soc_codec_get_bias_level(codec) == SND_SOC_BIAS_OFF) { + if (snd_soc_component_get_bias_level(component) == SND_SOC_BIAS_OFF) { regcache_sync(wm8510->regmap);

/* Initial cap charge at VMID 5k */ - snd_soc_write(codec, WM8510_POWER1, power1 | 0x3); + snd_soc_component_write(component, WM8510_POWER1, power1 | 0x3); mdelay(100); }

power1 |= 0x2; /* VMID 500k */ - snd_soc_write(codec, WM8510_POWER1, power1); + snd_soc_component_write(component, WM8510_POWER1, power1); break;

case SND_SOC_BIAS_OFF: - snd_soc_write(codec, WM8510_POWER1, 0); - snd_soc_write(codec, WM8510_POWER2, 0); - snd_soc_write(codec, WM8510_POWER3, 0); + snd_soc_component_write(component, WM8510_POWER1, 0); + snd_soc_component_write(component, WM8510_POWER2, 0); + snd_soc_component_write(component, WM8510_POWER3, 0); break; }

@@ -574,26 +574,27 @@ static int wm8510_set_bias_level(struct snd_soc_codec *codec, .symmetric_rates = 1, };

-static int wm8510_probe(struct snd_soc_codec *codec) +static int wm8510_probe(struct snd_soc_component *component) { - wm8510_reset(codec); + wm8510_reset(component);

return 0; }

-static const struct snd_soc_codec_driver soc_codec_dev_wm8510 = { - .probe = wm8510_probe, - .set_bias_level = wm8510_set_bias_level, - .suspend_bias_off = true, - - .component_driver = { - .controls = wm8510_snd_controls, - .num_controls = ARRAY_SIZE(wm8510_snd_controls), - .dapm_widgets = wm8510_dapm_widgets, - .num_dapm_widgets = ARRAY_SIZE(wm8510_dapm_widgets), - .dapm_routes = wm8510_dapm_routes, - .num_dapm_routes = ARRAY_SIZE(wm8510_dapm_routes), - }, +static const struct snd_soc_component_driver soc_component_dev_wm8510 = { + .probe = wm8510_probe, + .set_bias_level = wm8510_set_bias_level, + .controls = wm8510_snd_controls, + .num_controls = ARRAY_SIZE(wm8510_snd_controls), + .dapm_widgets = wm8510_dapm_widgets, + .num_dapm_widgets = ARRAY_SIZE(wm8510_dapm_widgets), + .dapm_routes = wm8510_dapm_routes, + .num_dapm_routes = ARRAY_SIZE(wm8510_dapm_routes), + .suspend_bias_off = 1, + .idle_bias_on = 1, + .pmdown_time = 1, + .endianness = 1, + .non_legacy_dai_naming = 1, };

static const struct of_device_id wm8510_of_match[] = { @@ -631,25 +632,18 @@ static int wm8510_spi_probe(struct spi_device *spi)

spi_set_drvdata(spi, wm8510);

- ret = snd_soc_register_codec(&spi->dev, - &soc_codec_dev_wm8510, &wm8510_dai, 1); + ret = devm_snd_soc_register_component(&spi->dev, + &soc_component_dev_wm8510, &wm8510_dai, 1);

return ret; }

-static int wm8510_spi_remove(struct spi_device *spi) -{ - snd_soc_unregister_codec(&spi->dev); - return 0; -} - static struct spi_driver wm8510_spi_driver = { .driver = { .name = "wm8510", .of_match_table = wm8510_of_match, }, .probe = wm8510_spi_probe, - .remove = wm8510_spi_remove, }; #endif /* CONFIG_SPI_MASTER */

@@ -671,18 +665,12 @@ static int wm8510_i2c_probe(struct i2c_client *i2c,

i2c_set_clientdata(i2c, wm8510);

- ret = snd_soc_register_codec(&i2c->dev, - &soc_codec_dev_wm8510, &wm8510_dai, 1); + ret = devm_snd_soc_register_component(&i2c->dev, + &soc_component_dev_wm8510, &wm8510_dai, 1);

return ret; }

-static int wm8510_i2c_remove(struct i2c_client *client) -{ - snd_soc_unregister_codec(&client->dev); - return 0; -} - static const struct i2c_device_id wm8510_i2c_id[] = { { "wm8510", 0 }, { } @@ -695,7 +683,6 @@ static int wm8510_i2c_remove(struct i2c_client *client) .of_match_table = wm8510_of_match, }, .probe = wm8510_i2c_probe, - .remove = wm8510_i2c_remove, .id_table = wm8510_i2c_id, }; #endif

From: Kuninori Morimoto kuninori.morimoto.gx@renesas.com

Now we can replace Codec to Component. Let's do it.

Note: xxx_codec_xxx() -> xxx_component_xxx() .idle_bias_off = 0 -> .idle_bias_on = 1 .ignore_pmdown_time = 0 -> .pmdown_time = 1 - -> .endianness = 1 - -> .non_legacy_dai_naming = 1

Signed-off-by: Kuninori Morimoto kuninori.morimoto.gx@renesas.com --- sound/soc/codecs/wm8711.c | 116 ++++++++++++++++++++-------------------------- 1 file changed, 51 insertions(+), 65 deletions(-)

diff --git a/sound/soc/codecs/wm8711.c b/sound/soc/codecs/wm8711.c index 2b376c9..fe7a40a 100644 --- a/sound/soc/codecs/wm8711.c +++ b/sound/soc/codecs/wm8711.c @@ -58,7 +58,7 @@ static bool wm8711_volatile(struct device *dev, unsigned int reg) } }

-#define wm8711_reset(c) snd_soc_write(c, WM8711_RESET, 0) +#define wm8711_reset(c) snd_soc_component_write(c, WM8711_RESET, 0)

static const DECLARE_TLV_DB_SCALE(out_tlv, -12100, 100, 1);

@@ -159,14 +159,14 @@ static int wm8711_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params, struct snd_soc_dai *dai) { - struct snd_soc_codec *codec = dai->codec; - struct wm8711_priv *wm8711 = snd_soc_codec_get_drvdata(codec); - u16 iface = snd_soc_read(codec, WM8711_IFACE) & 0xfff3; + struct snd_soc_component *component = dai->component; + struct wm8711_priv *wm8711 = snd_soc_component_get_drvdata(component); + u16 iface = snd_soc_component_read32(component, WM8711_IFACE) & 0xfff3; int i = get_coeff(wm8711->sysclk, params_rate(params)); u16 srate = (coeff_div[i].sr << 2) | (coeff_div[i].bosr << 1) | coeff_div[i].usb;

- snd_soc_write(codec, WM8711_SRATE, srate); + snd_soc_component_write(component, WM8711_SRATE, srate);

/* bit size */ switch (params_width(params)) { @@ -180,17 +180,17 @@ static int wm8711_hw_params(struct snd_pcm_substream *substream, break; }

- snd_soc_write(codec, WM8711_IFACE, iface); + snd_soc_component_write(component, WM8711_IFACE, iface); return 0; }

static int wm8711_pcm_prepare(struct snd_pcm_substream *substream, struct snd_soc_dai *dai) { - struct snd_soc_codec *codec = dai->codec; + struct snd_soc_component *component = dai->component;

/* set active */ - snd_soc_write(codec, WM8711_ACTIVE, 0x0001); + snd_soc_component_write(component, WM8711_ACTIVE, 0x0001);

return 0; } @@ -198,24 +198,24 @@ static int wm8711_pcm_prepare(struct snd_pcm_substream *substream, static void wm8711_shutdown(struct snd_pcm_substream *substream, struct snd_soc_dai *dai) { - struct snd_soc_codec *codec = dai->codec; + struct snd_soc_component *component = dai->component;

/* deactivate */ - if (!snd_soc_codec_is_active(codec)) { + if (!snd_soc_component_is_active(component)) { udelay(50); - snd_soc_write(codec, WM8711_ACTIVE, 0x0); + snd_soc_component_write(component, WM8711_ACTIVE, 0x0); } }

static int wm8711_mute(struct snd_soc_dai *dai, int mute) { - struct snd_soc_codec *codec = dai->codec; - u16 mute_reg = snd_soc_read(codec, WM8711_APDIGI) & 0xfff7; + struct snd_soc_component *component = dai->component; + u16 mute_reg = snd_soc_component_read32(component, WM8711_APDIGI) & 0xfff7;

if (mute) - snd_soc_write(codec, WM8711_APDIGI, mute_reg | 0x8); + snd_soc_component_write(component, WM8711_APDIGI, mute_reg | 0x8); else - snd_soc_write(codec, WM8711_APDIGI, mute_reg); + snd_soc_component_write(component, WM8711_APDIGI, mute_reg);

return 0; } @@ -223,8 +223,8 @@ static int wm8711_mute(struct snd_soc_dai *dai, int mute) static int wm8711_set_dai_sysclk(struct snd_soc_dai *codec_dai, int clk_id, unsigned int freq, int dir) { - struct snd_soc_codec *codec = codec_dai->codec; - struct wm8711_priv *wm8711 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = codec_dai->component; + struct wm8711_priv *wm8711 = snd_soc_component_get_drvdata(component);

switch (freq) { case 11289600: @@ -241,8 +241,8 @@ static int wm8711_set_dai_sysclk(struct snd_soc_dai *codec_dai, static int wm8711_set_dai_fmt(struct snd_soc_dai *codec_dai, unsigned int fmt) { - struct snd_soc_codec *codec = codec_dai->codec; - u16 iface = snd_soc_read(codec, WM8711_IFACE) & 0x000c; + struct snd_soc_component *component = codec_dai->component; + u16 iface = snd_soc_component_read32(component, WM8711_IFACE) & 0x000c;

/* set master/slave audio interface */ switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) { @@ -293,31 +293,31 @@ static int wm8711_set_dai_fmt(struct snd_soc_dai *codec_dai, }

/* set iface */ - snd_soc_write(codec, WM8711_IFACE, iface); + snd_soc_component_write(component, WM8711_IFACE, iface); return 0; }

-static int wm8711_set_bias_level(struct snd_soc_codec *codec, +static int wm8711_set_bias_level(struct snd_soc_component *component, enum snd_soc_bias_level level) { - struct wm8711_priv *wm8711 = snd_soc_codec_get_drvdata(codec); - u16 reg = snd_soc_read(codec, WM8711_PWR) & 0xff7f; + struct wm8711_priv *wm8711 = snd_soc_component_get_drvdata(component); + u16 reg = snd_soc_component_read32(component, WM8711_PWR) & 0xff7f;

switch (level) { case SND_SOC_BIAS_ON: - snd_soc_write(codec, WM8711_PWR, reg); + snd_soc_component_write(component, WM8711_PWR, reg); break; case SND_SOC_BIAS_PREPARE: break; case SND_SOC_BIAS_STANDBY: - if (snd_soc_codec_get_bias_level(codec) == SND_SOC_BIAS_OFF) + if (snd_soc_component_get_bias_level(component) == SND_SOC_BIAS_OFF) regcache_sync(wm8711->regmap);

- snd_soc_write(codec, WM8711_PWR, reg | 0x0040); + snd_soc_component_write(component, WM8711_PWR, reg | 0x0040); break; case SND_SOC_BIAS_OFF: - snd_soc_write(codec, WM8711_ACTIVE, 0x0); - snd_soc_write(codec, WM8711_PWR, 0xffff); + snd_soc_component_write(component, WM8711_ACTIVE, 0x0); + snd_soc_component_write(component, WM8711_PWR, 0xffff); break; } return 0; @@ -349,37 +349,38 @@ static int wm8711_set_bias_level(struct snd_soc_codec *codec, .ops = &wm8711_ops, };

-static int wm8711_probe(struct snd_soc_codec *codec) +static int wm8711_probe(struct snd_soc_component *component) { int ret;

- ret = wm8711_reset(codec); + ret = wm8711_reset(component); if (ret < 0) { - dev_err(codec->dev, "Failed to issue reset\n"); + dev_err(component->dev, "Failed to issue reset\n"); return ret; }

/* Latch the update bits */ - snd_soc_update_bits(codec, WM8711_LOUT1V, 0x0100, 0x0100); - snd_soc_update_bits(codec, WM8711_ROUT1V, 0x0100, 0x0100); + snd_soc_component_update_bits(component, WM8711_LOUT1V, 0x0100, 0x0100); + snd_soc_component_update_bits(component, WM8711_ROUT1V, 0x0100, 0x0100);

return ret;

}

-static const struct snd_soc_codec_driver soc_codec_dev_wm8711 = { - .probe = wm8711_probe, - .set_bias_level = wm8711_set_bias_level, - .suspend_bias_off = true, - - .component_driver = { - .controls = wm8711_snd_controls, - .num_controls = ARRAY_SIZE(wm8711_snd_controls), - .dapm_widgets = wm8711_dapm_widgets, - .num_dapm_widgets = ARRAY_SIZE(wm8711_dapm_widgets), - .dapm_routes = wm8711_intercon, - .num_dapm_routes = ARRAY_SIZE(wm8711_intercon), - }, +static const struct snd_soc_component_driver soc_component_dev_wm8711 = { + .probe = wm8711_probe, + .set_bias_level = wm8711_set_bias_level, + .controls = wm8711_snd_controls, + .num_controls = ARRAY_SIZE(wm8711_snd_controls), + .dapm_widgets = wm8711_dapm_widgets, + .num_dapm_widgets = ARRAY_SIZE(wm8711_dapm_widgets), + .dapm_routes = wm8711_intercon, + .num_dapm_routes = ARRAY_SIZE(wm8711_intercon), + .suspend_bias_off = 1, + .idle_bias_on = 1, + .pmdown_time = 1, + .endianness = 1, + .non_legacy_dai_naming = 1, };

static const struct of_device_id wm8711_of_match[] = { @@ -417,26 +418,18 @@ static int wm8711_spi_probe(struct spi_device *spi)

spi_set_drvdata(spi, wm8711);

- ret = snd_soc_register_codec(&spi->dev, - &soc_codec_dev_wm8711, &wm8711_dai, 1); + ret = devm_snd_soc_register_component(&spi->dev, + &soc_component_dev_wm8711, &wm8711_dai, 1);

return ret; }

-static int wm8711_spi_remove(struct spi_device *spi) -{ - snd_soc_unregister_codec(&spi->dev); - - return 0; -} - static struct spi_driver wm8711_spi_driver = { .driver = { .name = "wm8711", .of_match_table = wm8711_of_match, }, .probe = wm8711_spi_probe, - .remove = wm8711_spi_remove, }; #endif /* CONFIG_SPI_MASTER */

@@ -458,18 +451,12 @@ static int wm8711_i2c_probe(struct i2c_client *client,

i2c_set_clientdata(client, wm8711);

- ret = snd_soc_register_codec(&client->dev, - &soc_codec_dev_wm8711, &wm8711_dai, 1); + ret = devm_snd_soc_register_component(&client->dev, + &soc_component_dev_wm8711, &wm8711_dai, 1);

return ret; }

-static int wm8711_i2c_remove(struct i2c_client *client) -{ - snd_soc_unregister_codec(&client->dev); - return 0; -} - static const struct i2c_device_id wm8711_i2c_id[] = { { "wm8711", 0 }, { } @@ -482,7 +469,6 @@ static int wm8711_i2c_remove(struct i2c_client *client) .of_match_table = wm8711_of_match, }, .probe = wm8711_i2c_probe, - .remove = wm8711_i2c_remove, .id_table = wm8711_i2c_id, }; #endif

From: Kuninori Morimoto kuninori.morimoto.gx@renesas.com

Now we can replace Codec to Component. Let's do it.

Note: xxx_codec_xxx() -> xxx_component_xxx() .idle_bias_off = 0 -> .idle_bias_on = 1 .ignore_pmdown_time = 0 -> .pmdown_time = 1 - -> .endianness = 1 - -> .non_legacy_dai_naming = 1

Signed-off-by: Kuninori Morimoto kuninori.morimoto.gx@renesas.com --- sound/soc/codecs/wm8737.c | 109 ++++++++++++++++++++-------------------------- 1 file changed, 47 insertions(+), 62 deletions(-)

diff --git a/sound/soc/codecs/wm8737.c b/sound/soc/codecs/wm8737.c index f0cb1c4..5c277e7 100644 --- a/sound/soc/codecs/wm8737.c +++ b/sound/soc/codecs/wm8737.c @@ -74,9 +74,9 @@ static bool wm8737_volatile(struct device *dev, unsigned int reg) } }

-static int wm8737_reset(struct snd_soc_codec *codec) +static int wm8737_reset(struct snd_soc_component *component) { - return snd_soc_write(codec, WM8737_RESET, 0); + return snd_soc_component_write(component, WM8737_RESET, 0); }

static const DECLARE_TLV_DB_RANGE(micboost_tlv, @@ -328,8 +328,8 @@ static int wm8737_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params, struct snd_soc_dai *dai) { - struct snd_soc_codec *codec = dai->codec; - struct wm8737_priv *wm8737 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = dai->component; + struct wm8737_priv *wm8737 = snd_soc_component_get_drvdata(component); int i; u16 clocking = 0; u16 af = 0; @@ -348,7 +348,7 @@ static int wm8737_hw_params(struct snd_pcm_substream *substream, }

if (i == ARRAY_SIZE(coeff_div)) { - dev_err(codec->dev, "%dHz MCLK can't support %dHz\n", + dev_err(component->dev, "%dHz MCLK can't support %dHz\n", wm8737->mclk, params_rate(params)); return -EINVAL; } @@ -371,8 +371,8 @@ static int wm8737_hw_params(struct snd_pcm_substream *substream, return -EINVAL; }

- snd_soc_update_bits(codec, WM8737_AUDIO_FORMAT, WM8737_WL_MASK, af); - snd_soc_update_bits(codec, WM8737_CLOCKING, + snd_soc_component_update_bits(component, WM8737_AUDIO_FORMAT, WM8737_WL_MASK, af); + snd_soc_component_update_bits(component, WM8737_CLOCKING, WM8737_USB_MODE | WM8737_CLKDIV2 | WM8737_SR_MASK, clocking);

@@ -382,8 +382,8 @@ static int wm8737_hw_params(struct snd_pcm_substream *substream, static int wm8737_set_dai_sysclk(struct snd_soc_dai *codec_dai, int clk_id, unsigned int freq, int dir) { - struct snd_soc_codec *codec = codec_dai->codec; - struct wm8737_priv *wm8737 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = codec_dai->component; + struct wm8737_priv *wm8737 = snd_soc_component_get_drvdata(component); int i;

for (i = 0; i < ARRAY_SIZE(coeff_div); i++) { @@ -394,7 +394,7 @@ static int wm8737_set_dai_sysclk(struct snd_soc_dai *codec_dai, } }

- dev_err(codec->dev, "MCLK rate %dHz not supported\n", freq); + dev_err(component->dev, "MCLK rate %dHz not supported\n", freq);

return -EINVAL; } @@ -403,7 +403,7 @@ static int wm8737_set_dai_sysclk(struct snd_soc_dai *codec_dai, static int wm8737_set_dai_fmt(struct snd_soc_dai *codec_dai, unsigned int fmt) { - struct snd_soc_codec *codec = codec_dai->codec; + struct snd_soc_component *component = codec_dai->component; u16 af = 0;

switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) { @@ -445,16 +445,16 @@ static int wm8737_set_dai_fmt(struct snd_soc_dai *codec_dai, return -EINVAL; }

- snd_soc_update_bits(codec, WM8737_AUDIO_FORMAT, + snd_soc_component_update_bits(component, WM8737_AUDIO_FORMAT, WM8737_FORMAT_MASK | WM8737_LRP | WM8737_MS, af);

return 0; }

-static int wm8737_set_bias_level(struct snd_soc_codec *codec, +static int wm8737_set_bias_level(struct snd_soc_component *component, enum snd_soc_bias_level level) { - struct wm8737_priv *wm8737 = snd_soc_codec_get_drvdata(codec); + struct wm8737_priv *wm8737 = snd_soc_component_get_drvdata(component); int ret;

switch (level) { @@ -463,16 +463,16 @@ static int wm8737_set_bias_level(struct snd_soc_codec *codec,

case SND_SOC_BIAS_PREPARE: /* VMID at 2*75k */ - snd_soc_update_bits(codec, WM8737_MISC_BIAS_CONTROL, + snd_soc_component_update_bits(component, WM8737_MISC_BIAS_CONTROL, WM8737_VMIDSEL_MASK, 0); break;

case SND_SOC_BIAS_STANDBY: - if (snd_soc_codec_get_bias_level(codec) == SND_SOC_BIAS_OFF) { + if (snd_soc_component_get_bias_level(component) == SND_SOC_BIAS_OFF) { ret = regulator_bulk_enable(ARRAY_SIZE(wm8737->supplies), wm8737->supplies); if (ret != 0) { - dev_err(codec->dev, + dev_err(component->dev, "Failed to enable supplies: %d\n", ret); return ret; @@ -481,12 +481,12 @@ static int wm8737_set_bias_level(struct snd_soc_codec *codec, regcache_sync(wm8737->regmap);

/* Fast VMID ramp at 2*2.5k */ - snd_soc_update_bits(codec, WM8737_MISC_BIAS_CONTROL, + snd_soc_component_update_bits(component, WM8737_MISC_BIAS_CONTROL, WM8737_VMIDSEL_MASK, 2 << WM8737_VMIDSEL_SHIFT);

/* Bring VMID up */ - snd_soc_update_bits(codec, WM8737_POWER_MANAGEMENT, + snd_soc_component_update_bits(component, WM8737_POWER_MANAGEMENT, WM8737_VMID_MASK | WM8737_VREF_MASK, WM8737_VMID_MASK | @@ -496,14 +496,14 @@ static int wm8737_set_bias_level(struct snd_soc_codec *codec, }

/* VMID at 2*300k */ - snd_soc_update_bits(codec, WM8737_MISC_BIAS_CONTROL, + snd_soc_component_update_bits(component, WM8737_MISC_BIAS_CONTROL, WM8737_VMIDSEL_MASK, 1 << WM8737_VMIDSEL_SHIFT);

break;

case SND_SOC_BIAS_OFF: - snd_soc_update_bits(codec, WM8737_POWER_MANAGEMENT, + snd_soc_component_update_bits(component, WM8737_POWER_MANAGEMENT, WM8737_VMID_MASK | WM8737_VREF_MASK, 0);

regulator_bulk_disable(ARRAY_SIZE(wm8737->supplies), @@ -537,30 +537,30 @@ static int wm8737_set_bias_level(struct snd_soc_codec *codec, .ops = &wm8737_dai_ops, };

-static int wm8737_probe(struct snd_soc_codec *codec) +static int wm8737_probe(struct snd_soc_component *component) { - struct wm8737_priv *wm8737 = snd_soc_codec_get_drvdata(codec); + struct wm8737_priv *wm8737 = snd_soc_component_get_drvdata(component); int ret;

ret = regulator_bulk_enable(ARRAY_SIZE(wm8737->supplies), wm8737->supplies); if (ret != 0) { - dev_err(codec->dev, "Failed to enable supplies: %d\n", ret); + dev_err(component->dev, "Failed to enable supplies: %d\n", ret); goto err_get; }

- ret = wm8737_reset(codec); + ret = wm8737_reset(component); if (ret < 0) { - dev_err(codec->dev, "Failed to issue reset\n"); + dev_err(component->dev, "Failed to issue reset\n"); goto err_enable; }

- snd_soc_update_bits(codec, WM8737_LEFT_PGA_VOLUME, WM8737_LVU, + snd_soc_component_update_bits(component, WM8737_LEFT_PGA_VOLUME, WM8737_LVU, WM8737_LVU); - snd_soc_update_bits(codec, WM8737_RIGHT_PGA_VOLUME, WM8737_RVU, + snd_soc_component_update_bits(component, WM8737_RIGHT_PGA_VOLUME, WM8737_RVU, WM8737_RVU);

- snd_soc_codec_force_bias_level(codec, SND_SOC_BIAS_STANDBY); + snd_soc_component_force_bias_level(component, SND_SOC_BIAS_STANDBY);

/* Bias level configuration will have done an extra enable */ regulator_bulk_disable(ARRAY_SIZE(wm8737->supplies), wm8737->supplies); @@ -573,19 +573,20 @@ static int wm8737_probe(struct snd_soc_codec *codec) return ret; }

-static const struct snd_soc_codec_driver soc_codec_dev_wm8737 = { - .probe = wm8737_probe, - .set_bias_level = wm8737_set_bias_level, - .suspend_bias_off = true, - - .component_driver = { - .controls = wm8737_snd_controls, - .num_controls = ARRAY_SIZE(wm8737_snd_controls), - .dapm_widgets = wm8737_dapm_widgets, - .num_dapm_widgets = ARRAY_SIZE(wm8737_dapm_widgets), - .dapm_routes = intercon, - .num_dapm_routes = ARRAY_SIZE(intercon), - }, +static const struct snd_soc_component_driver soc_component_dev_wm8737 = { + .probe = wm8737_probe, + .set_bias_level = wm8737_set_bias_level, + .controls = wm8737_snd_controls, + .num_controls = ARRAY_SIZE(wm8737_snd_controls), + .dapm_widgets = wm8737_dapm_widgets, + .num_dapm_widgets = ARRAY_SIZE(wm8737_dapm_widgets), + .dapm_routes = intercon, + .num_dapm_routes = ARRAY_SIZE(intercon), + .suspend_bias_off = 1, + .idle_bias_on = 1, + .pmdown_time = 1, + .endianness = 1, + .non_legacy_dai_naming = 1, };

static const struct of_device_id wm8737_of_match[] = { @@ -635,20 +636,13 @@ static int wm8737_i2c_probe(struct i2c_client *i2c,

i2c_set_clientdata(i2c, wm8737);

- ret = snd_soc_register_codec(&i2c->dev, - &soc_codec_dev_wm8737, &wm8737_dai, 1); + ret = devm_snd_soc_register_component(&i2c->dev, + &soc_component_dev_wm8737, &wm8737_dai, 1);

return ret;

}

-static int wm8737_i2c_remove(struct i2c_client *client) -{ - snd_soc_unregister_codec(&client->dev); - - return 0; -} - static const struct i2c_device_id wm8737_i2c_id[] = { { "wm8737", 0 }, { } @@ -661,7 +655,6 @@ static int wm8737_i2c_remove(struct i2c_client *client) .of_match_table = wm8737_of_match, }, .probe = wm8737_i2c_probe, - .remove = wm8737_i2c_remove, .id_table = wm8737_i2c_id, }; #endif @@ -693,26 +686,18 @@ static int wm8737_spi_probe(struct spi_device *spi)

spi_set_drvdata(spi, wm8737);

- ret = snd_soc_register_codec(&spi->dev, - &soc_codec_dev_wm8737, &wm8737_dai, 1); + ret = devm_snd_soc_register_component(&spi->dev, + &soc_component_dev_wm8737, &wm8737_dai, 1);

return ret; }

-static int wm8737_spi_remove(struct spi_device *spi) -{ - snd_soc_unregister_codec(&spi->dev); - - return 0; -} - static struct spi_driver wm8737_spi_driver = { .driver = { .name = "wm8737", .of_match_table = wm8737_of_match, }, .probe = wm8737_spi_probe, - .remove = wm8737_spi_remove, }; #endif /* CONFIG_SPI_MASTER */

From: Kuninori Morimoto kuninori.morimoto.gx@renesas.com

Now we can replace Codec to Component. Let's do it.

Note: xxx_codec_xxx() -> xxx_component_xxx() .idle_bias_off = 1 -> .idle_bias_on = 0 .ignore_pmdown_time = 0 -> .pmdown_time = 1 - -> .endianness = 1 - -> .non_legacy_dai_naming = 1

Signed-off-by: Kuninori Morimoto kuninori.morimoto.gx@renesas.com --- sound/soc/codecs/wm8770.c | 131 ++++++++++++++++++++++------------------------ 1 file changed, 64 insertions(+), 67 deletions(-)

diff --git a/sound/soc/codecs/wm8770.c b/sound/soc/codecs/wm8770.c index d6edcbb..9bd2098 100644 --- a/sound/soc/codecs/wm8770.c +++ b/sound/soc/codecs/wm8770.c @@ -84,7 +84,7 @@ struct wm8770_priv { struct regmap *regmap; struct regulator_bulk_data supplies[WM8770_NUM_SUPPLIES]; struct notifier_block disable_nb[WM8770_NUM_SUPPLIES]; - struct snd_soc_codec *codec; + struct snd_soc_component *component; int sysclk; };

@@ -308,14 +308,14 @@ static SOC_ENUM_DOUBLE_DECL(ain_enum, static int vout12supply_event(struct snd_soc_dapm_widget *w, struct snd_kcontrol *kcontrol, int event) { - struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm); + struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);

switch (event) { case SND_SOC_DAPM_PRE_PMU: - snd_soc_update_bits(codec, WM8770_OUTMUX1, 0x180, 0); + snd_soc_component_update_bits(component, WM8770_OUTMUX1, 0x180, 0); break; case SND_SOC_DAPM_POST_PMD: - snd_soc_update_bits(codec, WM8770_OUTMUX1, 0x180, 0x180); + snd_soc_component_update_bits(component, WM8770_OUTMUX1, 0x180, 0x180); break; }

@@ -325,31 +325,31 @@ static int vout12supply_event(struct snd_soc_dapm_widget *w, static int vout34supply_event(struct snd_soc_dapm_widget *w, struct snd_kcontrol *kcontrol, int event) { - struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm); + struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);

switch (event) { case SND_SOC_DAPM_PRE_PMU: - snd_soc_update_bits(codec, WM8770_OUTMUX2, 0x180, 0); + snd_soc_component_update_bits(component, WM8770_OUTMUX2, 0x180, 0); break; case SND_SOC_DAPM_POST_PMD: - snd_soc_update_bits(codec, WM8770_OUTMUX2, 0x180, 0x180); + snd_soc_component_update_bits(component, WM8770_OUTMUX2, 0x180, 0x180); break; }

return 0; }

-static int wm8770_reset(struct snd_soc_codec *codec) +static int wm8770_reset(struct snd_soc_component *component) { - return snd_soc_write(codec, WM8770_RESET, 0); + return snd_soc_component_write(component, WM8770_RESET, 0); }

static int wm8770_set_fmt(struct snd_soc_dai *dai, unsigned int fmt) { - struct snd_soc_codec *codec; + struct snd_soc_component *component; int iface, master;

- codec = dai->codec; + component = dai->component;

switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) { case SND_SOC_DAIFMT_CBM_CFM: @@ -392,8 +392,8 @@ static int wm8770_set_fmt(struct snd_soc_dai *dai, unsigned int fmt) return -EINVAL; }

- snd_soc_update_bits(codec, WM8770_IFACECTRL, 0xf, iface); - snd_soc_update_bits(codec, WM8770_MSTRCTRL, 0x100, master); + snd_soc_component_update_bits(component, WM8770_IFACECTRL, 0xf, iface); + snd_soc_component_update_bits(component, WM8770_MSTRCTRL, 0x100, master);

return 0; } @@ -411,15 +411,15 @@ static int wm8770_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params, struct snd_soc_dai *dai) { - struct snd_soc_codec *codec; + struct snd_soc_component *component; struct wm8770_priv *wm8770; int i; int iface; int shift; int ratio;

- codec = dai->codec; - wm8770 = snd_soc_codec_get_drvdata(codec); + component = dai->component; + wm8770 = snd_soc_component_get_drvdata(component);

iface = 0; switch (params_width(params)) { @@ -450,7 +450,7 @@ static int wm8770_hw_params(struct snd_pcm_substream *substream, }

/* Only need to set MCLK/LRCLK ratio if we're master */ - if (snd_soc_read(codec, WM8770_MSTRCTRL) & 0x100) { + if (snd_soc_component_read32(component, WM8770_MSTRCTRL) & 0x100) { for (; i < ARRAY_SIZE(mclk_ratios); ++i) { ratio = wm8770->sysclk / params_rate(params); if (ratio == mclk_ratios[i]) @@ -458,51 +458,51 @@ static int wm8770_hw_params(struct snd_pcm_substream *substream, }

if (i == ARRAY_SIZE(mclk_ratios)) { - dev_err(codec->dev, + dev_err(component->dev, "Unable to configure MCLK ratio %d/%d\n", wm8770->sysclk, params_rate(params)); return -EINVAL; }

- dev_dbg(codec->dev, "MCLK is %dfs\n", mclk_ratios[i]); + dev_dbg(component->dev, "MCLK is %dfs\n", mclk_ratios[i]);

- snd_soc_update_bits(codec, WM8770_MSTRCTRL, 0x7 << shift, + snd_soc_component_update_bits(component, WM8770_MSTRCTRL, 0x7 << shift, i << shift); }

- snd_soc_update_bits(codec, WM8770_IFACECTRL, 0x30, iface); + snd_soc_component_update_bits(component, WM8770_IFACECTRL, 0x30, iface);

return 0; }

static int wm8770_mute(struct snd_soc_dai *dai, int mute) { - struct snd_soc_codec *codec; + struct snd_soc_component *component;

- codec = dai->codec; - return snd_soc_update_bits(codec, WM8770_DACMUTE, 0x10, + component = dai->component; + return snd_soc_component_update_bits(component, WM8770_DACMUTE, 0x10, !!mute << 4); }

static int wm8770_set_sysclk(struct snd_soc_dai *dai, int clk_id, unsigned int freq, int dir) { - struct snd_soc_codec *codec; + struct snd_soc_component *component; struct wm8770_priv *wm8770;

- codec = dai->codec; - wm8770 = snd_soc_codec_get_drvdata(codec); + component = dai->component; + wm8770 = snd_soc_component_get_drvdata(component); wm8770->sysclk = freq; return 0; }

-static int wm8770_set_bias_level(struct snd_soc_codec *codec, +static int wm8770_set_bias_level(struct snd_soc_component *component, enum snd_soc_bias_level level) { int ret; struct wm8770_priv *wm8770;

- wm8770 = snd_soc_codec_get_drvdata(codec); + wm8770 = snd_soc_component_get_drvdata(component);

switch (level) { case SND_SOC_BIAS_ON: @@ -510,11 +510,11 @@ static int wm8770_set_bias_level(struct snd_soc_codec *codec, case SND_SOC_BIAS_PREPARE: break; case SND_SOC_BIAS_STANDBY: - if (snd_soc_codec_get_bias_level(codec) == SND_SOC_BIAS_OFF) { + if (snd_soc_component_get_bias_level(component) == SND_SOC_BIAS_OFF) { ret = regulator_bulk_enable(ARRAY_SIZE(wm8770->supplies), wm8770->supplies); if (ret) { - dev_err(codec->dev, + dev_err(component->dev, "Failed to enable supplies: %d\n", ret); return ret; @@ -523,12 +523,12 @@ static int wm8770_set_bias_level(struct snd_soc_codec *codec, regcache_sync(wm8770->regmap);

/* global powerup */ - snd_soc_write(codec, WM8770_PWDNCTRL, 0); + snd_soc_component_write(component, WM8770_PWDNCTRL, 0); } break; case SND_SOC_BIAS_OFF: /* global powerdown */ - snd_soc_write(codec, WM8770_PWDNCTRL, 1); + snd_soc_component_write(component, WM8770_PWDNCTRL, 1); regulator_bulk_disable(ARRAY_SIZE(wm8770->supplies), wm8770->supplies); break; @@ -567,60 +567,59 @@ static int wm8770_set_bias_level(struct snd_soc_codec *codec, .symmetric_rates = 1 };

-static int wm8770_probe(struct snd_soc_codec *codec) +static int wm8770_probe(struct snd_soc_component *component) { struct wm8770_priv *wm8770; int ret;

- wm8770 = snd_soc_codec_get_drvdata(codec); - wm8770->codec = codec; + wm8770 = snd_soc_component_get_drvdata(component); + wm8770->component = component;

ret = regulator_bulk_enable(ARRAY_SIZE(wm8770->supplies), wm8770->supplies); if (ret) { - dev_err(codec->dev, "Failed to enable supplies: %d\n", ret); + dev_err(component->dev, "Failed to enable supplies: %d\n", ret); return ret; }

- ret = wm8770_reset(codec); + ret = wm8770_reset(component); if (ret < 0) { - dev_err(codec->dev, "Failed to issue reset: %d\n", ret); + dev_err(component->dev, "Failed to issue reset: %d\n", ret); goto err_reg_enable; }

/* latch the volume update bits */ - snd_soc_update_bits(codec, WM8770_MSDIGVOL, 0x100, 0x100); - snd_soc_update_bits(codec, WM8770_MSALGVOL, 0x100, 0x100); - snd_soc_update_bits(codec, WM8770_VOUT1RVOL, 0x100, 0x100); - snd_soc_update_bits(codec, WM8770_VOUT2RVOL, 0x100, 0x100); - snd_soc_update_bits(codec, WM8770_VOUT3RVOL, 0x100, 0x100); - snd_soc_update_bits(codec, WM8770_VOUT4RVOL, 0x100, 0x100); - snd_soc_update_bits(codec, WM8770_DAC1RVOL, 0x100, 0x100); - snd_soc_update_bits(codec, WM8770_DAC2RVOL, 0x100, 0x100); - snd_soc_update_bits(codec, WM8770_DAC3RVOL, 0x100, 0x100); - snd_soc_update_bits(codec, WM8770_DAC4RVOL, 0x100, 0x100); + snd_soc_component_update_bits(component, WM8770_MSDIGVOL, 0x100, 0x100); + snd_soc_component_update_bits(component, WM8770_MSALGVOL, 0x100, 0x100); + snd_soc_component_update_bits(component, WM8770_VOUT1RVOL, 0x100, 0x100); + snd_soc_component_update_bits(component, WM8770_VOUT2RVOL, 0x100, 0x100); + snd_soc_component_update_bits(component, WM8770_VOUT3RVOL, 0x100, 0x100); + snd_soc_component_update_bits(component, WM8770_VOUT4RVOL, 0x100, 0x100); + snd_soc_component_update_bits(component, WM8770_DAC1RVOL, 0x100, 0x100); + snd_soc_component_update_bits(component, WM8770_DAC2RVOL, 0x100, 0x100); + snd_soc_component_update_bits(component, WM8770_DAC3RVOL, 0x100, 0x100); + snd_soc_component_update_bits(component, WM8770_DAC4RVOL, 0x100, 0x100);

/* mute all DACs */ - snd_soc_update_bits(codec, WM8770_DACMUTE, 0x10, 0x10); + snd_soc_component_update_bits(component, WM8770_DACMUTE, 0x10, 0x10);

err_reg_enable: regulator_bulk_disable(ARRAY_SIZE(wm8770->supplies), wm8770->supplies); return ret; }

-static const struct snd_soc_codec_driver soc_codec_dev_wm8770 = { - .probe = wm8770_probe, - .set_bias_level = wm8770_set_bias_level, - .idle_bias_off = true, - - .component_driver = { - .controls = wm8770_snd_controls, - .num_controls = ARRAY_SIZE(wm8770_snd_controls), - .dapm_widgets = wm8770_dapm_widgets, - .num_dapm_widgets = ARRAY_SIZE(wm8770_dapm_widgets), - .dapm_routes = wm8770_intercon, - .num_dapm_routes = ARRAY_SIZE(wm8770_intercon), - }, +static const struct snd_soc_component_driver soc_component_dev_wm8770 = { + .probe = wm8770_probe, + .set_bias_level = wm8770_set_bias_level, + .controls = wm8770_snd_controls, + .num_controls = ARRAY_SIZE(wm8770_snd_controls), + .dapm_widgets = wm8770_dapm_widgets, + .num_dapm_widgets = ARRAY_SIZE(wm8770_dapm_widgets), + .dapm_routes = wm8770_intercon, + .num_dapm_routes = ARRAY_SIZE(wm8770_intercon), + .pmdown_time = 1, + .endianness = 1, + .non_legacy_dai_naming = 1, };

static const struct of_device_id wm8770_of_match[] = { @@ -682,8 +681,8 @@ static int wm8770_spi_probe(struct spi_device *spi)

spi_set_drvdata(spi, wm8770);

- ret = snd_soc_register_codec(&spi->dev, - &soc_codec_dev_wm8770, &wm8770_dai, 1); + ret = devm_snd_soc_register_component(&spi->dev, + &soc_component_dev_wm8770, &wm8770_dai, 1);

return ret; } @@ -697,8 +696,6 @@ static int wm8770_spi_remove(struct spi_device *spi) regulator_unregister_notifier(wm8770->supplies[i].consumer, &wm8770->disable_nb[i]);

- snd_soc_unregister_codec(&spi->dev); - return 0; }

From: Kuninori Morimoto kuninori.morimoto.gx@renesas.com

Now we can replace Codec to Component. Let's do it.

Note: xxx_codec_xxx() -> xxx_component_xxx() .idle_bias_off = 0 -> .idle_bias_on = 1 .ignore_pmdown_time = 0 -> .pmdown_time = 1 - -> .endianness = 1 - -> .non_legacy_dai_naming = 1

Signed-off-by: Kuninori Morimoto kuninori.morimoto.gx@renesas.com --- sound/soc/codecs/wm8731.c | 101 +++++++++++++++++++++++----------------------- 1 file changed, 50 insertions(+), 51 deletions(-)

diff --git a/sound/soc/codecs/wm8731.c b/sound/soc/codecs/wm8731.c index 4f9a1eb..4e67b07 100644 --- a/sound/soc/codecs/wm8731.c +++ b/sound/soc/codecs/wm8731.c @@ -88,9 +88,9 @@ static SOC_ENUM_SINGLE_DECL(wm8731_insel_enum,

static int wm8731_deemph[] = { 0, 32000, 44100, 48000 };

-static int wm8731_set_deemph(struct snd_soc_codec *codec) +static int wm8731_set_deemph(struct snd_soc_component *component) { - struct wm8731_priv *wm8731 = snd_soc_codec_get_drvdata(codec); + struct wm8731_priv *wm8731 = snd_soc_component_get_drvdata(component); int val, i, best;

/* If we're using deemphasis select the nearest available sample @@ -110,17 +110,17 @@ static int wm8731_set_deemph(struct snd_soc_codec *codec) val = 0; }

- dev_dbg(codec->dev, "Set deemphasis %d (%dHz)\n", + dev_dbg(component->dev, "Set deemphasis %d (%dHz)\n", best, wm8731_deemph[best]);

- return snd_soc_update_bits(codec, WM8731_APDIGI, 0x6, val); + return snd_soc_component_update_bits(component, WM8731_APDIGI, 0x6, val); }

static int wm8731_get_deemph(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { - struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol); - struct wm8731_priv *wm8731 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol); + struct wm8731_priv *wm8731 = snd_soc_component_get_drvdata(component);

ucontrol->value.integer.value[0] = wm8731->deemph;

@@ -130,8 +130,8 @@ static int wm8731_get_deemph(struct snd_kcontrol *kcontrol, static int wm8731_put_deemph(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { - struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol); - struct wm8731_priv *wm8731 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol); + struct wm8731_priv *wm8731 = snd_soc_component_get_drvdata(component); unsigned int deemph = ucontrol->value.integer.value[0]; int ret = 0;

@@ -142,7 +142,7 @@ static int wm8731_put_deemph(struct snd_kcontrol *kcontrol, if (wm8731->deemph != deemph) { wm8731->deemph = deemph;

- wm8731_set_deemph(codec); + wm8731_set_deemph(component);

ret = 1; } @@ -214,8 +214,8 @@ static int wm8731_put_deemph(struct snd_kcontrol *kcontrol, static int wm8731_check_osc(struct snd_soc_dapm_widget *source, struct snd_soc_dapm_widget *sink) { - struct snd_soc_codec *codec = snd_soc_dapm_to_codec(source->dapm); - struct wm8731_priv *wm8731 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = snd_soc_dapm_to_component(source->dapm); + struct wm8731_priv *wm8731 = snd_soc_component_get_drvdata(component);

return wm8731->sysclk_type == WM8731_SYSCLK_XTAL; } @@ -337,16 +337,16 @@ static int wm8731_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params, struct snd_soc_dai *dai) { - struct snd_soc_codec *codec = dai->codec; - struct wm8731_priv *wm8731 = snd_soc_codec_get_drvdata(codec); - u16 iface = snd_soc_read(codec, WM8731_IFACE) & 0xfff3; + struct snd_soc_component *component = dai->component; + struct wm8731_priv *wm8731 = snd_soc_component_get_drvdata(component); + u16 iface = snd_soc_component_read32(component, WM8731_IFACE) & 0xfff3; int i = get_coeff(wm8731->sysclk, params_rate(params)); u16 srate = (coeff_div[i].sr << 2) | (coeff_div[i].bosr << 1) | coeff_div[i].usb;

wm8731->playback_fs = params_rate(params);

- snd_soc_write(codec, WM8731_SRATE, srate); + snd_soc_component_write(component, WM8731_SRATE, srate);

/* bit size */ switch (params_width(params)) { @@ -363,30 +363,30 @@ static int wm8731_hw_params(struct snd_pcm_substream *substream, break; }

- wm8731_set_deemph(codec); + wm8731_set_deemph(component);

- snd_soc_write(codec, WM8731_IFACE, iface); + snd_soc_component_write(component, WM8731_IFACE, iface); return 0; }

static int wm8731_mute(struct snd_soc_dai *dai, int mute) { - struct snd_soc_codec *codec = dai->codec; - u16 mute_reg = snd_soc_read(codec, WM8731_APDIGI) & 0xfff7; + struct snd_soc_component *component = dai->component; + u16 mute_reg = snd_soc_component_read32(component, WM8731_APDIGI) & 0xfff7;

if (mute) - snd_soc_write(codec, WM8731_APDIGI, mute_reg | 0x8); + snd_soc_component_write(component, WM8731_APDIGI, mute_reg | 0x8); else - snd_soc_write(codec, WM8731_APDIGI, mute_reg); + snd_soc_component_write(component, WM8731_APDIGI, mute_reg); return 0; }

static int wm8731_set_dai_sysclk(struct snd_soc_dai *codec_dai, int clk_id, unsigned int freq, int dir) { - struct snd_soc_codec *codec = codec_dai->codec; - struct snd_soc_dapm_context *dapm = snd_soc_codec_get_dapm(codec); - struct wm8731_priv *wm8731 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = codec_dai->component; + struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(component); + struct wm8731_priv *wm8731 = snd_soc_component_get_drvdata(component);

switch (clk_id) { case WM8731_SYSCLK_XTAL: @@ -429,7 +429,7 @@ static int wm8731_set_dai_sysclk(struct snd_soc_dai *codec_dai, static int wm8731_set_dai_fmt(struct snd_soc_dai *codec_dai, unsigned int fmt) { - struct snd_soc_codec *codec = codec_dai->codec; + struct snd_soc_component *component = codec_dai->component; u16 iface = 0;

/* set master/slave audio interface */ @@ -481,14 +481,14 @@ static int wm8731_set_dai_fmt(struct snd_soc_dai *codec_dai, }

/* set iface */ - snd_soc_write(codec, WM8731_IFACE, iface); + snd_soc_component_write(component, WM8731_IFACE, iface); return 0; }

-static int wm8731_set_bias_level(struct snd_soc_codec *codec, +static int wm8731_set_bias_level(struct snd_soc_component *component, enum snd_soc_bias_level level) { - struct wm8731_priv *wm8731 = snd_soc_codec_get_drvdata(codec); + struct wm8731_priv *wm8731 = snd_soc_component_get_drvdata(component); int ret; u16 reg;

@@ -503,7 +503,7 @@ static int wm8731_set_bias_level(struct snd_soc_codec *codec, case SND_SOC_BIAS_PREPARE: break; case SND_SOC_BIAS_STANDBY: - if (snd_soc_codec_get_bias_level(codec) == SND_SOC_BIAS_OFF) { + if (snd_soc_component_get_bias_level(component) == SND_SOC_BIAS_OFF) { ret = regulator_bulk_enable(ARRAY_SIZE(wm8731->supplies), wm8731->supplies); if (ret != 0) @@ -513,13 +513,13 @@ static int wm8731_set_bias_level(struct snd_soc_codec *codec, }

/* Clear PWROFF, gate CLKOUT, everything else as-is */ - reg = snd_soc_read(codec, WM8731_PWR) & 0xff7f; - snd_soc_write(codec, WM8731_PWR, reg | 0x0040); + reg = snd_soc_component_read32(component, WM8731_PWR) & 0xff7f; + snd_soc_component_write(component, WM8731_PWR, reg | 0x0040); break; case SND_SOC_BIAS_OFF: if (wm8731->mclk) clk_disable_unprepare(wm8731->mclk); - snd_soc_write(codec, WM8731_PWR, 0xffff); + snd_soc_component_write(component, WM8731_PWR, 0xffff); regulator_bulk_disable(ARRAY_SIZE(wm8731->supplies), wm8731->supplies); regcache_mark_dirty(wm8731->regmap); @@ -531,7 +531,7 @@ static int wm8731_set_bias_level(struct snd_soc_codec *codec, static int wm8731_startup(struct snd_pcm_substream *substream, struct snd_soc_dai *dai) { - struct wm8731_priv *wm8731 = snd_soc_codec_get_drvdata(dai->codec); + struct wm8731_priv *wm8731 = snd_soc_component_get_drvdata(dai->component);

if (wm8731->constraints) snd_pcm_hw_constraint_list(substream->runtime, 0, @@ -628,18 +628,19 @@ static int wm8731_hw_init(struct device *dev, struct wm8731_priv *wm8731) return ret; }

-static const struct snd_soc_codec_driver soc_codec_dev_wm8731 = { - .set_bias_level = wm8731_set_bias_level, - .suspend_bias_off = true, - - .component_driver = { - .controls = wm8731_snd_controls, - .num_controls = ARRAY_SIZE(wm8731_snd_controls), - .dapm_widgets = wm8731_dapm_widgets, - .num_dapm_widgets = ARRAY_SIZE(wm8731_dapm_widgets), - .dapm_routes = wm8731_intercon, - .num_dapm_routes = ARRAY_SIZE(wm8731_intercon), - }, +static const struct snd_soc_component_driver soc_component_dev_wm8731 = { + .set_bias_level = wm8731_set_bias_level, + .controls = wm8731_snd_controls, + .num_controls = ARRAY_SIZE(wm8731_snd_controls), + .dapm_widgets = wm8731_dapm_widgets, + .num_dapm_widgets = ARRAY_SIZE(wm8731_dapm_widgets), + .dapm_routes = wm8731_intercon, + .num_dapm_routes = ARRAY_SIZE(wm8731_intercon), + .suspend_bias_off = 1, + .idle_bias_on = 1, + .pmdown_time = 1, + .endianness = 1, + .non_legacy_dai_naming = 1, };

static const struct of_device_id wm8731_of_match[] = { @@ -704,8 +705,8 @@ static int wm8731_spi_probe(struct spi_device *spi) if (ret != 0) return ret;

- ret = snd_soc_register_codec(&spi->dev, - &soc_codec_dev_wm8731, &wm8731_dai, 1); + ret = devm_snd_soc_register_component(&spi->dev, + &soc_component_dev_wm8731, &wm8731_dai, 1); if (ret != 0) { dev_err(&spi->dev, "Failed to register CODEC: %d\n", ret); return ret; @@ -716,7 +717,6 @@ static int wm8731_spi_probe(struct spi_device *spi)

static int wm8731_spi_remove(struct spi_device *spi) { - snd_soc_unregister_codec(&spi->dev); return 0; }

@@ -775,8 +775,8 @@ static int wm8731_i2c_probe(struct i2c_client *i2c, if (ret != 0) return ret;

- ret = snd_soc_register_codec(&i2c->dev, - &soc_codec_dev_wm8731, &wm8731_dai, 1); + ret = devm_snd_soc_register_component(&i2c->dev, + &soc_component_dev_wm8731, &wm8731_dai, 1); if (ret != 0) { dev_err(&i2c->dev, "Failed to register CODEC: %d\n", ret); return ret; @@ -787,7 +787,6 @@ static int wm8731_i2c_probe(struct i2c_client *i2c,

static int wm8731_i2c_remove(struct i2c_client *client) { - snd_soc_unregister_codec(&client->dev); return 0; }

From: Kuninori Morimoto kuninori.morimoto.gx@renesas.com

Now we can replace Codec to Component. Let's do it.

Note: xxx_codec_xxx() -> xxx_component_xxx() .idle_bias_off = 0 -> .idle_bias_on = 1 .ignore_pmdown_time = 0 -> .pmdown_time = 1 - -> .endianness = 1 - -> .non_legacy_dai_naming = 1

Signed-off-by: Kuninori Morimoto kuninori.morimoto.gx@renesas.com --- sound/soc/codecs/wm8728.c | 82 ++++++++++++++++++++--------------------------- 1 file changed, 34 insertions(+), 48 deletions(-)

diff --git a/sound/soc/codecs/wm8728.c b/sound/soc/codecs/wm8728.c index 797cc6e..b6f4cf0 100644 --- a/sound/soc/codecs/wm8728.c +++ b/sound/soc/codecs/wm8728.c @@ -74,13 +74,13 @@ struct wm8728_priv {

static int wm8728_mute(struct snd_soc_dai *dai, int mute) { - struct snd_soc_codec *codec = dai->codec; - u16 mute_reg = snd_soc_read(codec, WM8728_DACCTL); + struct snd_soc_component *component = dai->component; + u16 mute_reg = snd_soc_component_read32(component, WM8728_DACCTL);

if (mute) - snd_soc_write(codec, WM8728_DACCTL, mute_reg | 1); + snd_soc_component_write(component, WM8728_DACCTL, mute_reg | 1); else - snd_soc_write(codec, WM8728_DACCTL, mute_reg & ~1); + snd_soc_component_write(component, WM8728_DACCTL, mute_reg & ~1);

return 0; } @@ -89,8 +89,8 @@ static int wm8728_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params, struct snd_soc_dai *dai) { - struct snd_soc_codec *codec = dai->codec; - u16 dac = snd_soc_read(codec, WM8728_DACCTL); + struct snd_soc_component *component = dai->component; + u16 dac = snd_soc_component_read32(component, WM8728_DACCTL);

dac &= ~0x18;

@@ -107,7 +107,7 @@ static int wm8728_hw_params(struct snd_pcm_substream *substream, return -EINVAL; }

- snd_soc_write(codec, WM8728_DACCTL, dac); + snd_soc_component_write(component, WM8728_DACCTL, dac);

return 0; } @@ -115,8 +115,8 @@ static int wm8728_hw_params(struct snd_pcm_substream *substream, static int wm8728_set_dai_fmt(struct snd_soc_dai *codec_dai, unsigned int fmt) { - struct snd_soc_codec *codec = codec_dai->codec; - u16 iface = snd_soc_read(codec, WM8728_IFCTL); + struct snd_soc_component *component = codec_dai->component; + u16 iface = snd_soc_component_read32(component, WM8728_IFCTL);

/* Currently only I2S is supported by the driver, though the * hardware is more flexible. @@ -156,24 +156,24 @@ static int wm8728_set_dai_fmt(struct snd_soc_dai *codec_dai, return -EINVAL; }

- snd_soc_write(codec, WM8728_IFCTL, iface); + snd_soc_component_write(component, WM8728_IFCTL, iface); return 0; }

-static int wm8728_set_bias_level(struct snd_soc_codec *codec, +static int wm8728_set_bias_level(struct snd_soc_component *component, enum snd_soc_bias_level level) { - struct wm8728_priv *wm8728 = snd_soc_codec_get_drvdata(codec); + struct wm8728_priv *wm8728 = snd_soc_component_get_drvdata(component); u16 reg;

switch (level) { case SND_SOC_BIAS_ON: case SND_SOC_BIAS_PREPARE: case SND_SOC_BIAS_STANDBY: - if (snd_soc_codec_get_bias_level(codec) == SND_SOC_BIAS_OFF) { + if (snd_soc_component_get_bias_level(component) == SND_SOC_BIAS_OFF) { /* Power everything up... */ - reg = snd_soc_read(codec, WM8728_DACCTL); - snd_soc_write(codec, WM8728_DACCTL, reg & ~0x4); + reg = snd_soc_component_read32(component, WM8728_DACCTL); + snd_soc_component_write(component, WM8728_DACCTL, reg & ~0x4);

/* ..then sync in the register cache. */ regcache_sync(wm8728->regmap); @@ -181,8 +181,8 @@ static int wm8728_set_bias_level(struct snd_soc_codec *codec, break;

case SND_SOC_BIAS_OFF: - reg = snd_soc_read(codec, WM8728_DACCTL); - snd_soc_write(codec, WM8728_DACCTL, reg | 0x4); + reg = snd_soc_component_read32(component, WM8728_DACCTL); + snd_soc_component_write(component, WM8728_DACCTL, reg | 0x4); break; } return 0; @@ -211,18 +211,19 @@ static int wm8728_set_bias_level(struct snd_soc_codec *codec, .ops = &wm8728_dai_ops, };

-static const struct snd_soc_codec_driver soc_codec_dev_wm8728 = { - .set_bias_level = wm8728_set_bias_level, - .suspend_bias_off = true, - - .component_driver = { - .controls = wm8728_snd_controls, - .num_controls = ARRAY_SIZE(wm8728_snd_controls), - .dapm_widgets = wm8728_dapm_widgets, - .num_dapm_widgets = ARRAY_SIZE(wm8728_dapm_widgets), - .dapm_routes = wm8728_intercon, - .num_dapm_routes = ARRAY_SIZE(wm8728_intercon), - }, +static const struct snd_soc_component_driver soc_component_dev_wm8728 = { + .set_bias_level = wm8728_set_bias_level, + .controls = wm8728_snd_controls, + .num_controls = ARRAY_SIZE(wm8728_snd_controls), + .dapm_widgets = wm8728_dapm_widgets, + .num_dapm_widgets = ARRAY_SIZE(wm8728_dapm_widgets), + .dapm_routes = wm8728_intercon, + .num_dapm_routes = ARRAY_SIZE(wm8728_intercon), + .suspend_bias_off = 1, + .idle_bias_on = 1, + .pmdown_time = 1, + .endianness = 1, + .non_legacy_dai_naming = 1, };

static const struct of_device_id wm8728_of_match[] = { @@ -258,26 +259,18 @@ static int wm8728_spi_probe(struct spi_device *spi)

spi_set_drvdata(spi, wm8728);

- ret = snd_soc_register_codec(&spi->dev, - &soc_codec_dev_wm8728, &wm8728_dai, 1); + ret = devm_snd_soc_register_component(&spi->dev, + &soc_component_dev_wm8728, &wm8728_dai, 1);

return ret; }

-static int wm8728_spi_remove(struct spi_device *spi) -{ - snd_soc_unregister_codec(&spi->dev); - - return 0; -} - static struct spi_driver wm8728_spi_driver = { .driver = { .name = "wm8728", .of_match_table = wm8728_of_match, }, .probe = wm8728_spi_probe, - .remove = wm8728_spi_remove, }; #endif /* CONFIG_SPI_MASTER */

@@ -299,18 +292,12 @@ static int wm8728_i2c_probe(struct i2c_client *i2c,

i2c_set_clientdata(i2c, wm8728);

- ret = snd_soc_register_codec(&i2c->dev, - &soc_codec_dev_wm8728, &wm8728_dai, 1); + ret = devm_snd_soc_register_component(&i2c->dev, + &soc_component_dev_wm8728, &wm8728_dai, 1);

return ret; }

-static int wm8728_i2c_remove(struct i2c_client *client) -{ - snd_soc_unregister_codec(&client->dev); - return 0; -} - static const struct i2c_device_id wm8728_i2c_id[] = { { "wm8728", 0 }, { } @@ -323,7 +310,6 @@ static int wm8728_i2c_remove(struct i2c_client *client) .of_match_table = wm8728_of_match, }, .probe = wm8728_i2c_probe, - .remove = wm8728_i2c_remove, .id_table = wm8728_i2c_id, }; #endif

From: Kuninori Morimoto kuninori.morimoto.gx@renesas.com

Now we can replace Codec to Component. Let's do it.

Note: xxx_codec_xxx() -> xxx_component_xxx() .idle_bias_off = 0 -> .idle_bias_on = 1 .ignore_pmdown_time = 0 -> .pmdown_time = 1 - -> .endianness = 1 - -> .non_legacy_dai_naming = 1

Signed-off-by: Kuninori Morimoto kuninori.morimoto.gx@renesas.com --- sound/soc/codecs/wm8753.c | 289 ++++++++++++++++++++++------------------------ 1 file changed, 138 insertions(+), 151 deletions(-)

diff --git a/sound/soc/codecs/wm8753.c b/sound/soc/codecs/wm8753.c index 0271a52..cbcd998 100644 --- a/sound/soc/codecs/wm8753.c +++ b/sound/soc/codecs/wm8753.c @@ -55,9 +55,9 @@ module_param(caps_charge, int, 0); MODULE_PARM_DESC(caps_charge, "WM8753 cap charge time (msecs)");

-static int wm8753_hifi_write_dai_fmt(struct snd_soc_codec *codec, +static int wm8753_hifi_write_dai_fmt(struct snd_soc_component *component, unsigned int fmt); -static int wm8753_voice_write_dai_fmt(struct snd_soc_codec *codec, +static int wm8753_voice_write_dai_fmt(struct snd_soc_component *component, unsigned int fmt);

/* @@ -150,7 +150,7 @@ struct wm8753_priv { struct delayed_work charge_work; };

-#define wm8753_reset(c) snd_soc_write(c, WM8753_RESET, 0) +#define wm8753_reset(c) snd_soc_component_write(c, WM8753_RESET, 0)

/* * WM8753 Controls @@ -229,8 +229,8 @@ struct wm8753_priv { static int wm8753_get_dai(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { - struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol); - struct wm8753_priv *wm8753 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol); + struct wm8753_priv *wm8753 = snd_soc_component_get_drvdata(component);

ucontrol->value.enumerated.item[0] = wm8753->dai_func; return 0; @@ -239,17 +239,17 @@ static int wm8753_get_dai(struct snd_kcontrol *kcontrol, static int wm8753_set_dai(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { - struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol); - struct wm8753_priv *wm8753 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol); + struct wm8753_priv *wm8753 = snd_soc_component_get_drvdata(component); u16 ioctl;

if (wm8753->dai_func == ucontrol->value.enumerated.item[0]) return 0;

- if (snd_soc_codec_is_active(codec)) + if (snd_soc_component_is_active(component)) return -EBUSY;

- ioctl = snd_soc_read(codec, WM8753_IOCTL); + ioctl = snd_soc_component_read32(component, WM8753_IOCTL);

wm8753->dai_func = ucontrol->value.enumerated.item[0];

@@ -257,11 +257,11 @@ static int wm8753_set_dai(struct snd_kcontrol *kcontrol, return 1;

ioctl = (ioctl & 0x1f3) | (wm8753->dai_func << 2); - snd_soc_write(codec, WM8753_IOCTL, ioctl); + snd_soc_component_write(component, WM8753_IOCTL, ioctl);

- wm8753_hifi_write_dai_fmt(codec, wm8753->hifi_fmt); - wm8753_voice_write_dai_fmt(codec, wm8753->voice_fmt); + wm8753_hifi_write_dai_fmt(component, wm8753->hifi_fmt); + wm8753_voice_write_dai_fmt(component, wm8753->voice_fmt);

return 1; } @@ -745,7 +745,7 @@ static int wm8753_set_dai_pll(struct snd_soc_dai *codec_dai, int pll_id, { u16 reg, enable; int offset; - struct snd_soc_codec *codec = codec_dai->codec; + struct snd_soc_component *component = codec_dai->component;

if (pll_id < WM8753_PLL1 || pll_id > WM8753_PLL2) return -ENODEV; @@ -753,17 +753,17 @@ static int wm8753_set_dai_pll(struct snd_soc_dai *codec_dai, int pll_id, if (pll_id == WM8753_PLL1) { offset = 0; enable = 0x10; - reg = snd_soc_read(codec, WM8753_CLOCK) & 0xffef; + reg = snd_soc_component_read32(component, WM8753_CLOCK) & 0xffef; } else { offset = 4; enable = 0x8; - reg = snd_soc_read(codec, WM8753_CLOCK) & 0xfff7; + reg = snd_soc_component_read32(component, WM8753_CLOCK) & 0xfff7; }

if (!freq_in || !freq_out) { /* disable PLL */ - snd_soc_write(codec, WM8753_PLL1CTL1 + offset, 0x0026); - snd_soc_write(codec, WM8753_CLOCK, reg); + snd_soc_component_write(component, WM8753_PLL1CTL1 + offset, 0x0026); + snd_soc_component_write(component, WM8753_CLOCK, reg); return 0; } else { u16 value = 0; @@ -774,20 +774,20 @@ static int wm8753_set_dai_pll(struct snd_soc_dai *codec_dai, int pll_id, /* set up N and K PLL divisor ratios */ /* bits 8:5 = PLL_N, bits 3:0 = PLL_K[21:18] */ value = (pll_div.n << 5) + ((pll_div.k & 0x3c0000) >> 18); - snd_soc_write(codec, WM8753_PLL1CTL2 + offset, value); + snd_soc_component_write(component, WM8753_PLL1CTL2 + offset, value);

/* bits 8:0 = PLL_K[17:9] */ value = (pll_div.k & 0x03fe00) >> 9; - snd_soc_write(codec, WM8753_PLL1CTL3 + offset, value); + snd_soc_component_write(component, WM8753_PLL1CTL3 + offset, value);

/* bits 8:0 = PLL_K[8:0] */ value = pll_div.k & 0x0001ff; - snd_soc_write(codec, WM8753_PLL1CTL4 + offset, value); + snd_soc_component_write(component, WM8753_PLL1CTL4 + offset, value);

/* set PLL as input and enable */ - snd_soc_write(codec, WM8753_PLL1CTL1 + offset, 0x0027 | + snd_soc_component_write(component, WM8753_PLL1CTL1 + offset, 0x0027 | (pll_div.div2 << 3)); - snd_soc_write(codec, WM8753_CLOCK, reg | enable); + snd_soc_component_write(component, WM8753_CLOCK, reg | enable); } return 0; } @@ -866,8 +866,8 @@ static int get_coeff(int mclk, int rate) static int wm8753_set_dai_sysclk(struct snd_soc_dai *codec_dai, int clk_id, unsigned int freq, int dir) { - struct snd_soc_codec *codec = codec_dai->codec; - struct wm8753_priv *wm8753 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = codec_dai->component; + struct wm8753_priv *wm8753 = snd_soc_component_get_drvdata(component);

switch (freq) { case 11289600: @@ -890,10 +890,10 @@ static int wm8753_set_dai_sysclk(struct snd_soc_dai *codec_dai, /* * Set's ADC and Voice DAC format. */ -static int wm8753_vdac_adc_set_dai_fmt(struct snd_soc_codec *codec, +static int wm8753_vdac_adc_set_dai_fmt(struct snd_soc_component *component, unsigned int fmt) { - u16 voice = snd_soc_read(codec, WM8753_PCM) & 0x01ec; + u16 voice = snd_soc_component_read32(component, WM8753_PCM) & 0x01ec;

/* interface format */ switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) { @@ -915,7 +915,7 @@ static int wm8753_vdac_adc_set_dai_fmt(struct snd_soc_codec *codec, return -EINVAL; }

- snd_soc_write(codec, WM8753_PCM, voice); + snd_soc_component_write(component, WM8753_PCM, voice); return 0; }

@@ -926,10 +926,10 @@ static int wm8753_pcm_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params, struct snd_soc_dai *dai) { - struct snd_soc_codec *codec = dai->codec; - struct wm8753_priv *wm8753 = snd_soc_codec_get_drvdata(codec); - u16 voice = snd_soc_read(codec, WM8753_PCM) & 0x01f3; - u16 srate = snd_soc_read(codec, WM8753_SRATE1) & 0x017f; + struct snd_soc_component *component = dai->component; + struct wm8753_priv *wm8753 = snd_soc_component_get_drvdata(component); + u16 voice = snd_soc_component_read32(component, WM8753_PCM) & 0x01f3; + u16 srate = snd_soc_component_read32(component, WM8753_SRATE1) & 0x017f;

/* bit size */ switch (params_width(params)) { @@ -949,22 +949,22 @@ static int wm8753_pcm_hw_params(struct snd_pcm_substream *substream, /* sample rate */ if (params_rate(params) * 384 == wm8753->pcmclk) srate |= 0x80; - snd_soc_write(codec, WM8753_SRATE1, srate); + snd_soc_component_write(component, WM8753_SRATE1, srate);

- snd_soc_write(codec, WM8753_PCM, voice); + snd_soc_component_write(component, WM8753_PCM, voice); return 0; }

/* * Set's PCM dai fmt and BCLK. */ -static int wm8753_pcm_set_dai_fmt(struct snd_soc_codec *codec, +static int wm8753_pcm_set_dai_fmt(struct snd_soc_component *component, unsigned int fmt) { u16 voice, ioctl;

- voice = snd_soc_read(codec, WM8753_PCM) & 0x011f; - ioctl = snd_soc_read(codec, WM8753_IOCTL) & 0x015d; + voice = snd_soc_component_read32(component, WM8753_PCM) & 0x011f; + ioctl = snd_soc_component_read32(component, WM8753_IOCTL) & 0x015d;

/* set master/slave audio interface */ switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) { @@ -1018,29 +1018,29 @@ static int wm8753_pcm_set_dai_fmt(struct snd_soc_codec *codec, return -EINVAL; }

- snd_soc_write(codec, WM8753_PCM, voice); - snd_soc_write(codec, WM8753_IOCTL, ioctl); + snd_soc_component_write(component, WM8753_PCM, voice); + snd_soc_component_write(component, WM8753_IOCTL, ioctl); return 0; }

static int wm8753_set_dai_clkdiv(struct snd_soc_dai *codec_dai, int div_id, int div) { - struct snd_soc_codec *codec = codec_dai->codec; + struct snd_soc_component *component = codec_dai->component; u16 reg;

switch (div_id) { case WM8753_PCMDIV: - reg = snd_soc_read(codec, WM8753_CLOCK) & 0x003f; - snd_soc_write(codec, WM8753_CLOCK, reg | div); + reg = snd_soc_component_read32(component, WM8753_CLOCK) & 0x003f; + snd_soc_component_write(component, WM8753_CLOCK, reg | div); break; case WM8753_BCLKDIV: - reg = snd_soc_read(codec, WM8753_SRATE2) & 0x01c7; - snd_soc_write(codec, WM8753_SRATE2, reg | div); + reg = snd_soc_component_read32(component, WM8753_SRATE2) & 0x01c7; + snd_soc_component_write(component, WM8753_SRATE2, reg | div); break; case WM8753_VXCLKDIV: - reg = snd_soc_read(codec, WM8753_SRATE2) & 0x003f; - snd_soc_write(codec, WM8753_SRATE2, reg | div); + reg = snd_soc_component_read32(component, WM8753_SRATE2) & 0x003f; + snd_soc_component_write(component, WM8753_SRATE2, reg | div); break; default: return -EINVAL; @@ -1051,10 +1051,10 @@ static int wm8753_set_dai_clkdiv(struct snd_soc_dai *codec_dai, /* * Set's HiFi DAC format. */ -static int wm8753_hdac_set_dai_fmt(struct snd_soc_codec *codec, +static int wm8753_hdac_set_dai_fmt(struct snd_soc_component *component, unsigned int fmt) { - u16 hifi = snd_soc_read(codec, WM8753_HIFI) & 0x01e0; + u16 hifi = snd_soc_component_read32(component, WM8753_HIFI) & 0x01e0;

/* interface format */ switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) { @@ -1076,20 +1076,20 @@ static int wm8753_hdac_set_dai_fmt(struct snd_soc_codec *codec, return -EINVAL; }

- snd_soc_write(codec, WM8753_HIFI, hifi); + snd_soc_component_write(component, WM8753_HIFI, hifi); return 0; }

/* * Set's I2S DAI format. */ -static int wm8753_i2s_set_dai_fmt(struct snd_soc_codec *codec, +static int wm8753_i2s_set_dai_fmt(struct snd_soc_component *component, unsigned int fmt) { u16 ioctl, hifi;

- hifi = snd_soc_read(codec, WM8753_HIFI) & 0x013f; - ioctl = snd_soc_read(codec, WM8753_IOCTL) & 0x00ae; + hifi = snd_soc_component_read32(component, WM8753_HIFI) & 0x013f; + ioctl = snd_soc_component_read32(component, WM8753_IOCTL) & 0x00ae;

/* set master/slave audio interface */ switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) { @@ -1143,8 +1143,8 @@ static int wm8753_i2s_set_dai_fmt(struct snd_soc_codec *codec, return -EINVAL; }

- snd_soc_write(codec, WM8753_HIFI, hifi); - snd_soc_write(codec, WM8753_IOCTL, ioctl); + snd_soc_component_write(component, WM8753_HIFI, hifi); + snd_soc_component_write(component, WM8753_IOCTL, ioctl); return 0; }

@@ -1155,10 +1155,10 @@ static int wm8753_i2s_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params, struct snd_soc_dai *dai) { - struct snd_soc_codec *codec = dai->codec; - struct wm8753_priv *wm8753 = snd_soc_codec_get_drvdata(codec); - u16 srate = snd_soc_read(codec, WM8753_SRATE1) & 0x01c0; - u16 hifi = snd_soc_read(codec, WM8753_HIFI) & 0x01f3; + struct snd_soc_component *component = dai->component; + struct wm8753_priv *wm8753 = snd_soc_component_get_drvdata(component); + u16 srate = snd_soc_component_read32(component, WM8753_SRATE1) & 0x01c0; + u16 hifi = snd_soc_component_read32(component, WM8753_HIFI) & 0x01f3; int coeff;

/* is digital filter coefficient valid ? */ @@ -1167,7 +1167,7 @@ static int wm8753_i2s_hw_params(struct snd_pcm_substream *substream, printk(KERN_ERR "wm8753 invalid MCLK or rate\n"); return coeff; } - snd_soc_write(codec, WM8753_SRATE1, srate | (coeff_div[coeff].sr << 1) | + snd_soc_component_write(component, WM8753_SRATE1, srate | (coeff_div[coeff].sr << 1) | coeff_div[coeff].usb);

/* bit size */ @@ -1185,70 +1185,70 @@ static int wm8753_i2s_hw_params(struct snd_pcm_substream *substream, break; }

- snd_soc_write(codec, WM8753_HIFI, hifi); + snd_soc_component_write(component, WM8753_HIFI, hifi); return 0; }

-static int wm8753_mode1v_set_dai_fmt(struct snd_soc_codec *codec, +static int wm8753_mode1v_set_dai_fmt(struct snd_soc_component *component, unsigned int fmt) { u16 clock;

/* set clk source as pcmclk */ - clock = snd_soc_read(codec, WM8753_CLOCK) & 0xfffb; - snd_soc_write(codec, WM8753_CLOCK, clock); + clock = snd_soc_component_read32(component, WM8753_CLOCK) & 0xfffb; + snd_soc_component_write(component, WM8753_CLOCK, clock);

- return wm8753_vdac_adc_set_dai_fmt(codec, fmt); + return wm8753_vdac_adc_set_dai_fmt(component, fmt); }

-static int wm8753_mode1h_set_dai_fmt(struct snd_soc_codec *codec, +static int wm8753_mode1h_set_dai_fmt(struct snd_soc_component *component, unsigned int fmt) { - return wm8753_hdac_set_dai_fmt(codec, fmt); + return wm8753_hdac_set_dai_fmt(component, fmt); }

-static int wm8753_mode2_set_dai_fmt(struct snd_soc_codec *codec, +static int wm8753_mode2_set_dai_fmt(struct snd_soc_component *component, unsigned int fmt) { u16 clock;

/* set clk source as pcmclk */ - clock = snd_soc_read(codec, WM8753_CLOCK) & 0xfffb; - snd_soc_write(codec, WM8753_CLOCK, clock); + clock = snd_soc_component_read32(component, WM8753_CLOCK) & 0xfffb; + snd_soc_component_write(component, WM8753_CLOCK, clock);

- return wm8753_vdac_adc_set_dai_fmt(codec, fmt); + return wm8753_vdac_adc_set_dai_fmt(component, fmt); }

-static int wm8753_mode3_4_set_dai_fmt(struct snd_soc_codec *codec, +static int wm8753_mode3_4_set_dai_fmt(struct snd_soc_component *component, unsigned int fmt) { u16 clock;

/* set clk source as mclk */ - clock = snd_soc_read(codec, WM8753_CLOCK) & 0xfffb; - snd_soc_write(codec, WM8753_CLOCK, clock | 0x4); + clock = snd_soc_component_read32(component, WM8753_CLOCK) & 0xfffb; + snd_soc_component_write(component, WM8753_CLOCK, clock | 0x4);

- if (wm8753_hdac_set_dai_fmt(codec, fmt) < 0) + if (wm8753_hdac_set_dai_fmt(component, fmt) < 0) return -EINVAL; - return wm8753_vdac_adc_set_dai_fmt(codec, fmt); + return wm8753_vdac_adc_set_dai_fmt(component, fmt); }

-static int wm8753_hifi_write_dai_fmt(struct snd_soc_codec *codec, +static int wm8753_hifi_write_dai_fmt(struct snd_soc_component *component, unsigned int fmt) { - struct wm8753_priv *wm8753 = snd_soc_codec_get_drvdata(codec); + struct wm8753_priv *wm8753 = snd_soc_component_get_drvdata(component); int ret = 0;

switch (wm8753->dai_func) { case 0: - ret = wm8753_mode1h_set_dai_fmt(codec, fmt); + ret = wm8753_mode1h_set_dai_fmt(component, fmt); break; case 1: - ret = wm8753_mode2_set_dai_fmt(codec, fmt); + ret = wm8753_mode2_set_dai_fmt(component, fmt); break; case 2: case 3: - ret = wm8753_mode3_4_set_dai_fmt(codec, fmt); + ret = wm8753_mode3_4_set_dai_fmt(component, fmt); break; default: break; @@ -1256,33 +1256,33 @@ static int wm8753_hifi_write_dai_fmt(struct snd_soc_codec *codec, if (ret) return ret;

- return wm8753_i2s_set_dai_fmt(codec, fmt); + return wm8753_i2s_set_dai_fmt(component, fmt); }

static int wm8753_hifi_set_dai_fmt(struct snd_soc_dai *codec_dai, unsigned int fmt) { - struct snd_soc_codec *codec = codec_dai->codec; - struct wm8753_priv *wm8753 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = codec_dai->component; + struct wm8753_priv *wm8753 = snd_soc_component_get_drvdata(component);

wm8753->hifi_fmt = fmt;

- return wm8753_hifi_write_dai_fmt(codec, fmt); + return wm8753_hifi_write_dai_fmt(component, fmt); };

-static int wm8753_voice_write_dai_fmt(struct snd_soc_codec *codec, +static int wm8753_voice_write_dai_fmt(struct snd_soc_component *component, unsigned int fmt) { - struct wm8753_priv *wm8753 = snd_soc_codec_get_drvdata(codec); + struct wm8753_priv *wm8753 = snd_soc_component_get_drvdata(component); int ret = 0;

if (wm8753->dai_func != 0) return 0;

- ret = wm8753_mode1v_set_dai_fmt(codec, fmt); + ret = wm8753_mode1v_set_dai_fmt(component, fmt); if (ret) return ret; - ret = wm8753_pcm_set_dai_fmt(codec, fmt); + ret = wm8753_pcm_set_dai_fmt(component, fmt); if (ret) return ret;

@@ -1292,30 +1292,30 @@ static int wm8753_voice_write_dai_fmt(struct snd_soc_codec *codec, static int wm8753_voice_set_dai_fmt(struct snd_soc_dai *codec_dai, unsigned int fmt) { - struct snd_soc_codec *codec = codec_dai->codec; - struct wm8753_priv *wm8753 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = codec_dai->component; + struct wm8753_priv *wm8753 = snd_soc_component_get_drvdata(component);

wm8753->voice_fmt = fmt;

- return wm8753_voice_write_dai_fmt(codec, fmt); + return wm8753_voice_write_dai_fmt(component, fmt); };

static int wm8753_mute(struct snd_soc_dai *dai, int mute) { - struct snd_soc_codec *codec = dai->codec; - u16 mute_reg = snd_soc_read(codec, WM8753_DAC) & 0xfff7; - struct wm8753_priv *wm8753 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = dai->component; + u16 mute_reg = snd_soc_component_read32(component, WM8753_DAC) & 0xfff7; + struct wm8753_priv *wm8753 = snd_soc_component_get_drvdata(component);

/* the digital mute covers the HiFi and Voice DAC's on the WM8753. * make sure we check if they are not both active when we mute */ if (mute && wm8753->dai_func == 1) { - if (!snd_soc_codec_is_active(codec)) - snd_soc_write(codec, WM8753_DAC, mute_reg | 0x8); + if (!snd_soc_component_is_active(component)) + snd_soc_component_write(component, WM8753_DAC, mute_reg | 0x8); } else { if (mute) - snd_soc_write(codec, WM8753_DAC, mute_reg | 0x8); + snd_soc_component_write(component, WM8753_DAC, mute_reg | 0x8); else - snd_soc_write(codec, WM8753_DAC, mute_reg); + snd_soc_component_write(component, WM8753_DAC, mute_reg); }

return 0; @@ -1330,35 +1330,35 @@ static void wm8753_charge_work(struct work_struct *work) regmap_update_bits(wm8753->regmap, WM8753_PWR1, 0x0180, 0x0100); }

-static int wm8753_set_bias_level(struct snd_soc_codec *codec, +static int wm8753_set_bias_level(struct snd_soc_component *component, enum snd_soc_bias_level level) { - struct wm8753_priv *wm8753 = snd_soc_codec_get_drvdata(codec); - u16 pwr_reg = snd_soc_read(codec, WM8753_PWR1) & 0xfe3e; + struct wm8753_priv *wm8753 = snd_soc_component_get_drvdata(component); + u16 pwr_reg = snd_soc_component_read32(component, WM8753_PWR1) & 0xfe3e;

switch (level) { case SND_SOC_BIAS_ON: /* set vmid to 50k and unmute dac */ - snd_soc_write(codec, WM8753_PWR1, pwr_reg | 0x00c0); + snd_soc_component_write(component, WM8753_PWR1, pwr_reg | 0x00c0); break; case SND_SOC_BIAS_PREPARE: /* Wait until fully charged */ flush_delayed_work(&wm8753->charge_work); break; case SND_SOC_BIAS_STANDBY: - if (snd_soc_codec_get_bias_level(codec) == SND_SOC_BIAS_OFF) { + if (snd_soc_component_get_bias_level(component) == SND_SOC_BIAS_OFF) { /* set vmid to 5k for quick power up */ - snd_soc_write(codec, WM8753_PWR1, pwr_reg | 0x01c1); + snd_soc_component_write(component, WM8753_PWR1, pwr_reg | 0x01c1); schedule_delayed_work(&wm8753->charge_work, msecs_to_jiffies(caps_charge)); } else { /* mute dac and set vmid to 500k, enable VREF */ - snd_soc_write(codec, WM8753_PWR1, pwr_reg | 0x0141); + snd_soc_component_write(component, WM8753_PWR1, pwr_reg | 0x0141); } break; case SND_SOC_BIAS_OFF: cancel_delayed_work_sync(&wm8753->charge_work); - snd_soc_write(codec, WM8753_PWR1, 0x0001); + snd_soc_component_write(component, WM8753_PWR1, 0x0001); break; } return 0; @@ -1440,59 +1440,60 @@ static int wm8753_set_bias_level(struct snd_soc_codec *codec, }, };

-static int wm8753_resume(struct snd_soc_codec *codec) +static int wm8753_resume(struct snd_soc_component *component) { - struct wm8753_priv *wm8753 = snd_soc_codec_get_drvdata(codec); + struct wm8753_priv *wm8753 = snd_soc_component_get_drvdata(component);

regcache_sync(wm8753->regmap);

return 0; }

-static int wm8753_probe(struct snd_soc_codec *codec) +static int wm8753_probe(struct snd_soc_component *component) { - struct wm8753_priv *wm8753 = snd_soc_codec_get_drvdata(codec); + struct wm8753_priv *wm8753 = snd_soc_component_get_drvdata(component); int ret;

INIT_DELAYED_WORK(&wm8753->charge_work, wm8753_charge_work);

- ret = wm8753_reset(codec); + ret = wm8753_reset(component); if (ret < 0) { - dev_err(codec->dev, "Failed to issue reset: %d\n", ret); + dev_err(component->dev, "Failed to issue reset: %d\n", ret); return ret; }

wm8753->dai_func = 0;

/* set the update bits */ - snd_soc_update_bits(codec, WM8753_LDAC, 0x0100, 0x0100); - snd_soc_update_bits(codec, WM8753_RDAC, 0x0100, 0x0100); - snd_soc_update_bits(codec, WM8753_LADC, 0x0100, 0x0100); - snd_soc_update_bits(codec, WM8753_RADC, 0x0100, 0x0100); - snd_soc_update_bits(codec, WM8753_LOUT1V, 0x0100, 0x0100); - snd_soc_update_bits(codec, WM8753_ROUT1V, 0x0100, 0x0100); - snd_soc_update_bits(codec, WM8753_LOUT2V, 0x0100, 0x0100); - snd_soc_update_bits(codec, WM8753_ROUT2V, 0x0100, 0x0100); - snd_soc_update_bits(codec, WM8753_LINVOL, 0x0100, 0x0100); - snd_soc_update_bits(codec, WM8753_RINVOL, 0x0100, 0x0100); + snd_soc_component_update_bits(component, WM8753_LDAC, 0x0100, 0x0100); + snd_soc_component_update_bits(component, WM8753_RDAC, 0x0100, 0x0100); + snd_soc_component_update_bits(component, WM8753_LADC, 0x0100, 0x0100); + snd_soc_component_update_bits(component, WM8753_RADC, 0x0100, 0x0100); + snd_soc_component_update_bits(component, WM8753_LOUT1V, 0x0100, 0x0100); + snd_soc_component_update_bits(component, WM8753_ROUT1V, 0x0100, 0x0100); + snd_soc_component_update_bits(component, WM8753_LOUT2V, 0x0100, 0x0100); + snd_soc_component_update_bits(component, WM8753_ROUT2V, 0x0100, 0x0100); + snd_soc_component_update_bits(component, WM8753_LINVOL, 0x0100, 0x0100); + snd_soc_component_update_bits(component, WM8753_RINVOL, 0x0100, 0x0100);

return 0; }

-static const struct snd_soc_codec_driver soc_codec_dev_wm8753 = { - .probe = wm8753_probe, - .resume = wm8753_resume, - .set_bias_level = wm8753_set_bias_level, - .suspend_bias_off = true, - - .component_driver = { - .controls = wm8753_snd_controls, - .num_controls = ARRAY_SIZE(wm8753_snd_controls), - .dapm_widgets = wm8753_dapm_widgets, - .num_dapm_widgets = ARRAY_SIZE(wm8753_dapm_widgets), - .dapm_routes = wm8753_dapm_routes, - .num_dapm_routes = ARRAY_SIZE(wm8753_dapm_routes), - }, +static const struct snd_soc_component_driver soc_component_dev_wm8753 = { + .probe = wm8753_probe, + .resume = wm8753_resume, + .set_bias_level = wm8753_set_bias_level, + .controls = wm8753_snd_controls, + .num_controls = ARRAY_SIZE(wm8753_snd_controls), + .dapm_widgets = wm8753_dapm_widgets, + .num_dapm_widgets = ARRAY_SIZE(wm8753_dapm_widgets), + .dapm_routes = wm8753_dapm_routes, + .num_dapm_routes = ARRAY_SIZE(wm8753_dapm_routes), + .suspend_bias_off = 1, + .idle_bias_on = 1, + .pmdown_time = 1, + .endianness = 1, + .non_legacy_dai_naming = 1, };

static const struct of_device_id wm8753_of_match[] = { @@ -1534,7 +1535,7 @@ static int wm8753_spi_probe(struct spi_device *spi) return ret; }

- ret = snd_soc_register_codec(&spi->dev, &soc_codec_dev_wm8753, + ret = devm_snd_soc_register_component(&spi->dev, &soc_component_dev_wm8753, wm8753_dai, ARRAY_SIZE(wm8753_dai)); if (ret != 0) dev_err(&spi->dev, "Failed to register CODEC: %d\n", ret); @@ -1542,19 +1543,12 @@ static int wm8753_spi_probe(struct spi_device *spi) return ret; }

-static int wm8753_spi_remove(struct spi_device *spi) -{ - snd_soc_unregister_codec(&spi->dev); - return 0; -} - static struct spi_driver wm8753_spi_driver = { .driver = { .name = "wm8753", .of_match_table = wm8753_of_match, }, .probe = wm8753_spi_probe, - .remove = wm8753_spi_remove, }; #endif /* CONFIG_SPI_MASTER */

@@ -1580,7 +1574,7 @@ static int wm8753_i2c_probe(struct i2c_client *i2c, return ret; }

- ret = snd_soc_register_codec(&i2c->dev, &soc_codec_dev_wm8753, + ret = devm_snd_soc_register_component(&i2c->dev, &soc_component_dev_wm8753, wm8753_dai, ARRAY_SIZE(wm8753_dai)); if (ret != 0) dev_err(&i2c->dev, "Failed to register CODEC: %d\n", ret); @@ -1588,12 +1582,6 @@ static int wm8753_i2c_probe(struct i2c_client *i2c, return ret; }

-static int wm8753_i2c_remove(struct i2c_client *client) -{ - snd_soc_unregister_codec(&client->dev); - return 0; -} - static const struct i2c_device_id wm8753_i2c_id[] = { { "wm8753", 0 }, { } @@ -1606,7 +1594,6 @@ static int wm8753_i2c_remove(struct i2c_client *client) .of_match_table = wm8753_of_match, }, .probe = wm8753_i2c_probe, - .remove = wm8753_i2c_remove, .id_table = wm8753_i2c_id, }; #endif

From: Kuninori Morimoto kuninori.morimoto.gx@renesas.com

Now we can replace Codec to Component. Let's do it.

Note: xxx_codec_xxx() -> xxx_component_xxx() .idle_bias_off = 0 -> .idle_bias_on = 1 .ignore_pmdown_time = 0 -> .pmdown_time = 1 - -> .endianness = 1 - -> .non_legacy_dai_naming = 1

Signed-off-by: Kuninori Morimoto kuninori.morimoto.gx@renesas.com --- sound/soc/codecs/wm8900.c | 251 +++++++++++++++++++++++----------------------- 1 file changed, 125 insertions(+), 126 deletions(-)

diff --git a/sound/soc/codecs/wm8900.c b/sound/soc/codecs/wm8900.c index c77b49a..74a7d0c 100644 --- a/sound/soc/codecs/wm8900.c +++ b/sound/soc/codecs/wm8900.c @@ -216,23 +216,23 @@ static bool wm8900_volatile_register(struct device *dev, unsigned int reg) } }

-static void wm8900_reset(struct snd_soc_codec *codec) +static void wm8900_reset(struct snd_soc_component *component) { - snd_soc_write(codec, WM8900_REG_RESET, 0); + snd_soc_component_write(component, WM8900_REG_RESET, 0); }

static int wm8900_hp_event(struct snd_soc_dapm_widget *w, struct snd_kcontrol *kcontrol, int event) { - struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm); - u16 hpctl1 = snd_soc_read(codec, WM8900_REG_HPCTL1); + struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm); + u16 hpctl1 = snd_soc_component_read32(component, WM8900_REG_HPCTL1);

switch (event) { case SND_SOC_DAPM_PRE_PMU: /* Clamp headphone outputs */ hpctl1 = WM8900_REG_HPCTL1_HP_CLAMP_IP | WM8900_REG_HPCTL1_HP_CLAMP_OP; - snd_soc_write(codec, WM8900_REG_HPCTL1, hpctl1); + snd_soc_component_write(component, WM8900_REG_HPCTL1, hpctl1); break;

case SND_SOC_DAPM_POST_PMU: @@ -241,41 +241,41 @@ static int wm8900_hp_event(struct snd_soc_dapm_widget *w, hpctl1 |= WM8900_REG_HPCTL1_HP_SHORT | WM8900_REG_HPCTL1_HP_SHORT2 | WM8900_REG_HPCTL1_HP_IPSTAGE_ENA; - snd_soc_write(codec, WM8900_REG_HPCTL1, hpctl1); + snd_soc_component_write(component, WM8900_REG_HPCTL1, hpctl1);

msleep(400);

/* Enable the output stage */ hpctl1 &= ~WM8900_REG_HPCTL1_HP_CLAMP_OP; hpctl1 |= WM8900_REG_HPCTL1_HP_OPSTAGE_ENA; - snd_soc_write(codec, WM8900_REG_HPCTL1, hpctl1); + snd_soc_component_write(component, WM8900_REG_HPCTL1, hpctl1);

/* Remove the shorts */ hpctl1 &= ~WM8900_REG_HPCTL1_HP_SHORT2; - snd_soc_write(codec, WM8900_REG_HPCTL1, hpctl1); + snd_soc_component_write(component, WM8900_REG_HPCTL1, hpctl1); hpctl1 &= ~WM8900_REG_HPCTL1_HP_SHORT; - snd_soc_write(codec, WM8900_REG_HPCTL1, hpctl1); + snd_soc_component_write(component, WM8900_REG_HPCTL1, hpctl1); break;

case SND_SOC_DAPM_PRE_PMD: /* Short the output */ hpctl1 |= WM8900_REG_HPCTL1_HP_SHORT; - snd_soc_write(codec, WM8900_REG_HPCTL1, hpctl1); + snd_soc_component_write(component, WM8900_REG_HPCTL1, hpctl1);

/* Disable the output stage */ hpctl1 &= ~WM8900_REG_HPCTL1_HP_OPSTAGE_ENA; - snd_soc_write(codec, WM8900_REG_HPCTL1, hpctl1); + snd_soc_component_write(component, WM8900_REG_HPCTL1, hpctl1);

/* Clamp the outputs and power down input */ hpctl1 |= WM8900_REG_HPCTL1_HP_CLAMP_IP | WM8900_REG_HPCTL1_HP_CLAMP_OP; hpctl1 &= ~WM8900_REG_HPCTL1_HP_IPSTAGE_ENA; - snd_soc_write(codec, WM8900_REG_HPCTL1, hpctl1); + snd_soc_component_write(component, WM8900_REG_HPCTL1, hpctl1); break;

case SND_SOC_DAPM_POST_PMD: /* Disable everything */ - snd_soc_write(codec, WM8900_REG_HPCTL1, 0); + snd_soc_component_write(component, WM8900_REG_HPCTL1, 0); break;

default: @@ -635,10 +635,10 @@ static int wm8900_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params, struct snd_soc_dai *dai) { - struct snd_soc_codec *codec = dai->codec; + struct snd_soc_component *component = dai->component; u16 reg;

- reg = snd_soc_read(codec, WM8900_REG_AUDIO1) & ~0x60; + reg = snd_soc_component_read32(component, WM8900_REG_AUDIO1) & ~0x60;

switch (params_width(params)) { case 16: @@ -656,17 +656,17 @@ static int wm8900_hw_params(struct snd_pcm_substream *substream, return -EINVAL; }

- snd_soc_write(codec, WM8900_REG_AUDIO1, reg); + snd_soc_component_write(component, WM8900_REG_AUDIO1, reg);

if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { - reg = snd_soc_read(codec, WM8900_REG_DACCTRL); + reg = snd_soc_component_read32(component, WM8900_REG_DACCTRL);

if (params_rate(params) <= 24000) reg |= WM8900_REG_DACCTRL_DAC_SB_FILT; else reg &= ~WM8900_REG_DACCTRL_DAC_SB_FILT;

- snd_soc_write(codec, WM8900_REG_DACCTRL, reg); + snd_soc_component_write(component, WM8900_REG_DACCTRL, reg); }

return 0; @@ -751,24 +751,24 @@ static int fll_factors(struct _fll_div *fll_div, unsigned int Fref, return 0; }

-static int wm8900_set_fll(struct snd_soc_codec *codec, +static int wm8900_set_fll(struct snd_soc_component *component, int fll_id, unsigned int freq_in, unsigned int freq_out) { - struct wm8900_priv *wm8900 = snd_soc_codec_get_drvdata(codec); + struct wm8900_priv *wm8900 = snd_soc_component_get_drvdata(component); struct _fll_div fll_div;

if (wm8900->fll_in == freq_in && wm8900->fll_out == freq_out) return 0;

/* The digital side should be disabled during any change. */ - snd_soc_update_bits(codec, WM8900_REG_POWER1, + snd_soc_component_update_bits(component, WM8900_REG_POWER1, WM8900_REG_POWER1_FLL_ENA, 0);

/* Disable the FLL? */ if (!freq_in || !freq_out) { - snd_soc_update_bits(codec, WM8900_REG_CLOCKING1, + snd_soc_component_update_bits(component, WM8900_REG_CLOCKING1, WM8900_REG_CLOCKING1_MCLK_SRC, 0); - snd_soc_update_bits(codec, WM8900_REG_FLLCTL1, + snd_soc_component_update_bits(component, WM8900_REG_FLLCTL1, WM8900_REG_FLLCTL1_OSC_ENA, 0); wm8900->fll_in = freq_in; wm8900->fll_out = freq_out; @@ -784,32 +784,32 @@ static int wm8900_set_fll(struct snd_soc_codec *codec,

/* The osclilator *MUST* be enabled before we enable the * digital circuit. */ - snd_soc_write(codec, WM8900_REG_FLLCTL1, + snd_soc_component_write(component, WM8900_REG_FLLCTL1, fll_div.fll_ratio | WM8900_REG_FLLCTL1_OSC_ENA);

- snd_soc_write(codec, WM8900_REG_FLLCTL4, fll_div.n >> 5); - snd_soc_write(codec, WM8900_REG_FLLCTL5, + snd_soc_component_write(component, WM8900_REG_FLLCTL4, fll_div.n >> 5); + snd_soc_component_write(component, WM8900_REG_FLLCTL5, (fll_div.fllclk_div << 6) | (fll_div.n & 0x1f));

if (fll_div.k) { - snd_soc_write(codec, WM8900_REG_FLLCTL2, + snd_soc_component_write(component, WM8900_REG_FLLCTL2, (fll_div.k >> 8) | 0x100); - snd_soc_write(codec, WM8900_REG_FLLCTL3, fll_div.k & 0xff); + snd_soc_component_write(component, WM8900_REG_FLLCTL3, fll_div.k & 0xff); } else - snd_soc_write(codec, WM8900_REG_FLLCTL2, 0); + snd_soc_component_write(component, WM8900_REG_FLLCTL2, 0);

if (fll_div.fll_slow_lock_ref) - snd_soc_write(codec, WM8900_REG_FLLCTL6, + snd_soc_component_write(component, WM8900_REG_FLLCTL6, WM8900_REG_FLLCTL6_FLL_SLOW_LOCK_REF); else - snd_soc_write(codec, WM8900_REG_FLLCTL6, 0); + snd_soc_component_write(component, WM8900_REG_FLLCTL6, 0);

- snd_soc_update_bits(codec, WM8900_REG_POWER1, + snd_soc_component_update_bits(component, WM8900_REG_POWER1, WM8900_REG_POWER1_FLL_ENA, WM8900_REG_POWER1_FLL_ENA);

reenable: - snd_soc_update_bits(codec, WM8900_REG_CLOCKING1, + snd_soc_component_update_bits(component, WM8900_REG_CLOCKING1, WM8900_REG_CLOCKING1_MCLK_SRC, WM8900_REG_CLOCKING1_MCLK_SRC); return 0; @@ -818,41 +818,41 @@ static int wm8900_set_fll(struct snd_soc_codec *codec, static int wm8900_set_dai_pll(struct snd_soc_dai *codec_dai, int pll_id, int source, unsigned int freq_in, unsigned int freq_out) { - return wm8900_set_fll(codec_dai->codec, pll_id, freq_in, freq_out); + return wm8900_set_fll(codec_dai->component, pll_id, freq_in, freq_out); }

static int wm8900_set_dai_clkdiv(struct snd_soc_dai *codec_dai, int div_id, int div) { - struct snd_soc_codec *codec = codec_dai->codec; + struct snd_soc_component *component = codec_dai->component;

switch (div_id) { case WM8900_BCLK_DIV: - snd_soc_update_bits(codec, WM8900_REG_CLOCKING1, + snd_soc_component_update_bits(component, WM8900_REG_CLOCKING1, WM8900_REG_CLOCKING1_BCLK_MASK, div); break; case WM8900_OPCLK_DIV: - snd_soc_update_bits(codec, WM8900_REG_CLOCKING1, + snd_soc_component_update_bits(component, WM8900_REG_CLOCKING1, WM8900_REG_CLOCKING1_OPCLK_MASK, div); break; case WM8900_DAC_LRCLK: - snd_soc_update_bits(codec, WM8900_REG_AUDIO4, + snd_soc_component_update_bits(component, WM8900_REG_AUDIO4, WM8900_LRC_MASK, div); break; case WM8900_ADC_LRCLK: - snd_soc_update_bits(codec, WM8900_REG_AUDIO3, + snd_soc_component_update_bits(component, WM8900_REG_AUDIO3, WM8900_LRC_MASK, div); break; case WM8900_DAC_CLKDIV: - snd_soc_update_bits(codec, WM8900_REG_CLOCKING2, + snd_soc_component_update_bits(component, WM8900_REG_CLOCKING2, WM8900_REG_CLOCKING2_DAC_CLKDIV, div); break; case WM8900_ADC_CLKDIV: - snd_soc_update_bits(codec, WM8900_REG_CLOCKING2, + snd_soc_component_update_bits(component, WM8900_REG_CLOCKING2, WM8900_REG_CLOCKING2_ADC_CLKDIV, div); break; case WM8900_LRCLK_MODE: - snd_soc_update_bits(codec, WM8900_REG_DACCTRL, + snd_soc_component_update_bits(component, WM8900_REG_DACCTRL, WM8900_REG_DACCTRL_AIF_LRCLKRATE, div); break; default: @@ -866,13 +866,13 @@ static int wm8900_set_dai_clkdiv(struct snd_soc_dai *codec_dai, static int wm8900_set_dai_fmt(struct snd_soc_dai *codec_dai, unsigned int fmt) { - struct snd_soc_codec *codec = codec_dai->codec; + struct snd_soc_component *component = codec_dai->component; unsigned int clocking1, aif1, aif3, aif4;

- clocking1 = snd_soc_read(codec, WM8900_REG_CLOCKING1); - aif1 = snd_soc_read(codec, WM8900_REG_AUDIO1); - aif3 = snd_soc_read(codec, WM8900_REG_AUDIO3); - aif4 = snd_soc_read(codec, WM8900_REG_AUDIO4); + clocking1 = snd_soc_component_read32(component, WM8900_REG_CLOCKING1); + aif1 = snd_soc_component_read32(component, WM8900_REG_AUDIO1); + aif3 = snd_soc_component_read32(component, WM8900_REG_AUDIO3); + aif4 = snd_soc_component_read32(component, WM8900_REG_AUDIO4);

/* set master/slave audio interface */ switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) { @@ -968,27 +968,27 @@ static int wm8900_set_dai_fmt(struct snd_soc_dai *codec_dai, return -EINVAL; }

- snd_soc_write(codec, WM8900_REG_CLOCKING1, clocking1); - snd_soc_write(codec, WM8900_REG_AUDIO1, aif1); - snd_soc_write(codec, WM8900_REG_AUDIO3, aif3); - snd_soc_write(codec, WM8900_REG_AUDIO4, aif4); + snd_soc_component_write(component, WM8900_REG_CLOCKING1, clocking1); + snd_soc_component_write(component, WM8900_REG_AUDIO1, aif1); + snd_soc_component_write(component, WM8900_REG_AUDIO3, aif3); + snd_soc_component_write(component, WM8900_REG_AUDIO4, aif4);

return 0; }

static int wm8900_digital_mute(struct snd_soc_dai *codec_dai, int mute) { - struct snd_soc_codec *codec = codec_dai->codec; + struct snd_soc_component *component = codec_dai->component; u16 reg;

- reg = snd_soc_read(codec, WM8900_REG_DACCTRL); + reg = snd_soc_component_read32(component, WM8900_REG_DACCTRL);

if (mute) reg |= WM8900_REG_DACCTRL_MUTE; else reg &= ~WM8900_REG_DACCTRL_MUTE;

- snd_soc_write(codec, WM8900_REG_DACCTRL, reg); + snd_soc_component_write(component, WM8900_REG_DACCTRL, reg);

return 0; } @@ -1028,7 +1028,7 @@ static int wm8900_digital_mute(struct snd_soc_dai *codec_dai, int mute) .ops = &wm8900_dai_ops, };

-static int wm8900_set_bias_level(struct snd_soc_codec *codec, +static int wm8900_set_bias_level(struct snd_soc_component *component, enum snd_soc_bias_level level) { u16 reg; @@ -1036,10 +1036,10 @@ static int wm8900_set_bias_level(struct snd_soc_codec *codec, switch (level) { case SND_SOC_BIAS_ON: /* Enable thermal shutdown */ - snd_soc_update_bits(codec, WM8900_REG_GPIO, + snd_soc_component_update_bits(component, WM8900_REG_GPIO, WM8900_REG_GPIO_TEMP_ENA, WM8900_REG_GPIO_TEMP_ENA); - snd_soc_update_bits(codec, WM8900_REG_ADDCTL, + snd_soc_component_update_bits(component, WM8900_REG_ADDCTL, WM8900_REG_ADDCTL_TEMP_SD, WM8900_REG_ADDCTL_TEMP_SD); break; @@ -1049,113 +1049,113 @@ static int wm8900_set_bias_level(struct snd_soc_codec *codec,

case SND_SOC_BIAS_STANDBY: /* Charge capacitors if initial power up */ - if (snd_soc_codec_get_bias_level(codec) == SND_SOC_BIAS_OFF) { + if (snd_soc_component_get_bias_level(component) == SND_SOC_BIAS_OFF) { /* STARTUP_BIAS_ENA on */ - snd_soc_write(codec, WM8900_REG_POWER1, + snd_soc_component_write(component, WM8900_REG_POWER1, WM8900_REG_POWER1_STARTUP_BIAS_ENA);

/* Startup bias mode */ - snd_soc_write(codec, WM8900_REG_ADDCTL, + snd_soc_component_write(component, WM8900_REG_ADDCTL, WM8900_REG_ADDCTL_BIAS_SRC | WM8900_REG_ADDCTL_VMID_SOFTST);

/* VMID 2x50k */ - snd_soc_write(codec, WM8900_REG_POWER1, + snd_soc_component_write(component, WM8900_REG_POWER1, WM8900_REG_POWER1_STARTUP_BIAS_ENA | 0x1);

/* Allow capacitors to charge */ schedule_timeout_interruptible(msecs_to_jiffies(400));

/* Enable bias */ - snd_soc_write(codec, WM8900_REG_POWER1, + snd_soc_component_write(component, WM8900_REG_POWER1, WM8900_REG_POWER1_STARTUP_BIAS_ENA | WM8900_REG_POWER1_BIAS_ENA | 0x1);

- snd_soc_write(codec, WM8900_REG_ADDCTL, 0); + snd_soc_component_write(component, WM8900_REG_ADDCTL, 0);

- snd_soc_write(codec, WM8900_REG_POWER1, + snd_soc_component_write(component, WM8900_REG_POWER1, WM8900_REG_POWER1_BIAS_ENA | 0x1); }

- reg = snd_soc_read(codec, WM8900_REG_POWER1); - snd_soc_write(codec, WM8900_REG_POWER1, + reg = snd_soc_component_read32(component, WM8900_REG_POWER1); + snd_soc_component_write(component, WM8900_REG_POWER1, (reg & WM8900_REG_POWER1_FLL_ENA) | WM8900_REG_POWER1_BIAS_ENA | 0x1); - snd_soc_write(codec, WM8900_REG_POWER2, + snd_soc_component_write(component, WM8900_REG_POWER2, WM8900_REG_POWER2_SYSCLK_ENA); - snd_soc_write(codec, WM8900_REG_POWER3, 0); + snd_soc_component_write(component, WM8900_REG_POWER3, 0); break;

case SND_SOC_BIAS_OFF: /* Startup bias enable */ - reg = snd_soc_read(codec, WM8900_REG_POWER1); - snd_soc_write(codec, WM8900_REG_POWER1, + reg = snd_soc_component_read32(component, WM8900_REG_POWER1); + snd_soc_component_write(component, WM8900_REG_POWER1, reg & WM8900_REG_POWER1_STARTUP_BIAS_ENA); - snd_soc_write(codec, WM8900_REG_ADDCTL, + snd_soc_component_write(component, WM8900_REG_ADDCTL, WM8900_REG_ADDCTL_BIAS_SRC | WM8900_REG_ADDCTL_VMID_SOFTST);

/* Discharge caps */ - snd_soc_write(codec, WM8900_REG_POWER1, + snd_soc_component_write(component, WM8900_REG_POWER1, WM8900_REG_POWER1_STARTUP_BIAS_ENA); schedule_timeout_interruptible(msecs_to_jiffies(500));

/* Remove clamp */ - snd_soc_write(codec, WM8900_REG_HPCTL1, 0); + snd_soc_component_write(component, WM8900_REG_HPCTL1, 0);

/* Power down */ - snd_soc_write(codec, WM8900_REG_ADDCTL, 0); - snd_soc_write(codec, WM8900_REG_POWER1, 0); - snd_soc_write(codec, WM8900_REG_POWER2, 0); - snd_soc_write(codec, WM8900_REG_POWER3, 0); + snd_soc_component_write(component, WM8900_REG_ADDCTL, 0); + snd_soc_component_write(component, WM8900_REG_POWER1, 0); + snd_soc_component_write(component, WM8900_REG_POWER2, 0); + snd_soc_component_write(component, WM8900_REG_POWER3, 0);

/* Need to let things settle before stopping the clock * to ensure that restart works, see "Stopping the * master clock" in the datasheet. */ schedule_timeout_interruptible(msecs_to_jiffies(1)); - snd_soc_write(codec, WM8900_REG_POWER2, + snd_soc_component_write(component, WM8900_REG_POWER2, WM8900_REG_POWER2_SYSCLK_ENA); break; } return 0; }

-static int wm8900_suspend(struct snd_soc_codec *codec) +static int wm8900_suspend(struct snd_soc_component *component) { - struct wm8900_priv *wm8900 = snd_soc_codec_get_drvdata(codec); + struct wm8900_priv *wm8900 = snd_soc_component_get_drvdata(component); int fll_out = wm8900->fll_out; int fll_in = wm8900->fll_in; int ret;

/* Stop the FLL in an orderly fashion */ - ret = wm8900_set_fll(codec, 0, 0, 0); + ret = wm8900_set_fll(component, 0, 0, 0); if (ret != 0) { - dev_err(codec->dev, "Failed to stop FLL\n"); + dev_err(component->dev, "Failed to stop FLL\n"); return ret; }

wm8900->fll_out = fll_out; wm8900->fll_in = fll_in;

- snd_soc_codec_force_bias_level(codec, SND_SOC_BIAS_OFF); + snd_soc_component_force_bias_level(component, SND_SOC_BIAS_OFF);

return 0; }

-static int wm8900_resume(struct snd_soc_codec *codec) +static int wm8900_resume(struct snd_soc_component *component) { - struct wm8900_priv *wm8900 = snd_soc_codec_get_drvdata(codec); + struct wm8900_priv *wm8900 = snd_soc_component_get_drvdata(component); int ret;

- wm8900_reset(codec); + wm8900_reset(component);

ret = regcache_sync(wm8900->regmap); if (ret != 0) { - dev_err(codec->dev, "Failed to restore cache: %d\n", ret); + dev_err(component->dev, "Failed to restore cache: %d\n", ret); return ret; }

- snd_soc_codec_force_bias_level(codec, SND_SOC_BIAS_STANDBY); + snd_soc_component_force_bias_level(component, SND_SOC_BIAS_STANDBY);

/* Restart the FLL? */ if (wm8900->fll_out) { @@ -1165,9 +1165,9 @@ static int wm8900_resume(struct snd_soc_codec *codec) wm8900->fll_in = 0; wm8900->fll_out = 0;

- ret = wm8900_set_fll(codec, 0, fll_in, fll_out); + ret = wm8900_set_fll(component, 0, fll_in, fll_out); if (ret != 0) { - dev_err(codec->dev, "Failed to restart FLL\n"); + dev_err(component->dev, "Failed to restart FLL\n"); return ret; } } @@ -1175,53 +1175,54 @@ static int wm8900_resume(struct snd_soc_codec *codec) return 0; }

-static int wm8900_probe(struct snd_soc_codec *codec) +static int wm8900_probe(struct snd_soc_component *component) { int reg;

- reg = snd_soc_read(codec, WM8900_REG_ID); + reg = snd_soc_component_read32(component, WM8900_REG_ID); if (reg != 0x8900) { - dev_err(codec->dev, "Device is not a WM8900 - ID %x\n", reg); + dev_err(component->dev, "Device is not a WM8900 - ID %x\n", reg); return -ENODEV; }

- wm8900_reset(codec); + wm8900_reset(component);

/* Turn the chip on */ - snd_soc_codec_force_bias_level(codec, SND_SOC_BIAS_STANDBY); + snd_soc_component_force_bias_level(component, SND_SOC_BIAS_STANDBY);

/* Latch the volume update bits */ - snd_soc_update_bits(codec, WM8900_REG_LINVOL, 0x100, 0x100); - snd_soc_update_bits(codec, WM8900_REG_RINVOL, 0x100, 0x100); - snd_soc_update_bits(codec, WM8900_REG_LOUT1CTL, 0x100, 0x100); - snd_soc_update_bits(codec, WM8900_REG_ROUT1CTL, 0x100, 0x100); - snd_soc_update_bits(codec, WM8900_REG_LOUT2CTL, 0x100, 0x100); - snd_soc_update_bits(codec, WM8900_REG_ROUT2CTL, 0x100, 0x100); - snd_soc_update_bits(codec, WM8900_REG_LDAC_DV, 0x100, 0x100); - snd_soc_update_bits(codec, WM8900_REG_RDAC_DV, 0x100, 0x100); - snd_soc_update_bits(codec, WM8900_REG_LADC_DV, 0x100, 0x100); - snd_soc_update_bits(codec, WM8900_REG_RADC_DV, 0x100, 0x100); + snd_soc_component_update_bits(component, WM8900_REG_LINVOL, 0x100, 0x100); + snd_soc_component_update_bits(component, WM8900_REG_RINVOL, 0x100, 0x100); + snd_soc_component_update_bits(component, WM8900_REG_LOUT1CTL, 0x100, 0x100); + snd_soc_component_update_bits(component, WM8900_REG_ROUT1CTL, 0x100, 0x100); + snd_soc_component_update_bits(component, WM8900_REG_LOUT2CTL, 0x100, 0x100); + snd_soc_component_update_bits(component, WM8900_REG_ROUT2CTL, 0x100, 0x100); + snd_soc_component_update_bits(component, WM8900_REG_LDAC_DV, 0x100, 0x100); + snd_soc_component_update_bits(component, WM8900_REG_RDAC_DV, 0x100, 0x100); + snd_soc_component_update_bits(component, WM8900_REG_LADC_DV, 0x100, 0x100); + snd_soc_component_update_bits(component, WM8900_REG_RADC_DV, 0x100, 0x100);

/* Set the DAC and mixer output bias */ - snd_soc_write(codec, WM8900_REG_OUTBIASCTL, 0x81); + snd_soc_component_write(component, WM8900_REG_OUTBIASCTL, 0x81);

return 0; }

-static const struct snd_soc_codec_driver soc_codec_dev_wm8900 = { - .probe = wm8900_probe, - .suspend = wm8900_suspend, - .resume = wm8900_resume, - .set_bias_level = wm8900_set_bias_level, - - .component_driver = { - .controls = wm8900_snd_controls, - .num_controls = ARRAY_SIZE(wm8900_snd_controls), - .dapm_widgets = wm8900_dapm_widgets, - .num_dapm_widgets = ARRAY_SIZE(wm8900_dapm_widgets), - .dapm_routes = wm8900_dapm_routes, - .num_dapm_routes = ARRAY_SIZE(wm8900_dapm_routes), - }, +static const struct snd_soc_component_driver soc_component_dev_wm8900 = { + .probe = wm8900_probe, + .suspend = wm8900_suspend, + .resume = wm8900_resume, + .set_bias_level = wm8900_set_bias_level, + .controls = wm8900_snd_controls, + .num_controls = ARRAY_SIZE(wm8900_snd_controls), + .dapm_widgets = wm8900_dapm_widgets, + .num_dapm_widgets = ARRAY_SIZE(wm8900_dapm_widgets), + .dapm_routes = wm8900_dapm_routes, + .num_dapm_routes = ARRAY_SIZE(wm8900_dapm_routes), + .idle_bias_on = 1, + .pmdown_time = 1, + .endianness = 1, + .non_legacy_dai_naming = 1, };

static const struct regmap_config wm8900_regmap = { @@ -1253,15 +1254,14 @@ static int wm8900_spi_probe(struct spi_device *spi)

spi_set_drvdata(spi, wm8900);

- ret = snd_soc_register_codec(&spi->dev, - &soc_codec_dev_wm8900, &wm8900_dai, 1); + ret = devm_snd_soc_register_component(&spi->dev, + &soc_component_dev_wm8900, &wm8900_dai, 1);

return ret; }

static int wm8900_spi_remove(struct spi_device *spi) { - snd_soc_unregister_codec(&spi->dev); return 0; }

@@ -1292,15 +1292,14 @@ static int wm8900_i2c_probe(struct i2c_client *i2c,

i2c_set_clientdata(i2c, wm8900);

- ret = snd_soc_register_codec(&i2c->dev, - &soc_codec_dev_wm8900, &wm8900_dai, 1); + ret = devm_snd_soc_register_component(&i2c->dev, + &soc_component_dev_wm8900, &wm8900_dai, 1);

return ret; }

static int wm8900_i2c_remove(struct i2c_client *client) { - snd_soc_unregister_codec(&client->dev); return 0; }

From: Kuninori Morimoto kuninori.morimoto.gx@renesas.com

Now we can replace Codec to Component. Let's do it.

Note: xxx_codec_xxx() -> xxx_component_xxx() .idle_bias_off = 0 -> .idle_bias_on = 1 .ignore_pmdown_time = 0 -> .pmdown_time = 1 - -> .endianness = 1 - -> .non_legacy_dai_naming = 1

Signed-off-by: Kuninori Morimoto kuninori.morimoto.gx@renesas.com --- sound/soc/codecs/wm8955.c | 189 ++++++++++++++++++++++------------------------ 1 file changed, 91 insertions(+), 98 deletions(-)

diff --git a/sound/soc/codecs/wm8955.c b/sound/soc/codecs/wm8955.c index 1edc7b1..d1d5292 100644 --- a/sound/soc/codecs/wm8955.c +++ b/sound/soc/codecs/wm8955.c @@ -128,9 +128,9 @@ static bool wm8955_volatile(struct device *dev, unsigned int reg) } }

-static int wm8955_reset(struct snd_soc_codec *codec) +static int wm8955_reset(struct snd_soc_component *component) { - return snd_soc_write(codec, WM8955_RESET, 0); + return snd_soc_component_write(component, WM8955_RESET, 0); }

struct pll_factors { @@ -242,9 +242,9 @@ static int wm8995_pll_factors(struct device *dev, { 11289600, 88200, 0, 31, }, };

-static int wm8955_configure_clocking(struct snd_soc_codec *codec) +static int wm8955_configure_clocking(struct snd_soc_component *component) { - struct wm8955_priv *wm8955 = snd_soc_codec_get_drvdata(codec); + struct wm8955_priv *wm8955 = snd_soc_component_get_drvdata(component); int i, ret, val; int clocking = 0; int srate = 0; @@ -267,7 +267,7 @@ static int wm8955_configure_clocking(struct snd_soc_codec *codec)

/* We should never get here with an unsupported sample rate */ if (sr == -1) { - dev_err(codec->dev, "Sample rate %dHz unsupported\n", + dev_err(component->dev, "Sample rate %dHz unsupported\n", wm8955->fs); WARN_ON(sr == -1); return -EINVAL; @@ -282,30 +282,30 @@ static int wm8955_configure_clocking(struct snd_soc_codec *codec)

/* Use the last divider configuration we saw for the * sample rate. */ - ret = wm8995_pll_factors(codec->dev, wm8955->mclk_rate, + ret = wm8995_pll_factors(component->dev, wm8955->mclk_rate, clock_cfgs[sr].mclk, &pll); if (ret != 0) { - dev_err(codec->dev, + dev_err(component->dev, "Unable to generate %dHz from %dHz MCLK\n", wm8955->fs, wm8955->mclk_rate); return -EINVAL; }

- snd_soc_update_bits(codec, WM8955_PLL_CONTROL_1, + snd_soc_component_update_bits(component, WM8955_PLL_CONTROL_1, WM8955_N_MASK | WM8955_K_21_18_MASK, (pll.n << WM8955_N_SHIFT) | pll.k >> 18); - snd_soc_update_bits(codec, WM8955_PLL_CONTROL_2, + snd_soc_component_update_bits(component, WM8955_PLL_CONTROL_2, WM8955_K_17_9_MASK, (pll.k >> 9) & WM8955_K_17_9_MASK); - snd_soc_update_bits(codec, WM8955_PLL_CONTROL_3, + snd_soc_component_update_bits(component, WM8955_PLL_CONTROL_3, WM8955_K_8_0_MASK, pll.k & WM8955_K_8_0_MASK); if (pll.k) - snd_soc_update_bits(codec, WM8955_PLL_CONTROL_4, + snd_soc_component_update_bits(component, WM8955_PLL_CONTROL_4, WM8955_KEN, WM8955_KEN); else - snd_soc_update_bits(codec, WM8955_PLL_CONTROL_4, + snd_soc_component_update_bits(component, WM8955_PLL_CONTROL_4, WM8955_KEN, 0);

if (pll.outdiv) @@ -314,17 +314,17 @@ static int wm8955_configure_clocking(struct snd_soc_codec *codec) val = WM8955_PLL_RB;

/* Now start the PLL running */ - snd_soc_update_bits(codec, WM8955_CLOCKING_PLL, + snd_soc_component_update_bits(component, WM8955_CLOCKING_PLL, WM8955_PLL_RB | WM8955_PLLOUTDIV2, val); - snd_soc_update_bits(codec, WM8955_CLOCKING_PLL, + snd_soc_component_update_bits(component, WM8955_CLOCKING_PLL, WM8955_PLLEN, WM8955_PLLEN); }

srate = clock_cfgs[sr].usb | (clock_cfgs[sr].sr << WM8955_SR_SHIFT);

- snd_soc_update_bits(codec, WM8955_SAMPLE_RATE, + snd_soc_component_update_bits(component, WM8955_SAMPLE_RATE, WM8955_USB | WM8955_SR_MASK, srate); - snd_soc_update_bits(codec, WM8955_CLOCKING_PLL, + snd_soc_component_update_bits(component, WM8955_CLOCKING_PLL, WM8955_MCLKSEL, clocking);

return 0; @@ -333,22 +333,22 @@ static int wm8955_configure_clocking(struct snd_soc_codec *codec) static int wm8955_sysclk(struct snd_soc_dapm_widget *w, struct snd_kcontrol *kcontrol, int event) { - struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm); + struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm); int ret = 0;

/* Always disable the clocks - if we're doing reconfiguration this * avoids misclocking. */ - snd_soc_update_bits(codec, WM8955_POWER_MANAGEMENT_1, + snd_soc_component_update_bits(component, WM8955_POWER_MANAGEMENT_1, WM8955_DIGENB, 0); - snd_soc_update_bits(codec, WM8955_CLOCKING_PLL, + snd_soc_component_update_bits(component, WM8955_CLOCKING_PLL, WM8955_PLL_RB | WM8955_PLLEN, 0);

switch (event) { case SND_SOC_DAPM_POST_PMD: break; case SND_SOC_DAPM_PRE_PMU: - ret = wm8955_configure_clocking(codec); + ret = wm8955_configure_clocking(component); break; default: ret = -EINVAL; @@ -360,9 +360,9 @@ static int wm8955_sysclk(struct snd_soc_dapm_widget *w,

static int deemph_settings[] = { 0, 32000, 44100, 48000 };

-static int wm8955_set_deemph(struct snd_soc_codec *codec) +static int wm8955_set_deemph(struct snd_soc_component *component) { - struct wm8955_priv *wm8955 = snd_soc_codec_get_drvdata(codec); + struct wm8955_priv *wm8955 = snd_soc_component_get_drvdata(component); int val, i, best;

/* If we're using deemphasis select the nearest available sample @@ -381,17 +381,17 @@ static int wm8955_set_deemph(struct snd_soc_codec *codec) val = 0; }

- dev_dbg(codec->dev, "Set deemphasis %d\n", val); + dev_dbg(component->dev, "Set deemphasis %d\n", val);

- return snd_soc_update_bits(codec, WM8955_DAC_CONTROL, + return snd_soc_component_update_bits(component, WM8955_DAC_CONTROL, WM8955_DEEMPH_MASK, val); }

static int wm8955_get_deemph(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { - struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol); - struct wm8955_priv *wm8955 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol); + struct wm8955_priv *wm8955 = snd_soc_component_get_drvdata(component);

ucontrol->value.integer.value[0] = wm8955->deemph; return 0; @@ -400,8 +400,8 @@ static int wm8955_get_deemph(struct snd_kcontrol *kcontrol, static int wm8955_put_deemph(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { - struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol); - struct wm8955_priv *wm8955 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol); + struct wm8955_priv *wm8955 = snd_soc_component_get_drvdata(component); unsigned int deemph = ucontrol->value.integer.value[0];

if (deemph > 1) @@ -409,7 +409,7 @@ static int wm8955_put_deemph(struct snd_kcontrol *kcontrol,

wm8955->deemph = deemph;

- return wm8955_set_deemph(codec); + return wm8955_set_deemph(component); }

static const char *bass_mode_text[] = { @@ -592,8 +592,8 @@ static int wm8955_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params, struct snd_soc_dai *dai) { - struct snd_soc_codec *codec = dai->codec; - struct wm8955_priv *wm8955 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = dai->component; + struct wm8955_priv *wm8955 = snd_soc_component_get_drvdata(component); int ret; int wl;

@@ -613,25 +613,25 @@ static int wm8955_hw_params(struct snd_pcm_substream *substream, default: return -EINVAL; } - snd_soc_update_bits(codec, WM8955_AUDIO_INTERFACE, + snd_soc_component_update_bits(component, WM8955_AUDIO_INTERFACE, WM8955_WL_MASK, wl);

wm8955->fs = params_rate(params); - wm8955_set_deemph(codec); + wm8955_set_deemph(component);

/* If the chip is clocked then disable the clocks and force a * reconfiguration, otherwise DAPM will power up the * clocks for us later. */ - ret = snd_soc_read(codec, WM8955_POWER_MANAGEMENT_1); + ret = snd_soc_component_read32(component, WM8955_POWER_MANAGEMENT_1); if (ret < 0) return ret; if (ret & WM8955_DIGENB) { - snd_soc_update_bits(codec, WM8955_POWER_MANAGEMENT_1, + snd_soc_component_update_bits(component, WM8955_POWER_MANAGEMENT_1, WM8955_DIGENB, 0); - snd_soc_update_bits(codec, WM8955_CLOCKING_PLL, + snd_soc_component_update_bits(component, WM8955_CLOCKING_PLL, WM8955_PLL_RB | WM8955_PLLEN, 0);

- wm8955_configure_clocking(codec); + wm8955_configure_clocking(component); }

return 0; @@ -641,8 +641,8 @@ static int wm8955_hw_params(struct snd_pcm_substream *substream, static int wm8955_set_sysclk(struct snd_soc_dai *dai, int clk_id, unsigned int freq, int dir) { - struct snd_soc_codec *codec = dai->codec; - struct wm8955_priv *priv = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = dai->component; + struct wm8955_priv *priv = snd_soc_component_get_drvdata(component); int div;

switch (clk_id) { @@ -655,7 +655,7 @@ static int wm8955_set_sysclk(struct snd_soc_dai *dai, int clk_id, div = 0; }

- snd_soc_update_bits(codec, WM8955_SAMPLE_RATE, + snd_soc_component_update_bits(component, WM8955_SAMPLE_RATE, WM8955_MCLKDIV2, div); break;

@@ -670,7 +670,7 @@ static int wm8955_set_sysclk(struct snd_soc_dai *dai, int clk_id,

static int wm8955_set_fmt(struct snd_soc_dai *dai, unsigned int fmt) { - struct snd_soc_codec *codec = dai->codec; + struct snd_soc_component *component = dai->component; u16 aif = 0;

switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) { @@ -739,7 +739,7 @@ static int wm8955_set_fmt(struct snd_soc_dai *dai, unsigned int fmt) return -EINVAL; }

- snd_soc_update_bits(codec, WM8955_AUDIO_INTERFACE, + snd_soc_component_update_bits(component, WM8955_AUDIO_INTERFACE, WM8955_MS | WM8955_FORMAT_MASK | WM8955_BCLKINV | WM8955_LRP, aif);

@@ -749,7 +749,7 @@ static int wm8955_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)

static int wm8955_digital_mute(struct snd_soc_dai *codec_dai, int mute) { - struct snd_soc_codec *codec = codec_dai->codec; + struct snd_soc_component *component = codec_dai->component; int val;

if (mute) @@ -757,15 +757,15 @@ static int wm8955_digital_mute(struct snd_soc_dai *codec_dai, int mute) else val = 0;

- snd_soc_update_bits(codec, WM8955_DAC_CONTROL, WM8955_DACMU, val); + snd_soc_component_update_bits(component, WM8955_DAC_CONTROL, WM8955_DACMU, val);

return 0; }

-static int wm8955_set_bias_level(struct snd_soc_codec *codec, +static int wm8955_set_bias_level(struct snd_soc_component *component, enum snd_soc_bias_level level) { - struct wm8955_priv *wm8955 = snd_soc_codec_get_drvdata(codec); + struct wm8955_priv *wm8955 = snd_soc_component_get_drvdata(component); int ret;

switch (level) { @@ -774,22 +774,22 @@ static int wm8955_set_bias_level(struct snd_soc_codec *codec,

case SND_SOC_BIAS_PREPARE: /* VMID resistance 2*50k */ - snd_soc_update_bits(codec, WM8955_POWER_MANAGEMENT_1, + snd_soc_component_update_bits(component, WM8955_POWER_MANAGEMENT_1, WM8955_VMIDSEL_MASK, 0x1 << WM8955_VMIDSEL_SHIFT);

/* Default bias current */ - snd_soc_update_bits(codec, WM8955_ADDITIONAL_CONTROL_1, + snd_soc_component_update_bits(component, WM8955_ADDITIONAL_CONTROL_1, WM8955_VSEL_MASK, 0x2 << WM8955_VSEL_SHIFT); break;

case SND_SOC_BIAS_STANDBY: - if (snd_soc_codec_get_bias_level(codec) == SND_SOC_BIAS_OFF) { + if (snd_soc_component_get_bias_level(component) == SND_SOC_BIAS_OFF) { ret = regulator_bulk_enable(ARRAY_SIZE(wm8955->supplies), wm8955->supplies); if (ret != 0) { - dev_err(codec->dev, + dev_err(component->dev, "Failed to enable supplies: %d\n", ret); return ret; @@ -798,7 +798,7 @@ static int wm8955_set_bias_level(struct snd_soc_codec *codec, regcache_sync(wm8955->regmap);

/* Enable VREF and VMID */ - snd_soc_update_bits(codec, WM8955_POWER_MANAGEMENT_1, + snd_soc_component_update_bits(component, WM8955_POWER_MANAGEMENT_1, WM8955_VREF | WM8955_VMIDSEL_MASK, WM8955_VREF | @@ -808,29 +808,29 @@ static int wm8955_set_bias_level(struct snd_soc_codec *codec, msleep(500);

/* High resistance VROI to maintain outputs */ - snd_soc_update_bits(codec, + snd_soc_component_update_bits(component, WM8955_ADDITIONAL_CONTROL_3, WM8955_VROI, WM8955_VROI); }

/* Maintain VMID with 2*250k */ - snd_soc_update_bits(codec, WM8955_POWER_MANAGEMENT_1, + snd_soc_component_update_bits(component, WM8955_POWER_MANAGEMENT_1, WM8955_VMIDSEL_MASK, 0x2 << WM8955_VMIDSEL_SHIFT);

/* Minimum bias current */ - snd_soc_update_bits(codec, WM8955_ADDITIONAL_CONTROL_1, + snd_soc_component_update_bits(component, WM8955_ADDITIONAL_CONTROL_1, WM8955_VSEL_MASK, 0); break;

case SND_SOC_BIAS_OFF: /* Low resistance VROI to help discharge */ - snd_soc_update_bits(codec, + snd_soc_component_update_bits(component, WM8955_ADDITIONAL_CONTROL_3, WM8955_VROI, 0);

/* Turn off VMID and VREF */ - snd_soc_update_bits(codec, WM8955_POWER_MANAGEMENT_1, + snd_soc_component_update_bits(component, WM8955_POWER_MANAGEMENT_1, WM8955_VREF | WM8955_VMIDSEL_MASK, 0);

@@ -865,70 +865,70 @@ static int wm8955_set_bias_level(struct snd_soc_codec *codec, .ops = &wm8955_dai_ops, };

-static int wm8955_probe(struct snd_soc_codec *codec) +static int wm8955_probe(struct snd_soc_component *component) { - struct wm8955_priv *wm8955 = snd_soc_codec_get_drvdata(codec); - struct wm8955_pdata *pdata = dev_get_platdata(codec->dev); + struct wm8955_priv *wm8955 = snd_soc_component_get_drvdata(component); + struct wm8955_pdata *pdata = dev_get_platdata(component->dev); int ret, i;

for (i = 0; i < ARRAY_SIZE(wm8955->supplies); i++) wm8955->supplies[i].supply = wm8955_supply_names[i];

- ret = devm_regulator_bulk_get(codec->dev, ARRAY_SIZE(wm8955->supplies), + ret = devm_regulator_bulk_get(component->dev, ARRAY_SIZE(wm8955->supplies), wm8955->supplies); if (ret != 0) { - dev_err(codec->dev, "Failed to request supplies: %d\n", ret); + dev_err(component->dev, "Failed to request supplies: %d\n", ret); return ret; }

ret = regulator_bulk_enable(ARRAY_SIZE(wm8955->supplies), wm8955->supplies); if (ret != 0) { - dev_err(codec->dev, "Failed to enable supplies: %d\n", ret); + dev_err(component->dev, "Failed to enable supplies: %d\n", ret); return ret; }

- ret = wm8955_reset(codec); + ret = wm8955_reset(component); if (ret < 0) { - dev_err(codec->dev, "Failed to issue reset: %d\n", ret); + dev_err(component->dev, "Failed to issue reset: %d\n", ret); goto err_enable; }

/* Change some default settings - latch VU and enable ZC */ - snd_soc_update_bits(codec, WM8955_LEFT_DAC_VOLUME, + snd_soc_component_update_bits(component, WM8955_LEFT_DAC_VOLUME, WM8955_LDVU, WM8955_LDVU); - snd_soc_update_bits(codec, WM8955_RIGHT_DAC_VOLUME, + snd_soc_component_update_bits(component, WM8955_RIGHT_DAC_VOLUME, WM8955_RDVU, WM8955_RDVU); - snd_soc_update_bits(codec, WM8955_LOUT1_VOLUME, + snd_soc_component_update_bits(component, WM8955_LOUT1_VOLUME, WM8955_LO1VU | WM8955_LO1ZC, WM8955_LO1VU | WM8955_LO1ZC); - snd_soc_update_bits(codec, WM8955_ROUT1_VOLUME, + snd_soc_component_update_bits(component, WM8955_ROUT1_VOLUME, WM8955_RO1VU | WM8955_RO1ZC, WM8955_RO1VU | WM8955_RO1ZC); - snd_soc_update_bits(codec, WM8955_LOUT2_VOLUME, + snd_soc_component_update_bits(component, WM8955_LOUT2_VOLUME, WM8955_LO2VU | WM8955_LO2ZC, WM8955_LO2VU | WM8955_LO2ZC); - snd_soc_update_bits(codec, WM8955_ROUT2_VOLUME, + snd_soc_component_update_bits(component, WM8955_ROUT2_VOLUME, WM8955_RO2VU | WM8955_RO2ZC, WM8955_RO2VU | WM8955_RO2ZC); - snd_soc_update_bits(codec, WM8955_MONOOUT_VOLUME, + snd_soc_component_update_bits(component, WM8955_MONOOUT_VOLUME, WM8955_MOZC, WM8955_MOZC);

/* Also enable adaptive bass boost by default */ - snd_soc_update_bits(codec, WM8955_BASS_CONTROL, WM8955_BB, WM8955_BB); + snd_soc_component_update_bits(component, WM8955_BASS_CONTROL, WM8955_BB, WM8955_BB);

/* Set platform data values */ if (pdata) { if (pdata->out2_speaker) - snd_soc_update_bits(codec, WM8955_ADDITIONAL_CONTROL_2, + snd_soc_component_update_bits(component, WM8955_ADDITIONAL_CONTROL_2, WM8955_ROUT2INV, WM8955_ROUT2INV);

if (pdata->monoin_diff) - snd_soc_update_bits(codec, WM8955_MONO_OUT_MIX_1, + snd_soc_component_update_bits(component, WM8955_MONO_OUT_MIX_1, WM8955_DMEN, WM8955_DMEN); }

- snd_soc_codec_force_bias_level(codec, SND_SOC_BIAS_STANDBY); + snd_soc_component_force_bias_level(component, SND_SOC_BIAS_STANDBY);

/* Bias level configuration will have done an extra enable */ regulator_bulk_disable(ARRAY_SIZE(wm8955->supplies), wm8955->supplies); @@ -940,19 +940,20 @@ static int wm8955_probe(struct snd_soc_codec *codec) return ret; }

-static const struct snd_soc_codec_driver soc_codec_dev_wm8955 = { - .probe = wm8955_probe, - .set_bias_level = wm8955_set_bias_level, - .suspend_bias_off = true, - - .component_driver = { - .controls = wm8955_snd_controls, - .num_controls = ARRAY_SIZE(wm8955_snd_controls), - .dapm_widgets = wm8955_dapm_widgets, - .num_dapm_widgets = ARRAY_SIZE(wm8955_dapm_widgets), - .dapm_routes = wm8955_dapm_routes, - .num_dapm_routes = ARRAY_SIZE(wm8955_dapm_routes), - }, +static const struct snd_soc_component_driver soc_component_dev_wm8955 = { + .probe = wm8955_probe, + .set_bias_level = wm8955_set_bias_level, + .controls = wm8955_snd_controls, + .num_controls = ARRAY_SIZE(wm8955_snd_controls), + .dapm_widgets = wm8955_dapm_widgets, + .num_dapm_widgets = ARRAY_SIZE(wm8955_dapm_widgets), + .dapm_routes = wm8955_dapm_routes, + .num_dapm_routes = ARRAY_SIZE(wm8955_dapm_routes), + .suspend_bias_off = 1, + .idle_bias_on = 1, + .pmdown_time = 1, + .endianness = 1, + .non_legacy_dai_naming = 1, };

static const struct regmap_config wm8955_regmap = { @@ -989,19 +990,12 @@ static int wm8955_i2c_probe(struct i2c_client *i2c,

i2c_set_clientdata(i2c, wm8955);

- ret = snd_soc_register_codec(&i2c->dev, - &soc_codec_dev_wm8955, &wm8955_dai, 1); + ret = devm_snd_soc_register_component(&i2c->dev, + &soc_component_dev_wm8955, &wm8955_dai, 1);

return ret; }

-static int wm8955_i2c_remove(struct i2c_client *client) -{ - snd_soc_unregister_codec(&client->dev); - - return 0; -} - static const struct i2c_device_id wm8955_i2c_id[] = { { "wm8955", 0 }, { } @@ -1013,7 +1007,6 @@ static int wm8955_i2c_remove(struct i2c_client *client) .name = "wm8955", }, .probe = wm8955_i2c_probe, - .remove = wm8955_i2c_remove, .id_table = wm8955_i2c_id, };

From: Kuninori Morimoto kuninori.morimoto.gx@renesas.com

Now we can replace Codec to Component. Let's do it.

Note: xxx_codec_xxx() -> xxx_component_xxx() .idle_bias_off = 0 -> .idle_bias_on = 1 .ignore_pmdown_time = 0 -> .pmdown_time = 1 - -> .endianness = 1 - -> .non_legacy_dai_naming = 1

Signed-off-by: Kuninori Morimoto kuninori.morimoto.gx@renesas.com --- sound/soc/codecs/wm8971.c | 108 ++++++++++++++++++++++------------------------ 1 file changed, 51 insertions(+), 57 deletions(-)

diff --git a/sound/soc/codecs/wm8971.c b/sound/soc/codecs/wm8971.c index 887d31c..4b02561 100644 --- a/sound/soc/codecs/wm8971.c +++ b/sound/soc/codecs/wm8971.c @@ -89,7 +89,7 @@ struct wm8971_priv { { 42, 0x0079 }, };

-#define wm8971_reset(c) snd_soc_write(c, WM8971_RESET, 0) +#define wm8971_reset(c) snd_soc_component_write(c, WM8971_RESET, 0)

/* WM8971 Controls */ static const char *wm8971_bass[] = { "Linear Control", "Adaptive Boost" }; @@ -433,8 +433,8 @@ static int get_coeff(int mclk, int rate) static int wm8971_set_dai_sysclk(struct snd_soc_dai *codec_dai, int clk_id, unsigned int freq, int dir) { - struct snd_soc_codec *codec = codec_dai->codec; - struct wm8971_priv *wm8971 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = codec_dai->component; + struct wm8971_priv *wm8971 = snd_soc_component_get_drvdata(component);

switch (freq) { case 11289600: @@ -451,7 +451,7 @@ static int wm8971_set_dai_sysclk(struct snd_soc_dai *codec_dai, static int wm8971_set_dai_fmt(struct snd_soc_dai *codec_dai, unsigned int fmt) { - struct snd_soc_codec *codec = codec_dai->codec; + struct snd_soc_component *component = codec_dai->component; u16 iface = 0;

/* set master/slave audio interface */ @@ -502,7 +502,7 @@ static int wm8971_set_dai_fmt(struct snd_soc_dai *codec_dai, return -EINVAL; }

- snd_soc_write(codec, WM8971_IFACE, iface); + snd_soc_component_write(component, WM8971_IFACE, iface); return 0; }

@@ -510,10 +510,10 @@ static int wm8971_pcm_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params, struct snd_soc_dai *dai) { - struct snd_soc_codec *codec = dai->codec; - struct wm8971_priv *wm8971 = snd_soc_codec_get_drvdata(codec); - u16 iface = snd_soc_read(codec, WM8971_IFACE) & 0x1f3; - u16 srate = snd_soc_read(codec, WM8971_SRATE) & 0x1c0; + struct snd_soc_component *component = dai->component; + struct wm8971_priv *wm8971 = snd_soc_component_get_drvdata(component); + u16 iface = snd_soc_component_read32(component, WM8971_IFACE) & 0x1f3; + u16 srate = snd_soc_component_read32(component, WM8971_SRATE) & 0x1c0; int coeff = get_coeff(wm8971->sysclk, params_rate(params));

/* bit size */ @@ -532,9 +532,9 @@ static int wm8971_pcm_hw_params(struct snd_pcm_substream *substream, }

/* set iface & srate */ - snd_soc_write(codec, WM8971_IFACE, iface); + snd_soc_component_write(component, WM8971_IFACE, iface); if (coeff >= 0) - snd_soc_write(codec, WM8971_SRATE, srate | + snd_soc_component_write(component, WM8971_SRATE, srate | (coeff_div[coeff].sr << 1) | coeff_div[coeff].usb);

return 0; @@ -542,13 +542,13 @@ static int wm8971_pcm_hw_params(struct snd_pcm_substream *substream,

static int wm8971_mute(struct snd_soc_dai *dai, int mute) { - struct snd_soc_codec *codec = dai->codec; - u16 mute_reg = snd_soc_read(codec, WM8971_ADCDAC) & 0xfff7; + struct snd_soc_component *component = dai->component; + u16 mute_reg = snd_soc_component_read32(component, WM8971_ADCDAC) & 0xfff7;

if (mute) - snd_soc_write(codec, WM8971_ADCDAC, mute_reg | 0x8); + snd_soc_component_write(component, WM8971_ADCDAC, mute_reg | 0x8); else - snd_soc_write(codec, WM8971_ADCDAC, mute_reg); + snd_soc_component_write(component, WM8971_ADCDAC, mute_reg); return 0; }

@@ -561,37 +561,37 @@ static void wm8971_charge_work(struct work_struct *work) regmap_update_bits(wm8971->regmap, WM8971_PWR1, 0x0180, 0x0100); }

-static int wm8971_set_bias_level(struct snd_soc_codec *codec, +static int wm8971_set_bias_level(struct snd_soc_component *component, enum snd_soc_bias_level level) { - struct wm8971_priv *wm8971 = snd_soc_codec_get_drvdata(codec); - u16 pwr_reg = snd_soc_read(codec, WM8971_PWR1) & 0xfe3e; + struct wm8971_priv *wm8971 = snd_soc_component_get_drvdata(component); + u16 pwr_reg = snd_soc_component_read32(component, WM8971_PWR1) & 0xfe3e;

switch (level) { case SND_SOC_BIAS_ON: /* set vmid to 50k and unmute dac */ - snd_soc_write(codec, WM8971_PWR1, pwr_reg | 0x00c1); + snd_soc_component_write(component, WM8971_PWR1, pwr_reg | 0x00c1); break; case SND_SOC_BIAS_PREPARE: /* Wait until fully charged */ flush_delayed_work(&wm8971->charge_work); break; case SND_SOC_BIAS_STANDBY: - if (snd_soc_codec_get_bias_level(codec) == SND_SOC_BIAS_OFF) { - snd_soc_cache_sync(codec); + if (snd_soc_component_get_bias_level(component) == SND_SOC_BIAS_OFF) { + snd_soc_component_cache_sync(component); /* charge output caps - set vmid to 5k for quick power up */ - snd_soc_write(codec, WM8971_PWR1, pwr_reg | 0x01c0); + snd_soc_component_write(component, WM8971_PWR1, pwr_reg | 0x01c0); queue_delayed_work(system_power_efficient_wq, &wm8971->charge_work, msecs_to_jiffies(1000)); } else { /* mute dac and set vmid to 500k, enable VREF */ - snd_soc_write(codec, WM8971_PWR1, pwr_reg | 0x0140); + snd_soc_component_write(component, WM8971_PWR1, pwr_reg | 0x0140); }

break; case SND_SOC_BIAS_OFF: cancel_delayed_work_sync(&wm8971->charge_work); - snd_soc_write(codec, WM8971_PWR1, 0x0001); + snd_soc_component_write(component, WM8971_PWR1, 0x0001); break; } return 0; @@ -628,40 +628,41 @@ static int wm8971_set_bias_level(struct snd_soc_codec *codec, .ops = &wm8971_dai_ops, };

-static int wm8971_probe(struct snd_soc_codec *codec) +static int wm8971_probe(struct snd_soc_component *component) { - struct wm8971_priv *wm8971 = snd_soc_codec_get_drvdata(codec); + struct wm8971_priv *wm8971 = snd_soc_component_get_drvdata(component);

INIT_DELAYED_WORK(&wm8971->charge_work, wm8971_charge_work);

- wm8971_reset(codec); + wm8971_reset(component);

/* set the update bits */ - snd_soc_update_bits(codec, WM8971_LDAC, 0x0100, 0x0100); - snd_soc_update_bits(codec, WM8971_RDAC, 0x0100, 0x0100); - snd_soc_update_bits(codec, WM8971_LOUT1V, 0x0100, 0x0100); - snd_soc_update_bits(codec, WM8971_ROUT1V, 0x0100, 0x0100); - snd_soc_update_bits(codec, WM8971_LOUT2V, 0x0100, 0x0100); - snd_soc_update_bits(codec, WM8971_ROUT2V, 0x0100, 0x0100); - snd_soc_update_bits(codec, WM8971_LINVOL, 0x0100, 0x0100); - snd_soc_update_bits(codec, WM8971_RINVOL, 0x0100, 0x0100); + snd_soc_component_update_bits(component, WM8971_LDAC, 0x0100, 0x0100); + snd_soc_component_update_bits(component, WM8971_RDAC, 0x0100, 0x0100); + snd_soc_component_update_bits(component, WM8971_LOUT1V, 0x0100, 0x0100); + snd_soc_component_update_bits(component, WM8971_ROUT1V, 0x0100, 0x0100); + snd_soc_component_update_bits(component, WM8971_LOUT2V, 0x0100, 0x0100); + snd_soc_component_update_bits(component, WM8971_ROUT2V, 0x0100, 0x0100); + snd_soc_component_update_bits(component, WM8971_LINVOL, 0x0100, 0x0100); + snd_soc_component_update_bits(component, WM8971_RINVOL, 0x0100, 0x0100);

return 0; }

-static const struct snd_soc_codec_driver soc_codec_dev_wm8971 = { - .probe = wm8971_probe, - .set_bias_level = wm8971_set_bias_level, - .suspend_bias_off = true, - - .component_driver = { - .controls = wm8971_snd_controls, - .num_controls = ARRAY_SIZE(wm8971_snd_controls), - .dapm_widgets = wm8971_dapm_widgets, - .num_dapm_widgets = ARRAY_SIZE(wm8971_dapm_widgets), - .dapm_routes = wm8971_dapm_routes, - .num_dapm_routes = ARRAY_SIZE(wm8971_dapm_routes), - }, +static const struct snd_soc_component_driver soc_component_dev_wm8971 = { + .probe = wm8971_probe, + .set_bias_level = wm8971_set_bias_level, + .controls = wm8971_snd_controls, + .num_controls = ARRAY_SIZE(wm8971_snd_controls), + .dapm_widgets = wm8971_dapm_widgets, + .num_dapm_widgets = ARRAY_SIZE(wm8971_dapm_widgets), + .dapm_routes = wm8971_dapm_routes, + .num_dapm_routes = ARRAY_SIZE(wm8971_dapm_routes), + .suspend_bias_off = 1, + .idle_bias_on = 1, + .pmdown_time = 1, + .endianness = 1, + .non_legacy_dai_naming = 1, };

static const struct regmap_config wm8971_regmap = { @@ -691,18 +692,12 @@ static int wm8971_i2c_probe(struct i2c_client *i2c,

i2c_set_clientdata(i2c, wm8971);

- ret = snd_soc_register_codec(&i2c->dev, - &soc_codec_dev_wm8971, &wm8971_dai, 1); + ret = devm_snd_soc_register_component(&i2c->dev, + &soc_component_dev_wm8971, &wm8971_dai, 1);

return ret; }

-static int wm8971_i2c_remove(struct i2c_client *client) -{ - snd_soc_unregister_codec(&client->dev); - return 0; -} - static const struct i2c_device_id wm8971_i2c_id[] = { { "wm8971", 0 }, { } @@ -714,7 +709,6 @@ static int wm8971_i2c_remove(struct i2c_client *client) .name = "wm8971", }, .probe = wm8971_i2c_probe, - .remove = wm8971_i2c_remove, .id_table = wm8971_i2c_id, };

From: Kuninori Morimoto kuninori.morimoto.gx@renesas.com

Now we can replace Codec to Component. Let's do it.

Note: xxx_codec_xxx() -> xxx_component_xxx() .idle_bias_off = 0 -> .idle_bias_on = 1 .ignore_pmdown_time = 0 -> .pmdown_time = 1 - -> .endianness = 1 - -> .non_legacy_dai_naming = 1

Signed-off-by: Kuninori Morimoto kuninori.morimoto.gx@renesas.com --- sound/soc/codecs/wm8974.c | 143 ++++++++++++++++++++++------------------------ 1 file changed, 68 insertions(+), 75 deletions(-)

diff --git a/sound/soc/codecs/wm8974.c b/sound/soc/codecs/wm8974.c index d414ddd..baf3fee 100644 --- a/sound/soc/codecs/wm8974.c +++ b/sound/soc/codecs/wm8974.c @@ -54,7 +54,7 @@ struct wm8974_priv { #define WM8974_POWER1_BIASEN 0x08 #define WM8974_POWER1_BUFIOEN 0x04

-#define wm8974_reset(c) snd_soc_write(c, WM8974_RESET, 0) +#define wm8974_reset(c) snd_soc_component_write(c, WM8974_RESET, 0)

static const char *wm8974_companding[] = {"Off", "NC", "u-law", "A-law" }; static const char *wm8974_deemp[] = {"None", "32kHz", "44.1kHz", "48kHz" }; @@ -324,33 +324,33 @@ static void pll_factors(struct pll_ *pll_div, static int wm8974_set_dai_pll(struct snd_soc_dai *codec_dai, int pll_id, int source, unsigned int freq_in, unsigned int freq_out) { - struct snd_soc_codec *codec = codec_dai->codec; + struct snd_soc_component *component = codec_dai->component; struct pll_ pll_div; u16 reg;

if (freq_in == 0 || freq_out == 0) { /* Clock CODEC directly from MCLK */ - reg = snd_soc_read(codec, WM8974_CLOCK); - snd_soc_write(codec, WM8974_CLOCK, reg & 0x0ff); + reg = snd_soc_component_read32(component, WM8974_CLOCK); + snd_soc_component_write(component, WM8974_CLOCK, reg & 0x0ff);

/* Turn off PLL */ - reg = snd_soc_read(codec, WM8974_POWER1); - snd_soc_write(codec, WM8974_POWER1, reg & 0x1df); + reg = snd_soc_component_read32(component, WM8974_POWER1); + snd_soc_component_write(component, WM8974_POWER1, reg & 0x1df); return 0; }

pll_factors(&pll_div, freq_out, freq_in);

- snd_soc_write(codec, WM8974_PLLN, (pll_div.pre_div << 4) | pll_div.n); - snd_soc_write(codec, WM8974_PLLK1, pll_div.k >> 18); - snd_soc_write(codec, WM8974_PLLK2, (pll_div.k >> 9) & 0x1ff); - snd_soc_write(codec, WM8974_PLLK3, pll_div.k & 0x1ff); - reg = snd_soc_read(codec, WM8974_POWER1); - snd_soc_write(codec, WM8974_POWER1, reg | 0x020); + snd_soc_component_write(component, WM8974_PLLN, (pll_div.pre_div << 4) | pll_div.n); + snd_soc_component_write(component, WM8974_PLLK1, pll_div.k >> 18); + snd_soc_component_write(component, WM8974_PLLK2, (pll_div.k >> 9) & 0x1ff); + snd_soc_component_write(component, WM8974_PLLK3, pll_div.k & 0x1ff); + reg = snd_soc_component_read32(component, WM8974_POWER1); + snd_soc_component_write(component, WM8974_POWER1, reg | 0x020);

/* Run CODEC from PLL instead of MCLK */ - reg = snd_soc_read(codec, WM8974_CLOCK); - snd_soc_write(codec, WM8974_CLOCK, reg | 0x100); + reg = snd_soc_component_read32(component, WM8974_CLOCK); + snd_soc_component_write(component, WM8974_CLOCK, reg | 0x100);

return 0; } @@ -361,21 +361,21 @@ static int wm8974_set_dai_pll(struct snd_soc_dai *codec_dai, int pll_id, static int wm8974_set_dai_clkdiv(struct snd_soc_dai *codec_dai, int div_id, int div) { - struct snd_soc_codec *codec = codec_dai->codec; + struct snd_soc_component *component = codec_dai->component; u16 reg;

switch (div_id) { case WM8974_OPCLKDIV: - reg = snd_soc_read(codec, WM8974_GPIO) & 0x1cf; - snd_soc_write(codec, WM8974_GPIO, reg | div); + reg = snd_soc_component_read32(component, WM8974_GPIO) & 0x1cf; + snd_soc_component_write(component, WM8974_GPIO, reg | div); break; case WM8974_MCLKDIV: - reg = snd_soc_read(codec, WM8974_CLOCK) & 0x11f; - snd_soc_write(codec, WM8974_CLOCK, reg | div); + reg = snd_soc_component_read32(component, WM8974_CLOCK) & 0x11f; + snd_soc_component_write(component, WM8974_CLOCK, reg | div); break; case WM8974_BCLKDIV: - reg = snd_soc_read(codec, WM8974_CLOCK) & 0x1e3; - snd_soc_write(codec, WM8974_CLOCK, reg | div); + reg = snd_soc_component_read32(component, WM8974_CLOCK) & 0x1e3; + snd_soc_component_write(component, WM8974_CLOCK, reg | div); break; default: return -EINVAL; @@ -418,8 +418,8 @@ static unsigned int wm8974_get_mclkdiv(unsigned int f_in, unsigned int f_out,

static int wm8974_update_clocks(struct snd_soc_dai *dai) { - struct snd_soc_codec *codec = dai->codec; - struct wm8974_priv *priv = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = dai->component; + struct wm8974_priv *priv = snd_soc_component_get_drvdata(component); unsigned int fs256; unsigned int fpll = 0; unsigned int f; @@ -446,8 +446,8 @@ static int wm8974_update_clocks(struct snd_soc_dai *dai) static int wm8974_set_dai_sysclk(struct snd_soc_dai *dai, int clk_id, unsigned int freq, int dir) { - struct snd_soc_codec *codec = dai->codec; - struct wm8974_priv *priv = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = dai->component; + struct wm8974_priv *priv = snd_soc_component_get_drvdata(component);

if (dir != SND_SOC_CLOCK_IN) return -EINVAL; @@ -460,9 +460,9 @@ static int wm8974_set_dai_sysclk(struct snd_soc_dai *dai, int clk_id, static int wm8974_set_dai_fmt(struct snd_soc_dai *codec_dai, unsigned int fmt) { - struct snd_soc_codec *codec = codec_dai->codec; + struct snd_soc_component *component = codec_dai->component; u16 iface = 0; - u16 clk = snd_soc_read(codec, WM8974_CLOCK) & 0x1fe; + u16 clk = snd_soc_component_read32(component, WM8974_CLOCK) & 0x1fe;

/* set master/slave audio interface */ switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) { @@ -509,8 +509,8 @@ static int wm8974_set_dai_fmt(struct snd_soc_dai *codec_dai, return -EINVAL; }

- snd_soc_write(codec, WM8974_IFACE, iface); - snd_soc_write(codec, WM8974_CLOCK, clk); + snd_soc_component_write(component, WM8974_IFACE, iface); + snd_soc_component_write(component, WM8974_CLOCK, clk); return 0; }

@@ -518,10 +518,10 @@ static int wm8974_pcm_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params, struct snd_soc_dai *dai) { - struct snd_soc_codec *codec = dai->codec; - struct wm8974_priv *priv = snd_soc_codec_get_drvdata(codec); - u16 iface = snd_soc_read(codec, WM8974_IFACE) & 0x19f; - u16 adn = snd_soc_read(codec, WM8974_ADD) & 0x1f1; + struct snd_soc_component *component = dai->component; + struct wm8974_priv *priv = snd_soc_component_get_drvdata(component); + u16 iface = snd_soc_component_read32(component, WM8974_IFACE) & 0x19f; + u16 adn = snd_soc_component_read32(component, WM8974_ADD) & 0x1f1; int err;

priv->fs = params_rate(params); @@ -566,55 +566,55 @@ static int wm8974_pcm_hw_params(struct snd_pcm_substream *substream, break; }

- snd_soc_write(codec, WM8974_IFACE, iface); - snd_soc_write(codec, WM8974_ADD, adn); + snd_soc_component_write(component, WM8974_IFACE, iface); + snd_soc_component_write(component, WM8974_ADD, adn); return 0; }

static int wm8974_mute(struct snd_soc_dai *dai, int mute) { - struct snd_soc_codec *codec = dai->codec; - u16 mute_reg = snd_soc_read(codec, WM8974_DAC) & 0xffbf; + struct snd_soc_component *component = dai->component; + u16 mute_reg = snd_soc_component_read32(component, WM8974_DAC) & 0xffbf;

if (mute) - snd_soc_write(codec, WM8974_DAC, mute_reg | 0x40); + snd_soc_component_write(component, WM8974_DAC, mute_reg | 0x40); else - snd_soc_write(codec, WM8974_DAC, mute_reg); + snd_soc_component_write(component, WM8974_DAC, mute_reg); return 0; }

/* liam need to make this lower power with dapm */ -static int wm8974_set_bias_level(struct snd_soc_codec *codec, +static int wm8974_set_bias_level(struct snd_soc_component *component, enum snd_soc_bias_level level) { - u16 power1 = snd_soc_read(codec, WM8974_POWER1) & ~0x3; + u16 power1 = snd_soc_component_read32(component, WM8974_POWER1) & ~0x3;

switch (level) { case SND_SOC_BIAS_ON: case SND_SOC_BIAS_PREPARE: power1 |= 0x1; /* VMID 50k */ - snd_soc_write(codec, WM8974_POWER1, power1); + snd_soc_component_write(component, WM8974_POWER1, power1); break;

case SND_SOC_BIAS_STANDBY: power1 |= WM8974_POWER1_BIASEN | WM8974_POWER1_BUFIOEN;

- if (snd_soc_codec_get_bias_level(codec) == SND_SOC_BIAS_OFF) { - regcache_sync(dev_get_regmap(codec->dev, NULL)); + if (snd_soc_component_get_bias_level(component) == SND_SOC_BIAS_OFF) { + regcache_sync(dev_get_regmap(component->dev, NULL));

/* Initial cap charge at VMID 5k */ - snd_soc_write(codec, WM8974_POWER1, power1 | 0x3); + snd_soc_component_write(component, WM8974_POWER1, power1 | 0x3); mdelay(100); }

power1 |= 0x2; /* VMID 500k */ - snd_soc_write(codec, WM8974_POWER1, power1); + snd_soc_component_write(component, WM8974_POWER1, power1); break;

case SND_SOC_BIAS_OFF: - snd_soc_write(codec, WM8974_POWER1, 0); - snd_soc_write(codec, WM8974_POWER2, 0); - snd_soc_write(codec, WM8974_POWER3, 0); + snd_soc_component_write(component, WM8974_POWER1, 0); + snd_soc_component_write(component, WM8974_POWER2, 0); + snd_soc_component_write(component, WM8974_POWER3, 0); break; }

@@ -663,32 +663,33 @@ static int wm8974_set_bias_level(struct snd_soc_codec *codec, .cache_type = REGCACHE_FLAT, };

-static int wm8974_probe(struct snd_soc_codec *codec) +static int wm8974_probe(struct snd_soc_component *component) { int ret = 0;

- ret = wm8974_reset(codec); + ret = wm8974_reset(component); if (ret < 0) { - dev_err(codec->dev, "Failed to issue reset\n"); + dev_err(component->dev, "Failed to issue reset\n"); return ret; }

return 0; }

-static const struct snd_soc_codec_driver soc_codec_dev_wm8974 = { - .probe = wm8974_probe, - .set_bias_level = wm8974_set_bias_level, - .suspend_bias_off = true, - - .component_driver = { - .controls = wm8974_snd_controls, - .num_controls = ARRAY_SIZE(wm8974_snd_controls), - .dapm_widgets = wm8974_dapm_widgets, - .num_dapm_widgets = ARRAY_SIZE(wm8974_dapm_widgets), - .dapm_routes = wm8974_dapm_routes, - .num_dapm_routes = ARRAY_SIZE(wm8974_dapm_routes), - }, +static const struct snd_soc_component_driver soc_component_dev_wm8974 = { + .probe = wm8974_probe, + .set_bias_level = wm8974_set_bias_level, + .controls = wm8974_snd_controls, + .num_controls = ARRAY_SIZE(wm8974_snd_controls), + .dapm_widgets = wm8974_dapm_widgets, + .num_dapm_widgets = ARRAY_SIZE(wm8974_dapm_widgets), + .dapm_routes = wm8974_dapm_routes, + .num_dapm_routes = ARRAY_SIZE(wm8974_dapm_routes), + .suspend_bias_off = 1, + .idle_bias_on = 1, + .pmdown_time = 1, + .endianness = 1, + .non_legacy_dai_naming = 1, };

static int wm8974_i2c_probe(struct i2c_client *i2c, @@ -708,19 +709,12 @@ static int wm8974_i2c_probe(struct i2c_client *i2c, if (IS_ERR(regmap)) return PTR_ERR(regmap);

- ret = snd_soc_register_codec(&i2c->dev, - &soc_codec_dev_wm8974, &wm8974_dai, 1); + ret = devm_snd_soc_register_component(&i2c->dev, + &soc_component_dev_wm8974, &wm8974_dai, 1);

return ret; }

-static int wm8974_i2c_remove(struct i2c_client *client) -{ - snd_soc_unregister_codec(&client->dev); - - return 0; -} - static const struct i2c_device_id wm8974_i2c_id[] = { { "wm8974", 0 }, { } @@ -739,7 +733,6 @@ static int wm8974_i2c_remove(struct i2c_client *client) .of_match_table = wm8974_of_match, }, .probe = wm8974_i2c_probe, - .remove = wm8974_i2c_remove, .id_table = wm8974_i2c_id, };

From: Kuninori Morimoto kuninori.morimoto.gx@renesas.com

Now we can replace Codec to Component. Let's do it.

Note: xxx_codec_xxx() -> xxx_component_xxx() .idle_bias_off = 0 -> .idle_bias_on = 1 .ignore_pmdown_time = 0 -> .pmdown_time = 1 - -> .endianness = 1 - -> .non_legacy_dai_naming = 1

Signed-off-by: Kuninori Morimoto kuninori.morimoto.gx@renesas.com --- sound/soc/codecs/wm8988.c | 127 +++++++++++++++++++++------------------------- 1 file changed, 57 insertions(+), 70 deletions(-)

diff --git a/sound/soc/codecs/wm8988.c b/sound/soc/codecs/wm8988.c index b0d0219..65f602d 100644 --- a/sound/soc/codecs/wm8988.c +++ b/sound/soc/codecs/wm8988.c @@ -119,7 +119,7 @@ struct wm8988_priv { const struct snd_pcm_hw_constraint_list *sysclk_constraints; };

-#define wm8988_reset(c) snd_soc_write(c, WM8988_RESET, 0) +#define wm8988_reset(c) snd_soc_component_write(c, WM8988_RESET, 0)

/* * WM8988 Controls @@ -244,16 +244,16 @@ static SOC_ENUM_SINGLE_DECL(adcpol, static int wm8988_lrc_control(struct snd_soc_dapm_widget *w, struct snd_kcontrol *kcontrol, int event) { - struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm); - u16 adctl2 = snd_soc_read(codec, WM8988_ADCTL2); + struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm); + u16 adctl2 = snd_soc_component_read32(component, WM8988_ADCTL2);

/* Use the DAC to gate LRC if active, otherwise use ADC */ - if (snd_soc_read(codec, WM8988_PWR2) & 0x180) + if (snd_soc_component_read32(component, WM8988_PWR2) & 0x180) adctl2 &= ~0x4; else adctl2 |= 0x4;

- return snd_soc_write(codec, WM8988_ADCTL2, adctl2); + return snd_soc_component_write(component, WM8988_ADCTL2, adctl2); }

static const char *wm8988_line_texts[] = { @@ -555,8 +555,8 @@ static inline int get_coeff(int mclk, int rate) static int wm8988_set_dai_sysclk(struct snd_soc_dai *codec_dai, int clk_id, unsigned int freq, int dir) { - struct snd_soc_codec *codec = codec_dai->codec; - struct wm8988_priv *wm8988 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = codec_dai->component; + struct wm8988_priv *wm8988 = snd_soc_component_get_drvdata(component);

switch (freq) { case 11289600: @@ -587,7 +587,7 @@ static int wm8988_set_dai_sysclk(struct snd_soc_dai *codec_dai, static int wm8988_set_dai_fmt(struct snd_soc_dai *codec_dai, unsigned int fmt) { - struct snd_soc_codec *codec = codec_dai->codec; + struct snd_soc_component *component = codec_dai->component; u16 iface = 0;

/* set master/slave audio interface */ @@ -638,21 +638,21 @@ static int wm8988_set_dai_fmt(struct snd_soc_dai *codec_dai, return -EINVAL; }

- snd_soc_write(codec, WM8988_IFACE, iface); + snd_soc_component_write(component, WM8988_IFACE, iface); return 0; }

static int wm8988_pcm_startup(struct snd_pcm_substream *substream, struct snd_soc_dai *dai) { - struct snd_soc_codec *codec = dai->codec; - struct wm8988_priv *wm8988 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = dai->component; + struct wm8988_priv *wm8988 = snd_soc_component_get_drvdata(component);

/* The set of sample rates that can be supported depends on the * MCLK supplied to the CODEC - enforce this. */ if (!wm8988->sysclk) { - dev_err(codec->dev, + dev_err(component->dev, "No MCLK configured, call set_sysclk() on init\n"); return -EINVAL; } @@ -668,10 +668,10 @@ static int wm8988_pcm_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params, struct snd_soc_dai *dai) { - struct snd_soc_codec *codec = dai->codec; - struct wm8988_priv *wm8988 = snd_soc_codec_get_drvdata(codec); - u16 iface = snd_soc_read(codec, WM8988_IFACE) & 0x1f3; - u16 srate = snd_soc_read(codec, WM8988_SRATE) & 0x180; + struct snd_soc_component *component = dai->component; + struct wm8988_priv *wm8988 = snd_soc_component_get_drvdata(component); + u16 iface = snd_soc_component_read32(component, WM8988_IFACE) & 0x1f3; + u16 srate = snd_soc_component_read32(component, WM8988_SRATE) & 0x180; int coeff;

coeff = get_coeff(wm8988->sysclk, params_rate(params)); @@ -680,7 +680,7 @@ static int wm8988_pcm_hw_params(struct snd_pcm_substream *substream, srate |= 0x40; } if (coeff < 0) { - dev_err(codec->dev, + dev_err(component->dev, "Unable to configure sample rate %dHz with %dHz MCLK\n", params_rate(params), wm8988->sysclk); return coeff; @@ -702,9 +702,9 @@ static int wm8988_pcm_hw_params(struct snd_pcm_substream *substream, }

/* set iface & srate */ - snd_soc_write(codec, WM8988_IFACE, iface); + snd_soc_component_write(component, WM8988_IFACE, iface); if (coeff >= 0) - snd_soc_write(codec, WM8988_SRATE, srate | + snd_soc_component_write(component, WM8988_SRATE, srate | (coeff_div[coeff].sr << 1) | coeff_div[coeff].usb);

return 0; @@ -712,21 +712,21 @@ static int wm8988_pcm_hw_params(struct snd_pcm_substream *substream,

static int wm8988_mute(struct snd_soc_dai *dai, int mute) { - struct snd_soc_codec *codec = dai->codec; - u16 mute_reg = snd_soc_read(codec, WM8988_ADCDAC) & 0xfff7; + struct snd_soc_component *component = dai->component; + u16 mute_reg = snd_soc_component_read32(component, WM8988_ADCDAC) & 0xfff7;

if (mute) - snd_soc_write(codec, WM8988_ADCDAC, mute_reg | 0x8); + snd_soc_component_write(component, WM8988_ADCDAC, mute_reg | 0x8); else - snd_soc_write(codec, WM8988_ADCDAC, mute_reg); + snd_soc_component_write(component, WM8988_ADCDAC, mute_reg); return 0; }

-static int wm8988_set_bias_level(struct snd_soc_codec *codec, +static int wm8988_set_bias_level(struct snd_soc_component *component, enum snd_soc_bias_level level) { - struct wm8988_priv *wm8988 = snd_soc_codec_get_drvdata(codec); - u16 pwr_reg = snd_soc_read(codec, WM8988_PWR1) & ~0x1c1; + struct wm8988_priv *wm8988 = snd_soc_component_get_drvdata(component); + u16 pwr_reg = snd_soc_component_read32(component, WM8988_PWR1) & ~0x1c1;

switch (level) { case SND_SOC_BIAS_ON: @@ -734,26 +734,26 @@ static int wm8988_set_bias_level(struct snd_soc_codec *codec,

case SND_SOC_BIAS_PREPARE: /* VREF, VMID=2x50k, digital enabled */ - snd_soc_write(codec, WM8988_PWR1, pwr_reg | 0x00c0); + snd_soc_component_write(component, WM8988_PWR1, pwr_reg | 0x00c0); break;

case SND_SOC_BIAS_STANDBY: - if (snd_soc_codec_get_bias_level(codec) == SND_SOC_BIAS_OFF) { + if (snd_soc_component_get_bias_level(component) == SND_SOC_BIAS_OFF) { regcache_sync(wm8988->regmap);

/* VREF, VMID=2x5k */ - snd_soc_write(codec, WM8988_PWR1, pwr_reg | 0x1c1); + snd_soc_component_write(component, WM8988_PWR1, pwr_reg | 0x1c1);

/* Charge caps */ msleep(100); }

/* VREF, VMID=2*500k, digital stopped */ - snd_soc_write(codec, WM8988_PWR1, pwr_reg | 0x0141); + snd_soc_component_write(component, WM8988_PWR1, pwr_reg | 0x0141); break;

case SND_SOC_BIAS_OFF: - snd_soc_write(codec, WM8988_PWR1, 0x0000); + snd_soc_component_write(component, WM8988_PWR1, 0x0000); break; } return 0; @@ -792,39 +792,40 @@ static int wm8988_set_bias_level(struct snd_soc_codec *codec, .symmetric_rates = 1, };

-static int wm8988_probe(struct snd_soc_codec *codec) +static int wm8988_probe(struct snd_soc_component *component) { int ret = 0;

- ret = wm8988_reset(codec); + ret = wm8988_reset(component); if (ret < 0) { - dev_err(codec->dev, "Failed to issue reset\n"); + dev_err(component->dev, "Failed to issue reset\n"); return ret; }

/* set the update bits (we always update left then right) */ - snd_soc_update_bits(codec, WM8988_RADC, 0x0100, 0x0100); - snd_soc_update_bits(codec, WM8988_RDAC, 0x0100, 0x0100); - snd_soc_update_bits(codec, WM8988_ROUT1V, 0x0100, 0x0100); - snd_soc_update_bits(codec, WM8988_ROUT2V, 0x0100, 0x0100); - snd_soc_update_bits(codec, WM8988_RINVOL, 0x0100, 0x0100); + snd_soc_component_update_bits(component, WM8988_RADC, 0x0100, 0x0100); + snd_soc_component_update_bits(component, WM8988_RDAC, 0x0100, 0x0100); + snd_soc_component_update_bits(component, WM8988_ROUT1V, 0x0100, 0x0100); + snd_soc_component_update_bits(component, WM8988_ROUT2V, 0x0100, 0x0100); + snd_soc_component_update_bits(component, WM8988_RINVOL, 0x0100, 0x0100);

return 0; }

-static const struct snd_soc_codec_driver soc_codec_dev_wm8988 = { - .probe = wm8988_probe, - .set_bias_level = wm8988_set_bias_level, - .suspend_bias_off = true, - - .component_driver = { - .controls = wm8988_snd_controls, - .num_controls = ARRAY_SIZE(wm8988_snd_controls), - .dapm_widgets = wm8988_dapm_widgets, - .num_dapm_widgets = ARRAY_SIZE(wm8988_dapm_widgets), - .dapm_routes = wm8988_dapm_routes, - .num_dapm_routes = ARRAY_SIZE(wm8988_dapm_routes), - }, +static const struct snd_soc_component_driver soc_component_dev_wm8988 = { + .probe = wm8988_probe, + .set_bias_level = wm8988_set_bias_level, + .controls = wm8988_snd_controls, + .num_controls = ARRAY_SIZE(wm8988_snd_controls), + .dapm_widgets = wm8988_dapm_widgets, + .num_dapm_widgets = ARRAY_SIZE(wm8988_dapm_widgets), + .dapm_routes = wm8988_dapm_routes, + .num_dapm_routes = ARRAY_SIZE(wm8988_dapm_routes), + .suspend_bias_off = 1, + .idle_bias_on = 1, + .pmdown_time = 1, + .endianness = 1, + .non_legacy_dai_naming = 1, };

static const struct regmap_config wm8988_regmap = { @@ -859,23 +860,16 @@ static int wm8988_spi_probe(struct spi_device *spi)

spi_set_drvdata(spi, wm8988);

- ret = snd_soc_register_codec(&spi->dev, - &soc_codec_dev_wm8988, &wm8988_dai, 1); + ret = devm_snd_soc_register_component(&spi->dev, + &soc_component_dev_wm8988, &wm8988_dai, 1); return ret; }

-static int wm8988_spi_remove(struct spi_device *spi) -{ - snd_soc_unregister_codec(&spi->dev); - return 0; -} - static struct spi_driver wm8988_spi_driver = { .driver = { .name = "wm8988", }, .probe = wm8988_spi_probe, - .remove = wm8988_spi_remove, }; #endif /* CONFIG_SPI_MASTER */

@@ -900,17 +894,11 @@ static int wm8988_i2c_probe(struct i2c_client *i2c, return ret; }

- ret = snd_soc_register_codec(&i2c->dev, - &soc_codec_dev_wm8988, &wm8988_dai, 1); + ret = devm_snd_soc_register_component(&i2c->dev, + &soc_component_dev_wm8988, &wm8988_dai, 1); return ret; }

-static int wm8988_i2c_remove(struct i2c_client *client) -{ - snd_soc_unregister_codec(&client->dev); - return 0; -} - static const struct i2c_device_id wm8988_i2c_id[] = { { "wm8988", 0 }, { } @@ -922,7 +910,6 @@ static int wm8988_i2c_remove(struct i2c_client *client) .name = "wm8988", }, .probe = wm8988_i2c_probe, - .remove = wm8988_i2c_remove, .id_table = wm8988_i2c_id, }; #endif

From: Kuninori Morimoto kuninori.morimoto.gx@renesas.com

Now we can replace Codec to Component. Let's do it.

Note: xxx_codec_xxx() -> xxx_component_xxx() .idle_bias_off = 1 -> .idle_bias_on = 0 .ignore_pmdown_time = 0 -> .pmdown_time = 1 - -> .endianness = 1 - -> .non_legacy_dai_naming = 1

Signed-off-by: Kuninori Morimoto kuninori.morimoto.gx@renesas.com --- sound/soc/codecs/wm8962.c | 397 +++++++++++++++++++++--------------------- sound/soc/codecs/wm8962.h | 2 +- sound/soc/samsung/tobermory.c | 6 +- 3 files changed, 202 insertions(+), 203 deletions(-)

diff --git a/sound/soc/codecs/wm8962.c b/sound/soc/codecs/wm8962.c index fd2731d..05b0fc2 100644 --- a/sound/soc/codecs/wm8962.c +++ b/sound/soc/codecs/wm8962.c @@ -55,7 +55,7 @@ struct wm8962_priv { struct wm8962_pdata pdata; struct regmap *regmap; - struct snd_soc_codec *codec; + struct snd_soc_component *component;

int sysclk; int sysclk_rate; @@ -1475,55 +1475,55 @@ static const DECLARE_TLV_DB_RANGE(classd_tlv, ); static const DECLARE_TLV_DB_SCALE(eq_tlv, -1200, 100, 0);

-static int wm8962_dsp2_write_config(struct snd_soc_codec *codec) +static int wm8962_dsp2_write_config(struct snd_soc_component *component) { - struct wm8962_priv *wm8962 = snd_soc_codec_get_drvdata(codec); + struct wm8962_priv *wm8962 = snd_soc_component_get_drvdata(component);

return regcache_sync_region(wm8962->regmap, WM8962_HDBASS_AI_1, WM8962_MAX_REGISTER); }

-static int wm8962_dsp2_set_enable(struct snd_soc_codec *codec, u16 val) +static int wm8962_dsp2_set_enable(struct snd_soc_component *component, u16 val) { - u16 adcl = snd_soc_read(codec, WM8962_LEFT_ADC_VOLUME); - u16 adcr = snd_soc_read(codec, WM8962_RIGHT_ADC_VOLUME); - u16 dac = snd_soc_read(codec, WM8962_ADC_DAC_CONTROL_1); + u16 adcl = snd_soc_component_read32(component, WM8962_LEFT_ADC_VOLUME); + u16 adcr = snd_soc_component_read32(component, WM8962_RIGHT_ADC_VOLUME); + u16 dac = snd_soc_component_read32(component, WM8962_ADC_DAC_CONTROL_1);

/* Mute the ADCs and DACs */ - snd_soc_write(codec, WM8962_LEFT_ADC_VOLUME, 0); - snd_soc_write(codec, WM8962_RIGHT_ADC_VOLUME, WM8962_ADC_VU); - snd_soc_update_bits(codec, WM8962_ADC_DAC_CONTROL_1, + snd_soc_component_write(component, WM8962_LEFT_ADC_VOLUME, 0); + snd_soc_component_write(component, WM8962_RIGHT_ADC_VOLUME, WM8962_ADC_VU); + snd_soc_component_update_bits(component, WM8962_ADC_DAC_CONTROL_1, WM8962_DAC_MUTE, WM8962_DAC_MUTE);

- snd_soc_write(codec, WM8962_SOUNDSTAGE_ENABLES_0, val); + snd_soc_component_write(component, WM8962_SOUNDSTAGE_ENABLES_0, val);

/* Restore the ADCs and DACs */ - snd_soc_write(codec, WM8962_LEFT_ADC_VOLUME, adcl); - snd_soc_write(codec, WM8962_RIGHT_ADC_VOLUME, adcr); - snd_soc_update_bits(codec, WM8962_ADC_DAC_CONTROL_1, + snd_soc_component_write(component, WM8962_LEFT_ADC_VOLUME, adcl); + snd_soc_component_write(component, WM8962_RIGHT_ADC_VOLUME, adcr); + snd_soc_component_update_bits(component, WM8962_ADC_DAC_CONTROL_1, WM8962_DAC_MUTE, dac);

return 0; }

-static int wm8962_dsp2_start(struct snd_soc_codec *codec) +static int wm8962_dsp2_start(struct snd_soc_component *component) { - struct wm8962_priv *wm8962 = snd_soc_codec_get_drvdata(codec); + struct wm8962_priv *wm8962 = snd_soc_component_get_drvdata(component);

- wm8962_dsp2_write_config(codec); + wm8962_dsp2_write_config(component);

- snd_soc_write(codec, WM8962_DSP2_EXECCONTROL, WM8962_DSP2_RUNR); + snd_soc_component_write(component, WM8962_DSP2_EXECCONTROL, WM8962_DSP2_RUNR);

- wm8962_dsp2_set_enable(codec, wm8962->dsp2_ena); + wm8962_dsp2_set_enable(component, wm8962->dsp2_ena);

return 0; }

-static int wm8962_dsp2_stop(struct snd_soc_codec *codec) +static int wm8962_dsp2_stop(struct snd_soc_component *component) { - wm8962_dsp2_set_enable(codec, 0); + wm8962_dsp2_set_enable(component, 0);

- snd_soc_write(codec, WM8962_DSP2_EXECCONTROL, WM8962_DSP2_STOP); + snd_soc_component_write(component, WM8962_DSP2_EXECCONTROL, WM8962_DSP2_STOP);

return 0; } @@ -1550,8 +1550,8 @@ static int wm8962_dsp2_ena_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { int shift = kcontrol->private_value; - struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol); - struct wm8962_priv *wm8962 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol); + struct wm8962_priv *wm8962 = snd_soc_component_get_drvdata(component);

ucontrol->value.integer.value[0] = !!(wm8962->dsp2_ena & 1 << shift);

@@ -1562,11 +1562,11 @@ static int wm8962_dsp2_ena_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { int shift = kcontrol->private_value; - struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol); - struct wm8962_priv *wm8962 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol); + struct wm8962_priv *wm8962 = snd_soc_component_get_drvdata(component); int old = wm8962->dsp2_ena; int ret = 0; - int dsp2_running = snd_soc_read(codec, WM8962_DSP2_POWER_MANAGEMENT) & + int dsp2_running = snd_soc_component_read32(component, WM8962_DSP2_POWER_MANAGEMENT) & WM8962_DSP2_ENA;

mutex_lock(&wm8962->dsp2_ena_lock); @@ -1583,9 +1583,9 @@ static int wm8962_dsp2_ena_put(struct snd_kcontrol *kcontrol,

if (dsp2_running) { if (wm8962->dsp2_ena) - wm8962_dsp2_set_enable(codec, wm8962->dsp2_ena); + wm8962_dsp2_set_enable(component, wm8962->dsp2_ena); else - wm8962_dsp2_stop(codec); + wm8962_dsp2_stop(component); }

out: @@ -1600,7 +1600,7 @@ static int wm8962_dsp2_ena_put(struct snd_kcontrol *kcontrol, static int wm8962_put_hp_sw(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { - struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol); + struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol); int ret;

/* Apply the update (if any) */ @@ -1609,17 +1609,17 @@ static int wm8962_put_hp_sw(struct snd_kcontrol *kcontrol, return 0;

/* If the left PGA is enabled hit that VU bit... */ - ret = snd_soc_read(codec, WM8962_PWR_MGMT_2); + ret = snd_soc_component_read32(component, WM8962_PWR_MGMT_2); if (ret & WM8962_HPOUTL_PGA_ENA) { - snd_soc_write(codec, WM8962_HPOUTL_VOLUME, - snd_soc_read(codec, WM8962_HPOUTL_VOLUME)); + snd_soc_component_write(component, WM8962_HPOUTL_VOLUME, + snd_soc_component_read32(component, WM8962_HPOUTL_VOLUME)); return 1; }

/* ...otherwise the right. The VU is stereo. */ if (ret & WM8962_HPOUTR_PGA_ENA) - snd_soc_write(codec, WM8962_HPOUTR_VOLUME, - snd_soc_read(codec, WM8962_HPOUTR_VOLUME)); + snd_soc_component_write(component, WM8962_HPOUTR_VOLUME, + snd_soc_component_read32(component, WM8962_HPOUTR_VOLUME));

return 1; } @@ -1630,7 +1630,7 @@ static int wm8962_put_hp_sw(struct snd_kcontrol *kcontrol, static int wm8962_put_spk_sw(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { - struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol); + struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol); int ret;

/* Apply the update (if any) */ @@ -1639,17 +1639,17 @@ static int wm8962_put_spk_sw(struct snd_kcontrol *kcontrol, return 0;

/* If the left PGA is enabled hit that VU bit... */ - ret = snd_soc_read(codec, WM8962_PWR_MGMT_2); + ret = snd_soc_component_read32(component, WM8962_PWR_MGMT_2); if (ret & WM8962_SPKOUTL_PGA_ENA) { - snd_soc_write(codec, WM8962_SPKOUTL_VOLUME, - snd_soc_read(codec, WM8962_SPKOUTL_VOLUME)); + snd_soc_component_write(component, WM8962_SPKOUTL_VOLUME, + snd_soc_component_read32(component, WM8962_SPKOUTL_VOLUME)); return 1; }

/* ...otherwise the right. The VU is stereo. */ if (ret & WM8962_SPKOUTR_PGA_ENA) - snd_soc_write(codec, WM8962_SPKOUTR_VOLUME, - snd_soc_read(codec, WM8962_SPKOUTR_VOLUME)); + snd_soc_component_write(component, WM8962_SPKOUTR_VOLUME, + snd_soc_component_read32(component, WM8962_SPKOUTR_VOLUME));

return 1; } @@ -1863,7 +1863,7 @@ static int cp_event(struct snd_soc_dapm_widget *w, static int hp_event(struct snd_soc_dapm_widget *w, struct snd_kcontrol *kcontrol, int event) { - struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm); + struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm); int timeout; int reg; int expected = (WM8962_DCS_STARTUP_DONE_HP1L | @@ -1871,17 +1871,17 @@ static int hp_event(struct snd_soc_dapm_widget *w,

switch (event) { case SND_SOC_DAPM_POST_PMU: - snd_soc_update_bits(codec, WM8962_ANALOGUE_HP_0, + snd_soc_component_update_bits(component, WM8962_ANALOGUE_HP_0, WM8962_HP1L_ENA | WM8962_HP1R_ENA, WM8962_HP1L_ENA | WM8962_HP1R_ENA); udelay(20);

- snd_soc_update_bits(codec, WM8962_ANALOGUE_HP_0, + snd_soc_component_update_bits(component, WM8962_ANALOGUE_HP_0, WM8962_HP1L_ENA_DLY | WM8962_HP1R_ENA_DLY, WM8962_HP1L_ENA_DLY | WM8962_HP1R_ENA_DLY);

/* Start the DC servo */ - snd_soc_update_bits(codec, WM8962_DC_SERVO_1, + snd_soc_component_update_bits(component, WM8962_DC_SERVO_1, WM8962_HP1L_DCS_ENA | WM8962_HP1R_DCS_ENA | WM8962_HP1L_DCS_STARTUP | WM8962_HP1R_DCS_STARTUP, @@ -1893,30 +1893,30 @@ static int hp_event(struct snd_soc_dapm_widget *w, timeout = 0; do { msleep(1); - reg = snd_soc_read(codec, WM8962_DC_SERVO_6); + reg = snd_soc_component_read32(component, WM8962_DC_SERVO_6); if (reg < 0) { - dev_err(codec->dev, + dev_err(component->dev, "Failed to read DCS status: %d\n", reg); continue; } - dev_dbg(codec->dev, "DCS status: %x\n", reg); + dev_dbg(component->dev, "DCS status: %x\n", reg); } while (++timeout < 200 && (reg & expected) != expected);

if ((reg & expected) != expected) - dev_err(codec->dev, "DC servo timed out\n"); + dev_err(component->dev, "DC servo timed out\n"); else - dev_dbg(codec->dev, "DC servo complete after %dms\n", + dev_dbg(component->dev, "DC servo complete after %dms\n", timeout);

- snd_soc_update_bits(codec, WM8962_ANALOGUE_HP_0, + snd_soc_component_update_bits(component, WM8962_ANALOGUE_HP_0, WM8962_HP1L_ENA_OUTP | WM8962_HP1R_ENA_OUTP, WM8962_HP1L_ENA_OUTP | WM8962_HP1R_ENA_OUTP); udelay(20);

- snd_soc_update_bits(codec, WM8962_ANALOGUE_HP_0, + snd_soc_component_update_bits(component, WM8962_ANALOGUE_HP_0, WM8962_HP1L_RMV_SHORT | WM8962_HP1R_RMV_SHORT, WM8962_HP1L_RMV_SHORT | @@ -1924,19 +1924,19 @@ static int hp_event(struct snd_soc_dapm_widget *w, break;

case SND_SOC_DAPM_PRE_PMD: - snd_soc_update_bits(codec, WM8962_ANALOGUE_HP_0, + snd_soc_component_update_bits(component, WM8962_ANALOGUE_HP_0, WM8962_HP1L_RMV_SHORT | WM8962_HP1R_RMV_SHORT, 0);

udelay(20);

- snd_soc_update_bits(codec, WM8962_DC_SERVO_1, + snd_soc_component_update_bits(component, WM8962_DC_SERVO_1, WM8962_HP1L_DCS_ENA | WM8962_HP1R_DCS_ENA | WM8962_HP1L_DCS_STARTUP | WM8962_HP1R_DCS_STARTUP, 0);

- snd_soc_update_bits(codec, WM8962_ANALOGUE_HP_0, + snd_soc_component_update_bits(component, WM8962_ANALOGUE_HP_0, WM8962_HP1L_ENA | WM8962_HP1R_ENA | WM8962_HP1L_ENA_DLY | WM8962_HP1R_ENA_DLY | WM8962_HP1L_ENA_OUTP | @@ -1957,7 +1957,7 @@ static int hp_event(struct snd_soc_dapm_widget *w, static int out_pga_event(struct snd_soc_dapm_widget *w, struct snd_kcontrol *kcontrol, int event) { - struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm); + struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm); int reg;

switch (w->shift) { @@ -1980,7 +1980,7 @@ static int out_pga_event(struct snd_soc_dapm_widget *w,

switch (event) { case SND_SOC_DAPM_POST_PMU: - return snd_soc_write(codec, reg, snd_soc_read(codec, reg)); + return snd_soc_component_write(component, reg, snd_soc_component_read32(component, reg)); default: WARN(1, "Invalid event %d\n", event); return -EINVAL; @@ -1990,18 +1990,18 @@ static int out_pga_event(struct snd_soc_dapm_widget *w, static int dsp2_event(struct snd_soc_dapm_widget *w, struct snd_kcontrol *kcontrol, int event) { - struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm); - struct wm8962_priv *wm8962 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm); + struct wm8962_priv *wm8962 = snd_soc_component_get_drvdata(component);

switch (event) { case SND_SOC_DAPM_POST_PMU: if (wm8962->dsp2_ena) - wm8962_dsp2_start(codec); + wm8962_dsp2_start(component); break;

case SND_SOC_DAPM_PRE_PMD: if (wm8962->dsp2_ena) - wm8962_dsp2_stop(codec); + wm8962_dsp2_stop(component); break;

default: @@ -2354,19 +2354,19 @@ static SOC_ENUM_SINGLE_DECL(hpoutl_enum, { "SPKOUTR", NULL, "SPKOUTR Output" }, };

-static int wm8962_add_widgets(struct snd_soc_codec *codec) +static int wm8962_add_widgets(struct snd_soc_component *component) { - struct wm8962_priv *wm8962 = snd_soc_codec_get_drvdata(codec); + struct wm8962_priv *wm8962 = snd_soc_component_get_drvdata(component); struct wm8962_pdata *pdata = &wm8962->pdata; - struct snd_soc_dapm_context *dapm = snd_soc_codec_get_dapm(codec); + struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(component);

- snd_soc_add_codec_controls(codec, wm8962_snd_controls, + snd_soc_add_component_controls(component, wm8962_snd_controls, ARRAY_SIZE(wm8962_snd_controls)); if (pdata->spk_mono) - snd_soc_add_codec_controls(codec, wm8962_spk_mono_controls, + snd_soc_add_component_controls(component, wm8962_spk_mono_controls, ARRAY_SIZE(wm8962_spk_mono_controls)); else - snd_soc_add_codec_controls(codec, wm8962_spk_stereo_controls, + snd_soc_add_component_controls(component, wm8962_spk_stereo_controls, ARRAY_SIZE(wm8962_spk_stereo_controls));

@@ -2403,21 +2403,21 @@ static int wm8962_add_widgets(struct snd_soc_codec *codec) 64, 128, 192, 256, 384, 512, 768, 1024, 1408, 1536, 3072, 6144 };

-static void wm8962_configure_bclk(struct snd_soc_codec *codec) +static void wm8962_configure_bclk(struct snd_soc_component *component) { - struct wm8962_priv *wm8962 = snd_soc_codec_get_drvdata(codec); + struct wm8962_priv *wm8962 = snd_soc_component_get_drvdata(component); int dspclk, i; int clocking2 = 0; int clocking4 = 0; int aif2 = 0;

if (!wm8962->sysclk_rate) { - dev_dbg(codec->dev, "No SYSCLK configured\n"); + dev_dbg(component->dev, "No SYSCLK configured\n"); return; }

if (!wm8962->bclk || !wm8962->lrclk) { - dev_dbg(codec->dev, "No audio clocks configured\n"); + dev_dbg(component->dev, "No audio clocks configured\n"); return; }

@@ -2429,32 +2429,32 @@ static void wm8962_configure_bclk(struct snd_soc_codec *codec) }

if (i == ARRAY_SIZE(sysclk_rates)) { - dev_err(codec->dev, "Unsupported sysclk ratio %d\n", + dev_err(component->dev, "Unsupported sysclk ratio %d\n", wm8962->sysclk_rate / wm8962->lrclk); return; }

- dev_dbg(codec->dev, "Selected sysclk ratio %d\n", sysclk_rates[i]); + dev_dbg(component->dev, "Selected sysclk ratio %d\n", sysclk_rates[i]);

- snd_soc_update_bits(codec, WM8962_CLOCKING_4, + snd_soc_component_update_bits(component, WM8962_CLOCKING_4, WM8962_SYSCLK_RATE_MASK, clocking4);

/* DSPCLK_DIV can be only generated correctly after enabling SYSCLK. * So we here provisionally enable it and then disable it afterward * if current bias_level hasn't reached SND_SOC_BIAS_ON. */ - if (snd_soc_codec_get_bias_level(codec) != SND_SOC_BIAS_ON) - snd_soc_update_bits(codec, WM8962_CLOCKING2, + if (snd_soc_component_get_bias_level(component) != SND_SOC_BIAS_ON) + snd_soc_component_update_bits(component, WM8962_CLOCKING2, WM8962_SYSCLK_ENA_MASK, WM8962_SYSCLK_ENA);

- dspclk = snd_soc_read(codec, WM8962_CLOCKING1); + dspclk = snd_soc_component_read32(component, WM8962_CLOCKING1);

- if (snd_soc_codec_get_bias_level(codec) != SND_SOC_BIAS_ON) - snd_soc_update_bits(codec, WM8962_CLOCKING2, + if (snd_soc_component_get_bias_level(component) != SND_SOC_BIAS_ON) + snd_soc_component_update_bits(component, WM8962_CLOCKING2, WM8962_SYSCLK_ENA_MASK, 0);

if (dspclk < 0) { - dev_err(codec->dev, "Failed to read DSPCLK: %d\n", dspclk); + dev_err(component->dev, "Failed to read DSPCLK: %d\n", dspclk); return; }

@@ -2470,11 +2470,11 @@ static void wm8962_configure_bclk(struct snd_soc_codec *codec) dspclk = wm8962->sysclk_rate / 4; break; default: - dev_warn(codec->dev, "Unknown DSPCLK divisor read back\n"); + dev_warn(component->dev, "Unknown DSPCLK divisor read back\n"); dspclk = wm8962->sysclk_rate; }

- dev_dbg(codec->dev, "DSPCLK is %dHz, BCLK %d\n", dspclk, wm8962->bclk); + dev_dbg(component->dev, "DSPCLK is %dHz, BCLK %d\n", dspclk, wm8962->bclk);

/* We're expecting an exact match */ for (i = 0; i < ARRAY_SIZE(bclk_divs); i++) { @@ -2482,29 +2482,29 @@ static void wm8962_configure_bclk(struct snd_soc_codec *codec) continue;

if (dspclk / bclk_divs[i] == wm8962->bclk) { - dev_dbg(codec->dev, "Selected BCLK_DIV %d for %dHz\n", + dev_dbg(component->dev, "Selected BCLK_DIV %d for %dHz\n", bclk_divs[i], wm8962->bclk); clocking2 |= i; break; } } if (i == ARRAY_SIZE(bclk_divs)) { - dev_err(codec->dev, "Unsupported BCLK ratio %d\n", + dev_err(component->dev, "Unsupported BCLK ratio %d\n", dspclk / wm8962->bclk); return; }

aif2 |= wm8962->bclk / wm8962->lrclk; - dev_dbg(codec->dev, "Selected LRCLK divisor %d for %dHz\n", + dev_dbg(component->dev, "Selected LRCLK divisor %d for %dHz\n", wm8962->bclk / wm8962->lrclk, wm8962->lrclk);

- snd_soc_update_bits(codec, WM8962_CLOCKING2, + snd_soc_component_update_bits(component, WM8962_CLOCKING2, WM8962_BCLK_DIV_MASK, clocking2); - snd_soc_update_bits(codec, WM8962_AUDIO_INTERFACE_2, + snd_soc_component_update_bits(component, WM8962_AUDIO_INTERFACE_2, WM8962_AIF_RATE_MASK, aif2); }

-static int wm8962_set_bias_level(struct snd_soc_codec *codec, +static int wm8962_set_bias_level(struct snd_soc_component *component, enum snd_soc_bias_level level) { switch (level) { @@ -2513,18 +2513,18 @@ static int wm8962_set_bias_level(struct snd_soc_codec *codec,

case SND_SOC_BIAS_PREPARE: /* VMID 2*50k */ - snd_soc_update_bits(codec, WM8962_PWR_MGMT_1, + snd_soc_component_update_bits(component, WM8962_PWR_MGMT_1, WM8962_VMID_SEL_MASK, 0x80);

- wm8962_configure_bclk(codec); + wm8962_configure_bclk(component); break;

case SND_SOC_BIAS_STANDBY: /* VMID 2*250k */ - snd_soc_update_bits(codec, WM8962_PWR_MGMT_1, + snd_soc_component_update_bits(component, WM8962_PWR_MGMT_1, WM8962_VMID_SEL_MASK, 0x100);

- if (snd_soc_codec_get_bias_level(codec) == SND_SOC_BIAS_OFF) + if (snd_soc_component_get_bias_level(component) == SND_SOC_BIAS_OFF) msleep(100); break;

@@ -2556,8 +2556,8 @@ static int wm8962_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params, struct snd_soc_dai *dai) { - struct snd_soc_codec *codec = dai->codec; - struct wm8962_priv *wm8962 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = dai->component; + struct wm8962_priv *wm8962 = snd_soc_component_get_drvdata(component); int i; int aif0 = 0; int adctl3 = 0; @@ -2575,7 +2575,7 @@ static int wm8962_hw_params(struct snd_pcm_substream *substream, } } if (i == ARRAY_SIZE(sr_vals)) { - dev_err(codec->dev, "Unsupported rate %dHz\n", wm8962->lrclk); + dev_err(component->dev, "Unsupported rate %dHz\n", wm8962->lrclk); return -EINVAL; }

@@ -2598,17 +2598,17 @@ static int wm8962_hw_params(struct snd_pcm_substream *substream, return -EINVAL; }

- snd_soc_update_bits(codec, WM8962_AUDIO_INTERFACE_0, + snd_soc_component_update_bits(component, WM8962_AUDIO_INTERFACE_0, WM8962_WL_MASK, aif0); - snd_soc_update_bits(codec, WM8962_ADDITIONAL_CONTROL_3, + snd_soc_component_update_bits(component, WM8962_ADDITIONAL_CONTROL_3, WM8962_SAMPLE_RATE_INT_MODE | WM8962_SAMPLE_RATE_MASK, adctl3);

- dev_dbg(codec->dev, "hw_params set BCLK %dHz LRCLK %dHz\n", + dev_dbg(component->dev, "hw_params set BCLK %dHz LRCLK %dHz\n", wm8962->bclk, wm8962->lrclk);

- if (snd_soc_codec_get_bias_level(codec) == SND_SOC_BIAS_ON) - wm8962_configure_bclk(codec); + if (snd_soc_component_get_bias_level(component) == SND_SOC_BIAS_ON) + wm8962_configure_bclk(component);

return 0; } @@ -2616,8 +2616,8 @@ static int wm8962_hw_params(struct snd_pcm_substream *substream, static int wm8962_set_dai_sysclk(struct snd_soc_dai *dai, int clk_id, unsigned int freq, int dir) { - struct snd_soc_codec *codec = dai->codec; - struct wm8962_priv *wm8962 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = dai->component; + struct wm8962_priv *wm8962 = snd_soc_component_get_drvdata(component); int src;

switch (clk_id) { @@ -2633,7 +2633,7 @@ static int wm8962_set_dai_sysclk(struct snd_soc_dai *dai, int clk_id, return -EINVAL; }

- snd_soc_update_bits(codec, WM8962_CLOCKING2, WM8962_SYSCLK_SRC_MASK, + snd_soc_component_update_bits(component, WM8962_CLOCKING2, WM8962_SYSCLK_SRC_MASK, src);

wm8962->sysclk_rate = freq; @@ -2643,7 +2643,7 @@ static int wm8962_set_dai_sysclk(struct snd_soc_dai *dai, int clk_id,

static int wm8962_set_dai_fmt(struct snd_soc_dai *dai, unsigned int fmt) { - struct snd_soc_codec *codec = dai->codec; + struct snd_soc_component *component = dai->component; int aif0 = 0;

switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) { @@ -2699,7 +2699,7 @@ static int wm8962_set_dai_fmt(struct snd_soc_dai *dai, unsigned int fmt) return -EINVAL; }

- snd_soc_update_bits(codec, WM8962_AUDIO_INTERFACE_0, + snd_soc_component_update_bits(component, WM8962_AUDIO_INTERFACE_0, WM8962_FMT_MASK | WM8962_BCLK_INV | WM8962_MSTR | WM8962_LRCLK_INV, aif0);

@@ -2809,10 +2809,10 @@ static int fll_factors(struct _fll_div *fll_div, unsigned int Fref, return 0; }

-static int wm8962_set_fll(struct snd_soc_codec *codec, int fll_id, int source, +static int wm8962_set_fll(struct snd_soc_component *component, int fll_id, int source, unsigned int Fref, unsigned int Fout) { - struct wm8962_priv *wm8962 = snd_soc_codec_get_drvdata(codec); + struct wm8962_priv *wm8962 = snd_soc_component_get_drvdata(component); struct _fll_div fll_div; unsigned long timeout; int ret; @@ -2824,15 +2824,15 @@ static int wm8962_set_fll(struct snd_soc_codec *codec, int fll_id, int source, return 0;

if (Fout == 0) { - dev_dbg(codec->dev, "FLL disabled\n"); + dev_dbg(component->dev, "FLL disabled\n");

wm8962->fll_fref = 0; wm8962->fll_fout = 0;

- snd_soc_update_bits(codec, WM8962_FLL_CONTROL_1, + snd_soc_component_update_bits(component, WM8962_FLL_CONTROL_1, WM8962_FLL_ENA, 0);

- pm_runtime_put(codec->dev); + pm_runtime_put(component->dev);

return 0; } @@ -2842,7 +2842,7 @@ static int wm8962_set_fll(struct snd_soc_codec *codec, int fll_id, int source, return ret;

/* Parameters good, disable so we can reprogram */ - snd_soc_update_bits(codec, WM8962_FLL_CONTROL_1, WM8962_FLL_ENA, 0); + snd_soc_component_update_bits(component, WM8962_FLL_CONTROL_1, WM8962_FLL_ENA, 0);

switch (fll_id) { case WM8962_FLL_MCLK: @@ -2851,13 +2851,13 @@ static int wm8962_set_fll(struct snd_soc_codec *codec, int fll_id, int source, fll1 |= (fll_id - 1) << WM8962_FLL_REFCLK_SRC_SHIFT; break; case WM8962_FLL_INT: - snd_soc_update_bits(codec, WM8962_FLL_CONTROL_1, + snd_soc_component_update_bits(component, WM8962_FLL_CONTROL_1, WM8962_FLL_OSC_ENA, WM8962_FLL_OSC_ENA); - snd_soc_update_bits(codec, WM8962_FLL_CONTROL_5, + snd_soc_component_update_bits(component, WM8962_FLL_CONTROL_5, WM8962_FLL_FRC_NCO, WM8962_FLL_FRC_NCO); break; default: - dev_err(codec->dev, "Unknown FLL source %d\n", ret); + dev_err(component->dev, "Unknown FLL source %d\n", ret); return -EINVAL; }

@@ -2865,34 +2865,34 @@ static int wm8962_set_fll(struct snd_soc_codec *codec, int fll_id, int source, fll1 |= WM8962_FLL_FRAC;

/* Stop the FLL while we reconfigure */ - snd_soc_update_bits(codec, WM8962_FLL_CONTROL_1, WM8962_FLL_ENA, 0); + snd_soc_component_update_bits(component, WM8962_FLL_CONTROL_1, WM8962_FLL_ENA, 0);

- snd_soc_update_bits(codec, WM8962_FLL_CONTROL_2, + snd_soc_component_update_bits(component, WM8962_FLL_CONTROL_2, WM8962_FLL_OUTDIV_MASK | WM8962_FLL_REFCLK_DIV_MASK, (fll_div.fll_outdiv << WM8962_FLL_OUTDIV_SHIFT) | (fll_div.fll_refclk_div));

- snd_soc_update_bits(codec, WM8962_FLL_CONTROL_3, + snd_soc_component_update_bits(component, WM8962_FLL_CONTROL_3, WM8962_FLL_FRATIO_MASK, fll_div.fll_fratio);

- snd_soc_write(codec, WM8962_FLL_CONTROL_6, fll_div.theta); - snd_soc_write(codec, WM8962_FLL_CONTROL_7, fll_div.lambda); - snd_soc_write(codec, WM8962_FLL_CONTROL_8, fll_div.n); + snd_soc_component_write(component, WM8962_FLL_CONTROL_6, fll_div.theta); + snd_soc_component_write(component, WM8962_FLL_CONTROL_7, fll_div.lambda); + snd_soc_component_write(component, WM8962_FLL_CONTROL_8, fll_div.n);

reinit_completion(&wm8962->fll_lock);

- ret = pm_runtime_get_sync(codec->dev); + ret = pm_runtime_get_sync(component->dev); if (ret < 0) { - dev_err(codec->dev, "Failed to resume device: %d\n", ret); + dev_err(component->dev, "Failed to resume device: %d\n", ret); return ret; }

- snd_soc_update_bits(codec, WM8962_FLL_CONTROL_1, + snd_soc_component_update_bits(component, WM8962_FLL_CONTROL_1, WM8962_FLL_FRAC | WM8962_FLL_REFCLK_SRC_MASK | WM8962_FLL_ENA, fll1 | WM8962_FLL_ENA);

- dev_dbg(codec->dev, "FLL configured for %dHz->%dHz\n", Fref, Fout); + dev_dbg(component->dev, "FLL configured for %dHz->%dHz\n", Fref, Fout);

/* This should be a massive overestimate but go even * higher if we'll error out @@ -2906,10 +2906,10 @@ static int wm8962_set_fll(struct snd_soc_codec *codec, int fll_id, int source, timeout);

if (timeout == 0 && wm8962->irq) { - dev_err(codec->dev, "FLL lock timed out"); - snd_soc_update_bits(codec, WM8962_FLL_CONTROL_1, + dev_err(component->dev, "FLL lock timed out"); + snd_soc_component_update_bits(component, WM8962_FLL_CONTROL_1, WM8962_FLL_ENA, 0); - pm_runtime_put(codec->dev); + pm_runtime_put(component->dev); return -ETIMEDOUT; }

@@ -2922,7 +2922,7 @@ static int wm8962_set_fll(struct snd_soc_codec *codec, int fll_id, int source,

static int wm8962_mute(struct snd_soc_dai *dai, int mute) { - struct snd_soc_codec *codec = dai->codec; + struct snd_soc_component *component = dai->component; int val, ret;

if (mute) @@ -2934,12 +2934,12 @@ static int wm8962_mute(struct snd_soc_dai *dai, int mute) * The DAC mute bit is mirrored in two registers, update both to keep * the register cache consistent. */ - ret = snd_soc_update_bits(codec, WM8962_CLASS_D_CONTROL_1, + ret = snd_soc_component_update_bits(component, WM8962_CLASS_D_CONTROL_1, WM8962_DAC_MUTE_ALT, val); if (ret < 0) return ret;

- return snd_soc_update_bits(codec, WM8962_ADC_DAC_CONTROL_1, + return snd_soc_component_update_bits(component, WM8962_ADC_DAC_CONTROL_1, WM8962_DAC_MUTE, val); }

@@ -2981,12 +2981,12 @@ static void wm8962_mic_work(struct work_struct *work) struct wm8962_priv *wm8962 = container_of(work, struct wm8962_priv, mic_work.work); - struct snd_soc_codec *codec = wm8962->codec; + struct snd_soc_component *component = wm8962->component; int status = 0; int irq_pol = 0; int reg;

- reg = snd_soc_read(codec, WM8962_ADDITIONAL_CONTROL_4); + reg = snd_soc_component_read32(component, WM8962_ADDITIONAL_CONTROL_4);

if (reg & WM8962_MICDET_STS) { status |= SND_JACK_MICROPHONE; @@ -3001,7 +3001,7 @@ static void wm8962_mic_work(struct work_struct *work) snd_soc_jack_report(wm8962->jack, status, SND_JACK_MICROPHONE | SND_JACK_BTN_0);

- snd_soc_update_bits(codec, WM8962_MICINT_SOURCE_POL, + snd_soc_component_update_bits(component, WM8962_MICINT_SOURCE_POL, WM8962_MICSCD_IRQ_POL | WM8962_MICD_IRQ_POL, irq_pol); } @@ -3099,7 +3099,7 @@ static irqreturn_t wm8962_irq(int irq, void *data) /** * wm8962_mic_detect - Enable microphone detection via the WM8962 IRQ * - * @codec: WM8962 codec + * @component: WM8962 component * @jack: jack to report detection events on * * Enable microphone detection via IRQ on the WM8962. If GPIOs are @@ -3109,10 +3109,10 @@ static irqreturn_t wm8962_irq(int irq, void *data) * * If no jack is supplied detection will be disabled. */ -int wm8962_mic_detect(struct snd_soc_codec *codec, struct snd_soc_jack *jack) +int wm8962_mic_detect(struct snd_soc_component *component, struct snd_soc_jack *jack) { - struct wm8962_priv *wm8962 = snd_soc_codec_get_drvdata(codec); - struct snd_soc_dapm_context *dapm = snd_soc_codec_get_dapm(codec); + struct wm8962_priv *wm8962 = snd_soc_component_get_drvdata(component); + struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(component); int irq_mask, enable;

wm8962->jack = jack; @@ -3124,9 +3124,9 @@ int wm8962_mic_detect(struct snd_soc_codec *codec, struct snd_soc_jack *jack) enable = 0; }

- snd_soc_update_bits(codec, WM8962_INTERRUPT_STATUS_2_MASK, + snd_soc_component_update_bits(component, WM8962_INTERRUPT_STATUS_2_MASK, WM8962_MICD_EINT | WM8962_MICSCD_EINT, irq_mask); - snd_soc_update_bits(codec, WM8962_ADDITIONAL_CONTROL_4, + snd_soc_component_update_bits(component, WM8962_ADDITIONAL_CONTROL_4, WM8962_MICDET_ENA, enable);

/* Send an initial empty report */ @@ -3157,8 +3157,8 @@ static void wm8962_beep_work(struct work_struct *work) { struct wm8962_priv *wm8962 = container_of(work, struct wm8962_priv, beep_work); - struct snd_soc_codec *codec = wm8962->codec; - struct snd_soc_dapm_context *dapm = snd_soc_codec_get_dapm(codec); + struct snd_soc_component *component = wm8962->component; + struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(component); int i; int reg = 0; int best = 0; @@ -3170,18 +3170,18 @@ static void wm8962_beep_work(struct work_struct *work) best = i; }

- dev_dbg(codec->dev, "Set beep rate %dHz for requested %dHz\n", + dev_dbg(component->dev, "Set beep rate %dHz for requested %dHz\n", beep_rates[best], wm8962->beep_rate);

reg = WM8962_BEEP_ENA | (best << WM8962_BEEP_RATE_SHIFT);

snd_soc_dapm_enable_pin(dapm, "Beep"); } else { - dev_dbg(codec->dev, "Disabling beep\n"); + dev_dbg(component->dev, "Disabling beep\n"); snd_soc_dapm_disable_pin(dapm, "Beep"); }

- snd_soc_update_bits(codec, WM8962_BEEP_GENERATOR_1, + snd_soc_component_update_bits(component, WM8962_BEEP_GENERATOR_1, WM8962_BEEP_ENA | WM8962_BEEP_RATE_MASK, reg);

snd_soc_dapm_sync(dapm); @@ -3193,10 +3193,10 @@ static void wm8962_beep_work(struct work_struct *work) static int wm8962_beep_event(struct input_dev *dev, unsigned int type, unsigned int code, int hz) { - struct snd_soc_codec *codec = input_get_drvdata(dev); - struct wm8962_priv *wm8962 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = input_get_drvdata(dev); + struct wm8962_priv *wm8962 = snd_soc_component_get_drvdata(component);

- dev_dbg(codec->dev, "Beep event %x %x\n", code, hz); + dev_dbg(component->dev, "Beep event %x %x\n", code, hz);

switch (code) { case SND_BELL: @@ -3233,14 +3233,14 @@ static ssize_t wm8962_beep_set(struct device *dev,

static DEVICE_ATTR(beep, 0200, NULL, wm8962_beep_set);

-static void wm8962_init_beep(struct snd_soc_codec *codec) +static void wm8962_init_beep(struct snd_soc_component *component) { - struct wm8962_priv *wm8962 = snd_soc_codec_get_drvdata(codec); + struct wm8962_priv *wm8962 = snd_soc_component_get_drvdata(component); int ret;

- wm8962->beep = devm_input_allocate_device(codec->dev); + wm8962->beep = devm_input_allocate_device(component->dev); if (!wm8962->beep) { - dev_err(codec->dev, "Failed to allocate beep device\n"); + dev_err(component->dev, "Failed to allocate beep device\n"); return; }

@@ -3248,37 +3248,37 @@ static void wm8962_init_beep(struct snd_soc_codec *codec) wm8962->beep_rate = 0;

wm8962->beep->name = "WM8962 Beep Generator"; - wm8962->beep->phys = dev_name(codec->dev); + wm8962->beep->phys = dev_name(component->dev); wm8962->beep->id.bustype = BUS_I2C;

wm8962->beep->evbit[0] = BIT_MASK(EV_SND); wm8962->beep->sndbit[0] = BIT_MASK(SND_BELL) | BIT_MASK(SND_TONE); wm8962->beep->event = wm8962_beep_event; - wm8962->beep->dev.parent = codec->dev; - input_set_drvdata(wm8962->beep, codec); + wm8962->beep->dev.parent = component->dev; + input_set_drvdata(wm8962->beep, component);

ret = input_register_device(wm8962->beep); if (ret != 0) { wm8962->beep = NULL; - dev_err(codec->dev, "Failed to register beep device\n"); + dev_err(component->dev, "Failed to register beep device\n"); }

- ret = device_create_file(codec->dev, &dev_attr_beep); + ret = device_create_file(component->dev, &dev_attr_beep); if (ret != 0) { - dev_err(codec->dev, "Failed to create keyclick file: %d\n", + dev_err(component->dev, "Failed to create keyclick file: %d\n", ret); } }

-static void wm8962_free_beep(struct snd_soc_codec *codec) +static void wm8962_free_beep(struct snd_soc_component *component) { - struct wm8962_priv *wm8962 = snd_soc_codec_get_drvdata(codec); + struct wm8962_priv *wm8962 = snd_soc_component_get_drvdata(component);

- device_remove_file(codec->dev, &dev_attr_beep); + device_remove_file(component->dev, &dev_attr_beep); cancel_work_sync(&wm8962->beep_work); wm8962->beep = NULL;

- snd_soc_update_bits(codec, WM8962_BEEP_GENERATOR_1, WM8962_BEEP_ENA,0); + snd_soc_component_update_bits(component, WM8962_BEEP_GENERATOR_1, WM8962_BEEP_ENA,0); }

static void wm8962_set_gpio_mode(struct wm8962_priv *wm8962, int gpio) @@ -3333,9 +3333,9 @@ static int wm8962_gpio_request(struct gpio_chip *chip, unsigned offset) static void wm8962_gpio_set(struct gpio_chip *chip, unsigned offset, int value) { struct wm8962_priv *wm8962 = gpiochip_get_data(chip); - struct snd_soc_codec *codec = wm8962->codec; + struct snd_soc_component *component = wm8962->component;

- snd_soc_update_bits(codec, WM8962_GPIO_BASE + offset, + snd_soc_component_update_bits(component, WM8962_GPIO_BASE + offset, WM8962_GP2_LVL, !!value << WM8962_GP2_LVL_SHIFT); }

@@ -3343,13 +3343,13 @@ static int wm8962_gpio_direction_out(struct gpio_chip *chip, unsigned offset, int value) { struct wm8962_priv *wm8962 = gpiochip_get_data(chip); - struct snd_soc_codec *codec = wm8962->codec; + struct snd_soc_component *component = wm8962->component; int ret, val;

/* Force function 1 (logic output) */ val = (1 << WM8962_GP2_FN_SHIFT) | (value << WM8962_GP2_LVL_SHIFT);

- ret = snd_soc_update_bits(codec, WM8962_GPIO_BASE + offset, + ret = snd_soc_component_update_bits(component, WM8962_GPIO_BASE + offset, WM8962_GP2_FN_MASK | WM8962_GP2_LVL, val); if (ret < 0) return ret; @@ -3366,15 +3366,15 @@ static int wm8962_gpio_direction_out(struct gpio_chip *chip, .can_sleep = 1, };

-static void wm8962_init_gpio(struct snd_soc_codec *codec) +static void wm8962_init_gpio(struct snd_soc_component *component) { - struct wm8962_priv *wm8962 = snd_soc_codec_get_drvdata(codec); + struct wm8962_priv *wm8962 = snd_soc_component_get_drvdata(component); struct wm8962_pdata *pdata = &wm8962->pdata; int ret;

wm8962->gpio_chip = wm8962_template_chip; wm8962->gpio_chip.ngpio = WM8962_MAX_GPIO; - wm8962->gpio_chip.parent = codec->dev; + wm8962->gpio_chip.parent = component->dev;

if (pdata->gpio_base) wm8962->gpio_chip.base = pdata->gpio_base; @@ -3383,34 +3383,34 @@ static void wm8962_init_gpio(struct snd_soc_codec *codec)

ret = gpiochip_add_data(&wm8962->gpio_chip, wm8962); if (ret != 0) - dev_err(codec->dev, "Failed to add GPIOs: %d\n", ret); + dev_err(component->dev, "Failed to add GPIOs: %d\n", ret); }

-static void wm8962_free_gpio(struct snd_soc_codec *codec) +static void wm8962_free_gpio(struct snd_soc_component *component) { - struct wm8962_priv *wm8962 = snd_soc_codec_get_drvdata(codec); + struct wm8962_priv *wm8962 = snd_soc_component_get_drvdata(component);

gpiochip_remove(&wm8962->gpio_chip); } #else -static void wm8962_init_gpio(struct snd_soc_codec *codec) +static void wm8962_init_gpio(struct snd_soc_component *component) { }

-static void wm8962_free_gpio(struct snd_soc_codec *codec) +static void wm8962_free_gpio(struct snd_soc_component *component) { } #endif

-static int wm8962_probe(struct snd_soc_codec *codec) +static int wm8962_probe(struct snd_soc_component *component) { - struct snd_soc_dapm_context *dapm = snd_soc_codec_get_dapm(codec); + struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(component); int ret; - struct wm8962_priv *wm8962 = snd_soc_codec_get_drvdata(codec); + struct wm8962_priv *wm8962 = snd_soc_component_get_drvdata(component); int i; bool dmicclk, dmicdat;

- wm8962->codec = codec; + wm8962->component = component;

wm8962->disable_nb[0].notifier_call = wm8962_regulator_event_0; wm8962->disable_nb[1].notifier_call = wm8962_regulator_event_1; @@ -3426,19 +3426,19 @@ static int wm8962_probe(struct snd_soc_codec *codec) ret = regulator_register_notifier(wm8962->supplies[i].consumer, &wm8962->disable_nb[i]); if (ret != 0) { - dev_err(codec->dev, + dev_err(component->dev, "Failed to register regulator notifier: %d\n", ret); } }

- wm8962_add_widgets(codec); + wm8962_add_widgets(component);

/* Save boards having to disable DMIC when not in use */ dmicclk = false; dmicdat = false; for (i = 0; i < WM8962_MAX_GPIO; i++) { - switch (snd_soc_read(codec, WM8962_GPIO_BASE + i) + switch (snd_soc_component_read32(component, WM8962_GPIO_BASE + i) & WM8962_GP2_FN_MASK) { case WM8962_GPIO_FN_DMICCLK: dmicclk = true; @@ -3451,40 +3451,40 @@ static int wm8962_probe(struct snd_soc_codec *codec) } } if (!dmicclk || !dmicdat) { - dev_dbg(codec->dev, "DMIC not in use, disabling\n"); + dev_dbg(component->dev, "DMIC not in use, disabling\n"); snd_soc_dapm_nc_pin(dapm, "DMICDAT"); } if (dmicclk != dmicdat) - dev_warn(codec->dev, "DMIC GPIOs partially configured\n"); + dev_warn(component->dev, "DMIC GPIOs partially configured\n");

- wm8962_init_beep(codec); - wm8962_init_gpio(codec); + wm8962_init_beep(component); + wm8962_init_gpio(component);

return 0; }

-static int wm8962_remove(struct snd_soc_codec *codec) +static void wm8962_remove(struct snd_soc_component *component) { - struct wm8962_priv *wm8962 = snd_soc_codec_get_drvdata(codec); + struct wm8962_priv *wm8962 = snd_soc_component_get_drvdata(component); int i;

cancel_delayed_work_sync(&wm8962->mic_work);

- wm8962_free_gpio(codec); - wm8962_free_beep(codec); + wm8962_free_gpio(component); + wm8962_free_beep(component); for (i = 0; i < ARRAY_SIZE(wm8962->supplies); i++) regulator_unregister_notifier(wm8962->supplies[i].consumer, &wm8962->disable_nb[i]); - - return 0; }

-static const struct snd_soc_codec_driver soc_codec_dev_wm8962 = { - .probe = wm8962_probe, - .remove = wm8962_remove, - .set_bias_level = wm8962_set_bias_level, - .set_pll = wm8962_set_fll, - .idle_bias_off = true, +static const struct snd_soc_component_driver soc_component_dev_wm8962 = { + .probe = wm8962_probe, + .remove = wm8962_remove, + .set_bias_level = wm8962_set_bias_level, + .set_pll = wm8962_set_fll, + .pmdown_time = 1, + .endianness = 1, + .non_legacy_dai_naming = 1, };

/* Improve power consumption for IN4 DC measurement mode */ @@ -3751,8 +3751,8 @@ static int wm8962_i2c_probe(struct i2c_client *i2c, pm_runtime_enable(&i2c->dev); pm_request_idle(&i2c->dev);

- ret = snd_soc_register_codec(&i2c->dev, - &soc_codec_dev_wm8962, &wm8962_dai, 1); + ret = devm_snd_soc_register_component(&i2c->dev, + &soc_component_dev_wm8962, &wm8962_dai, 1); if (ret < 0) goto err_pm_runtime;

@@ -3773,7 +3773,6 @@ static int wm8962_i2c_probe(struct i2c_client *i2c,

static int wm8962_i2c_remove(struct i2c_client *client) { - snd_soc_unregister_codec(&client->dev); pm_runtime_disable(&client->dev); return 0; } diff --git a/sound/soc/codecs/wm8962.h b/sound/soc/codecs/wm8962.h index e63a318..a4a42d2 100644 --- a/sound/soc/codecs/wm8962.h +++ b/sound/soc/codecs/wm8962.h @@ -3779,6 +3779,6 @@ #define WM8962_VSS_ENA_SHIFT 0 /* VSS_ENA */ #define WM8962_VSS_ENA_WIDTH 1 /* VSS_ENA */

-int wm8962_mic_detect(struct snd_soc_codec *codec, struct snd_soc_jack *jack); +int wm8962_mic_detect(struct snd_soc_component *component, struct snd_soc_jack *jack);

#endif diff --git a/sound/soc/samsung/tobermory.c b/sound/soc/samsung/tobermory.c index 3310eda..998727c 100644 --- a/sound/soc/samsung/tobermory.c +++ b/sound/soc/samsung/tobermory.c @@ -179,12 +179,12 @@ static int tobermory_hw_params(struct snd_pcm_substream *substream, static int tobermory_late_probe(struct snd_soc_card *card) { struct snd_soc_pcm_runtime *rtd; - struct snd_soc_codec *codec; + struct snd_soc_component *component; struct snd_soc_dai *codec_dai; int ret;

rtd = snd_soc_get_pcm_runtime(card, card->dai_link[0].name); - codec = rtd->codec; + component = rtd->codec_dai->component; codec_dai = rtd->codec_dai;

ret = snd_soc_dai_set_sysclk(codec_dai, WM8962_SYSCLK_MCLK, @@ -199,7 +199,7 @@ static int tobermory_late_probe(struct snd_soc_card *card) if (ret) return ret;

- wm8962_mic_detect(codec, &tobermory_headset); + wm8962_mic_detect(component, &tobermory_headset);

return 0; }

From: Kuninori Morimoto kuninori.morimoto.gx@renesas.com

Now we can replace Codec to Component. Let's do it.

Note: xxx_codec_xxx() -> xxx_component_xxx() .idle_bias_off = 0 -> .idle_bias_on = 1 .ignore_pmdown_time = 0 -> .pmdown_time = 1 - -> .endianness = 1 - -> .non_legacy_dai_naming = 1

Signed-off-by: Kuninori Morimoto kuninori.morimoto.gx@renesas.com --- sound/soc/codecs/wm8991.c | 167 ++++++++++++++++++++++------------------------ 1 file changed, 80 insertions(+), 87 deletions(-)

diff --git a/sound/soc/codecs/wm8991.c b/sound/soc/codecs/wm8991.c index 802c0694..99c397b 100644 --- a/sound/soc/codecs/wm8991.c +++ b/sound/soc/codecs/wm8991.c @@ -133,7 +133,7 @@ static const SNDRV_CTL_TLVD_DECLARE_DB_RANGE(out_sidetone_tlv, static int wm899x_outpga_put_volsw_vu(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { - struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol); + struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol); int reg = kcontrol->private_value & 0xff; int ret; u16 val; @@ -143,8 +143,8 @@ static int wm899x_outpga_put_volsw_vu(struct snd_kcontrol *kcontrol, return ret;

/* now hit the volume update bits (always bit 8) */ - val = snd_soc_read(codec, reg); - return snd_soc_write(codec, reg, val | 0x0100); + val = snd_soc_component_read32(component, reg); + return snd_soc_component_write(component, reg, val | 0x0100); }

static const char *wm8991_digital_sidetone[] = @@ -361,14 +361,14 @@ static SOC_ENUM_SINGLE_DECL(wm8991_right_adcmode_enum, static int outmixer_event(struct snd_soc_dapm_widget *w, struct snd_kcontrol *kcontrol, int event) { - struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm); + struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm); u32 reg_shift = kcontrol->private_value & 0xfff; int ret = 0; u16 reg;

switch (reg_shift) { case WM8991_SPEAKER_MIXER | (WM8991_LDSPK_BIT << 8): - reg = snd_soc_read(codec, WM8991_OUTPUT_MIXER1); + reg = snd_soc_component_read32(component, WM8991_OUTPUT_MIXER1); if (reg & WM8991_LDLO) { printk(KERN_WARNING "Cannot set as Output Mixer 1 LDLO Set\n"); @@ -377,7 +377,7 @@ static int outmixer_event(struct snd_soc_dapm_widget *w, break;

case WM8991_SPEAKER_MIXER | (WM8991_RDSPK_BIT << 8): - reg = snd_soc_read(codec, WM8991_OUTPUT_MIXER2); + reg = snd_soc_component_read32(component, WM8991_OUTPUT_MIXER2); if (reg & WM8991_RDRO) { printk(KERN_WARNING "Cannot set as Output Mixer 2 RDRO Set\n"); @@ -386,7 +386,7 @@ static int outmixer_event(struct snd_soc_dapm_widget *w, break;

case WM8991_OUTPUT_MIXER1 | (WM8991_LDLO_BIT << 8): - reg = snd_soc_read(codec, WM8991_SPEAKER_MIXER); + reg = snd_soc_component_read32(component, WM8991_SPEAKER_MIXER); if (reg & WM8991_LDSPK) { printk(KERN_WARNING "Cannot set as Speaker Mixer LDSPK Set\n"); @@ -395,7 +395,7 @@ static int outmixer_event(struct snd_soc_dapm_widget *w, break;

case WM8991_OUTPUT_MIXER2 | (WM8991_RDRO_BIT << 8): - reg = snd_soc_read(codec, WM8991_SPEAKER_MIXER); + reg = snd_soc_component_read32(component, WM8991_SPEAKER_MIXER); if (reg & WM8991_RDSPK) { printk(KERN_WARNING "Cannot set as Speaker Mixer RDSPK Set\n"); @@ -927,31 +927,31 @@ static int wm8991_set_dai_pll(struct snd_soc_dai *codec_dai, int pll_id, int src, unsigned int freq_in, unsigned int freq_out) { u16 reg; - struct snd_soc_codec *codec = codec_dai->codec; + struct snd_soc_component *component = codec_dai->component; struct _pll_div pll_div;

if (freq_in && freq_out) { pll_factors(&pll_div, freq_out * 4, freq_in);

/* Turn on PLL */ - reg = snd_soc_read(codec, WM8991_POWER_MANAGEMENT_2); + reg = snd_soc_component_read32(component, WM8991_POWER_MANAGEMENT_2); reg |= WM8991_PLL_ENA; - snd_soc_write(codec, WM8991_POWER_MANAGEMENT_2, reg); + snd_soc_component_write(component, WM8991_POWER_MANAGEMENT_2, reg);

/* sysclk comes from PLL */ - reg = snd_soc_read(codec, WM8991_CLOCKING_2); - snd_soc_write(codec, WM8991_CLOCKING_2, reg | WM8991_SYSCLK_SRC); + reg = snd_soc_component_read32(component, WM8991_CLOCKING_2); + snd_soc_component_write(component, WM8991_CLOCKING_2, reg | WM8991_SYSCLK_SRC);

/* set up N , fractional mode and pre-divisor if necessary */ - snd_soc_write(codec, WM8991_PLL1, pll_div.n | WM8991_SDM | + snd_soc_component_write(component, WM8991_PLL1, pll_div.n | WM8991_SDM | (pll_div.div2 ? WM8991_PRESCALE : 0)); - snd_soc_write(codec, WM8991_PLL2, (u8)(pll_div.k>>8)); - snd_soc_write(codec, WM8991_PLL3, (u8)(pll_div.k & 0xFF)); + snd_soc_component_write(component, WM8991_PLL2, (u8)(pll_div.k>>8)); + snd_soc_component_write(component, WM8991_PLL3, (u8)(pll_div.k & 0xFF)); } else { /* Turn on PLL */ - reg = snd_soc_read(codec, WM8991_POWER_MANAGEMENT_2); + reg = snd_soc_component_read32(component, WM8991_POWER_MANAGEMENT_2); reg &= ~WM8991_PLL_ENA; - snd_soc_write(codec, WM8991_POWER_MANAGEMENT_2, reg); + snd_soc_component_write(component, WM8991_POWER_MANAGEMENT_2, reg); } return 0; } @@ -962,11 +962,11 @@ static int wm8991_set_dai_pll(struct snd_soc_dai *codec_dai, static int wm8991_set_dai_fmt(struct snd_soc_dai *codec_dai, unsigned int fmt) { - struct snd_soc_codec *codec = codec_dai->codec; + struct snd_soc_component *component = codec_dai->component; u16 audio1, audio3;

- audio1 = snd_soc_read(codec, WM8991_AUDIO_INTERFACE_1); - audio3 = snd_soc_read(codec, WM8991_AUDIO_INTERFACE_3); + audio1 = snd_soc_component_read32(component, WM8991_AUDIO_INTERFACE_1); + audio3 = snd_soc_component_read32(component, WM8991_AUDIO_INTERFACE_3);

/* set master/slave audio interface */ switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) { @@ -1007,37 +1007,37 @@ static int wm8991_set_dai_fmt(struct snd_soc_dai *codec_dai, return -EINVAL; }

- snd_soc_write(codec, WM8991_AUDIO_INTERFACE_1, audio1); - snd_soc_write(codec, WM8991_AUDIO_INTERFACE_3, audio3); + snd_soc_component_write(component, WM8991_AUDIO_INTERFACE_1, audio1); + snd_soc_component_write(component, WM8991_AUDIO_INTERFACE_3, audio3); return 0; }

static int wm8991_set_dai_clkdiv(struct snd_soc_dai *codec_dai, int div_id, int div) { - struct snd_soc_codec *codec = codec_dai->codec; + struct snd_soc_component *component = codec_dai->component; u16 reg;

switch (div_id) { case WM8991_MCLK_DIV: - reg = snd_soc_read(codec, WM8991_CLOCKING_2) & + reg = snd_soc_component_read32(component, WM8991_CLOCKING_2) & ~WM8991_MCLK_DIV_MASK; - snd_soc_write(codec, WM8991_CLOCKING_2, reg | div); + snd_soc_component_write(component, WM8991_CLOCKING_2, reg | div); break; case WM8991_DACCLK_DIV: - reg = snd_soc_read(codec, WM8991_CLOCKING_2) & + reg = snd_soc_component_read32(component, WM8991_CLOCKING_2) & ~WM8991_DAC_CLKDIV_MASK; - snd_soc_write(codec, WM8991_CLOCKING_2, reg | div); + snd_soc_component_write(component, WM8991_CLOCKING_2, reg | div); break; case WM8991_ADCCLK_DIV: - reg = snd_soc_read(codec, WM8991_CLOCKING_2) & + reg = snd_soc_component_read32(component, WM8991_CLOCKING_2) & ~WM8991_ADC_CLKDIV_MASK; - snd_soc_write(codec, WM8991_CLOCKING_2, reg | div); + snd_soc_component_write(component, WM8991_CLOCKING_2, reg | div); break; case WM8991_BCLK_DIV: - reg = snd_soc_read(codec, WM8991_CLOCKING_1) & + reg = snd_soc_component_read32(component, WM8991_CLOCKING_1) & ~WM8991_BCLK_DIV_MASK; - snd_soc_write(codec, WM8991_CLOCKING_1, reg | div); + snd_soc_component_write(component, WM8991_CLOCKING_1, reg | div); break; default: return -EINVAL; @@ -1053,8 +1053,8 @@ static int wm8991_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params, struct snd_soc_dai *dai) { - struct snd_soc_codec *codec = dai->codec; - u16 audio1 = snd_soc_read(codec, WM8991_AUDIO_INTERFACE_1); + struct snd_soc_component *component = dai->component; + u16 audio1 = snd_soc_component_read32(component, WM8991_AUDIO_INTERFACE_1);

audio1 &= ~WM8991_AIF_WL_MASK; /* bit size */ @@ -1072,27 +1072,27 @@ static int wm8991_hw_params(struct snd_pcm_substream *substream, break; }

- snd_soc_write(codec, WM8991_AUDIO_INTERFACE_1, audio1); + snd_soc_component_write(component, WM8991_AUDIO_INTERFACE_1, audio1); return 0; }

static int wm8991_mute(struct snd_soc_dai *dai, int mute) { - struct snd_soc_codec *codec = dai->codec; + struct snd_soc_component *component = dai->component; u16 val;

- val = snd_soc_read(codec, WM8991_DAC_CTRL) & ~WM8991_DAC_MUTE; + val = snd_soc_component_read32(component, WM8991_DAC_CTRL) & ~WM8991_DAC_MUTE; if (mute) - snd_soc_write(codec, WM8991_DAC_CTRL, val | WM8991_DAC_MUTE); + snd_soc_component_write(component, WM8991_DAC_CTRL, val | WM8991_DAC_MUTE); else - snd_soc_write(codec, WM8991_DAC_CTRL, val); + snd_soc_component_write(component, WM8991_DAC_CTRL, val); return 0; }

-static int wm8991_set_bias_level(struct snd_soc_codec *codec, +static int wm8991_set_bias_level(struct snd_soc_component *component, enum snd_soc_bias_level level) { - struct wm8991_priv *wm8991 = snd_soc_codec_get_drvdata(codec); + struct wm8991_priv *wm8991 = snd_soc_component_get_drvdata(component); u16 val;

switch (level) { @@ -1101,22 +1101,22 @@ static int wm8991_set_bias_level(struct snd_soc_codec *codec,

case SND_SOC_BIAS_PREPARE: /* VMID=2*50k */ - val = snd_soc_read(codec, WM8991_POWER_MANAGEMENT_1) & + val = snd_soc_component_read32(component, WM8991_POWER_MANAGEMENT_1) & ~WM8991_VMID_MODE_MASK; - snd_soc_write(codec, WM8991_POWER_MANAGEMENT_1, val | 0x2); + snd_soc_component_write(component, WM8991_POWER_MANAGEMENT_1, val | 0x2); break;

case SND_SOC_BIAS_STANDBY: - if (snd_soc_codec_get_bias_level(codec) == SND_SOC_BIAS_OFF) { + if (snd_soc_component_get_bias_level(component) == SND_SOC_BIAS_OFF) { regcache_sync(wm8991->regmap); /* Enable all output discharge bits */ - snd_soc_write(codec, WM8991_ANTIPOP1, WM8991_DIS_LLINE | + snd_soc_component_write(component, WM8991_ANTIPOP1, WM8991_DIS_LLINE | WM8991_DIS_RLINE | WM8991_DIS_OUT3 | WM8991_DIS_OUT4 | WM8991_DIS_LOUT | WM8991_DIS_ROUT);

/* Enable POBCTRL, SOFT_ST, VMIDTOG and BUFDCOPEN */ - snd_soc_write(codec, WM8991_ANTIPOP2, WM8991_SOFTST | + snd_soc_component_write(component, WM8991_ANTIPOP2, WM8991_SOFTST | WM8991_BUFDCOPEN | WM8991_POBCTRL | WM8991_VMIDTOG);

@@ -1124,78 +1124,78 @@ static int wm8991_set_bias_level(struct snd_soc_codec *codec, msleep(300);

/* Disable VMIDTOG */ - snd_soc_write(codec, WM8991_ANTIPOP2, WM8991_SOFTST | + snd_soc_component_write(component, WM8991_ANTIPOP2, WM8991_SOFTST | WM8991_BUFDCOPEN | WM8991_POBCTRL);

/* disable all output discharge bits */ - snd_soc_write(codec, WM8991_ANTIPOP1, 0); + snd_soc_component_write(component, WM8991_ANTIPOP1, 0);

/* Enable outputs */ - snd_soc_write(codec, WM8991_POWER_MANAGEMENT_1, 0x1b00); + snd_soc_component_write(component, WM8991_POWER_MANAGEMENT_1, 0x1b00);

msleep(50);

/* Enable VMID at 2x50k */ - snd_soc_write(codec, WM8991_POWER_MANAGEMENT_1, 0x1f02); + snd_soc_component_write(component, WM8991_POWER_MANAGEMENT_1, 0x1f02);

msleep(100);

/* Enable VREF */ - snd_soc_write(codec, WM8991_POWER_MANAGEMENT_1, 0x1f03); + snd_soc_component_write(component, WM8991_POWER_MANAGEMENT_1, 0x1f03);

msleep(600);

/* Enable BUFIOEN */ - snd_soc_write(codec, WM8991_ANTIPOP2, WM8991_SOFTST | + snd_soc_component_write(component, WM8991_ANTIPOP2, WM8991_SOFTST | WM8991_BUFDCOPEN | WM8991_POBCTRL | WM8991_BUFIOEN);

/* Disable outputs */ - snd_soc_write(codec, WM8991_POWER_MANAGEMENT_1, 0x3); + snd_soc_component_write(component, WM8991_POWER_MANAGEMENT_1, 0x3);

/* disable POBCTRL, SOFT_ST and BUFDCOPEN */ - snd_soc_write(codec, WM8991_ANTIPOP2, WM8991_BUFIOEN); + snd_soc_component_write(component, WM8991_ANTIPOP2, WM8991_BUFIOEN); }

/* VMID=2*250k */ - val = snd_soc_read(codec, WM8991_POWER_MANAGEMENT_1) & + val = snd_soc_component_read32(component, WM8991_POWER_MANAGEMENT_1) & ~WM8991_VMID_MODE_MASK; - snd_soc_write(codec, WM8991_POWER_MANAGEMENT_1, val | 0x4); + snd_soc_component_write(component, WM8991_POWER_MANAGEMENT_1, val | 0x4); break;

case SND_SOC_BIAS_OFF: /* Enable POBCTRL and SOFT_ST */ - snd_soc_write(codec, WM8991_ANTIPOP2, WM8991_SOFTST | + snd_soc_component_write(component, WM8991_ANTIPOP2, WM8991_SOFTST | WM8991_POBCTRL | WM8991_BUFIOEN);

/* Enable POBCTRL, SOFT_ST and BUFDCOPEN */ - snd_soc_write(codec, WM8991_ANTIPOP2, WM8991_SOFTST | + snd_soc_component_write(component, WM8991_ANTIPOP2, WM8991_SOFTST | WM8991_BUFDCOPEN | WM8991_POBCTRL | WM8991_BUFIOEN);

/* mute DAC */ - val = snd_soc_read(codec, WM8991_DAC_CTRL); - snd_soc_write(codec, WM8991_DAC_CTRL, val | WM8991_DAC_MUTE); + val = snd_soc_component_read32(component, WM8991_DAC_CTRL); + snd_soc_component_write(component, WM8991_DAC_CTRL, val | WM8991_DAC_MUTE);

/* Enable any disabled outputs */ - snd_soc_write(codec, WM8991_POWER_MANAGEMENT_1, 0x1f03); + snd_soc_component_write(component, WM8991_POWER_MANAGEMENT_1, 0x1f03);

/* Disable VMID */ - snd_soc_write(codec, WM8991_POWER_MANAGEMENT_1, 0x1f01); + snd_soc_component_write(component, WM8991_POWER_MANAGEMENT_1, 0x1f01);

msleep(300);

/* Enable all output discharge bits */ - snd_soc_write(codec, WM8991_ANTIPOP1, WM8991_DIS_LLINE | + snd_soc_component_write(component, WM8991_ANTIPOP1, WM8991_DIS_LLINE | WM8991_DIS_RLINE | WM8991_DIS_OUT3 | WM8991_DIS_OUT4 | WM8991_DIS_LOUT | WM8991_DIS_ROUT);

/* Disable VREF */ - snd_soc_write(codec, WM8991_POWER_MANAGEMENT_1, 0x0); + snd_soc_component_write(component, WM8991_POWER_MANAGEMENT_1, 0x0);

/* disable POBCTRL, SOFT_ST and BUFDCOPEN */ - snd_soc_write(codec, WM8991_ANTIPOP2, 0x0); + snd_soc_component_write(component, WM8991_ANTIPOP2, 0x0); regcache_mark_dirty(wm8991->regmap); break; } @@ -1242,18 +1242,19 @@ static int wm8991_set_bias_level(struct snd_soc_codec *codec, .ops = &wm8991_ops };

-static const struct snd_soc_codec_driver soc_codec_dev_wm8991 = { - .set_bias_level = wm8991_set_bias_level, - .suspend_bias_off = true, - - .component_driver = { - .controls = wm8991_snd_controls, - .num_controls = ARRAY_SIZE(wm8991_snd_controls), - .dapm_widgets = wm8991_dapm_widgets, - .num_dapm_widgets = ARRAY_SIZE(wm8991_dapm_widgets), - .dapm_routes = wm8991_dapm_routes, - .num_dapm_routes = ARRAY_SIZE(wm8991_dapm_routes), - }, +static const struct snd_soc_component_driver soc_component_dev_wm8991 = { + .set_bias_level = wm8991_set_bias_level, + .controls = wm8991_snd_controls, + .num_controls = ARRAY_SIZE(wm8991_snd_controls), + .dapm_widgets = wm8991_dapm_widgets, + .num_dapm_widgets = ARRAY_SIZE(wm8991_dapm_widgets), + .dapm_routes = wm8991_dapm_routes, + .num_dapm_routes = ARRAY_SIZE(wm8991_dapm_routes), + .suspend_bias_off = 1, + .idle_bias_on = 1, + .pmdown_time = 1, + .endianness = 1, + .non_legacy_dai_naming = 1, };

static const struct regmap_config wm8991_regmap = { @@ -1319,19 +1320,12 @@ static int wm8991_i2c_probe(struct i2c_client *i2c, regmap_write(wm8991->regmap, WM8991_RIGHT_OUTPUT_VOLUME, 0x50 | (1<<8));

- ret = snd_soc_register_codec(&i2c->dev, - &soc_codec_dev_wm8991, &wm8991_dai, 1); + ret = devm_snd_soc_register_component(&i2c->dev, + &soc_component_dev_wm8991, &wm8991_dai, 1);

return ret; }

-static int wm8991_i2c_remove(struct i2c_client *client) -{ - snd_soc_unregister_codec(&client->dev); - - return 0; -} - static const struct i2c_device_id wm8991_i2c_id[] = { { "wm8991", 0 }, { } @@ -1343,7 +1337,6 @@ static int wm8991_i2c_remove(struct i2c_client *client) .name = "wm8991", }, .probe = wm8991_i2c_probe, - .remove = wm8991_i2c_remove, .id_table = wm8991_i2c_id, };

From: Kuninori Morimoto kuninori.morimoto.gx@renesas.com

Now we can replace Codec to Component. Let's do it.

Note: xxx_codec_xxx() -> xxx_component_xxx() .idle_bias_off = 0 -> .idle_bias_on = 1 .ignore_pmdown_time = 0 -> .pmdown_time = 1 - -> .endianness = 1 - -> .non_legacy_dai_naming = 1

Signed-off-by: Kuninori Morimoto kuninori.morimoto.gx@renesas.com --- sound/soc/codecs/wm8961.c | 241 ++++++++++++++++++++++------------------------ 1 file changed, 117 insertions(+), 124 deletions(-)

diff --git a/sound/soc/codecs/wm8961.c b/sound/soc/codecs/wm8961.c index e23ceac..cab7d63 100644 --- a/sound/soc/codecs/wm8961.c +++ b/sound/soc/codecs/wm8961.c @@ -194,89 +194,89 @@ static bool wm8961_readable(struct device *dev, unsigned int reg) static int wm8961_hp_event(struct snd_soc_dapm_widget *w, struct snd_kcontrol *kcontrol, int event) { - struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm); - u16 hp_reg = snd_soc_read(codec, WM8961_ANALOGUE_HP_0); - u16 cp_reg = snd_soc_read(codec, WM8961_CHARGE_PUMP_1); - u16 pwr_reg = snd_soc_read(codec, WM8961_PWR_MGMT_2); - u16 dcs_reg = snd_soc_read(codec, WM8961_DC_SERVO_1); + struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm); + u16 hp_reg = snd_soc_component_read32(component, WM8961_ANALOGUE_HP_0); + u16 cp_reg = snd_soc_component_read32(component, WM8961_CHARGE_PUMP_1); + u16 pwr_reg = snd_soc_component_read32(component, WM8961_PWR_MGMT_2); + u16 dcs_reg = snd_soc_component_read32(component, WM8961_DC_SERVO_1); int timeout = 500;

if (event & SND_SOC_DAPM_POST_PMU) { /* Make sure the output is shorted */ hp_reg &= ~(WM8961_HPR_RMV_SHORT | WM8961_HPL_RMV_SHORT); - snd_soc_write(codec, WM8961_ANALOGUE_HP_0, hp_reg); + snd_soc_component_write(component, WM8961_ANALOGUE_HP_0, hp_reg);

/* Enable the charge pump */ cp_reg |= WM8961_CP_ENA; - snd_soc_write(codec, WM8961_CHARGE_PUMP_1, cp_reg); + snd_soc_component_write(component, WM8961_CHARGE_PUMP_1, cp_reg); mdelay(5);

/* Enable the PGA */ pwr_reg |= WM8961_LOUT1_PGA | WM8961_ROUT1_PGA; - snd_soc_write(codec, WM8961_PWR_MGMT_2, pwr_reg); + snd_soc_component_write(component, WM8961_PWR_MGMT_2, pwr_reg);

/* Enable the amplifier */ hp_reg |= WM8961_HPR_ENA | WM8961_HPL_ENA; - snd_soc_write(codec, WM8961_ANALOGUE_HP_0, hp_reg); + snd_soc_component_write(component, WM8961_ANALOGUE_HP_0, hp_reg);

/* Second stage enable */ hp_reg |= WM8961_HPR_ENA_DLY | WM8961_HPL_ENA_DLY; - snd_soc_write(codec, WM8961_ANALOGUE_HP_0, hp_reg); + snd_soc_component_write(component, WM8961_ANALOGUE_HP_0, hp_reg);

/* Enable the DC servo & trigger startup */ dcs_reg |= WM8961_DCS_ENA_CHAN_HPR | WM8961_DCS_TRIG_STARTUP_HPR | WM8961_DCS_ENA_CHAN_HPL | WM8961_DCS_TRIG_STARTUP_HPL; - dev_dbg(codec->dev, "Enabling DC servo\n"); + dev_dbg(component->dev, "Enabling DC servo\n");

- snd_soc_write(codec, WM8961_DC_SERVO_1, dcs_reg); + snd_soc_component_write(component, WM8961_DC_SERVO_1, dcs_reg); do { msleep(1); - dcs_reg = snd_soc_read(codec, WM8961_DC_SERVO_1); + dcs_reg = snd_soc_component_read32(component, WM8961_DC_SERVO_1); } while (--timeout && dcs_reg & (WM8961_DCS_TRIG_STARTUP_HPR | WM8961_DCS_TRIG_STARTUP_HPL)); if (dcs_reg & (WM8961_DCS_TRIG_STARTUP_HPR | WM8961_DCS_TRIG_STARTUP_HPL)) - dev_err(codec->dev, "DC servo timed out\n"); + dev_err(component->dev, "DC servo timed out\n"); else - dev_dbg(codec->dev, "DC servo startup complete\n"); + dev_dbg(component->dev, "DC servo startup complete\n");

/* Enable the output stage */ hp_reg |= WM8961_HPR_ENA_OUTP | WM8961_HPL_ENA_OUTP; - snd_soc_write(codec, WM8961_ANALOGUE_HP_0, hp_reg); + snd_soc_component_write(component, WM8961_ANALOGUE_HP_0, hp_reg);

/* Remove the short on the output stage */ hp_reg |= WM8961_HPR_RMV_SHORT | WM8961_HPL_RMV_SHORT; - snd_soc_write(codec, WM8961_ANALOGUE_HP_0, hp_reg); + snd_soc_component_write(component, WM8961_ANALOGUE_HP_0, hp_reg); }

if (event & SND_SOC_DAPM_PRE_PMD) { /* Short the output */ hp_reg &= ~(WM8961_HPR_RMV_SHORT | WM8961_HPL_RMV_SHORT); - snd_soc_write(codec, WM8961_ANALOGUE_HP_0, hp_reg); + snd_soc_component_write(component, WM8961_ANALOGUE_HP_0, hp_reg);

/* Disable the output stage */ hp_reg &= ~(WM8961_HPR_ENA_OUTP | WM8961_HPL_ENA_OUTP); - snd_soc_write(codec, WM8961_ANALOGUE_HP_0, hp_reg); + snd_soc_component_write(component, WM8961_ANALOGUE_HP_0, hp_reg);

/* Disable DC offset cancellation */ dcs_reg &= ~(WM8961_DCS_ENA_CHAN_HPR | WM8961_DCS_ENA_CHAN_HPL); - snd_soc_write(codec, WM8961_DC_SERVO_1, dcs_reg); + snd_soc_component_write(component, WM8961_DC_SERVO_1, dcs_reg);

/* Finish up */ hp_reg &= ~(WM8961_HPR_ENA_DLY | WM8961_HPR_ENA | WM8961_HPL_ENA_DLY | WM8961_HPL_ENA); - snd_soc_write(codec, WM8961_ANALOGUE_HP_0, hp_reg); + snd_soc_component_write(component, WM8961_ANALOGUE_HP_0, hp_reg);

/* Disable the PGA */ pwr_reg &= ~(WM8961_LOUT1_PGA | WM8961_ROUT1_PGA); - snd_soc_write(codec, WM8961_PWR_MGMT_2, pwr_reg); + snd_soc_component_write(component, WM8961_PWR_MGMT_2, pwr_reg);

/* Disable the charge pump */ - dev_dbg(codec->dev, "Disabling charge pump\n"); - snd_soc_write(codec, WM8961_CHARGE_PUMP_1, + dev_dbg(component->dev, "Disabling charge pump\n"); + snd_soc_component_write(component, WM8961_CHARGE_PUMP_1, cp_reg & ~WM8961_CP_ENA); }

@@ -286,28 +286,28 @@ static int wm8961_hp_event(struct snd_soc_dapm_widget *w, static int wm8961_spk_event(struct snd_soc_dapm_widget *w, struct snd_kcontrol *kcontrol, int event) { - struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm); - u16 pwr_reg = snd_soc_read(codec, WM8961_PWR_MGMT_2); - u16 spk_reg = snd_soc_read(codec, WM8961_CLASS_D_CONTROL_1); + struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm); + u16 pwr_reg = snd_soc_component_read32(component, WM8961_PWR_MGMT_2); + u16 spk_reg = snd_soc_component_read32(component, WM8961_CLASS_D_CONTROL_1);

if (event & SND_SOC_DAPM_POST_PMU) { /* Enable the PGA */ pwr_reg |= WM8961_SPKL_PGA | WM8961_SPKR_PGA; - snd_soc_write(codec, WM8961_PWR_MGMT_2, pwr_reg); + snd_soc_component_write(component, WM8961_PWR_MGMT_2, pwr_reg);

/* Enable the amplifier */ spk_reg |= WM8961_SPKL_ENA | WM8961_SPKR_ENA; - snd_soc_write(codec, WM8961_CLASS_D_CONTROL_1, spk_reg); + snd_soc_component_write(component, WM8961_CLASS_D_CONTROL_1, spk_reg); }

if (event & SND_SOC_DAPM_PRE_PMD) { /* Disable the amplifier */ spk_reg &= ~(WM8961_SPKL_ENA | WM8961_SPKR_ENA); - snd_soc_write(codec, WM8961_CLASS_D_CONTROL_1, spk_reg); + snd_soc_component_write(component, WM8961_CLASS_D_CONTROL_1, spk_reg);

/* Disable the PGA */ pwr_reg &= ~(WM8961_SPKL_PGA | WM8961_SPKR_PGA); - snd_soc_write(codec, WM8961_PWR_MGMT_2, pwr_reg); + snd_soc_component_write(component, WM8961_PWR_MGMT_2, pwr_reg); }

return 0; @@ -505,15 +505,15 @@ static int wm8961_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params, struct snd_soc_dai *dai) { - struct snd_soc_codec *codec = dai->codec; - struct wm8961_priv *wm8961 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = dai->component; + struct wm8961_priv *wm8961 = snd_soc_component_get_drvdata(component); int i, best, target, fs; u16 reg;

fs = params_rate(params);

if (!wm8961->sysclk) { - dev_err(codec->dev, "MCLK has not been specified\n"); + dev_err(component->dev, "MCLK has not been specified\n"); return -EINVAL; }

@@ -524,23 +524,23 @@ static int wm8961_hw_params(struct snd_pcm_substream *substream, abs(wm8961_srate[best].rate - fs)) best = i; } - reg = snd_soc_read(codec, WM8961_ADDITIONAL_CONTROL_3); + reg = snd_soc_component_read32(component, WM8961_ADDITIONAL_CONTROL_3); reg &= ~WM8961_SAMPLE_RATE_MASK; reg |= wm8961_srate[best].val; - snd_soc_write(codec, WM8961_ADDITIONAL_CONTROL_3, reg); - dev_dbg(codec->dev, "Selected SRATE %dHz for %dHz\n", + snd_soc_component_write(component, WM8961_ADDITIONAL_CONTROL_3, reg); + dev_dbg(component->dev, "Selected SRATE %dHz for %dHz\n", wm8961_srate[best].rate, fs);

/* Select a CLK_SYS/fs ratio equal to or higher than required */ target = wm8961->sysclk / fs;

if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK && target < 64) { - dev_err(codec->dev, + dev_err(component->dev, "SYSCLK must be at least 64*fs for DAC\n"); return -EINVAL; } if (substream->stream == SNDRV_PCM_STREAM_CAPTURE && target < 256) { - dev_err(codec->dev, + dev_err(component->dev, "SYSCLK must be at least 256*fs for ADC\n"); return -EINVAL; } @@ -550,19 +550,19 @@ static int wm8961_hw_params(struct snd_pcm_substream *substream, break; } if (i == ARRAY_SIZE(wm8961_clk_sys_ratio)) { - dev_err(codec->dev, "Unable to generate CLK_SYS_RATE\n"); + dev_err(component->dev, "Unable to generate CLK_SYS_RATE\n"); return -EINVAL; } - dev_dbg(codec->dev, "Selected CLK_SYS_RATE of %d for %d/%d=%d\n", + dev_dbg(component->dev, "Selected CLK_SYS_RATE of %d for %d/%d=%d\n", wm8961_clk_sys_ratio[i].ratio, wm8961->sysclk, fs, wm8961->sysclk / fs);

- reg = snd_soc_read(codec, WM8961_CLOCKING_4); + reg = snd_soc_component_read32(component, WM8961_CLOCKING_4); reg &= ~WM8961_CLK_SYS_RATE_MASK; reg |= wm8961_clk_sys_ratio[i].val << WM8961_CLK_SYS_RATE_SHIFT; - snd_soc_write(codec, WM8961_CLOCKING_4, reg); + snd_soc_component_write(component, WM8961_CLOCKING_4, reg);

- reg = snd_soc_read(codec, WM8961_AUDIO_INTERFACE_0); + reg = snd_soc_component_read32(component, WM8961_AUDIO_INTERFACE_0); reg &= ~WM8961_WL_MASK; switch (params_width(params)) { case 16: @@ -579,15 +579,15 @@ static int wm8961_hw_params(struct snd_pcm_substream *substream, default: return -EINVAL; } - snd_soc_write(codec, WM8961_AUDIO_INTERFACE_0, reg); + snd_soc_component_write(component, WM8961_AUDIO_INTERFACE_0, reg);

/* Sloping stop-band filter is recommended for <= 24kHz */ - reg = snd_soc_read(codec, WM8961_ADC_DAC_CONTROL_2); + reg = snd_soc_component_read32(component, WM8961_ADC_DAC_CONTROL_2); if (fs <= 24000) reg |= WM8961_DACSLOPE; else reg &= ~WM8961_DACSLOPE; - snd_soc_write(codec, WM8961_ADC_DAC_CONTROL_2, reg); + snd_soc_component_write(component, WM8961_ADC_DAC_CONTROL_2, reg);

return 0; } @@ -596,25 +596,25 @@ static int wm8961_set_sysclk(struct snd_soc_dai *dai, int clk_id, unsigned int freq, int dir) { - struct snd_soc_codec *codec = dai->codec; - struct wm8961_priv *wm8961 = snd_soc_codec_get_drvdata(codec); - u16 reg = snd_soc_read(codec, WM8961_CLOCKING1); + struct snd_soc_component *component = dai->component; + struct wm8961_priv *wm8961 = snd_soc_component_get_drvdata(component); + u16 reg = snd_soc_component_read32(component, WM8961_CLOCKING1);

if (freq > 33000000) { - dev_err(codec->dev, "MCLK must be <33MHz\n"); + dev_err(component->dev, "MCLK must be <33MHz\n"); return -EINVAL; }

if (freq > 16500000) { - dev_dbg(codec->dev, "Using MCLK/2 for %dHz MCLK\n", freq); + dev_dbg(component->dev, "Using MCLK/2 for %dHz MCLK\n", freq); reg |= WM8961_MCLKDIV; freq /= 2; } else { - dev_dbg(codec->dev, "Using MCLK/1 for %dHz MCLK\n", freq); + dev_dbg(component->dev, "Using MCLK/1 for %dHz MCLK\n", freq); reg &= ~WM8961_MCLKDIV; }

- snd_soc_write(codec, WM8961_CLOCKING1, reg); + snd_soc_component_write(component, WM8961_CLOCKING1, reg);

wm8961->sysclk = freq;

@@ -623,8 +623,8 @@ static int wm8961_set_sysclk(struct snd_soc_dai *dai, int clk_id,

static int wm8961_set_fmt(struct snd_soc_dai *dai, unsigned int fmt) { - struct snd_soc_codec *codec = dai->codec; - u16 aif = snd_soc_read(codec, WM8961_AUDIO_INTERFACE_0); + struct snd_soc_component *component = dai->component; + u16 aif = snd_soc_component_read32(component, WM8961_AUDIO_INTERFACE_0);

aif &= ~(WM8961_BCLKINV | WM8961_LRP | WM8961_MS | WM8961_FORMAT_MASK); @@ -684,26 +684,26 @@ static int wm8961_set_fmt(struct snd_soc_dai *dai, unsigned int fmt) return -EINVAL; }

- return snd_soc_write(codec, WM8961_AUDIO_INTERFACE_0, aif); + return snd_soc_component_write(component, WM8961_AUDIO_INTERFACE_0, aif); }

static int wm8961_set_tristate(struct snd_soc_dai *dai, int tristate) { - struct snd_soc_codec *codec = dai->codec; - u16 reg = snd_soc_read(codec, WM8961_ADDITIONAL_CONTROL_2); + struct snd_soc_component *component = dai->component; + u16 reg = snd_soc_component_read32(component, WM8961_ADDITIONAL_CONTROL_2);

if (tristate) reg |= WM8961_TRIS; else reg &= ~WM8961_TRIS;

- return snd_soc_write(codec, WM8961_ADDITIONAL_CONTROL_2, reg); + return snd_soc_component_write(component, WM8961_ADDITIONAL_CONTROL_2, reg); }

static int wm8961_digital_mute(struct snd_soc_dai *dai, int mute) { - struct snd_soc_codec *codec = dai->codec; - u16 reg = snd_soc_read(codec, WM8961_ADC_DAC_CONTROL_1); + struct snd_soc_component *component = dai->component; + u16 reg = snd_soc_component_read32(component, WM8961_ADC_DAC_CONTROL_1);

if (mute) reg |= WM8961_DACMU; @@ -712,27 +712,27 @@ static int wm8961_digital_mute(struct snd_soc_dai *dai, int mute)

msleep(17);

- return snd_soc_write(codec, WM8961_ADC_DAC_CONTROL_1, reg); + return snd_soc_component_write(component, WM8961_ADC_DAC_CONTROL_1, reg); }

static int wm8961_set_clkdiv(struct snd_soc_dai *dai, int div_id, int div) { - struct snd_soc_codec *codec = dai->codec; + struct snd_soc_component *component = dai->component; u16 reg;

switch (div_id) { case WM8961_BCLK: - reg = snd_soc_read(codec, WM8961_CLOCKING2); + reg = snd_soc_component_read32(component, WM8961_CLOCKING2); reg &= ~WM8961_BCLKDIV_MASK; reg |= div; - snd_soc_write(codec, WM8961_CLOCKING2, reg); + snd_soc_component_write(component, WM8961_CLOCKING2, reg); break;

case WM8961_LRCLK: - reg = snd_soc_read(codec, WM8961_AUDIO_INTERFACE_2); + reg = snd_soc_component_read32(component, WM8961_AUDIO_INTERFACE_2); reg &= ~WM8961_LRCLK_RATE_MASK; reg |= div; - snd_soc_write(codec, WM8961_AUDIO_INTERFACE_2, reg); + snd_soc_component_write(component, WM8961_AUDIO_INTERFACE_2, reg); break;

default: @@ -742,7 +742,7 @@ static int wm8961_set_clkdiv(struct snd_soc_dai *dai, int div_id, int div) return 0; }

-static int wm8961_set_bias_level(struct snd_soc_codec *codec, +static int wm8961_set_bias_level(struct snd_soc_component *component, enum snd_soc_bias_level level) { u16 reg; @@ -757,36 +757,36 @@ static int wm8961_set_bias_level(struct snd_soc_codec *codec, break;

case SND_SOC_BIAS_PREPARE: - if (snd_soc_codec_get_bias_level(codec) == SND_SOC_BIAS_STANDBY) { + if (snd_soc_component_get_bias_level(component) == SND_SOC_BIAS_STANDBY) { /* Enable bias generation */ - reg = snd_soc_read(codec, WM8961_ANTI_POP); + reg = snd_soc_component_read32(component, WM8961_ANTI_POP); reg |= WM8961_BUFIOEN | WM8961_BUFDCOPEN; - snd_soc_write(codec, WM8961_ANTI_POP, reg); + snd_soc_component_write(component, WM8961_ANTI_POP, reg);

/* VMID=2*50k, VREF */ - reg = snd_soc_read(codec, WM8961_PWR_MGMT_1); + reg = snd_soc_component_read32(component, WM8961_PWR_MGMT_1); reg &= ~WM8961_VMIDSEL_MASK; reg |= (1 << WM8961_VMIDSEL_SHIFT) | WM8961_VREF; - snd_soc_write(codec, WM8961_PWR_MGMT_1, reg); + snd_soc_component_write(component, WM8961_PWR_MGMT_1, reg); } break;

case SND_SOC_BIAS_STANDBY: - if (snd_soc_codec_get_bias_level(codec) == SND_SOC_BIAS_PREPARE) { + if (snd_soc_component_get_bias_level(component) == SND_SOC_BIAS_PREPARE) { /* VREF off */ - reg = snd_soc_read(codec, WM8961_PWR_MGMT_1); + reg = snd_soc_component_read32(component, WM8961_PWR_MGMT_1); reg &= ~WM8961_VREF; - snd_soc_write(codec, WM8961_PWR_MGMT_1, reg); + snd_soc_component_write(component, WM8961_PWR_MGMT_1, reg);

/* Bias generation off */ - reg = snd_soc_read(codec, WM8961_ANTI_POP); + reg = snd_soc_component_read32(component, WM8961_ANTI_POP); reg &= ~(WM8961_BUFIOEN | WM8961_BUFDCOPEN); - snd_soc_write(codec, WM8961_ANTI_POP, reg); + snd_soc_component_write(component, WM8961_ANTI_POP, reg);

/* VMID off */ - reg = snd_soc_read(codec, WM8961_PWR_MGMT_1); + reg = snd_soc_component_read32(component, WM8961_PWR_MGMT_1); reg &= ~WM8961_VMIDSEL_MASK; - snd_soc_write(codec, WM8961_PWR_MGMT_1, reg); + snd_soc_component_write(component, WM8961_PWR_MGMT_1, reg); } break;

@@ -830,51 +830,51 @@ static int wm8961_set_bias_level(struct snd_soc_codec *codec, .ops = &wm8961_dai_ops, };

-static int wm8961_probe(struct snd_soc_codec *codec) +static int wm8961_probe(struct snd_soc_component *component) { u16 reg;

/* Enable class W */ - reg = snd_soc_read(codec, WM8961_CHARGE_PUMP_B); + reg = snd_soc_component_read32(component, WM8961_CHARGE_PUMP_B); reg |= WM8961_CP_DYN_PWR_MASK; - snd_soc_write(codec, WM8961_CHARGE_PUMP_B, reg); + snd_soc_component_write(component, WM8961_CHARGE_PUMP_B, reg);

/* Latch volume update bits (right channel only, we always * write both out) and default ZC on. */ - reg = snd_soc_read(codec, WM8961_ROUT1_VOLUME); - snd_soc_write(codec, WM8961_ROUT1_VOLUME, + reg = snd_soc_component_read32(component, WM8961_ROUT1_VOLUME); + snd_soc_component_write(component, WM8961_ROUT1_VOLUME, reg | WM8961_LO1ZC | WM8961_OUT1VU); - snd_soc_write(codec, WM8961_LOUT1_VOLUME, reg | WM8961_LO1ZC); - reg = snd_soc_read(codec, WM8961_ROUT2_VOLUME); - snd_soc_write(codec, WM8961_ROUT2_VOLUME, + snd_soc_component_write(component, WM8961_LOUT1_VOLUME, reg | WM8961_LO1ZC); + reg = snd_soc_component_read32(component, WM8961_ROUT2_VOLUME); + snd_soc_component_write(component, WM8961_ROUT2_VOLUME, reg | WM8961_SPKRZC | WM8961_SPKVU); - snd_soc_write(codec, WM8961_LOUT2_VOLUME, reg | WM8961_SPKLZC); + snd_soc_component_write(component, WM8961_LOUT2_VOLUME, reg | WM8961_SPKLZC);

- reg = snd_soc_read(codec, WM8961_RIGHT_ADC_VOLUME); - snd_soc_write(codec, WM8961_RIGHT_ADC_VOLUME, reg | WM8961_ADCVU); - reg = snd_soc_read(codec, WM8961_RIGHT_INPUT_VOLUME); - snd_soc_write(codec, WM8961_RIGHT_INPUT_VOLUME, reg | WM8961_IPVU); + reg = snd_soc_component_read32(component, WM8961_RIGHT_ADC_VOLUME); + snd_soc_component_write(component, WM8961_RIGHT_ADC_VOLUME, reg | WM8961_ADCVU); + reg = snd_soc_component_read32(component, WM8961_RIGHT_INPUT_VOLUME); + snd_soc_component_write(component, WM8961_RIGHT_INPUT_VOLUME, reg | WM8961_IPVU);

/* Use soft mute by default */ - reg = snd_soc_read(codec, WM8961_ADC_DAC_CONTROL_2); + reg = snd_soc_component_read32(component, WM8961_ADC_DAC_CONTROL_2); reg |= WM8961_DACSMM; - snd_soc_write(codec, WM8961_ADC_DAC_CONTROL_2, reg); + snd_soc_component_write(component, WM8961_ADC_DAC_CONTROL_2, reg);

/* Use automatic clocking mode by default; for now this is all * we support. */ - reg = snd_soc_read(codec, WM8961_CLOCKING_3); + reg = snd_soc_component_read32(component, WM8961_CLOCKING_3); reg &= ~WM8961_MANUAL_MODE; - snd_soc_write(codec, WM8961_CLOCKING_3, reg); + snd_soc_component_write(component, WM8961_CLOCKING_3, reg);

return 0; }

#ifdef CONFIG_PM

-static int wm8961_resume(struct snd_soc_codec *codec) +static int wm8961_resume(struct snd_soc_component *component) { - snd_soc_cache_sync(codec); + snd_soc_component_cache_sync(component);

return 0; } @@ -882,20 +882,21 @@ static int wm8961_resume(struct snd_soc_codec *codec) #define wm8961_resume NULL #endif

-static const struct snd_soc_codec_driver soc_codec_dev_wm8961 = { - .probe = wm8961_probe, - .resume = wm8961_resume, - .set_bias_level = wm8961_set_bias_level, - .suspend_bias_off = true, - - .component_driver = { - .controls = wm8961_snd_controls, - .num_controls = ARRAY_SIZE(wm8961_snd_controls), - .dapm_widgets = wm8961_dapm_widgets, - .num_dapm_widgets = ARRAY_SIZE(wm8961_dapm_widgets), - .dapm_routes = audio_paths, - .num_dapm_routes = ARRAY_SIZE(audio_paths), - }, +static const struct snd_soc_component_driver soc_component_dev_wm8961 = { + .probe = wm8961_probe, + .resume = wm8961_resume, + .set_bias_level = wm8961_set_bias_level, + .controls = wm8961_snd_controls, + .num_controls = ARRAY_SIZE(wm8961_snd_controls), + .dapm_widgets = wm8961_dapm_widgets, + .num_dapm_widgets = ARRAY_SIZE(wm8961_dapm_widgets), + .dapm_routes = audio_paths, + .num_dapm_routes = ARRAY_SIZE(audio_paths), + .suspend_bias_off = 1, + .idle_bias_on = 1, + .pmdown_time = 1, + .endianness = 1, + .non_legacy_dai_naming = 1, };

static const struct regmap_config wm8961_regmap = { @@ -961,19 +962,12 @@ static int wm8961_i2c_probe(struct i2c_client *i2c,

i2c_set_clientdata(i2c, wm8961);

- ret = snd_soc_register_codec(&i2c->dev, - &soc_codec_dev_wm8961, &wm8961_dai, 1); + ret = devm_snd_soc_register_component(&i2c->dev, + &soc_component_dev_wm8961, &wm8961_dai, 1);

return ret; }

-static int wm8961_i2c_remove(struct i2c_client *client) -{ - snd_soc_unregister_codec(&client->dev); - - return 0; -} - static const struct i2c_device_id wm8961_i2c_id[] = { { "wm8961", 0 }, { } @@ -985,7 +979,6 @@ static int wm8961_i2c_remove(struct i2c_client *client) .name = "wm8961", }, .probe = wm8961_i2c_probe, - .remove = wm8961_i2c_remove, .id_table = wm8961_i2c_id, };

From: Kuninori Morimoto kuninori.morimoto.gx@renesas.com

Now we can replace Codec to Component. Let's do it.

Note: xxx_codec_xxx() -> xxx_component_xxx() .idle_bias_off = 1 -> .idle_bias_on = 0 .ignore_pmdown_time = 0 -> .pmdown_time = 1 - -> .endianness = 1 - -> .non_legacy_dai_naming = 1

Signed-off-by: Kuninori Morimoto kuninori.morimoto.gx@renesas.com --- sound/soc/codecs/wm8904.c | 355 +++++++++++++++++++++++----------------------- 1 file changed, 174 insertions(+), 181 deletions(-)

diff --git a/sound/soc/codecs/wm8904.c b/sound/soc/codecs/wm8904.c index 4fd350e8..182821e 100644 --- a/sound/soc/codecs/wm8904.c +++ b/sound/soc/codecs/wm8904.c @@ -316,31 +316,31 @@ static bool wm8904_readable_register(struct device *dev, unsigned int reg) } }

-static int wm8904_configure_clocking(struct snd_soc_codec *codec) +static int wm8904_configure_clocking(struct snd_soc_component *component) { - struct wm8904_priv *wm8904 = snd_soc_codec_get_drvdata(codec); + struct wm8904_priv *wm8904 = snd_soc_component_get_drvdata(component); unsigned int clock0, clock2, rate;

/* Gate the clock while we're updating to avoid misclocking */ - clock2 = snd_soc_read(codec, WM8904_CLOCK_RATES_2); - snd_soc_update_bits(codec, WM8904_CLOCK_RATES_2, + clock2 = snd_soc_component_read32(component, WM8904_CLOCK_RATES_2); + snd_soc_component_update_bits(component, WM8904_CLOCK_RATES_2, WM8904_SYSCLK_SRC, 0);

/* This should be done on init() for bypass paths */ switch (wm8904->sysclk_src) { case WM8904_CLK_MCLK: - dev_dbg(codec->dev, "Using %dHz MCLK\n", wm8904->mclk_rate); + dev_dbg(component->dev, "Using %dHz MCLK\n", wm8904->mclk_rate);

clock2 &= ~WM8904_SYSCLK_SRC; rate = wm8904->mclk_rate;

/* Ensure the FLL is stopped */ - snd_soc_update_bits(codec, WM8904_FLL_CONTROL_1, + snd_soc_component_update_bits(component, WM8904_FLL_CONTROL_1, WM8904_FLL_OSC_ENA | WM8904_FLL_ENA, 0); break;

case WM8904_CLK_FLL: - dev_dbg(codec->dev, "Using %dHz FLL clock\n", + dev_dbg(component->dev, "Using %dHz FLL clock\n", wm8904->fll_fout);

clock2 |= WM8904_SYSCLK_SRC; @@ -348,7 +348,7 @@ static int wm8904_configure_clocking(struct snd_soc_codec *codec) break;

default: - dev_err(codec->dev, "System clock not configured\n"); + dev_err(component->dev, "System clock not configured\n"); return -EINVAL; }

@@ -361,40 +361,40 @@ static int wm8904_configure_clocking(struct snd_soc_codec *codec) wm8904->sysclk_rate = rate; }

- snd_soc_update_bits(codec, WM8904_CLOCK_RATES_0, WM8904_MCLK_DIV, + snd_soc_component_update_bits(component, WM8904_CLOCK_RATES_0, WM8904_MCLK_DIV, clock0);

- snd_soc_update_bits(codec, WM8904_CLOCK_RATES_2, + snd_soc_component_update_bits(component, WM8904_CLOCK_RATES_2, WM8904_CLK_SYS_ENA | WM8904_SYSCLK_SRC, clock2);

- dev_dbg(codec->dev, "CLK_SYS is %dHz\n", wm8904->sysclk_rate); + dev_dbg(component->dev, "CLK_SYS is %dHz\n", wm8904->sysclk_rate);

return 0; }

-static void wm8904_set_drc(struct snd_soc_codec *codec) +static void wm8904_set_drc(struct snd_soc_component *component) { - struct wm8904_priv *wm8904 = snd_soc_codec_get_drvdata(codec); + struct wm8904_priv *wm8904 = snd_soc_component_get_drvdata(component); struct wm8904_pdata *pdata = wm8904->pdata; int save, i;

/* Save any enables; the configuration should clear them. */ - save = snd_soc_read(codec, WM8904_DRC_0); + save = snd_soc_component_read32(component, WM8904_DRC_0);

for (i = 0; i < WM8904_DRC_REGS; i++) - snd_soc_update_bits(codec, WM8904_DRC_0 + i, 0xffff, + snd_soc_component_update_bits(component, WM8904_DRC_0 + i, 0xffff, pdata->drc_cfgs[wm8904->drc_cfg].regs[i]);

/* Reenable the DRC */ - snd_soc_update_bits(codec, WM8904_DRC_0, + snd_soc_component_update_bits(component, WM8904_DRC_0, WM8904_DRC_ENA | WM8904_DRC_DAC_PATH, save); }

static int wm8904_put_drc_enum(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { - struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol); - struct wm8904_priv *wm8904 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol); + struct wm8904_priv *wm8904 = snd_soc_component_get_drvdata(component); struct wm8904_pdata *pdata = wm8904->pdata; int value = ucontrol->value.enumerated.item[0];

@@ -403,7 +403,7 @@ static int wm8904_put_drc_enum(struct snd_kcontrol *kcontrol,

wm8904->drc_cfg = value;

- wm8904_set_drc(codec); + wm8904_set_drc(component);

return 0; } @@ -411,17 +411,17 @@ static int wm8904_put_drc_enum(struct snd_kcontrol *kcontrol, static int wm8904_get_drc_enum(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { - struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol); - struct wm8904_priv *wm8904 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol); + struct wm8904_priv *wm8904 = snd_soc_component_get_drvdata(component);

ucontrol->value.enumerated.item[0] = wm8904->drc_cfg;

return 0; }

-static void wm8904_set_retune_mobile(struct snd_soc_codec *codec) +static void wm8904_set_retune_mobile(struct snd_soc_component *component) { - struct wm8904_priv *wm8904 = snd_soc_codec_get_drvdata(codec); + struct wm8904_priv *wm8904 = snd_soc_component_get_drvdata(component); struct wm8904_pdata *pdata = wm8904->pdata; int best, best_val, save, i, cfg;

@@ -444,7 +444,7 @@ static void wm8904_set_retune_mobile(struct snd_soc_codec *codec) } }

- dev_dbg(codec->dev, "ReTune Mobile %s/%dHz for %dHz sample rate\n", + dev_dbg(component->dev, "ReTune Mobile %s/%dHz for %dHz sample rate\n", pdata->retune_mobile_cfgs[best].name, pdata->retune_mobile_cfgs[best].rate, wm8904->fs); @@ -452,20 +452,20 @@ static void wm8904_set_retune_mobile(struct snd_soc_codec *codec) /* The EQ will be disabled while reconfiguring it, remember the * current configuration. */ - save = snd_soc_read(codec, WM8904_EQ1); + save = snd_soc_component_read32(component, WM8904_EQ1);

for (i = 0; i < WM8904_EQ_REGS; i++) - snd_soc_update_bits(codec, WM8904_EQ1 + i, 0xffff, + snd_soc_component_update_bits(component, WM8904_EQ1 + i, 0xffff, pdata->retune_mobile_cfgs[best].regs[i]);

- snd_soc_update_bits(codec, WM8904_EQ1, WM8904_EQ_ENA, save); + snd_soc_component_update_bits(component, WM8904_EQ1, WM8904_EQ_ENA, save); }

static int wm8904_put_retune_mobile_enum(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { - struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol); - struct wm8904_priv *wm8904 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol); + struct wm8904_priv *wm8904 = snd_soc_component_get_drvdata(component); struct wm8904_pdata *pdata = wm8904->pdata; int value = ucontrol->value.enumerated.item[0];

@@ -474,7 +474,7 @@ static int wm8904_put_retune_mobile_enum(struct snd_kcontrol *kcontrol,

wm8904->retune_mobile_cfg = value;

- wm8904_set_retune_mobile(codec); + wm8904_set_retune_mobile(component);

return 0; } @@ -482,8 +482,8 @@ static int wm8904_put_retune_mobile_enum(struct snd_kcontrol *kcontrol, static int wm8904_get_retune_mobile_enum(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { - struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol); - struct wm8904_priv *wm8904 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol); + struct wm8904_priv *wm8904 = snd_soc_component_get_drvdata(component);

ucontrol->value.enumerated.item[0] = wm8904->retune_mobile_cfg;

@@ -492,9 +492,9 @@ static int wm8904_get_retune_mobile_enum(struct snd_kcontrol *kcontrol,

static int deemph_settings[] = { 0, 32000, 44100, 48000 };

-static int wm8904_set_deemph(struct snd_soc_codec *codec) +static int wm8904_set_deemph(struct snd_soc_component *component) { - struct wm8904_priv *wm8904 = snd_soc_codec_get_drvdata(codec); + struct wm8904_priv *wm8904 = snd_soc_component_get_drvdata(component); int val, i, best;

/* If we're using deemphasis select the nearest available sample @@ -513,17 +513,17 @@ static int wm8904_set_deemph(struct snd_soc_codec *codec) val = 0; }

- dev_dbg(codec->dev, "Set deemphasis %d\n", val); + dev_dbg(component->dev, "Set deemphasis %d\n", val);

- return snd_soc_update_bits(codec, WM8904_DAC_DIGITAL_1, + return snd_soc_component_update_bits(component, WM8904_DAC_DIGITAL_1, WM8904_DEEMPH_MASK, val); }

static int wm8904_get_deemph(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { - struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol); - struct wm8904_priv *wm8904 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol); + struct wm8904_priv *wm8904 = snd_soc_component_get_drvdata(component);

ucontrol->value.integer.value[0] = wm8904->deemph; return 0; @@ -532,8 +532,8 @@ static int wm8904_get_deemph(struct snd_kcontrol *kcontrol, static int wm8904_put_deemph(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { - struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol); - struct wm8904_priv *wm8904 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol); + struct wm8904_priv *wm8904 = snd_soc_component_get_drvdata(component); unsigned int deemph = ucontrol->value.integer.value[0];

if (deemph > 1) @@ -541,7 +541,7 @@ static int wm8904_put_deemph(struct snd_kcontrol *kcontrol,

wm8904->deemph = deemph;

- return wm8904_set_deemph(codec); + return wm8904_set_deemph(component); }

static const DECLARE_TLV_DB_SCALE(dac_boost_tlv, 0, 600, 0); @@ -572,7 +572,7 @@ static SOC_ENUM_SINGLE_DECL(hpf_mode, WM8904_ADC_DIGITAL_0, 5, static int wm8904_adc_osr_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { - struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol); + struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol); unsigned int val; int ret;

@@ -585,7 +585,7 @@ static int wm8904_adc_osr_put(struct snd_kcontrol *kcontrol, else val = WM8904_ADC_128_OSR_TST_MODE | WM8904_ADC_BIASX1P5;

- snd_soc_update_bits(codec, WM8904_ADC_TEST_0, + snd_soc_component_update_bits(component, WM8904_ADC_TEST_0, WM8904_ADC_128_OSR_TST_MODE | WM8904_ADC_BIASX1P5, val);

@@ -673,8 +673,8 @@ static int cp_event(struct snd_soc_dapm_widget *w, static int sysclk_event(struct snd_soc_dapm_widget *w, struct snd_kcontrol *kcontrol, int event) { - struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm); - struct wm8904_priv *wm8904 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm); + struct wm8904_priv *wm8904 = snd_soc_component_get_drvdata(component);

switch (event) { case SND_SOC_DAPM_PRE_PMU: @@ -685,11 +685,11 @@ static int sysclk_event(struct snd_soc_dapm_widget *w, */ switch (wm8904->sysclk_src) { case WM8904_CLK_FLL: - snd_soc_update_bits(codec, WM8904_FLL_CONTROL_1, + snd_soc_component_update_bits(component, WM8904_FLL_CONTROL_1, WM8904_FLL_OSC_ENA, WM8904_FLL_OSC_ENA);

- snd_soc_update_bits(codec, WM8904_FLL_CONTROL_1, + snd_soc_component_update_bits(component, WM8904_FLL_CONTROL_1, WM8904_FLL_ENA, WM8904_FLL_ENA); break; @@ -700,7 +700,7 @@ static int sysclk_event(struct snd_soc_dapm_widget *w, break;

case SND_SOC_DAPM_POST_PMD: - snd_soc_update_bits(codec, WM8904_FLL_CONTROL_1, + snd_soc_component_update_bits(component, WM8904_FLL_CONTROL_1, WM8904_FLL_OSC_ENA | WM8904_FLL_ENA, 0); break; } @@ -711,8 +711,8 @@ static int sysclk_event(struct snd_soc_dapm_widget *w, static int out_pga_event(struct snd_soc_dapm_widget *w, struct snd_kcontrol *kcontrol, int event) { - struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm); - struct wm8904_priv *wm8904 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm); + struct wm8904_priv *wm8904 = snd_soc_component_get_drvdata(component); int reg, val; int dcs_mask; int dcs_l, dcs_r; @@ -751,43 +751,43 @@ static int out_pga_event(struct snd_soc_dapm_widget *w, switch (event) { case SND_SOC_DAPM_PRE_PMU: /* Power on the PGAs */ - snd_soc_update_bits(codec, pwr_reg, + snd_soc_component_update_bits(component, pwr_reg, WM8904_HPL_PGA_ENA | WM8904_HPR_PGA_ENA, WM8904_HPL_PGA_ENA | WM8904_HPR_PGA_ENA);

/* Power on the amplifier */ - snd_soc_update_bits(codec, reg, + snd_soc_component_update_bits(component, reg, WM8904_HPL_ENA | WM8904_HPR_ENA, WM8904_HPL_ENA | WM8904_HPR_ENA);

/* Enable the first stage */ - snd_soc_update_bits(codec, reg, + snd_soc_component_update_bits(component, reg, WM8904_HPL_ENA_DLY | WM8904_HPR_ENA_DLY, WM8904_HPL_ENA_DLY | WM8904_HPR_ENA_DLY);

/* Power up the DC servo */ - snd_soc_update_bits(codec, WM8904_DC_SERVO_0, + snd_soc_component_update_bits(component, WM8904_DC_SERVO_0, dcs_mask, dcs_mask);

/* Either calibrate the DC servo or restore cached state * if we have that. */ if (wm8904->dcs_state[dcs_l] || wm8904->dcs_state[dcs_r]) { - dev_dbg(codec->dev, "Restoring DC servo state\n"); + dev_dbg(component->dev, "Restoring DC servo state\n");

- snd_soc_write(codec, dcs_l_reg, + snd_soc_component_write(component, dcs_l_reg, wm8904->dcs_state[dcs_l]); - snd_soc_write(codec, dcs_r_reg, + snd_soc_component_write(component, dcs_r_reg, wm8904->dcs_state[dcs_r]);

- snd_soc_write(codec, WM8904_DC_SERVO_1, dcs_mask); + snd_soc_component_write(component, WM8904_DC_SERVO_1, dcs_mask);

timeout = 20; } else { - dev_dbg(codec->dev, "Calibrating DC servo\n"); + dev_dbg(component->dev, "Calibrating DC servo\n");

- snd_soc_write(codec, WM8904_DC_SERVO_1, + snd_soc_component_write(component, WM8904_DC_SERVO_1, dcs_mask << WM8904_DCS_TRIG_STARTUP_0_SHIFT);

timeout = 500; @@ -796,7 +796,7 @@ static int out_pga_event(struct snd_soc_dapm_widget *w, /* Wait for DC servo to complete */ dcs_mask <<= WM8904_DCS_CAL_COMPLETE_SHIFT; do { - val = snd_soc_read(codec, WM8904_DC_SERVO_READBACK_0); + val = snd_soc_component_read32(component, WM8904_DC_SERVO_READBACK_0); if ((val & dcs_mask) == dcs_mask) break;

@@ -804,19 +804,19 @@ static int out_pga_event(struct snd_soc_dapm_widget *w, } while (--timeout);

if ((val & dcs_mask) != dcs_mask) - dev_warn(codec->dev, "DC servo timed out\n"); + dev_warn(component->dev, "DC servo timed out\n"); else - dev_dbg(codec->dev, "DC servo ready\n"); + dev_dbg(component->dev, "DC servo ready\n");

/* Enable the output stage */ - snd_soc_update_bits(codec, reg, + snd_soc_component_update_bits(component, reg, WM8904_HPL_ENA_OUTP | WM8904_HPR_ENA_OUTP, WM8904_HPL_ENA_OUTP | WM8904_HPR_ENA_OUTP); break;

case SND_SOC_DAPM_POST_PMU: /* Unshort the output itself */ - snd_soc_update_bits(codec, reg, + snd_soc_component_update_bits(component, reg, WM8904_HPL_RMV_SHORT | WM8904_HPR_RMV_SHORT, WM8904_HPL_RMV_SHORT | @@ -826,7 +826,7 @@ static int out_pga_event(struct snd_soc_dapm_widget *w,

case SND_SOC_DAPM_PRE_PMD: /* Short the output */ - snd_soc_update_bits(codec, reg, + snd_soc_component_update_bits(component, reg, WM8904_HPL_RMV_SHORT | WM8904_HPR_RMV_SHORT, 0); break; @@ -834,21 +834,21 @@ static int out_pga_event(struct snd_soc_dapm_widget *w, case SND_SOC_DAPM_POST_PMD: /* Cache the DC servo configuration; this will be * invalidated if we change the configuration. */ - wm8904->dcs_state[dcs_l] = snd_soc_read(codec, dcs_l_reg); - wm8904->dcs_state[dcs_r] = snd_soc_read(codec, dcs_r_reg); + wm8904->dcs_state[dcs_l] = snd_soc_component_read32(component, dcs_l_reg); + wm8904->dcs_state[dcs_r] = snd_soc_component_read32(component, dcs_r_reg);

- snd_soc_update_bits(codec, WM8904_DC_SERVO_0, + snd_soc_component_update_bits(component, WM8904_DC_SERVO_0, dcs_mask, 0);

/* Disable the amplifier input and output stages */ - snd_soc_update_bits(codec, reg, + snd_soc_component_update_bits(component, reg, WM8904_HPL_ENA | WM8904_HPR_ENA | WM8904_HPL_ENA_DLY | WM8904_HPR_ENA_DLY | WM8904_HPL_ENA_OUTP | WM8904_HPR_ENA_OUTP, 0);

/* PGAs too */ - snd_soc_update_bits(codec, pwr_reg, + snd_soc_component_update_bits(component, pwr_reg, WM8904_HPL_PGA_ENA | WM8904_HPR_PGA_ENA, 0); break; @@ -1165,10 +1165,10 @@ static SOC_ENUM_SINGLE_DECL(dacr_sidetone_enum, WM8904_DAC_DIGITAL_0, 0, { "LINER PGA", NULL, "DACR" }, };

-static int wm8904_add_widgets(struct snd_soc_codec *codec) +static int wm8904_add_widgets(struct snd_soc_component *component) { - struct wm8904_priv *wm8904 = snd_soc_codec_get_drvdata(codec); - struct snd_soc_dapm_context *dapm = snd_soc_codec_get_dapm(codec); + struct wm8904_priv *wm8904 = snd_soc_component_get_drvdata(component); + struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(component);

snd_soc_dapm_new_controls(dapm, wm8904_core_dapm_widgets, ARRAY_SIZE(wm8904_core_dapm_widgets)); @@ -1177,11 +1177,11 @@ static int wm8904_add_widgets(struct snd_soc_codec *codec)

switch (wm8904->devtype) { case WM8904: - snd_soc_add_codec_controls(codec, wm8904_adc_snd_controls, + snd_soc_add_component_controls(component, wm8904_adc_snd_controls, ARRAY_SIZE(wm8904_adc_snd_controls)); - snd_soc_add_codec_controls(codec, wm8904_dac_snd_controls, + snd_soc_add_component_controls(component, wm8904_dac_snd_controls, ARRAY_SIZE(wm8904_dac_snd_controls)); - snd_soc_add_codec_controls(codec, wm8904_snd_controls, + snd_soc_add_component_controls(component, wm8904_snd_controls, ARRAY_SIZE(wm8904_snd_controls));

snd_soc_dapm_new_controls(dapm, wm8904_adc_dapm_widgets, @@ -1200,7 +1200,7 @@ static int wm8904_add_widgets(struct snd_soc_codec *codec) break;

case WM8912: - snd_soc_add_codec_controls(codec, wm8904_dac_snd_controls, + snd_soc_add_component_controls(component, wm8904_dac_snd_controls, ARRAY_SIZE(wm8904_dac_snd_controls));

snd_soc_dapm_new_controls(dapm, wm8904_dac_dapm_widgets, @@ -1278,8 +1278,8 @@ static int wm8904_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params, struct snd_soc_dai *dai) { - struct snd_soc_codec *codec = dai->codec; - struct wm8904_priv *wm8904 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = dai->component; + struct wm8904_priv *wm8904 = snd_soc_component_get_drvdata(component); int ret, i, best, best_val, cur_val; unsigned int aif1 = 0; unsigned int aif2 = 0; @@ -1290,7 +1290,7 @@ static int wm8904_hw_params(struct snd_pcm_substream *substream, /* What BCLK do we need? */ wm8904->fs = params_rate(params); if (wm8904->tdm_slots) { - dev_dbg(codec->dev, "Configuring for %d %d bit TDM slots\n", + dev_dbg(component->dev, "Configuring for %d %d bit TDM slots\n", wm8904->tdm_slots, wm8904->tdm_width); wm8904->bclk = snd_soc_calc_bclk(wm8904->fs, wm8904->tdm_width, 2, @@ -1316,9 +1316,9 @@ static int wm8904_hw_params(struct snd_pcm_substream *substream, }

- dev_dbg(codec->dev, "Target BCLK is %dHz\n", wm8904->bclk); + dev_dbg(component->dev, "Target BCLK is %dHz\n", wm8904->bclk);

- ret = wm8904_configure_clocking(codec); + ret = wm8904_configure_clocking(component); if (ret != 0) return ret;

@@ -1334,7 +1334,7 @@ static int wm8904_hw_params(struct snd_pcm_substream *substream, best_val = cur_val; } } - dev_dbg(codec->dev, "Selected CLK_SYS_RATIO of %d\n", + dev_dbg(component->dev, "Selected CLK_SYS_RATIO of %d\n", clk_sys_rates[best].ratio); clock1 |= (clk_sys_rates[best].clk_sys_rate << WM8904_CLK_SYS_RATE_SHIFT); @@ -1350,7 +1350,7 @@ static int wm8904_hw_params(struct snd_pcm_substream *substream, best_val = cur_val; } } - dev_dbg(codec->dev, "Selected SAMPLE_RATE of %dHz\n", + dev_dbg(component->dev, "Selected SAMPLE_RATE of %dHz\n", sample_rates[best].rate); clock1 |= (sample_rates[best].sample_rate << WM8904_SAMPLE_RATE_SHIFT); @@ -1373,30 +1373,30 @@ static int wm8904_hw_params(struct snd_pcm_substream *substream, } } wm8904->bclk = (wm8904->sysclk_rate * 10) / bclk_divs[best].div; - dev_dbg(codec->dev, "Selected BCLK_DIV of %d for %dHz BCLK\n", + dev_dbg(component->dev, "Selected BCLK_DIV of %d for %dHz BCLK\n", bclk_divs[best].div, wm8904->bclk); aif2 |= bclk_divs[best].bclk_div;

/* LRCLK is a simple fraction of BCLK */ - dev_dbg(codec->dev, "LRCLK_RATE is %d\n", wm8904->bclk / wm8904->fs); + dev_dbg(component->dev, "LRCLK_RATE is %d\n", wm8904->bclk / wm8904->fs); aif3 |= wm8904->bclk / wm8904->fs;

/* Apply the settings */ - snd_soc_update_bits(codec, WM8904_DAC_DIGITAL_1, + snd_soc_component_update_bits(component, WM8904_DAC_DIGITAL_1, WM8904_DAC_SB_FILT, dac_digital1); - snd_soc_update_bits(codec, WM8904_AUDIO_INTERFACE_1, + snd_soc_component_update_bits(component, WM8904_AUDIO_INTERFACE_1, WM8904_AIF_WL_MASK, aif1); - snd_soc_update_bits(codec, WM8904_AUDIO_INTERFACE_2, + snd_soc_component_update_bits(component, WM8904_AUDIO_INTERFACE_2, WM8904_BCLK_DIV_MASK, aif2); - snd_soc_update_bits(codec, WM8904_AUDIO_INTERFACE_3, + snd_soc_component_update_bits(component, WM8904_AUDIO_INTERFACE_3, WM8904_LRCLK_RATE_MASK, aif3); - snd_soc_update_bits(codec, WM8904_CLOCK_RATES_1, + snd_soc_component_update_bits(component, WM8904_CLOCK_RATES_1, WM8904_SAMPLE_RATE_MASK | WM8904_CLK_SYS_RATE_MASK, clock1);

/* Update filters for the new settings */ - wm8904_set_retune_mobile(codec); - wm8904_set_deemph(codec); + wm8904_set_retune_mobile(component); + wm8904_set_deemph(component);

return 0; } @@ -1405,8 +1405,8 @@ static int wm8904_hw_params(struct snd_pcm_substream *substream, static int wm8904_set_sysclk(struct snd_soc_dai *dai, int clk_id, unsigned int freq, int dir) { - struct snd_soc_codec *codec = dai->codec; - struct wm8904_priv *priv = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = dai->component; + struct wm8904_priv *priv = snd_soc_component_get_drvdata(component);

switch (clk_id) { case WM8904_CLK_MCLK: @@ -1424,14 +1424,14 @@ static int wm8904_set_sysclk(struct snd_soc_dai *dai, int clk_id,

dev_dbg(dai->dev, "Clock source is %d at %uHz\n", clk_id, freq);

- wm8904_configure_clocking(codec); + wm8904_configure_clocking(component);

return 0; }

static int wm8904_set_fmt(struct snd_soc_dai *dai, unsigned int fmt) { - struct snd_soc_codec *codec = dai->codec; + struct snd_soc_component *component = dai->component; unsigned int aif1 = 0; unsigned int aif3 = 0;

@@ -1508,10 +1508,10 @@ static int wm8904_set_fmt(struct snd_soc_dai *dai, unsigned int fmt) return -EINVAL; }

- snd_soc_update_bits(codec, WM8904_AUDIO_INTERFACE_1, + snd_soc_component_update_bits(component, WM8904_AUDIO_INTERFACE_1, WM8904_AIF_BCLK_INV | WM8904_AIF_LRCLK_INV | WM8904_AIF_FMT_MASK | WM8904_BCLK_DIR, aif1); - snd_soc_update_bits(codec, WM8904_AUDIO_INTERFACE_3, + snd_soc_component_update_bits(component, WM8904_AUDIO_INTERFACE_3, WM8904_LRCLK_DIR, aif3);

return 0; @@ -1521,8 +1521,8 @@ static int wm8904_set_fmt(struct snd_soc_dai *dai, unsigned int fmt) static int wm8904_set_tdm_slot(struct snd_soc_dai *dai, unsigned int tx_mask, unsigned int rx_mask, int slots, int slot_width) { - struct snd_soc_codec *codec = dai->codec; - struct wm8904_priv *wm8904 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = dai->component; + struct wm8904_priv *wm8904 = snd_soc_component_get_drvdata(component); int aif1 = 0;

/* Don't need to validate anything if we're turning off TDM */ @@ -1560,7 +1560,7 @@ static int wm8904_set_tdm_slot(struct snd_soc_dai *dai, unsigned int tx_mask, wm8904->tdm_width = slot_width; wm8904->tdm_slots = slots / 2;

- snd_soc_update_bits(codec, WM8904_AUDIO_INTERFACE_1, + snd_soc_component_update_bits(component, WM8904_AUDIO_INTERFACE_1, WM8904_AIFADC_TDM | WM8904_AIFADC_TDM_CHAN | WM8904_AIFDAC_TDM | WM8904_AIFDAC_TDM_CHAN, aif1);

@@ -1678,8 +1678,8 @@ static int fll_factors(struct _fll_div *fll_div, unsigned int Fref, static int wm8904_set_fll(struct snd_soc_dai *dai, int fll_id, int source, unsigned int Fref, unsigned int Fout) { - struct snd_soc_codec *codec = dai->codec; - struct wm8904_priv *wm8904 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = dai->component; + struct wm8904_priv *wm8904 = snd_soc_component_get_drvdata(component); struct _fll_div fll_div; int ret, val; int clock2, fll1; @@ -1689,19 +1689,19 @@ static int wm8904_set_fll(struct snd_soc_dai *dai, int fll_id, int source, Fout == wm8904->fll_fout) return 0;

- clock2 = snd_soc_read(codec, WM8904_CLOCK_RATES_2); + clock2 = snd_soc_component_read32(component, WM8904_CLOCK_RATES_2);

if (Fout == 0) { - dev_dbg(codec->dev, "FLL disabled\n"); + dev_dbg(component->dev, "FLL disabled\n");

wm8904->fll_fref = 0; wm8904->fll_fout = 0;

/* Gate SYSCLK to avoid glitches */ - snd_soc_update_bits(codec, WM8904_CLOCK_RATES_2, + snd_soc_component_update_bits(component, WM8904_CLOCK_RATES_2, WM8904_CLK_SYS_ENA, 0);

- snd_soc_update_bits(codec, WM8904_FLL_CONTROL_1, + snd_soc_component_update_bits(component, WM8904_FLL_CONTROL_1, WM8904_FLL_OSC_ENA | WM8904_FLL_ENA, 0);

goto out; @@ -1718,7 +1718,7 @@ static int wm8904_set_fll(struct snd_soc_dai *dai, int fll_id, int source, break;

case WM8904_FLL_FREE_RUNNING: - dev_dbg(codec->dev, "Using free running FLL\n"); + dev_dbg(component->dev, "Using free running FLL\n"); /* Force 12MHz and output/4 for now */ Fout = 12000000; Fref = 12000000; @@ -1728,20 +1728,20 @@ static int wm8904_set_fll(struct snd_soc_dai *dai, int fll_id, int source, break;

default: - dev_err(codec->dev, "Unknown FLL ID %d\n", fll_id); + dev_err(component->dev, "Unknown FLL ID %d\n", fll_id); return -EINVAL; }

/* Save current state then disable the FLL and SYSCLK to avoid * misclocking */ - fll1 = snd_soc_read(codec, WM8904_FLL_CONTROL_1); - snd_soc_update_bits(codec, WM8904_CLOCK_RATES_2, + fll1 = snd_soc_component_read32(component, WM8904_FLL_CONTROL_1); + snd_soc_component_update_bits(component, WM8904_CLOCK_RATES_2, WM8904_CLK_SYS_ENA, 0); - snd_soc_update_bits(codec, WM8904_FLL_CONTROL_1, + snd_soc_component_update_bits(component, WM8904_FLL_CONTROL_1, WM8904_FLL_OSC_ENA | WM8904_FLL_ENA, 0);

/* Unlock forced oscilator control to switch it on/off */ - snd_soc_update_bits(codec, WM8904_CONTROL_INTERFACE_TEST_1, + snd_soc_component_update_bits(component, WM8904_CONTROL_INTERFACE_TEST_1, WM8904_USER_KEY, WM8904_USER_KEY);

if (fll_id == WM8904_FLL_FREE_RUNNING) { @@ -1750,24 +1750,24 @@ static int wm8904_set_fll(struct snd_soc_dai *dai, int fll_id, int source, val = 0; }

- snd_soc_update_bits(codec, WM8904_FLL_NCO_TEST_1, WM8904_FLL_FRC_NCO, + snd_soc_component_update_bits(component, WM8904_FLL_NCO_TEST_1, WM8904_FLL_FRC_NCO, val); - snd_soc_update_bits(codec, WM8904_CONTROL_INTERFACE_TEST_1, + snd_soc_component_update_bits(component, WM8904_CONTROL_INTERFACE_TEST_1, WM8904_USER_KEY, 0);

switch (fll_id) { case WM8904_FLL_MCLK: - snd_soc_update_bits(codec, WM8904_FLL_CONTROL_5, + snd_soc_component_update_bits(component, WM8904_FLL_CONTROL_5, WM8904_FLL_CLK_REF_SRC_MASK, 0); break;

case WM8904_FLL_LRCLK: - snd_soc_update_bits(codec, WM8904_FLL_CONTROL_5, + snd_soc_component_update_bits(component, WM8904_FLL_CONTROL_5, WM8904_FLL_CLK_REF_SRC_MASK, 1); break;

case WM8904_FLL_BCLK: - snd_soc_update_bits(codec, WM8904_FLL_CONTROL_5, + snd_soc_component_update_bits(component, WM8904_FLL_CONTROL_5, WM8904_FLL_CLK_REF_SRC_MASK, 2); break; } @@ -1776,39 +1776,39 @@ static int wm8904_set_fll(struct snd_soc_dai *dai, int fll_id, int source, val = WM8904_FLL_FRACN_ENA; else val = 0; - snd_soc_update_bits(codec, WM8904_FLL_CONTROL_1, + snd_soc_component_update_bits(component, WM8904_FLL_CONTROL_1, WM8904_FLL_FRACN_ENA, val);

- snd_soc_update_bits(codec, WM8904_FLL_CONTROL_2, + snd_soc_component_update_bits(component, WM8904_FLL_CONTROL_2, WM8904_FLL_OUTDIV_MASK | WM8904_FLL_FRATIO_MASK, (fll_div.fll_outdiv << WM8904_FLL_OUTDIV_SHIFT) | (fll_div.fll_fratio << WM8904_FLL_FRATIO_SHIFT));

- snd_soc_write(codec, WM8904_FLL_CONTROL_3, fll_div.k); + snd_soc_component_write(component, WM8904_FLL_CONTROL_3, fll_div.k);

- snd_soc_update_bits(codec, WM8904_FLL_CONTROL_4, WM8904_FLL_N_MASK, + snd_soc_component_update_bits(component, WM8904_FLL_CONTROL_4, WM8904_FLL_N_MASK, fll_div.n << WM8904_FLL_N_SHIFT);

- snd_soc_update_bits(codec, WM8904_FLL_CONTROL_5, + snd_soc_component_update_bits(component, WM8904_FLL_CONTROL_5, WM8904_FLL_CLK_REF_DIV_MASK, fll_div.fll_clk_ref_div << WM8904_FLL_CLK_REF_DIV_SHIFT);

- dev_dbg(codec->dev, "FLL configured for %dHz->%dHz\n", Fref, Fout); + dev_dbg(component->dev, "FLL configured for %dHz->%dHz\n", Fref, Fout);

wm8904->fll_fref = Fref; wm8904->fll_fout = Fout; wm8904->fll_src = source;

/* Enable the FLL if it was previously active */ - snd_soc_update_bits(codec, WM8904_FLL_CONTROL_1, + snd_soc_component_update_bits(component, WM8904_FLL_CONTROL_1, WM8904_FLL_OSC_ENA, fll1); - snd_soc_update_bits(codec, WM8904_FLL_CONTROL_1, + snd_soc_component_update_bits(component, WM8904_FLL_CONTROL_1, WM8904_FLL_ENA, fll1);

out: /* Reenable SYSCLK if it was previously active */ - snd_soc_update_bits(codec, WM8904_CLOCK_RATES_2, + snd_soc_component_update_bits(component, WM8904_CLOCK_RATES_2, WM8904_CLK_SYS_ENA, clock2);

return 0; @@ -1816,7 +1816,7 @@ static int wm8904_set_fll(struct snd_soc_dai *dai, int fll_id, int source,

static int wm8904_digital_mute(struct snd_soc_dai *codec_dai, int mute) { - struct snd_soc_codec *codec = codec_dai->codec; + struct snd_soc_component *component = codec_dai->component; int val;

if (mute) @@ -1824,15 +1824,15 @@ static int wm8904_digital_mute(struct snd_soc_dai *codec_dai, int mute) else val = 0;

- snd_soc_update_bits(codec, WM8904_DAC_DIGITAL_1, WM8904_DAC_MUTE, val); + snd_soc_component_update_bits(component, WM8904_DAC_DIGITAL_1, WM8904_DAC_MUTE, val);

return 0; }

-static int wm8904_set_bias_level(struct snd_soc_codec *codec, +static int wm8904_set_bias_level(struct snd_soc_component *component, enum snd_soc_bias_level level) { - struct wm8904_priv *wm8904 = snd_soc_codec_get_drvdata(codec); + struct wm8904_priv *wm8904 = snd_soc_component_get_drvdata(component); int ret;

switch (level) { @@ -1844,21 +1844,21 @@ static int wm8904_set_bias_level(struct snd_soc_codec *codec,

case SND_SOC_BIAS_PREPARE: /* VMID resistance 2*50k */ - snd_soc_update_bits(codec, WM8904_VMID_CONTROL_0, + snd_soc_component_update_bits(component, WM8904_VMID_CONTROL_0, WM8904_VMID_RES_MASK, 0x1 << WM8904_VMID_RES_SHIFT);

/* Normal bias current */ - snd_soc_update_bits(codec, WM8904_BIAS_CONTROL_0, + snd_soc_component_update_bits(component, WM8904_BIAS_CONTROL_0, WM8904_ISEL_MASK, 2 << WM8904_ISEL_SHIFT); break;

case SND_SOC_BIAS_STANDBY: - if (snd_soc_codec_get_bias_level(codec) == SND_SOC_BIAS_OFF) { + if (snd_soc_component_get_bias_level(component) == SND_SOC_BIAS_OFF) { ret = regulator_bulk_enable(ARRAY_SIZE(wm8904->supplies), wm8904->supplies); if (ret != 0) { - dev_err(codec->dev, + dev_err(component->dev, "Failed to enable supplies: %d\n", ret); return ret; @@ -1868,11 +1868,11 @@ static int wm8904_set_bias_level(struct snd_soc_codec *codec, regcache_sync(wm8904->regmap);

/* Enable bias */ - snd_soc_update_bits(codec, WM8904_BIAS_CONTROL_0, + snd_soc_component_update_bits(component, WM8904_BIAS_CONTROL_0, WM8904_BIAS_ENA, WM8904_BIAS_ENA);

/* Enable VMID, VMID buffering, 2*5k resistance */ - snd_soc_update_bits(codec, WM8904_VMID_CONTROL_0, + snd_soc_component_update_bits(component, WM8904_VMID_CONTROL_0, WM8904_VMID_ENA | WM8904_VMID_RES_MASK, WM8904_VMID_ENA | @@ -1883,22 +1883,22 @@ static int wm8904_set_bias_level(struct snd_soc_codec *codec, }

/* Maintain VMID with 2*250k */ - snd_soc_update_bits(codec, WM8904_VMID_CONTROL_0, + snd_soc_component_update_bits(component, WM8904_VMID_CONTROL_0, WM8904_VMID_RES_MASK, 0x2 << WM8904_VMID_RES_SHIFT);

/* Bias current *0.5 */ - snd_soc_update_bits(codec, WM8904_BIAS_CONTROL_0, + snd_soc_component_update_bits(component, WM8904_BIAS_CONTROL_0, WM8904_ISEL_MASK, 0); break;

case SND_SOC_BIAS_OFF: /* Turn off VMID */ - snd_soc_update_bits(codec, WM8904_VMID_CONTROL_0, + snd_soc_component_update_bits(component, WM8904_VMID_CONTROL_0, WM8904_VMID_RES_MASK | WM8904_VMID_ENA, 0);

/* Stop bias generation */ - snd_soc_update_bits(codec, WM8904_BIAS_CONTROL_0, + snd_soc_component_update_bits(component, WM8904_BIAS_CONTROL_0, WM8904_BIAS_ENA, 0);

regcache_cache_only(wm8904->regmap, true); @@ -1946,9 +1946,9 @@ static int wm8904_set_bias_level(struct snd_soc_codec *codec, .symmetric_rates = 1, };

-static void wm8904_handle_retune_mobile_pdata(struct snd_soc_codec *codec) +static void wm8904_handle_retune_mobile_pdata(struct snd_soc_component *component) { - struct wm8904_priv *wm8904 = snd_soc_codec_get_drvdata(codec); + struct wm8904_priv *wm8904 = snd_soc_component_get_drvdata(component); struct wm8904_pdata *pdata = wm8904->pdata; struct snd_kcontrol_new control = SOC_ENUM_EXT("EQ Mode", @@ -1991,31 +1991,31 @@ static void wm8904_handle_retune_mobile_pdata(struct snd_soc_codec *codec) wm8904->retune_mobile_texts = t; }

- dev_dbg(codec->dev, "Allocated %d unique ReTune Mobile names\n", + dev_dbg(component->dev, "Allocated %d unique ReTune Mobile names\n", wm8904->num_retune_mobile_texts);

wm8904->retune_mobile_enum.items = wm8904->num_retune_mobile_texts; wm8904->retune_mobile_enum.texts = wm8904->retune_mobile_texts;

- ret = snd_soc_add_codec_controls(codec, &control, 1); + ret = snd_soc_add_component_controls(component, &control, 1); if (ret != 0) - dev_err(codec->dev, + dev_err(component->dev, "Failed to add ReTune Mobile control: %d\n", ret); }

-static void wm8904_handle_pdata(struct snd_soc_codec *codec) +static void wm8904_handle_pdata(struct snd_soc_component *component) { - struct wm8904_priv *wm8904 = snd_soc_codec_get_drvdata(codec); + struct wm8904_priv *wm8904 = snd_soc_component_get_drvdata(component); struct wm8904_pdata *pdata = wm8904->pdata; int ret, i;

if (!pdata) { - snd_soc_add_codec_controls(codec, wm8904_eq_controls, + snd_soc_add_component_controls(component, wm8904_eq_controls, ARRAY_SIZE(wm8904_eq_controls)); return; }

- dev_dbg(codec->dev, "%d DRC configurations\n", pdata->num_drc_cfgs); + dev_dbg(component->dev, "%d DRC configurations\n", pdata->num_drc_cfgs);

if (pdata->num_drc_cfgs) { struct snd_kcontrol_new control = @@ -2034,28 +2034,28 @@ static void wm8904_handle_pdata(struct snd_soc_codec *codec) wm8904->drc_enum.items = pdata->num_drc_cfgs; wm8904->drc_enum.texts = wm8904->drc_texts;

- ret = snd_soc_add_codec_controls(codec, &control, 1); + ret = snd_soc_add_component_controls(component, &control, 1); if (ret != 0) - dev_err(codec->dev, + dev_err(component->dev, "Failed to add DRC mode control: %d\n", ret);

- wm8904_set_drc(codec); + wm8904_set_drc(component); }

- dev_dbg(codec->dev, "%d ReTune Mobile configurations\n", + dev_dbg(component->dev, "%d ReTune Mobile configurations\n", pdata->num_retune_mobile_cfgs);

if (pdata->num_retune_mobile_cfgs) - wm8904_handle_retune_mobile_pdata(codec); + wm8904_handle_retune_mobile_pdata(component); else - snd_soc_add_codec_controls(codec, wm8904_eq_controls, + snd_soc_add_component_controls(component, wm8904_eq_controls, ARRAY_SIZE(wm8904_eq_controls)); }

-static int wm8904_probe(struct snd_soc_codec *codec) +static int wm8904_probe(struct snd_soc_component *component) { - struct wm8904_priv *wm8904 = snd_soc_codec_get_drvdata(codec); + struct wm8904_priv *wm8904 = snd_soc_component_get_drvdata(component);

switch (wm8904->devtype) { case WM8904: @@ -2064,33 +2064,33 @@ static int wm8904_probe(struct snd_soc_codec *codec) memset(&wm8904_dai.capture, 0, sizeof(wm8904_dai.capture)); break; default: - dev_err(codec->dev, "Unknown device type %d\n", + dev_err(component->dev, "Unknown device type %d\n", wm8904->devtype); return -EINVAL; }

- wm8904_handle_pdata(codec); + wm8904_handle_pdata(component);

- wm8904_add_widgets(codec); + wm8904_add_widgets(component);

return 0; }

-static int wm8904_remove(struct snd_soc_codec *codec) +static void wm8904_remove(struct snd_soc_component *component) { - struct wm8904_priv *wm8904 = snd_soc_codec_get_drvdata(codec); + struct wm8904_priv *wm8904 = snd_soc_component_get_drvdata(component);

kfree(wm8904->retune_mobile_texts); kfree(wm8904->drc_texts); - - return 0; }

-static const struct snd_soc_codec_driver soc_codec_dev_wm8904 = { - .probe = wm8904_probe, - .remove = wm8904_remove, - .set_bias_level = wm8904_set_bias_level, - .idle_bias_off = true, +static const struct snd_soc_component_driver soc_component_dev_wm8904 = { + .probe = wm8904_probe, + .remove = wm8904_remove, + .set_bias_level = wm8904_set_bias_level, + .pmdown_time = 1, + .endianness = 1, + .non_legacy_dai_naming = 1, };

static const struct regmap_config wm8904_regmap = { @@ -2265,8 +2265,8 @@ static int wm8904_i2c_probe(struct i2c_client *i2c, regcache_cache_only(wm8904->regmap, true); regulator_bulk_disable(ARRAY_SIZE(wm8904->supplies), wm8904->supplies);

- ret = snd_soc_register_codec(&i2c->dev, - &soc_codec_dev_wm8904, &wm8904_dai, 1); + ret = devm_snd_soc_register_component(&i2c->dev, + &soc_component_dev_wm8904, &wm8904_dai, 1); if (ret != 0) return ret;

@@ -2277,12 +2277,6 @@ static int wm8904_i2c_probe(struct i2c_client *i2c, return ret; }

-static int wm8904_i2c_remove(struct i2c_client *client) -{ - snd_soc_unregister_codec(&client->dev); - return 0; -} - static const struct i2c_device_id wm8904_i2c_id[] = { { "wm8904", WM8904 }, { "wm8912", WM8912 }, @@ -2297,7 +2291,6 @@ static int wm8904_i2c_remove(struct i2c_client *client) .of_match_table = of_match_ptr(wm8904_of_match), }, .probe = wm8904_i2c_probe, - .remove = wm8904_i2c_remove, .id_table = wm8904_i2c_id, };

From: Kuninori Morimoto kuninori.morimoto.gx@renesas.com

Now we can replace Codec to Component. Let's do it.

Note: xxx_codec_xxx() -> xxx_component_xxx() .idle_bias_off = 0 -> .idle_bias_on = 1 .ignore_pmdown_time = 0 -> .pmdown_time = 1 - -> .endianness = 1 - -> .non_legacy_dai_naming = 1

Signed-off-by: Kuninori Morimoto kuninori.morimoto.gx@renesas.com --- sound/soc/codecs/wm9090.c | 109 ++++++++++++++++++++++------------------------ 1 file changed, 53 insertions(+), 56 deletions(-)

diff --git a/sound/soc/codecs/wm9090.c b/sound/soc/codecs/wm9090.c index 5a13138..9cd5f93 100644 --- a/sound/soc/codecs/wm9090.c +++ b/sound/soc/codecs/wm9090.c @@ -143,23 +143,23 @@ static bool wm9090_readable(struct device *dev, unsigned int reg) } }

-static void wait_for_dc_servo(struct snd_soc_codec *codec) +static void wait_for_dc_servo(struct snd_soc_component *component) { unsigned int reg; int count = 0;

- dev_dbg(codec->dev, "Waiting for DC servo...\n"); + dev_dbg(component->dev, "Waiting for DC servo...\n"); do { count++; msleep(1); - reg = snd_soc_read(codec, WM9090_DC_SERVO_READBACK_0); - dev_dbg(codec->dev, "DC servo status: %x\n", reg); + reg = snd_soc_component_read32(component, WM9090_DC_SERVO_READBACK_0); + dev_dbg(component->dev, "DC servo status: %x\n", reg); } while ((reg & WM9090_DCS_CAL_COMPLETE_MASK) != WM9090_DCS_CAL_COMPLETE_MASK && count < 1000);

if ((reg & WM9090_DCS_CAL_COMPLETE_MASK) != WM9090_DCS_CAL_COMPLETE_MASK) - dev_err(codec->dev, "Timed out waiting for DC Servo\n"); + dev_err(component->dev, "Timed out waiting for DC Servo\n"); }

static const DECLARE_TLV_DB_RANGE(in_tlv, @@ -251,22 +251,22 @@ static const DECLARE_TLV_DB_RANGE(spkboost_tlv, static int hp_ev(struct snd_soc_dapm_widget *w, struct snd_kcontrol *kcontrol, int event) { - struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm); - unsigned int reg = snd_soc_read(codec, WM9090_ANALOGUE_HP_0); + struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm); + unsigned int reg = snd_soc_component_read32(component, WM9090_ANALOGUE_HP_0);

switch (event) { case SND_SOC_DAPM_POST_PMU: - snd_soc_update_bits(codec, WM9090_CHARGE_PUMP_1, + snd_soc_component_update_bits(component, WM9090_CHARGE_PUMP_1, WM9090_CP_ENA, WM9090_CP_ENA);

msleep(5);

- snd_soc_update_bits(codec, WM9090_POWER_MANAGEMENT_1, + snd_soc_component_update_bits(component, WM9090_POWER_MANAGEMENT_1, WM9090_HPOUT1L_ENA | WM9090_HPOUT1R_ENA, WM9090_HPOUT1L_ENA | WM9090_HPOUT1R_ENA);

reg |= WM9090_HPOUT1L_DLY | WM9090_HPOUT1R_DLY; - snd_soc_write(codec, WM9090_ANALOGUE_HP_0, reg); + snd_soc_component_write(component, WM9090_ANALOGUE_HP_0, reg);

/* Start the DC servo. We don't currently use the * ability to save the state since we don't have full @@ -274,16 +274,16 @@ static int hp_ev(struct snd_soc_dapm_widget *w, * DC offsets; see the WM8904 driver for an example of * doing so. */ - snd_soc_write(codec, WM9090_DC_SERVO_0, + snd_soc_component_write(component, WM9090_DC_SERVO_0, WM9090_DCS_ENA_CHAN_0 | WM9090_DCS_ENA_CHAN_1 | WM9090_DCS_TRIG_STARTUP_1 | WM9090_DCS_TRIG_STARTUP_0); - wait_for_dc_servo(codec); + wait_for_dc_servo(component);

reg |= WM9090_HPOUT1R_OUTP | WM9090_HPOUT1R_RMV_SHORT | WM9090_HPOUT1L_OUTP | WM9090_HPOUT1L_RMV_SHORT; - snd_soc_write(codec, WM9090_ANALOGUE_HP_0, reg); + snd_soc_component_write(component, WM9090_ANALOGUE_HP_0, reg); break;

case SND_SOC_DAPM_PRE_PMD: @@ -294,15 +294,15 @@ static int hp_ev(struct snd_soc_dapm_widget *w, WM9090_HPOUT1R_DLY | WM9090_HPOUT1R_OUTP);

- snd_soc_write(codec, WM9090_ANALOGUE_HP_0, reg); + snd_soc_component_write(component, WM9090_ANALOGUE_HP_0, reg);

- snd_soc_write(codec, WM9090_DC_SERVO_0, 0); + snd_soc_component_write(component, WM9090_DC_SERVO_0, 0);

- snd_soc_update_bits(codec, WM9090_POWER_MANAGEMENT_1, + snd_soc_component_update_bits(component, WM9090_POWER_MANAGEMENT_1, WM9090_HPOUT1L_ENA | WM9090_HPOUT1R_ENA, 0);

- snd_soc_update_bits(codec, WM9090_CHARGE_PUMP_1, + snd_soc_component_update_bits(component, WM9090_CHARGE_PUMP_1, WM9090_CP_ENA, 0); break; } @@ -419,10 +419,10 @@ static int hp_ev(struct snd_soc_dapm_widget *w, { "IN2A PGA", NULL, "IN2-" }, };

-static int wm9090_add_controls(struct snd_soc_codec *codec) +static int wm9090_add_controls(struct snd_soc_component *component) { - struct wm9090_priv *wm9090 = snd_soc_codec_get_drvdata(codec); - struct snd_soc_dapm_context *dapm = snd_soc_codec_get_dapm(codec); + struct wm9090_priv *wm9090 = snd_soc_component_get_drvdata(component); + struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(component); int i;

snd_soc_dapm_new_controls(dapm, wm9090_dapm_widgets, @@ -430,7 +430,7 @@ static int wm9090_add_controls(struct snd_soc_codec *codec)

snd_soc_dapm_add_routes(dapm, audio_map, ARRAY_SIZE(audio_map));

- snd_soc_add_codec_controls(codec, wm9090_controls, + snd_soc_add_component_controls(component, wm9090_controls, ARRAY_SIZE(wm9090_controls));

if (wm9090->pdata.lin1_diff) { @@ -439,7 +439,7 @@ static int wm9090_add_controls(struct snd_soc_codec *codec) } else { snd_soc_dapm_add_routes(dapm, audio_map_in1_se, ARRAY_SIZE(audio_map_in1_se)); - snd_soc_add_codec_controls(codec, wm9090_in1_se_controls, + snd_soc_add_component_controls(component, wm9090_in1_se_controls, ARRAY_SIZE(wm9090_in1_se_controls)); }

@@ -449,18 +449,18 @@ static int wm9090_add_controls(struct snd_soc_codec *codec) } else { snd_soc_dapm_add_routes(dapm, audio_map_in2_se, ARRAY_SIZE(audio_map_in2_se)); - snd_soc_add_codec_controls(codec, wm9090_in2_se_controls, + snd_soc_add_component_controls(component, wm9090_in2_se_controls, ARRAY_SIZE(wm9090_in2_se_controls)); }

if (wm9090->pdata.agc_ena) { for (i = 0; i < ARRAY_SIZE(wm9090->pdata.agc); i++) - snd_soc_write(codec, WM9090_AGC_CONTROL_0 + i, + snd_soc_component_write(component, WM9090_AGC_CONTROL_0 + i, wm9090->pdata.agc[i]); - snd_soc_update_bits(codec, WM9090_POWER_MANAGEMENT_3, + snd_soc_component_update_bits(component, WM9090_POWER_MANAGEMENT_3, WM9090_AGC_ENA, WM9090_AGC_ENA); } else { - snd_soc_update_bits(codec, WM9090_POWER_MANAGEMENT_3, + snd_soc_component_update_bits(component, WM9090_POWER_MANAGEMENT_3, WM9090_AGC_ENA, 0); }

@@ -472,19 +472,19 @@ static int wm9090_add_controls(struct snd_soc_codec *codec) * The machine driver should call this from their set_bias_level; if there * isn't one then this can just be set as the set_bias_level function. */ -static int wm9090_set_bias_level(struct snd_soc_codec *codec, +static int wm9090_set_bias_level(struct snd_soc_component *component, enum snd_soc_bias_level level) { - struct wm9090_priv *wm9090 = snd_soc_codec_get_drvdata(codec); + struct wm9090_priv *wm9090 = snd_soc_component_get_drvdata(component);

switch (level) { case SND_SOC_BIAS_ON: break;

case SND_SOC_BIAS_PREPARE: - snd_soc_update_bits(codec, WM9090_ANTIPOP2, WM9090_VMID_ENA, + snd_soc_component_update_bits(component, WM9090_ANTIPOP2, WM9090_VMID_ENA, WM9090_VMID_ENA); - snd_soc_update_bits(codec, WM9090_POWER_MANAGEMENT_1, + snd_soc_component_update_bits(component, WM9090_POWER_MANAGEMENT_1, WM9090_BIAS_ENA | WM9090_VMID_RES_MASK, WM9090_BIAS_ENA | @@ -493,7 +493,7 @@ static int wm9090_set_bias_level(struct snd_soc_codec *codec, break;

case SND_SOC_BIAS_STANDBY: - if (snd_soc_codec_get_bias_level(codec) == SND_SOC_BIAS_OFF) { + if (snd_soc_component_get_bias_level(component) == SND_SOC_BIAS_OFF) { /* Restore the register cache */ regcache_sync(wm9090->regmap); } @@ -502,9 +502,9 @@ static int wm9090_set_bias_level(struct snd_soc_codec *codec, * ground referenced outputs and class D speaker mean that * latency is not an issue. */ - snd_soc_update_bits(codec, WM9090_POWER_MANAGEMENT_1, + snd_soc_component_update_bits(component, WM9090_POWER_MANAGEMENT_1, WM9090_BIAS_ENA | WM9090_VMID_RES_MASK, 0); - snd_soc_update_bits(codec, WM9090_ANTIPOP2, + snd_soc_component_update_bits(component, WM9090_ANTIPOP2, WM9090_VMID_ENA, 0); break;

@@ -515,45 +515,49 @@ static int wm9090_set_bias_level(struct snd_soc_codec *codec, return 0; }

-static int wm9090_probe(struct snd_soc_codec *codec) +static int wm9090_probe(struct snd_soc_component *component) { /* Configure some defaults; they will be written out when we * bring the bias up. */ - snd_soc_update_bits(codec, WM9090_IN1_LINE_INPUT_A_VOLUME, + snd_soc_component_update_bits(component, WM9090_IN1_LINE_INPUT_A_VOLUME, WM9090_IN1_VU | WM9090_IN1A_ZC, WM9090_IN1_VU | WM9090_IN1A_ZC); - snd_soc_update_bits(codec, WM9090_IN1_LINE_INPUT_B_VOLUME, + snd_soc_component_update_bits(component, WM9090_IN1_LINE_INPUT_B_VOLUME, WM9090_IN1_VU | WM9090_IN1B_ZC, WM9090_IN1_VU | WM9090_IN1B_ZC); - snd_soc_update_bits(codec, WM9090_IN2_LINE_INPUT_A_VOLUME, + snd_soc_component_update_bits(component, WM9090_IN2_LINE_INPUT_A_VOLUME, WM9090_IN2_VU | WM9090_IN2A_ZC, WM9090_IN2_VU | WM9090_IN2A_ZC); - snd_soc_update_bits(codec, WM9090_IN2_LINE_INPUT_B_VOLUME, + snd_soc_component_update_bits(component, WM9090_IN2_LINE_INPUT_B_VOLUME, WM9090_IN2_VU | WM9090_IN2B_ZC, WM9090_IN2_VU | WM9090_IN2B_ZC); - snd_soc_update_bits(codec, WM9090_SPEAKER_VOLUME_LEFT, + snd_soc_component_update_bits(component, WM9090_SPEAKER_VOLUME_LEFT, WM9090_SPKOUT_VU | WM9090_SPKOUTL_ZC, WM9090_SPKOUT_VU | WM9090_SPKOUTL_ZC); - snd_soc_update_bits(codec, WM9090_LEFT_OUTPUT_VOLUME, + snd_soc_component_update_bits(component, WM9090_LEFT_OUTPUT_VOLUME, WM9090_HPOUT1_VU | WM9090_HPOUT1L_ZC, WM9090_HPOUT1_VU | WM9090_HPOUT1L_ZC); - snd_soc_update_bits(codec, WM9090_RIGHT_OUTPUT_VOLUME, + snd_soc_component_update_bits(component, WM9090_RIGHT_OUTPUT_VOLUME, WM9090_HPOUT1_VU | WM9090_HPOUT1R_ZC, WM9090_HPOUT1_VU | WM9090_HPOUT1R_ZC);

- snd_soc_update_bits(codec, WM9090_CLOCKING_1, + snd_soc_component_update_bits(component, WM9090_CLOCKING_1, WM9090_TOCLK_ENA, WM9090_TOCLK_ENA);

- wm9090_add_controls(codec); + wm9090_add_controls(component);

return 0; }

-static const struct snd_soc_codec_driver soc_codec_dev_wm9090 = { - .probe = wm9090_probe, - .set_bias_level = wm9090_set_bias_level, - .suspend_bias_off = true, +static const struct snd_soc_component_driver soc_component_dev_wm9090 = { + .probe = wm9090_probe, + .set_bias_level = wm9090_set_bias_level, + .suspend_bias_off = 1, + .idle_bias_on = 1, + .pmdown_time = 1, + .endianness = 1, + .non_legacy_dai_naming = 1, };

static const struct regmap_config wm9090_regmap = { @@ -607,8 +611,8 @@ static int wm9090_i2c_probe(struct i2c_client *i2c,

i2c_set_clientdata(i2c, wm9090);

- ret = snd_soc_register_codec(&i2c->dev, - &soc_codec_dev_wm9090, NULL, 0); + ret = devm_snd_soc_register_component(&i2c->dev, + &soc_component_dev_wm9090, NULL, 0); if (ret != 0) { dev_err(&i2c->dev, "Failed to register CODEC: %d\n", ret); return ret; @@ -617,12 +621,6 @@ static int wm9090_i2c_probe(struct i2c_client *i2c, return 0; }

-static int wm9090_i2c_remove(struct i2c_client *i2c) -{ - snd_soc_unregister_codec(&i2c->dev); - return 0; -} - static const struct i2c_device_id wm9090_id[] = { { "wm9090", 0 }, { "wm9093", 0 }, @@ -635,7 +633,6 @@ static int wm9090_i2c_remove(struct i2c_client *i2c) .name = "wm9090", }, .probe = wm9090_i2c_probe, - .remove = wm9090_i2c_remove, .id_table = wm9090_id, };

From: Kuninori Morimoto kuninori.morimoto.gx@renesas.com

Now we can replace Codec to Component. Let's do it.

Note: xxx_codec_xxx() -> xxx_component_xxx() .idle_bias_off = 0 -> .idle_bias_on = 1 .ignore_pmdown_time = 0 -> .pmdown_time = 1 - -> .endianness = 1 - -> .non_legacy_dai_naming = 1

Signed-off-by: Kuninori Morimoto kuninori.morimoto.gx@renesas.com --- sound/soc/codecs/wm9712.c | 109 ++++++++++++++++++++++------------------------ 1 file changed, 51 insertions(+), 58 deletions(-)

diff --git a/sound/soc/codecs/wm9712.c b/sound/soc/codecs/wm9712.c index 4f6d1a4..d5ae120 100644 --- a/sound/soc/codecs/wm9712.c +++ b/sound/soc/codecs/wm9712.c @@ -220,8 +220,8 @@ static int wm9712_hp_mixer_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kcontrol); - struct snd_soc_codec *codec = snd_soc_dapm_to_codec(dapm); - struct wm9712_priv *wm9712 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = snd_soc_dapm_to_component(dapm); + struct wm9712_priv *wm9712 = snd_soc_component_get_drvdata(component); unsigned int val = ucontrol->value.integer.value[0]; struct soc_mixer_control *mc = (struct soc_mixer_control *)kcontrol->private_value; @@ -264,8 +264,8 @@ static int wm9712_hp_mixer_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kcontrol); - struct snd_soc_codec *codec = snd_soc_dapm_to_codec(dapm); - struct wm9712_priv *wm9712 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = snd_soc_dapm_to_component(dapm); + struct wm9712_priv *wm9712 = snd_soc_component_get_drvdata(component); struct soc_mixer_control *mc = (struct soc_mixer_control *)kcontrol->private_value; unsigned int shift, mixer; @@ -527,33 +527,33 @@ static int wm9712_hp_mixer_get(struct snd_kcontrol *kcontrol, static int ac97_prepare(struct snd_pcm_substream *substream, struct snd_soc_dai *dai) { - struct snd_soc_codec *codec = dai->codec; + struct snd_soc_component *component = dai->component; int reg; struct snd_pcm_runtime *runtime = substream->runtime;

- snd_soc_update_bits(codec, AC97_EXTENDED_STATUS, 0x1, 0x1); + snd_soc_component_update_bits(component, AC97_EXTENDED_STATUS, 0x1, 0x1);

if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) reg = AC97_PCM_FRONT_DAC_RATE; else reg = AC97_PCM_LR_ADC_RATE;

- return snd_soc_write(codec, reg, runtime->rate); + return snd_soc_component_write(component, reg, runtime->rate); }

static int ac97_aux_prepare(struct snd_pcm_substream *substream, struct snd_soc_dai *dai) { - struct snd_soc_codec *codec = dai->codec; + struct snd_soc_component *component = dai->component; struct snd_pcm_runtime *runtime = substream->runtime;

- snd_soc_update_bits(codec, AC97_EXTENDED_STATUS, 0x1, 0x1); - snd_soc_update_bits(codec, AC97_PCI_SID, 0x8000, 0x8000); + snd_soc_component_update_bits(component, AC97_EXTENDED_STATUS, 0x1, 0x1); + snd_soc_component_update_bits(component, AC97_PCI_SID, 0x8000, 0x8000);

if (substream->stream != SNDRV_PCM_STREAM_PLAYBACK) return -ENODEV;

- return snd_soc_write(codec, AC97_PCM_SURR_DAC_RATE, runtime->rate); + return snd_soc_component_write(component, AC97_PCM_SURR_DAC_RATE, runtime->rate); }

#define WM9712_AC97_RATES (SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_11025 |\ @@ -597,7 +597,7 @@ static int ac97_aux_prepare(struct snd_pcm_substream *substream, } };

-static int wm9712_set_bias_level(struct snd_soc_codec *codec, +static int wm9712_set_bias_level(struct snd_soc_component *component, enum snd_soc_bias_level level) { switch (level) { @@ -605,20 +605,20 @@ static int wm9712_set_bias_level(struct snd_soc_codec *codec, case SND_SOC_BIAS_PREPARE: break; case SND_SOC_BIAS_STANDBY: - snd_soc_write(codec, AC97_POWERDOWN, 0x0000); + snd_soc_component_write(component, AC97_POWERDOWN, 0x0000); break; case SND_SOC_BIAS_OFF: /* disable everything including AC link */ - snd_soc_write(codec, AC97_EXTENDED_MSTATUS, 0xffff); - snd_soc_write(codec, AC97_POWERDOWN, 0xffff); + snd_soc_component_write(component, AC97_EXTENDED_MSTATUS, 0xffff); + snd_soc_component_write(component, AC97_POWERDOWN, 0xffff); break; } return 0; }

-static int wm9712_soc_resume(struct snd_soc_codec *codec) +static int wm9712_soc_resume(struct snd_soc_component *component) { - struct wm9712_priv *wm9712 = snd_soc_codec_get_drvdata(codec); + struct wm9712_priv *wm9712 = snd_soc_component_get_drvdata(component); int ret;

ret = snd_ac97_reset(wm9712->ac97, true, WM9712_VENDOR_ID, @@ -626,17 +626,17 @@ static int wm9712_soc_resume(struct snd_soc_codec *codec) if (ret < 0) return ret;

- snd_soc_codec_force_bias_level(codec, SND_SOC_BIAS_STANDBY); + snd_soc_component_force_bias_level(component, SND_SOC_BIAS_STANDBY);

if (ret == 0) - regcache_sync(codec->component.regmap); + snd_soc_component_cache_sync(component);

return ret; }

-static int wm9712_soc_probe(struct snd_soc_codec *codec) +static int wm9712_soc_probe(struct snd_soc_component *component) { - struct wm9712_priv *wm9712 = snd_soc_codec_get_drvdata(codec); + struct wm9712_priv *wm9712 = snd_soc_component_get_drvdata(component); struct regmap *regmap; int ret;

@@ -645,59 +645,59 @@ static int wm9712_soc_probe(struct snd_soc_codec *codec) regmap = wm9712->mfd_pdata->regmap; } else { #ifdef CONFIG_SND_SOC_AC97_BUS - wm9712->ac97 = snd_soc_new_ac97_codec(codec, WM9712_VENDOR_ID, + wm9712->ac97 = snd_soc_new_ac97_component(component, WM9712_VENDOR_ID, WM9712_VENDOR_ID_MASK); if (IS_ERR(wm9712->ac97)) { ret = PTR_ERR(wm9712->ac97); - dev_err(codec->dev, + dev_err(component->dev, "Failed to register AC97 codec: %d\n", ret); return ret; }

regmap = regmap_init_ac97(wm9712->ac97, &wm9712_regmap_config); if (IS_ERR(regmap)) { - snd_soc_free_ac97_codec(wm9712->ac97); + snd_soc_free_ac97_component(wm9712->ac97); return PTR_ERR(regmap); } #endif }

- snd_soc_codec_init_regmap(codec, regmap); + snd_soc_component_init_regmap(component, regmap);

/* set alc mux to none */ - snd_soc_update_bits(codec, AC97_VIDEO, 0x3000, 0x3000); + snd_soc_component_update_bits(component, AC97_VIDEO, 0x3000, 0x3000);

return 0; }

-static int wm9712_soc_remove(struct snd_soc_codec *codec) +static void wm9712_soc_remove(struct snd_soc_component *component) { #ifdef CONFIG_SND_SOC_AC97_BUS - struct wm9712_priv *wm9712 = snd_soc_codec_get_drvdata(codec); + struct wm9712_priv *wm9712 = snd_soc_component_get_drvdata(component);

if (!wm9712->mfd_pdata) { - snd_soc_codec_exit_regmap(codec); - snd_soc_free_ac97_codec(wm9712->ac97); + snd_soc_component_exit_regmap(component); + snd_soc_free_ac97_component(wm9712->ac97); } #endif - return 0; }

-static const struct snd_soc_codec_driver soc_codec_dev_wm9712 = { - .probe = wm9712_soc_probe, - .remove = wm9712_soc_remove, - .resume = wm9712_soc_resume, - .set_bias_level = wm9712_set_bias_level, - .suspend_bias_off = true, - - .component_driver = { - .controls = wm9712_snd_ac97_controls, - .num_controls = ARRAY_SIZE(wm9712_snd_ac97_controls), - .dapm_widgets = wm9712_dapm_widgets, - .num_dapm_widgets = ARRAY_SIZE(wm9712_dapm_widgets), - .dapm_routes = wm9712_audio_map, - .num_dapm_routes = ARRAY_SIZE(wm9712_audio_map), - }, +static const struct snd_soc_component_driver soc_component_dev_wm9712 = { + .probe = wm9712_soc_probe, + .remove = wm9712_soc_remove, + .resume = wm9712_soc_resume, + .set_bias_level = wm9712_set_bias_level, + .controls = wm9712_snd_ac97_controls, + .num_controls = ARRAY_SIZE(wm9712_snd_ac97_controls), + .dapm_widgets = wm9712_dapm_widgets, + .num_dapm_widgets = ARRAY_SIZE(wm9712_dapm_widgets), + .dapm_routes = wm9712_audio_map, + .num_dapm_routes = ARRAY_SIZE(wm9712_audio_map), + .suspend_bias_off = 1, + .idle_bias_on = 1, + .pmdown_time = 1, + .endianness = 1, + .non_legacy_dai_naming = 1, };

static int wm9712_probe(struct platform_device *pdev) @@ -713,26 +713,19 @@ static int wm9712_probe(struct platform_device *pdev) wm9712->mfd_pdata = dev_get_platdata(&pdev->dev); platform_set_drvdata(pdev, wm9712);

- return snd_soc_register_codec(&pdev->dev, - &soc_codec_dev_wm9712, wm9712_dai, ARRAY_SIZE(wm9712_dai)); -} - -static int wm9712_remove(struct platform_device *pdev) -{ - snd_soc_unregister_codec(&pdev->dev); - return 0; + return devm_snd_soc_register_component(&pdev->dev, + &soc_component_dev_wm9712, wm9712_dai, ARRAY_SIZE(wm9712_dai)); }

-static struct platform_driver wm9712_codec_driver = { +static struct platform_driver wm9712_component_driver = { .driver = { - .name = "wm9712-codec", + .name = "wm9712-component", },

.probe = wm9712_probe, - .remove = wm9712_remove, };

-module_platform_driver(wm9712_codec_driver); +module_platform_driver(wm9712_component_driver);

MODULE_DESCRIPTION("ASoC WM9711/WM9712 driver"); MODULE_AUTHOR("Liam Girdwood");

From: Kuninori Morimoto kuninori.morimoto.gx@renesas.com

Now we can replace Codec to Component. Let's do it.

Note: xxx_codec_xxx() -> xxx_component_xxx() .idle_bias_off = 0 -> .idle_bias_on = 1 .ignore_pmdown_time = 0 -> .pmdown_time = 1 - -> .endianness = 1 - -> .non_legacy_dai_naming = 1

Signed-off-by: Kuninori Morimoto kuninori.morimoto.gx@renesas.com --- sound/soc/codecs/max9867.c | 65 +++++++++++++++++++++------------------------- sound/soc/codecs/max9867.h | 2 +- 2 files changed, 31 insertions(+), 36 deletions(-)

diff --git a/sound/soc/codecs/max9867.c b/sound/soc/codecs/max9867.c index 2f60924..2b96ebc 100644 --- a/sound/soc/codecs/max9867.c +++ b/sound/soc/codecs/max9867.c @@ -179,8 +179,8 @@ static inline int get_ni_value(int mclk, int rate) static int max9867_dai_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params, struct snd_soc_dai *dai) { - struct snd_soc_codec *codec = dai->codec; - struct max9867_priv *max9867 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = dai->component; + struct max9867_priv *max9867 = snd_soc_component_get_drvdata(component); unsigned int ni_h, ni_l; int value;

@@ -227,7 +227,7 @@ static int max9867_dai_hw_params(struct snd_pcm_substream *substream, bclk_value = MAX9867_IFC1B_PCLK_16; break; default: - dev_err(codec->dev, + dev_err(component->dev, "unsupported sampling rate\n"); return -EINVAL; } @@ -239,7 +239,7 @@ static int max9867_dai_hw_params(struct snd_pcm_substream *substream, bclk_value = MAX9867_IFC1B_32BIT; break; default: - dev_err(codec->dev, "unsupported sampling rate\n"); + dev_err(component->dev, "unsupported sampling rate\n"); return -EINVAL; } regmap_update_bits(max9867->regmap, MAX9867_IFC1B, @@ -251,8 +251,8 @@ static int max9867_dai_hw_params(struct snd_pcm_substream *substream, static int max9867_prepare(struct snd_pcm_substream *substream, struct snd_soc_dai *dai) { - struct snd_soc_codec *codec = dai->codec; - struct max9867_priv *max9867 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = dai->component; + struct max9867_priv *max9867 = snd_soc_component_get_drvdata(component);

regmap_update_bits(max9867->regmap, MAX9867_PWRMAN, MAX9867_SHTDOWN_MASK, MAX9867_SHTDOWN_MASK); @@ -261,8 +261,8 @@ static int max9867_prepare(struct snd_pcm_substream *substream,

static int max9867_mute(struct snd_soc_dai *dai, int mute) { - struct snd_soc_codec *codec = dai->codec; - struct max9867_priv *max9867 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = dai->component; + struct max9867_priv *max9867 = snd_soc_component_get_drvdata(component);

if (mute) regmap_update_bits(max9867->regmap, MAX9867_DACLEVEL, @@ -276,8 +276,8 @@ static int max9867_mute(struct snd_soc_dai *dai, int mute) static int max9867_set_dai_sysclk(struct snd_soc_dai *codec_dai, int clk_id, unsigned int freq, int dir) { - struct snd_soc_codec *codec = codec_dai->codec; - struct max9867_priv *max9867 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = codec_dai->component; + struct max9867_priv *max9867 = snd_soc_component_get_drvdata(component); int value = 0;

/* Set the prescaler based on the master clock frequency*/ @@ -306,8 +306,8 @@ static int max9867_set_dai_sysclk(struct snd_soc_dai *codec_dai, static int max9867_dai_set_fmt(struct snd_soc_dai *codec_dai, unsigned int fmt) { - struct snd_soc_codec *codec = codec_dai->codec; - struct max9867_priv *max9867 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = codec_dai->component; + struct max9867_priv *max9867 = snd_soc_component_get_drvdata(component); u8 iface1A = 0, iface1B = 0;

switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) { @@ -404,25 +404,27 @@ static int max9867_resume(struct device *dev) } #endif

-static int max9867_probe(struct snd_soc_codec *codec) +static int max9867_probe(struct snd_soc_component *component) { - struct max9867_priv *max9867 = snd_soc_codec_get_drvdata(codec); + struct max9867_priv *max9867 = snd_soc_component_get_drvdata(component);

- dev_dbg(codec->dev, "max98090_probe\n"); - max9867->codec = codec; + dev_dbg(component->dev, "max98090_probe\n"); + max9867->component = component; return 0; }

-static const struct snd_soc_codec_driver max9867_codec = { - .probe = max9867_probe, - .component_driver = { - .controls = max9867_snd_controls, - .num_controls = ARRAY_SIZE(max9867_snd_controls), - .dapm_routes = max9867_audio_map, - .num_dapm_routes = ARRAY_SIZE(max9867_audio_map), - .dapm_widgets = max9867_dapm_widgets, - .num_dapm_widgets = ARRAY_SIZE(max9867_dapm_widgets), - }, +static const struct snd_soc_component_driver max9867_component = { + .probe = max9867_probe, + .controls = max9867_snd_controls, + .num_controls = ARRAY_SIZE(max9867_snd_controls), + .dapm_routes = max9867_audio_map, + .num_dapm_routes = ARRAY_SIZE(max9867_audio_map), + .dapm_widgets = max9867_dapm_widgets, + .num_dapm_widgets = ARRAY_SIZE(max9867_dapm_widgets), + .idle_bias_on = 1, + .pmdown_time = 1, + .endianness = 1, + .non_legacy_dai_naming = 1, };

static bool max9867_volatile_register(struct device *dev, unsigned int reg) @@ -497,21 +499,15 @@ static int max9867_i2c_probe(struct i2c_client *i2c, return ret; } dev_info(&i2c->dev, "device revision: %x\n", reg); - ret = snd_soc_register_codec(&i2c->dev, &max9867_codec, + ret = devm_snd_soc_register_component(&i2c->dev, &max9867_component, max9867_dai, ARRAY_SIZE(max9867_dai)); if (ret < 0) { - dev_err(&i2c->dev, "Failed to register codec: %d\n", ret); + dev_err(&i2c->dev, "Failed to register component: %d\n", ret); return ret; } return ret; }

-static int max9867_i2c_remove(struct i2c_client *client) -{ - snd_soc_unregister_codec(&client->dev); - return 0; -} - static const struct i2c_device_id max9867_i2c_id[] = { { "max9867", 0 }, { } @@ -535,7 +531,6 @@ static int max9867_i2c_remove(struct i2c_client *client) .pm = &max9867_pm_ops, }, .probe = max9867_i2c_probe, - .remove = max9867_i2c_remove, .id_table = max9867_i2c_id, };

diff --git a/sound/soc/codecs/max9867.h b/sound/soc/codecs/max9867.h index 65590b4..c0aea3d 100644 --- a/sound/soc/codecs/max9867.h +++ b/sound/soc/codecs/max9867.h @@ -75,7 +75,7 @@ /* codec private data */ struct max9867_priv { struct regmap *regmap; - struct snd_soc_codec *codec; + struct snd_soc_component *component; unsigned int sysclk; unsigned int pclk; unsigned int master;

From: Kuninori Morimoto kuninori.morimoto.gx@renesas.com

Now we can replace Codec to Component. Let's do it.

Becase wm8993/wm8994/wm8958 are using wm_hubs feature, we need to update these all related drivers in same time. Otherwise compile error/warning happen

wm8993: xxx_codec_xxx() -> xxx_component_xxx() .idle_bias_off = 0 -> .idle_bias_on = 1 .ignore_pmdown_time = 0 -> .pmdown_time = 1 - -> .endianness = 1 - -> .non_legacy_dai_naming = 1

wm8994: xxx_codec_xxx() -> xxx_component_xxx() .idle_bias_off = 0 -> .idle_bias_on = 1 .ignore_pmdown_time = 0 -> .pmdown_time = 1 - -> .endianness = 1 - -> .non_legacy_dai_naming = 1

Signed-off-by: Kuninori Morimoto kuninori.morimoto.gx@renesas.com --- sound/soc/codecs/wm8958-dsp2.c | 278 +++++++------- sound/soc/codecs/wm8993.c | 237 ++++++------ sound/soc/codecs/wm8994.c | 810 +++++++++++++++++++++-------------------- sound/soc/codecs/wm8994.h | 8 +- sound/soc/codecs/wm_hubs.c | 254 ++++++------- sound/soc/codecs/wm_hubs.h | 18 +- sound/soc/samsung/littlemill.c | 8 +- 7 files changed, 809 insertions(+), 804 deletions(-)

diff --git a/sound/soc/codecs/wm8958-dsp2.c b/sound/soc/codecs/wm8958-dsp2.c index 6b864c0..8d49522 100644 --- a/sound/soc/codecs/wm8958-dsp2.c +++ b/sound/soc/codecs/wm8958-dsp2.c @@ -39,10 +39,10 @@ #define WM_FW_BLOCK_A 0x08 #define WM_FW_BLOCK_C 0x0c

-static int wm8958_dsp2_fw(struct snd_soc_codec *codec, const char *name, +static int wm8958_dsp2_fw(struct snd_soc_component *component, const char *name, const struct firmware *fw, bool check) { - struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec); + struct wm8994_priv *wm8994 = snd_soc_component_get_drvdata(component); u64 data64; u32 data32; const u8 *data; @@ -55,7 +55,7 @@ static int wm8958_dsp2_fw(struct snd_soc_codec *codec, const char *name, return 0;

if (fw->size < 32) { - dev_err(codec->dev, "%s: firmware too short (%zd bytes)\n", + dev_err(component->dev, "%s: firmware too short (%zd bytes)\n", name, fw->size); goto err; } @@ -63,7 +63,7 @@ static int wm8958_dsp2_fw(struct snd_soc_codec *codec, const char *name, if (memcmp(fw->data, "WMFW", 4) != 0) { memcpy(&data32, fw->data, sizeof(data32)); data32 = be32_to_cpu(data32); - dev_err(codec->dev, "%s: firmware has bad file magic %08x\n", + dev_err(component->dev, "%s: firmware has bad file magic %08x\n", name, data32); goto err; } @@ -74,35 +74,35 @@ static int wm8958_dsp2_fw(struct snd_soc_codec *codec, const char *name, memcpy(&data32, fw->data + 8, sizeof(data32)); data32 = be32_to_cpu(data32); if ((data32 >> 24) & 0xff) { - dev_err(codec->dev, "%s: unsupported firmware version %d\n", + dev_err(component->dev, "%s: unsupported firmware version %d\n", name, (data32 >> 24) & 0xff); goto err; } if ((data32 & 0xffff) != 8958) { - dev_err(codec->dev, "%s: unsupported target device %d\n", + dev_err(component->dev, "%s: unsupported target device %d\n", name, data32 & 0xffff); goto err; } if (((data32 >> 16) & 0xff) != 0xc) { - dev_err(codec->dev, "%s: unsupported target core %d\n", + dev_err(component->dev, "%s: unsupported target core %d\n", name, (data32 >> 16) & 0xff); goto err; }

if (check) { memcpy(&data64, fw->data + 24, sizeof(u64)); - dev_info(codec->dev, "%s timestamp %llx\n", + dev_info(component->dev, "%s timestamp %llx\n", name, be64_to_cpu(data64)); } else { - snd_soc_write(codec, 0x102, 0x2); - snd_soc_write(codec, 0x900, 0x2); + snd_soc_component_write(component, 0x102, 0x2); + snd_soc_component_write(component, 0x900, 0x2); }

data = fw->data + len; len = fw->size - len; while (len) { if (len < 12) { - dev_err(codec->dev, "%s short data block of %zd\n", + dev_err(component->dev, "%s short data block of %zd\n", name, len); goto err; } @@ -110,12 +110,12 @@ static int wm8958_dsp2_fw(struct snd_soc_codec *codec, const char *name, memcpy(&data32, data + 4, sizeof(data32)); block_len = be32_to_cpu(data32); if (block_len + 8 > len) { - dev_err(codec->dev, "%zd byte block longer than file\n", + dev_err(component->dev, "%zd byte block longer than file\n", block_len); goto err; } if (block_len == 0) { - dev_err(codec->dev, "Zero length block\n"); + dev_err(component->dev, "Zero length block\n"); goto err; }

@@ -131,10 +131,10 @@ static int wm8958_dsp2_fw(struct snd_soc_codec *codec, const char *name, str = kzalloc(block_len + 1, GFP_KERNEL); if (str) { memcpy(str, data + 8, block_len); - dev_info(codec->dev, "%s: %s\n", name, str); + dev_info(component->dev, "%s: %s\n", name, str); kfree(str); } else { - dev_err(codec->dev, "Out of memory\n"); + dev_err(component->dev, "Out of memory\n"); } break; case WM_FW_BLOCK_PM: @@ -144,7 +144,7 @@ static int wm8958_dsp2_fw(struct snd_soc_codec *codec, const char *name, case WM_FW_BLOCK_I: case WM_FW_BLOCK_A: case WM_FW_BLOCK_C: - dev_dbg(codec->dev, "%s: %zd bytes of %x@%x\n", name, + dev_dbg(component->dev, "%s: %zd bytes of %x@%x\n", name, block_len, (data32 >> 24) & 0xff, data32 & 0xffffff);

@@ -160,7 +160,7 @@ static int wm8958_dsp2_fw(struct snd_soc_codec *codec, const char *name,

break; default: - dev_warn(codec->dev, "%s: unknown block type %d\n", + dev_warn(component->dev, "%s: unknown block type %d\n", name, (data32 >> 24) & 0xff); break; } @@ -173,10 +173,10 @@ static int wm8958_dsp2_fw(struct snd_soc_codec *codec, const char *name, }

if (!check) { - dev_dbg(codec->dev, "%s: download done\n", name); + dev_dbg(component->dev, "%s: download done\n", name); wm8994->cur_fw = fw; } else { - dev_info(codec->dev, "%s: got firmware\n", name); + dev_info(component->dev, "%s: got firmware\n", name); }

goto ok; @@ -185,28 +185,28 @@ static int wm8958_dsp2_fw(struct snd_soc_codec *codec, const char *name, ret = -EINVAL; ok: if (!check) { - snd_soc_write(codec, 0x900, 0x0); - snd_soc_write(codec, 0x102, 0x0); + snd_soc_component_write(component, 0x900, 0x0); + snd_soc_component_write(component, 0x102, 0x0); }

return ret; }

-static void wm8958_dsp_start_mbc(struct snd_soc_codec *codec, int path) +static void wm8958_dsp_start_mbc(struct snd_soc_component *component, int path) { - struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec); + struct wm8994_priv *wm8994 = snd_soc_component_get_drvdata(component); struct wm8994 *control = wm8994->wm8994; int i;

/* If the DSP is already running then noop */ - if (snd_soc_read(codec, WM8958_DSP2_PROGRAM) & WM8958_DSP2_ENA) + if (snd_soc_component_read32(component, WM8958_DSP2_PROGRAM) & WM8958_DSP2_ENA) return;

/* If we have MBC firmware download it */ if (wm8994->mbc) - wm8958_dsp2_fw(codec, "MBC", wm8994->mbc, false); + wm8958_dsp2_fw(component, "MBC", wm8994->mbc, false);

- snd_soc_update_bits(codec, WM8958_DSP2_PROGRAM, + snd_soc_component_update_bits(component, WM8958_DSP2_PROGRAM, WM8958_DSP2_ENA, WM8958_DSP2_ENA);

/* If we've got user supplied MBC settings use them */ @@ -215,37 +215,37 @@ static void wm8958_dsp_start_mbc(struct snd_soc_codec *codec, int path) = &control->pdata.mbc_cfgs[wm8994->mbc_cfg];

for (i = 0; i < ARRAY_SIZE(cfg->coeff_regs); i++) - snd_soc_write(codec, i + WM8958_MBC_BAND_1_K_1, + snd_soc_component_write(component, i + WM8958_MBC_BAND_1_K_1, cfg->coeff_regs[i]);

for (i = 0; i < ARRAY_SIZE(cfg->cutoff_regs); i++) - snd_soc_write(codec, + snd_soc_component_write(component, i + WM8958_MBC_BAND_2_LOWER_CUTOFF_C1_1, cfg->cutoff_regs[i]); }

/* Run the DSP */ - snd_soc_write(codec, WM8958_DSP2_EXECCONTROL, + snd_soc_component_write(component, WM8958_DSP2_EXECCONTROL, WM8958_DSP2_RUNR);

/* And we're off! */ - snd_soc_update_bits(codec, WM8958_DSP2_CONFIG, + snd_soc_component_update_bits(component, WM8958_DSP2_CONFIG, WM8958_MBC_ENA | WM8958_MBC_SEL_MASK, path << WM8958_MBC_SEL_SHIFT | WM8958_MBC_ENA); }

-static void wm8958_dsp_start_vss(struct snd_soc_codec *codec, int path) +static void wm8958_dsp_start_vss(struct snd_soc_component *component, int path) { - struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec); + struct wm8994_priv *wm8994 = snd_soc_component_get_drvdata(component); struct wm8994 *control = wm8994->wm8994; int i, ena;

if (wm8994->mbc_vss) - wm8958_dsp2_fw(codec, "MBC+VSS", wm8994->mbc_vss, false); + wm8958_dsp2_fw(component, "MBC+VSS", wm8994->mbc_vss, false);

- snd_soc_update_bits(codec, WM8958_DSP2_PROGRAM, + snd_soc_component_update_bits(component, WM8958_DSP2_PROGRAM, WM8958_DSP2_ENA, WM8958_DSP2_ENA);

/* If we've got user supplied settings use them */ @@ -254,7 +254,7 @@ static void wm8958_dsp_start_vss(struct snd_soc_codec *codec, int path) = &control->pdata.mbc_cfgs[wm8994->mbc_cfg];

for (i = 0; i < ARRAY_SIZE(cfg->combined_regs); i++) - snd_soc_write(codec, i + 0x2800, + snd_soc_component_write(component, i + 0x2800, cfg->combined_regs[i]); }

@@ -263,7 +263,7 @@ static void wm8958_dsp_start_vss(struct snd_soc_codec *codec, int path) = &control->pdata.vss_cfgs[wm8994->vss_cfg];

for (i = 0; i < ARRAY_SIZE(cfg->regs); i++) - snd_soc_write(codec, i + 0x2600, cfg->regs[i]); + snd_soc_component_write(component, i + 0x2600, cfg->regs[i]); }

if (control->pdata.num_vss_hpf_cfgs) { @@ -271,11 +271,11 @@ static void wm8958_dsp_start_vss(struct snd_soc_codec *codec, int path) = &control->pdata.vss_hpf_cfgs[wm8994->vss_hpf_cfg];

for (i = 0; i < ARRAY_SIZE(cfg->regs); i++) - snd_soc_write(codec, i + 0x2400, cfg->regs[i]); + snd_soc_component_write(component, i + 0x2400, cfg->regs[i]); }

/* Run the DSP */ - snd_soc_write(codec, WM8958_DSP2_EXECCONTROL, + snd_soc_component_write(component, WM8958_DSP2_EXECCONTROL, WM8958_DSP2_RUNR);

/* Enable the algorithms we've selected */ @@ -289,23 +289,23 @@ static void wm8958_dsp_start_vss(struct snd_soc_codec *codec, int path) if (wm8994->vss_ena[path]) ena |= 0x1;

- snd_soc_write(codec, 0x2201, ena); + snd_soc_component_write(component, 0x2201, ena);

/* Switch the DSP into the data path */ - snd_soc_update_bits(codec, WM8958_DSP2_CONFIG, + snd_soc_component_update_bits(component, WM8958_DSP2_CONFIG, WM8958_MBC_SEL_MASK | WM8958_MBC_ENA, path << WM8958_MBC_SEL_SHIFT | WM8958_MBC_ENA); }

-static void wm8958_dsp_start_enh_eq(struct snd_soc_codec *codec, int path) +static void wm8958_dsp_start_enh_eq(struct snd_soc_component *component, int path) { - struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec); + struct wm8994_priv *wm8994 = snd_soc_component_get_drvdata(component); struct wm8994 *control = wm8994->wm8994; int i;

- wm8958_dsp2_fw(codec, "ENH_EQ", wm8994->enh_eq, false); + wm8958_dsp2_fw(component, "ENH_EQ", wm8994->enh_eq, false);

- snd_soc_update_bits(codec, WM8958_DSP2_PROGRAM, + snd_soc_component_update_bits(component, WM8958_DSP2_PROGRAM, WM8958_DSP2_ENA, WM8958_DSP2_ENA);

/* If we've got user supplied settings use them */ @@ -314,24 +314,24 @@ static void wm8958_dsp_start_enh_eq(struct snd_soc_codec *codec, int path) = &control->pdata.enh_eq_cfgs[wm8994->enh_eq_cfg];

for (i = 0; i < ARRAY_SIZE(cfg->regs); i++) - snd_soc_write(codec, i + 0x2200, + snd_soc_component_write(component, i + 0x2200, cfg->regs[i]); }

/* Run the DSP */ - snd_soc_write(codec, WM8958_DSP2_EXECCONTROL, + snd_soc_component_write(component, WM8958_DSP2_EXECCONTROL, WM8958_DSP2_RUNR);

/* Switch the DSP into the data path */ - snd_soc_update_bits(codec, WM8958_DSP2_CONFIG, + snd_soc_component_update_bits(component, WM8958_DSP2_CONFIG, WM8958_MBC_SEL_MASK | WM8958_MBC_ENA, path << WM8958_MBC_SEL_SHIFT | WM8958_MBC_ENA); }

-static void wm8958_dsp_apply(struct snd_soc_codec *codec, int path, int start) +static void wm8958_dsp_apply(struct snd_soc_component *component, int path, int start) { - struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec); - int pwr_reg = snd_soc_read(codec, WM8994_POWER_MANAGEMENT_5); + struct wm8994_priv *wm8994 = snd_soc_component_get_drvdata(component); + int pwr_reg = snd_soc_component_read32(component, WM8994_POWER_MANAGEMENT_5); int ena, reg, aif;

switch (path) { @@ -359,9 +359,9 @@ static void wm8958_dsp_apply(struct snd_soc_codec *codec, int path, int start) if (!pwr_reg) ena = 0;

- reg = snd_soc_read(codec, WM8958_DSP2_PROGRAM); + reg = snd_soc_component_read32(component, WM8958_DSP2_PROGRAM);

- dev_dbg(codec->dev, "DSP path %d %d startup: %d, power: %x, DSP: %x\n", + dev_dbg(component->dev, "DSP path %d %d startup: %d, power: %x, DSP: %x\n", path, wm8994->dsp_active, start, pwr_reg, reg);

if (start && ena) { @@ -370,29 +370,29 @@ static void wm8958_dsp_apply(struct snd_soc_codec *codec, int path, int start) return;

/* If either AIFnCLK is not yet enabled postpone */ - if (!(snd_soc_read(codec, WM8994_AIF1_CLOCKING_1) + if (!(snd_soc_component_read32(component, WM8994_AIF1_CLOCKING_1) & WM8994_AIF1CLK_ENA_MASK) && - !(snd_soc_read(codec, WM8994_AIF2_CLOCKING_1) + !(snd_soc_component_read32(component, WM8994_AIF2_CLOCKING_1) & WM8994_AIF2CLK_ENA_MASK)) return;

/* Switch the clock over to the appropriate AIF */ - snd_soc_update_bits(codec, WM8994_CLOCKING_1, + snd_soc_component_update_bits(component, WM8994_CLOCKING_1, WM8958_DSP2CLK_SRC | WM8958_DSP2CLK_ENA, aif << WM8958_DSP2CLK_SRC_SHIFT | WM8958_DSP2CLK_ENA);

if (wm8994->enh_eq_ena[path]) - wm8958_dsp_start_enh_eq(codec, path); + wm8958_dsp_start_enh_eq(component, path); else if (wm8994->vss_ena[path] || wm8994->hpf1_ena[path] || wm8994->hpf2_ena[path]) - wm8958_dsp_start_vss(codec, path); + wm8958_dsp_start_vss(component, path); else if (wm8994->mbc_ena[path]) - wm8958_dsp_start_mbc(codec, path); + wm8958_dsp_start_mbc(component, path);

wm8994->dsp_active = path;

- dev_dbg(codec->dev, "DSP running in path %d\n", path); + dev_dbg(component->dev, "DSP running in path %d\n", path); }

if (!start && wm8994->dsp_active == path) { @@ -400,37 +400,37 @@ static void wm8958_dsp_apply(struct snd_soc_codec *codec, int path, int start) if (!(reg & WM8958_DSP2_ENA)) return;

- snd_soc_update_bits(codec, WM8958_DSP2_CONFIG, + snd_soc_component_update_bits(component, WM8958_DSP2_CONFIG, WM8958_MBC_ENA, 0); - snd_soc_write(codec, WM8958_DSP2_EXECCONTROL, + snd_soc_component_write(component, WM8958_DSP2_EXECCONTROL, WM8958_DSP2_STOP); - snd_soc_update_bits(codec, WM8958_DSP2_PROGRAM, + snd_soc_component_update_bits(component, WM8958_DSP2_PROGRAM, WM8958_DSP2_ENA, 0); - snd_soc_update_bits(codec, WM8994_CLOCKING_1, + snd_soc_component_update_bits(component, WM8994_CLOCKING_1, WM8958_DSP2CLK_ENA, 0);

wm8994->dsp_active = -1;

- dev_dbg(codec->dev, "DSP stopped\n"); + dev_dbg(component->dev, "DSP stopped\n"); } }

int wm8958_aif_ev(struct snd_soc_dapm_widget *w, struct snd_kcontrol *kcontrol, int event) { - struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm); + struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm); int i;

switch (event) { case SND_SOC_DAPM_POST_PMU: case SND_SOC_DAPM_PRE_PMU: for (i = 0; i < 3; i++) - wm8958_dsp_apply(codec, i, 1); + wm8958_dsp_apply(component, i, 1); break; case SND_SOC_DAPM_POST_PMD: case SND_SOC_DAPM_PRE_PMD: for (i = 0; i < 3; i++) - wm8958_dsp_apply(codec, i, 0); + wm8958_dsp_apply(component, i, 0); break; }

@@ -456,14 +456,14 @@ static int wm8958_dsp2_busy(struct wm8994_priv *wm8994, int aif) static int wm8958_put_mbc_enum(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { - struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol); - struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol); + struct wm8994_priv *wm8994 = snd_soc_component_get_drvdata(component); struct wm8994 *control = wm8994->wm8994; int value = ucontrol->value.enumerated.item[0]; int reg;

/* Don't allow on the fly reconfiguration */ - reg = snd_soc_read(codec, WM8994_CLOCKING_1); + reg = snd_soc_component_read32(component, WM8994_CLOCKING_1); if (reg < 0 || reg & WM8958_DSP2CLK_ENA) return -EBUSY;

@@ -478,8 +478,8 @@ static int wm8958_put_mbc_enum(struct snd_kcontrol *kcontrol, static int wm8958_get_mbc_enum(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { - struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol); - struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol); + struct wm8994_priv *wm8994 = snd_soc_component_get_drvdata(component);

ucontrol->value.enumerated.item[0] = wm8994->mbc_cfg;

@@ -500,8 +500,8 @@ static int wm8958_mbc_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { int mbc = kcontrol->private_value; - struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol); - struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol); + struct wm8994_priv *wm8994 = snd_soc_component_get_drvdata(component);

ucontrol->value.integer.value[0] = wm8994->mbc_ena[mbc];

@@ -512,8 +512,8 @@ static int wm8958_mbc_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { int mbc = kcontrol->private_value; - struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol); - struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol); + struct wm8994_priv *wm8994 = snd_soc_component_get_drvdata(component);

if (wm8994->mbc_ena[mbc] == ucontrol->value.integer.value[0]) return 0; @@ -522,7 +522,7 @@ static int wm8958_mbc_put(struct snd_kcontrol *kcontrol, return -EINVAL;

if (wm8958_dsp2_busy(wm8994, mbc)) { - dev_dbg(codec->dev, "DSP2 active on %d already\n", mbc); + dev_dbg(component->dev, "DSP2 active on %d already\n", mbc); return -EBUSY; }

@@ -531,7 +531,7 @@ static int wm8958_mbc_put(struct snd_kcontrol *kcontrol,

wm8994->mbc_ena[mbc] = ucontrol->value.integer.value[0];

- wm8958_dsp_apply(codec, mbc, wm8994->mbc_ena[mbc]); + wm8958_dsp_apply(component, mbc, wm8994->mbc_ena[mbc]);

return 0; } @@ -546,14 +546,14 @@ static int wm8958_mbc_put(struct snd_kcontrol *kcontrol, static int wm8958_put_vss_enum(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { - struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol); - struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol); + struct wm8994_priv *wm8994 = snd_soc_component_get_drvdata(component); struct wm8994 *control = wm8994->wm8994; int value = ucontrol->value.enumerated.item[0]; int reg;

/* Don't allow on the fly reconfiguration */ - reg = snd_soc_read(codec, WM8994_CLOCKING_1); + reg = snd_soc_component_read32(component, WM8994_CLOCKING_1); if (reg < 0 || reg & WM8958_DSP2CLK_ENA) return -EBUSY;

@@ -568,8 +568,8 @@ static int wm8958_put_vss_enum(struct snd_kcontrol *kcontrol, static int wm8958_get_vss_enum(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { - struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol); - struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol); + struct wm8994_priv *wm8994 = snd_soc_component_get_drvdata(component);

ucontrol->value.enumerated.item[0] = wm8994->vss_cfg;

@@ -579,14 +579,14 @@ static int wm8958_get_vss_enum(struct snd_kcontrol *kcontrol, static int wm8958_put_vss_hpf_enum(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { - struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol); - struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol); + struct wm8994_priv *wm8994 = snd_soc_component_get_drvdata(component); struct wm8994 *control = wm8994->wm8994; int value = ucontrol->value.enumerated.item[0]; int reg;

/* Don't allow on the fly reconfiguration */ - reg = snd_soc_read(codec, WM8994_CLOCKING_1); + reg = snd_soc_component_read32(component, WM8994_CLOCKING_1); if (reg < 0 || reg & WM8958_DSP2CLK_ENA) return -EBUSY;

@@ -601,8 +601,8 @@ static int wm8958_put_vss_hpf_enum(struct snd_kcontrol *kcontrol, static int wm8958_get_vss_hpf_enum(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { - struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol); - struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol); + struct wm8994_priv *wm8994 = snd_soc_component_get_drvdata(component);

ucontrol->value.enumerated.item[0] = wm8994->vss_hpf_cfg;

@@ -623,8 +623,8 @@ static int wm8958_vss_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { int vss = kcontrol->private_value; - struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol); - struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol); + struct wm8994_priv *wm8994 = snd_soc_component_get_drvdata(component);

ucontrol->value.integer.value[0] = wm8994->vss_ena[vss];

@@ -635,8 +635,8 @@ static int wm8958_vss_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { int vss = kcontrol->private_value; - struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol); - struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol); + struct wm8994_priv *wm8994 = snd_soc_component_get_drvdata(component);

if (wm8994->vss_ena[vss] == ucontrol->value.integer.value[0]) return 0; @@ -648,7 +648,7 @@ static int wm8958_vss_put(struct snd_kcontrol *kcontrol, return -ENODEV;

if (wm8958_dsp2_busy(wm8994, vss)) { - dev_dbg(codec->dev, "DSP2 active on %d already\n", vss); + dev_dbg(component->dev, "DSP2 active on %d already\n", vss); return -EBUSY; }

@@ -657,7 +657,7 @@ static int wm8958_vss_put(struct snd_kcontrol *kcontrol,

wm8994->vss_ena[vss] = ucontrol->value.integer.value[0];

- wm8958_dsp_apply(codec, vss, wm8994->vss_ena[vss]); + wm8958_dsp_apply(component, vss, wm8994->vss_ena[vss]);

return 0; } @@ -684,8 +684,8 @@ static int wm8958_hpf_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { int hpf = kcontrol->private_value; - struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol); - struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol); + struct wm8994_priv *wm8994 = snd_soc_component_get_drvdata(component);

if (hpf < 3) ucontrol->value.integer.value[0] = wm8994->hpf1_ena[hpf % 3]; @@ -699,8 +699,8 @@ static int wm8958_hpf_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { int hpf = kcontrol->private_value; - struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol); - struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol); + struct wm8994_priv *wm8994 = snd_soc_component_get_drvdata(component);

if (hpf < 3) { if (wm8994->hpf1_ena[hpf % 3] == @@ -719,7 +719,7 @@ static int wm8958_hpf_put(struct snd_kcontrol *kcontrol, return -ENODEV;

if (wm8958_dsp2_busy(wm8994, hpf % 3)) { - dev_dbg(codec->dev, "DSP2 active on %d already\n", hpf); + dev_dbg(component->dev, "DSP2 active on %d already\n", hpf); return -EBUSY; }

@@ -731,7 +731,7 @@ static int wm8958_hpf_put(struct snd_kcontrol *kcontrol, else wm8994->hpf2_ena[hpf % 3] = ucontrol->value.integer.value[0];

- wm8958_dsp_apply(codec, hpf % 3, ucontrol->value.integer.value[0]); + wm8958_dsp_apply(component, hpf % 3, ucontrol->value.integer.value[0]);

return 0; } @@ -746,14 +746,14 @@ static int wm8958_hpf_put(struct snd_kcontrol *kcontrol, static int wm8958_put_enh_eq_enum(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { - struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol); - struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol); + struct wm8994_priv *wm8994 = snd_soc_component_get_drvdata(component); struct wm8994 *control = wm8994->wm8994; int value = ucontrol->value.enumerated.item[0]; int reg;

/* Don't allow on the fly reconfiguration */ - reg = snd_soc_read(codec, WM8994_CLOCKING_1); + reg = snd_soc_component_read32(component, WM8994_CLOCKING_1); if (reg < 0 || reg & WM8958_DSP2CLK_ENA) return -EBUSY;

@@ -768,8 +768,8 @@ static int wm8958_put_enh_eq_enum(struct snd_kcontrol *kcontrol, static int wm8958_get_enh_eq_enum(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { - struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol); - struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol); + struct wm8994_priv *wm8994 = snd_soc_component_get_drvdata(component);

ucontrol->value.enumerated.item[0] = wm8994->enh_eq_cfg;

@@ -790,8 +790,8 @@ static int wm8958_enh_eq_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { int eq = kcontrol->private_value; - struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol); - struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol); + struct wm8994_priv *wm8994 = snd_soc_component_get_drvdata(component);

ucontrol->value.integer.value[0] = wm8994->enh_eq_ena[eq];

@@ -802,8 +802,8 @@ static int wm8958_enh_eq_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { int eq = kcontrol->private_value; - struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol); - struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol); + struct wm8994_priv *wm8994 = snd_soc_component_get_drvdata(component);

if (wm8994->enh_eq_ena[eq] == ucontrol->value.integer.value[0]) return 0; @@ -815,7 +815,7 @@ static int wm8958_enh_eq_put(struct snd_kcontrol *kcontrol, return -ENODEV;

if (wm8958_dsp2_busy(wm8994, eq)) { - dev_dbg(codec->dev, "DSP2 active on %d already\n", eq); + dev_dbg(component->dev, "DSP2 active on %d already\n", eq); return -EBUSY; }

@@ -825,7 +825,7 @@ static int wm8958_enh_eq_put(struct snd_kcontrol *kcontrol,

wm8994->enh_eq_ena[eq] = ucontrol->value.integer.value[0];

- wm8958_dsp_apply(codec, eq, ucontrol->value.integer.value[0]); + wm8958_dsp_apply(component, eq, ucontrol->value.integer.value[0]);

return 0; } @@ -863,10 +863,10 @@ static int wm8958_enh_eq_put(struct snd_kcontrol *kcontrol,

static void wm8958_enh_eq_loaded(const struct firmware *fw, void *context) { - struct snd_soc_codec *codec = context; - struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = context; + struct wm8994_priv *wm8994 = snd_soc_component_get_drvdata(component);

- if (fw && (wm8958_dsp2_fw(codec, "ENH_EQ", fw, true) == 0)) { + if (fw && (wm8958_dsp2_fw(component, "ENH_EQ", fw, true) == 0)) { mutex_lock(&wm8994->fw_lock); wm8994->enh_eq = fw; mutex_unlock(&wm8994->fw_lock); @@ -875,10 +875,10 @@ static void wm8958_enh_eq_loaded(const struct firmware *fw, void *context)

static void wm8958_mbc_vss_loaded(const struct firmware *fw, void *context) { - struct snd_soc_codec *codec = context; - struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = context; + struct wm8994_priv *wm8994 = snd_soc_component_get_drvdata(component);

- if (fw && (wm8958_dsp2_fw(codec, "MBC+VSS", fw, true) == 0)) { + if (fw && (wm8958_dsp2_fw(component, "MBC+VSS", fw, true) == 0)) { mutex_lock(&wm8994->fw_lock); wm8994->mbc_vss = fw; mutex_unlock(&wm8994->fw_lock); @@ -887,43 +887,43 @@ static void wm8958_mbc_vss_loaded(const struct firmware *fw, void *context)

static void wm8958_mbc_loaded(const struct firmware *fw, void *context) { - struct snd_soc_codec *codec = context; - struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = context; + struct wm8994_priv *wm8994 = snd_soc_component_get_drvdata(component);

- if (fw && (wm8958_dsp2_fw(codec, "MBC", fw, true) == 0)) { + if (fw && (wm8958_dsp2_fw(component, "MBC", fw, true) == 0)) { mutex_lock(&wm8994->fw_lock); wm8994->mbc = fw; mutex_unlock(&wm8994->fw_lock); } }

-void wm8958_dsp2_init(struct snd_soc_codec *codec) +void wm8958_dsp2_init(struct snd_soc_component *component) { - struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec); + struct wm8994_priv *wm8994 = snd_soc_component_get_drvdata(component); struct wm8994 *control = wm8994->wm8994; struct wm8994_pdata *pdata = &control->pdata; int ret, i;

wm8994->dsp_active = -1;

- snd_soc_add_codec_controls(codec, wm8958_mbc_snd_controls, + snd_soc_add_component_controls(component, wm8958_mbc_snd_controls, ARRAY_SIZE(wm8958_mbc_snd_controls)); - snd_soc_add_codec_controls(codec, wm8958_vss_snd_controls, + snd_soc_add_component_controls(component, wm8958_vss_snd_controls, ARRAY_SIZE(wm8958_vss_snd_controls)); - snd_soc_add_codec_controls(codec, wm8958_enh_eq_snd_controls, + snd_soc_add_component_controls(component, wm8958_enh_eq_snd_controls, ARRAY_SIZE(wm8958_enh_eq_snd_controls));

/* We don't *require* firmware and don't want to delay boot */ request_firmware_nowait(THIS_MODULE, FW_ACTION_HOTPLUG, - "wm8958_mbc.wfw", codec->dev, GFP_KERNEL, - codec, wm8958_mbc_loaded); + "wm8958_mbc.wfw", component->dev, GFP_KERNEL, + component, wm8958_mbc_loaded); request_firmware_nowait(THIS_MODULE, FW_ACTION_HOTPLUG, - "wm8958_mbc_vss.wfw", codec->dev, GFP_KERNEL, - codec, wm8958_mbc_vss_loaded); + "wm8958_mbc_vss.wfw", component->dev, GFP_KERNEL, + component, wm8958_mbc_vss_loaded); request_firmware_nowait(THIS_MODULE, FW_ACTION_HOTPLUG, - "wm8958_enh_eq.wfw", codec->dev, GFP_KERNEL, - codec, wm8958_enh_eq_loaded); + "wm8958_enh_eq.wfw", component->dev, GFP_KERNEL, + component, wm8958_enh_eq_loaded);

if (pdata->num_mbc_cfgs) { struct snd_kcontrol_new control[] = { @@ -943,10 +943,10 @@ void wm8958_dsp2_init(struct snd_soc_codec *codec) wm8994->mbc_enum.items = pdata->num_mbc_cfgs; wm8994->mbc_enum.texts = wm8994->mbc_texts;

- ret = snd_soc_add_codec_controls(wm8994->hubs.codec, + ret = snd_soc_add_component_controls(wm8994->hubs.component, control, 1); if (ret != 0) - dev_err(wm8994->hubs.codec->dev, + dev_err(wm8994->hubs.component->dev, "Failed to add MBC mode controls: %d\n", ret); }

@@ -968,10 +968,10 @@ void wm8958_dsp2_init(struct snd_soc_codec *codec) wm8994->vss_enum.items = pdata->num_vss_cfgs; wm8994->vss_enum.texts = wm8994->vss_texts;

- ret = snd_soc_add_codec_controls(wm8994->hubs.codec, + ret = snd_soc_add_component_controls(wm8994->hubs.component, control, 1); if (ret != 0) - dev_err(wm8994->hubs.codec->dev, + dev_err(wm8994->hubs.component->dev, "Failed to add VSS mode controls: %d\n", ret); }

@@ -994,10 +994,10 @@ void wm8958_dsp2_init(struct snd_soc_codec *codec) wm8994->vss_hpf_enum.items = pdata->num_vss_hpf_cfgs; wm8994->vss_hpf_enum.texts = wm8994->vss_hpf_texts;

- ret = snd_soc_add_codec_controls(wm8994->hubs.codec, + ret = snd_soc_add_component_controls(wm8994->hubs.component, control, 1); if (ret != 0) - dev_err(wm8994->hubs.codec->dev, + dev_err(wm8994->hubs.component->dev, "Failed to add VSS HPFmode controls: %d\n", ret); } @@ -1021,10 +1021,10 @@ void wm8958_dsp2_init(struct snd_soc_codec *codec) wm8994->enh_eq_enum.items = pdata->num_enh_eq_cfgs; wm8994->enh_eq_enum.texts = wm8994->enh_eq_texts;

- ret = snd_soc_add_codec_controls(wm8994->hubs.codec, + ret = snd_soc_add_component_controls(wm8994->hubs.component, control, 1); if (ret != 0) - dev_err(wm8994->hubs.codec->dev, + dev_err(wm8994->hubs.component->dev, "Failed to add enhanced EQ controls: %d\n", ret); } diff --git a/sound/soc/codecs/wm8993.c b/sound/soc/codecs/wm8993.c index 830ffd80..d606f5b 100644 --- a/sound/soc/codecs/wm8993.c +++ b/sound/soc/codecs/wm8993.c @@ -466,11 +466,11 @@ static int fll_factors(struct _fll_div *fll_div, unsigned int Fref, return 0; }

-static int _wm8993_set_fll(struct snd_soc_codec *codec, int fll_id, int source, +static int _wm8993_set_fll(struct snd_soc_component *component, int fll_id, int source, unsigned int Fref, unsigned int Fout) { - struct wm8993_priv *wm8993 = snd_soc_codec_get_drvdata(codec); - struct i2c_client *i2c = to_i2c_client(codec->dev); + struct wm8993_priv *wm8993 = snd_soc_component_get_drvdata(component); + struct i2c_client *i2c = to_i2c_client(component->dev); u16 reg1, reg4, reg5; struct _fll_div fll_div; unsigned int timeout; @@ -482,13 +482,13 @@ static int _wm8993_set_fll(struct snd_soc_codec *codec, int fll_id, int source,

/* Disable the FLL */ if (Fout == 0) { - dev_dbg(codec->dev, "FLL disabled\n"); + dev_dbg(component->dev, "FLL disabled\n"); wm8993->fll_fref = 0; wm8993->fll_fout = 0;

- reg1 = snd_soc_read(codec, WM8993_FLL_CONTROL_1); + reg1 = snd_soc_component_read32(component, WM8993_FLL_CONTROL_1); reg1 &= ~WM8993_FLL_ENA; - snd_soc_write(codec, WM8993_FLL_CONTROL_1, reg1); + snd_soc_component_write(component, WM8993_FLL_CONTROL_1, reg1);

return 0; } @@ -497,7 +497,7 @@ static int _wm8993_set_fll(struct snd_soc_codec *codec, int fll_id, int source, if (ret != 0) return ret;

- reg5 = snd_soc_read(codec, WM8993_FLL_CONTROL_5); + reg5 = snd_soc_component_read32(component, WM8993_FLL_CONTROL_5); reg5 &= ~WM8993_FLL_CLK_SRC_MASK;

switch (fll_id) { @@ -513,36 +513,36 @@ static int _wm8993_set_fll(struct snd_soc_codec *codec, int fll_id, int source, break;

default: - dev_err(codec->dev, "Unknown FLL ID %d\n", fll_id); + dev_err(component->dev, "Unknown FLL ID %d\n", fll_id); return -EINVAL; }

/* Any FLL configuration change requires that the FLL be * disabled first. */ - reg1 = snd_soc_read(codec, WM8993_FLL_CONTROL_1); + reg1 = snd_soc_component_read32(component, WM8993_FLL_CONTROL_1); reg1 &= ~WM8993_FLL_ENA; - snd_soc_write(codec, WM8993_FLL_CONTROL_1, reg1); + snd_soc_component_write(component, WM8993_FLL_CONTROL_1, reg1);

/* Apply the configuration */ if (fll_div.k) reg1 |= WM8993_FLL_FRAC_MASK; else reg1 &= ~WM8993_FLL_FRAC_MASK; - snd_soc_write(codec, WM8993_FLL_CONTROL_1, reg1); + snd_soc_component_write(component, WM8993_FLL_CONTROL_1, reg1);

- snd_soc_write(codec, WM8993_FLL_CONTROL_2, + snd_soc_component_write(component, WM8993_FLL_CONTROL_2, (fll_div.fll_outdiv << WM8993_FLL_OUTDIV_SHIFT) | (fll_div.fll_fratio << WM8993_FLL_FRATIO_SHIFT)); - snd_soc_write(codec, WM8993_FLL_CONTROL_3, fll_div.k); + snd_soc_component_write(component, WM8993_FLL_CONTROL_3, fll_div.k);

- reg4 = snd_soc_read(codec, WM8993_FLL_CONTROL_4); + reg4 = snd_soc_component_read32(component, WM8993_FLL_CONTROL_4); reg4 &= ~WM8993_FLL_N_MASK; reg4 |= fll_div.n << WM8993_FLL_N_SHIFT; - snd_soc_write(codec, WM8993_FLL_CONTROL_4, reg4); + snd_soc_component_write(component, WM8993_FLL_CONTROL_4, reg4);

reg5 &= ~WM8993_FLL_CLK_REF_DIV_MASK; reg5 |= fll_div.fll_clk_ref_div << WM8993_FLL_CLK_REF_DIV_SHIFT; - snd_soc_write(codec, WM8993_FLL_CONTROL_5, reg5); + snd_soc_component_write(component, WM8993_FLL_CONTROL_5, reg5);

/* If we've got an interrupt wired up make sure we get it */ if (i2c->irq) @@ -555,13 +555,13 @@ static int _wm8993_set_fll(struct snd_soc_codec *codec, int fll_id, int source, try_wait_for_completion(&wm8993->fll_lock);

/* Enable the FLL */ - snd_soc_write(codec, WM8993_FLL_CONTROL_1, reg1 | WM8993_FLL_ENA); + snd_soc_component_write(component, WM8993_FLL_CONTROL_1, reg1 | WM8993_FLL_ENA);

timeout = wait_for_completion_timeout(&wm8993->fll_lock, timeout); if (i2c->irq && !timeout) - dev_warn(codec->dev, "Timed out waiting for FLL\n"); + dev_warn(component->dev, "Timed out waiting for FLL\n");

- dev_dbg(codec->dev, "FLL enabled at %dHz->%dHz\n", Fref, Fout); + dev_dbg(component->dev, "FLL enabled at %dHz->%dHz\n", Fref, Fout);

wm8993->fll_fref = Fref; wm8993->fll_fout = Fout; @@ -573,20 +573,20 @@ static int _wm8993_set_fll(struct snd_soc_codec *codec, int fll_id, int source, static int wm8993_set_fll(struct snd_soc_dai *dai, int fll_id, int source, unsigned int Fref, unsigned int Fout) { - return _wm8993_set_fll(dai->codec, fll_id, source, Fref, Fout); + return _wm8993_set_fll(dai->component, fll_id, source, Fref, Fout); }

-static int configure_clock(struct snd_soc_codec *codec) +static int configure_clock(struct snd_soc_component *component) { - struct wm8993_priv *wm8993 = snd_soc_codec_get_drvdata(codec); + struct wm8993_priv *wm8993 = snd_soc_component_get_drvdata(component); unsigned int reg;

/* This should be done on init() for bypass paths */ switch (wm8993->sysclk_source) { case WM8993_SYSCLK_MCLK: - dev_dbg(codec->dev, "Using %dHz MCLK\n", wm8993->mclk_rate); + dev_dbg(component->dev, "Using %dHz MCLK\n", wm8993->mclk_rate);

- reg = snd_soc_read(codec, WM8993_CLOCKING_2); + reg = snd_soc_component_read32(component, WM8993_CLOCKING_2); reg &= ~(WM8993_MCLK_DIV | WM8993_SYSCLK_SRC); if (wm8993->mclk_rate > 13500000) { reg |= WM8993_MCLK_DIV; @@ -595,14 +595,14 @@ static int configure_clock(struct snd_soc_codec *codec) reg &= ~WM8993_MCLK_DIV; wm8993->sysclk_rate = wm8993->mclk_rate; } - snd_soc_write(codec, WM8993_CLOCKING_2, reg); + snd_soc_component_write(component, WM8993_CLOCKING_2, reg); break;

case WM8993_SYSCLK_FLL: - dev_dbg(codec->dev, "Using %dHz FLL clock\n", + dev_dbg(component->dev, "Using %dHz FLL clock\n", wm8993->fll_fout);

- reg = snd_soc_read(codec, WM8993_CLOCKING_2); + reg = snd_soc_component_read32(component, WM8993_CLOCKING_2); reg |= WM8993_SYSCLK_SRC; if (wm8993->fll_fout > 13500000) { reg |= WM8993_MCLK_DIV; @@ -611,15 +611,15 @@ static int configure_clock(struct snd_soc_codec *codec) reg &= ~WM8993_MCLK_DIV; wm8993->sysclk_rate = wm8993->fll_fout; } - snd_soc_write(codec, WM8993_CLOCKING_2, reg); + snd_soc_component_write(component, WM8993_CLOCKING_2, reg); break;

default: - dev_err(codec->dev, "System clock not configured\n"); + dev_err(component->dev, "System clock not configured\n"); return -EINVAL; }

- dev_dbg(codec->dev, "CLK_SYS is %dHz\n", wm8993->sysclk_rate); + dev_dbg(component->dev, "CLK_SYS is %dHz\n", wm8993->sysclk_rate);

return 0; } @@ -809,11 +809,11 @@ static SOC_ENUM_SINGLE_DECL(drc_smooth, static int clk_sys_event(struct snd_soc_dapm_widget *w, struct snd_kcontrol *kcontrol, int event) { - struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm); + struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);

switch (event) { case SND_SOC_DAPM_PRE_PMU: - return configure_clock(codec); + return configure_clock(component);

case SND_SOC_DAPM_POST_PMD: break; @@ -972,26 +972,26 @@ static SOC_ENUM_SINGLE_DECL(sidetoner_enum, { "Right Headphone Mux", "DAC", "DACR" }, };

-static int wm8993_set_bias_level(struct snd_soc_codec *codec, +static int wm8993_set_bias_level(struct snd_soc_component *component, enum snd_soc_bias_level level) { - struct wm8993_priv *wm8993 = snd_soc_codec_get_drvdata(codec); + struct wm8993_priv *wm8993 = snd_soc_component_get_drvdata(component); int ret;

- wm_hubs_set_bias_level(codec, level); + wm_hubs_set_bias_level(component, level);

switch (level) { case SND_SOC_BIAS_ON: case SND_SOC_BIAS_PREPARE: /* VMID=2*40k */ - snd_soc_update_bits(codec, WM8993_POWER_MANAGEMENT_1, + snd_soc_component_update_bits(component, WM8993_POWER_MANAGEMENT_1, WM8993_VMID_SEL_MASK, 0x2); - snd_soc_update_bits(codec, WM8993_POWER_MANAGEMENT_2, + snd_soc_component_update_bits(component, WM8993_POWER_MANAGEMENT_2, WM8993_TSHUT_ENA, WM8993_TSHUT_ENA); break;

case SND_SOC_BIAS_STANDBY: - if (snd_soc_codec_get_bias_level(codec) == SND_SOC_BIAS_OFF) { + if (snd_soc_component_get_bias_level(component) == SND_SOC_BIAS_OFF) { ret = regulator_bulk_enable(ARRAY_SIZE(wm8993->supplies), wm8993->supplies); if (ret != 0) @@ -1000,10 +1000,10 @@ static int wm8993_set_bias_level(struct snd_soc_codec *codec, regcache_cache_only(wm8993->regmap, false); regcache_sync(wm8993->regmap);

- wm_hubs_vmid_ena(codec); + wm_hubs_vmid_ena(component);

/* Bring up VMID with fast soft start */ - snd_soc_update_bits(codec, WM8993_ANTIPOP2, + snd_soc_component_update_bits(component, WM8993_ANTIPOP2, WM8993_STARTUP_BIAS_ENA | WM8993_VMID_BUF_ENA | WM8993_VMID_RAMP_MASK | @@ -1017,40 +1017,40 @@ static int wm8993_set_bias_level(struct snd_soc_codec *codec, * need the VMID buffer */ if (!wm8993->pdata.lineout1_diff || !wm8993->pdata.lineout2_diff) - snd_soc_update_bits(codec, WM8993_ANTIPOP1, + snd_soc_component_update_bits(component, WM8993_ANTIPOP1, WM8993_LINEOUT_VMID_BUF_ENA, WM8993_LINEOUT_VMID_BUF_ENA);

/* VMID=2*40k */ - snd_soc_update_bits(codec, WM8993_POWER_MANAGEMENT_1, + snd_soc_component_update_bits(component, WM8993_POWER_MANAGEMENT_1, WM8993_VMID_SEL_MASK | WM8993_BIAS_ENA, WM8993_BIAS_ENA | 0x2); msleep(32);

/* Switch to normal bias */ - snd_soc_update_bits(codec, WM8993_ANTIPOP2, + snd_soc_component_update_bits(component, WM8993_ANTIPOP2, WM8993_BIAS_SRC | WM8993_STARTUP_BIAS_ENA, 0); }

/* VMID=2*240k */ - snd_soc_update_bits(codec, WM8993_POWER_MANAGEMENT_1, + snd_soc_component_update_bits(component, WM8993_POWER_MANAGEMENT_1, WM8993_VMID_SEL_MASK, 0x4);

- snd_soc_update_bits(codec, WM8993_POWER_MANAGEMENT_2, + snd_soc_component_update_bits(component, WM8993_POWER_MANAGEMENT_2, WM8993_TSHUT_ENA, 0); break;

case SND_SOC_BIAS_OFF: - snd_soc_update_bits(codec, WM8993_ANTIPOP1, + snd_soc_component_update_bits(component, WM8993_ANTIPOP1, WM8993_LINEOUT_VMID_BUF_ENA, 0);

- snd_soc_update_bits(codec, WM8993_POWER_MANAGEMENT_1, + snd_soc_component_update_bits(component, WM8993_POWER_MANAGEMENT_1, WM8993_VMID_SEL_MASK | WM8993_BIAS_ENA, 0);

- snd_soc_update_bits(codec, WM8993_ANTIPOP2, + snd_soc_component_update_bits(component, WM8993_ANTIPOP2, WM8993_STARTUP_BIAS_ENA | WM8993_VMID_BUF_ENA | WM8993_VMID_RAMP_MASK | @@ -1070,8 +1070,8 @@ static int wm8993_set_bias_level(struct snd_soc_codec *codec, static int wm8993_set_sysclk(struct snd_soc_dai *codec_dai, int clk_id, unsigned int freq, int dir) { - struct snd_soc_codec *codec = codec_dai->codec; - struct wm8993_priv *wm8993 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = codec_dai->component; + struct wm8993_priv *wm8993 = snd_soc_component_get_drvdata(component);

switch (clk_id) { case WM8993_SYSCLK_MCLK: @@ -1091,10 +1091,10 @@ static int wm8993_set_sysclk(struct snd_soc_dai *codec_dai, static int wm8993_set_dai_fmt(struct snd_soc_dai *dai, unsigned int fmt) { - struct snd_soc_codec *codec = dai->codec; - struct wm8993_priv *wm8993 = snd_soc_codec_get_drvdata(codec); - unsigned int aif1 = snd_soc_read(codec, WM8993_AUDIO_INTERFACE_1); - unsigned int aif4 = snd_soc_read(codec, WM8993_AUDIO_INTERFACE_4); + struct snd_soc_component *component = dai->component; + struct wm8993_priv *wm8993 = snd_soc_component_get_drvdata(component); + unsigned int aif1 = snd_soc_component_read32(component, WM8993_AUDIO_INTERFACE_1); + unsigned int aif4 = snd_soc_component_read32(component, WM8993_AUDIO_INTERFACE_4);

aif1 &= ~(WM8993_BCLK_DIR | WM8993_AIF_BCLK_INV | WM8993_AIF_LRCLK_INV | WM8993_AIF_FMT_MASK); @@ -1178,8 +1178,8 @@ static int wm8993_set_dai_fmt(struct snd_soc_dai *dai, return -EINVAL; }

- snd_soc_write(codec, WM8993_AUDIO_INTERFACE_1, aif1); - snd_soc_write(codec, WM8993_AUDIO_INTERFACE_4, aif4); + snd_soc_component_write(component, WM8993_AUDIO_INTERFACE_1, aif1); + snd_soc_component_write(component, WM8993_AUDIO_INTERFACE_4, aif4);

return 0; } @@ -1188,28 +1188,28 @@ static int wm8993_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params, struct snd_soc_dai *dai) { - struct snd_soc_codec *codec = dai->codec; - struct wm8993_priv *wm8993 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = dai->component; + struct wm8993_priv *wm8993 = snd_soc_component_get_drvdata(component); int ret, i, best, best_val, cur_val; unsigned int clocking1, clocking3, aif1, aif4;

- clocking1 = snd_soc_read(codec, WM8993_CLOCKING_1); + clocking1 = snd_soc_component_read32(component, WM8993_CLOCKING_1); clocking1 &= ~WM8993_BCLK_DIV_MASK;

- clocking3 = snd_soc_read(codec, WM8993_CLOCKING_3); + clocking3 = snd_soc_component_read32(component, WM8993_CLOCKING_3); clocking3 &= ~(WM8993_CLK_SYS_RATE_MASK | WM8993_SAMPLE_RATE_MASK);

- aif1 = snd_soc_read(codec, WM8993_AUDIO_INTERFACE_1); + aif1 = snd_soc_component_read32(component, WM8993_AUDIO_INTERFACE_1); aif1 &= ~WM8993_AIF_WL_MASK;

- aif4 = snd_soc_read(codec, WM8993_AUDIO_INTERFACE_4); + aif4 = snd_soc_component_read32(component, WM8993_AUDIO_INTERFACE_4); aif4 &= ~WM8993_LRCLK_RATE_MASK;

/* What BCLK do we need? */ wm8993->fs = params_rate(params); wm8993->bclk = 2 * wm8993->fs; if (wm8993->tdm_slots) { - dev_dbg(codec->dev, "Configuring for %d %d bit TDM slots\n", + dev_dbg(component->dev, "Configuring for %d %d bit TDM slots\n", wm8993->tdm_slots, wm8993->tdm_width); wm8993->bclk *= wm8993->tdm_width * wm8993->tdm_slots; } else { @@ -1234,9 +1234,9 @@ static int wm8993_hw_params(struct snd_pcm_substream *substream, } }

- dev_dbg(codec->dev, "Target BCLK is %dHz\n", wm8993->bclk); + dev_dbg(component->dev, "Target BCLK is %dHz\n", wm8993->bclk);

- ret = configure_clock(codec); + ret = configure_clock(component); if (ret != 0) return ret;

@@ -1252,7 +1252,7 @@ static int wm8993_hw_params(struct snd_pcm_substream *substream, best_val = cur_val; } } - dev_dbg(codec->dev, "Selected CLK_SYS_RATIO of %d\n", + dev_dbg(component->dev, "Selected CLK_SYS_RATIO of %d\n", clk_sys_rates[best].ratio); clocking3 |= (clk_sys_rates[best].clk_sys_rate << WM8993_CLK_SYS_RATE_SHIFT); @@ -1268,7 +1268,7 @@ static int wm8993_hw_params(struct snd_pcm_substream *substream, best_val = cur_val; } } - dev_dbg(codec->dev, "Selected SAMPLE_RATE of %dHz\n", + dev_dbg(component->dev, "Selected SAMPLE_RATE of %dHz\n", sample_rates[best].rate); clocking3 |= (sample_rates[best].sample_rate << WM8993_SAMPLE_RATE_SHIFT); @@ -1287,22 +1287,22 @@ static int wm8993_hw_params(struct snd_pcm_substream *substream, } } wm8993->bclk = (wm8993->sysclk_rate * 10) / bclk_divs[best].div; - dev_dbg(codec->dev, "Selected BCLK_DIV of %d for %dHz BCLK\n", + dev_dbg(component->dev, "Selected BCLK_DIV of %d for %dHz BCLK\n", bclk_divs[best].div, wm8993->bclk); clocking1 |= bclk_divs[best].bclk_div << WM8993_BCLK_DIV_SHIFT;

/* LRCLK is a simple fraction of BCLK */ - dev_dbg(codec->dev, "LRCLK_RATE is %d\n", wm8993->bclk / wm8993->fs); + dev_dbg(component->dev, "LRCLK_RATE is %d\n", wm8993->bclk / wm8993->fs); aif4 |= wm8993->bclk / wm8993->fs;

- snd_soc_write(codec, WM8993_CLOCKING_1, clocking1); - snd_soc_write(codec, WM8993_CLOCKING_3, clocking3); - snd_soc_write(codec, WM8993_AUDIO_INTERFACE_1, aif1); - snd_soc_write(codec, WM8993_AUDIO_INTERFACE_4, aif4); + snd_soc_component_write(component, WM8993_CLOCKING_1, clocking1); + snd_soc_component_write(component, WM8993_CLOCKING_3, clocking3); + snd_soc_component_write(component, WM8993_AUDIO_INTERFACE_1, aif1); + snd_soc_component_write(component, WM8993_AUDIO_INTERFACE_4, aif4);

/* ReTune Mobile? */ if (wm8993->pdata.num_retune_configs) { - u16 eq1 = snd_soc_read(codec, WM8993_EQ1); + u16 eq1 = snd_soc_component_read32(component, WM8993_EQ1); struct wm8993_retune_mobile_setting *s;

best = 0; @@ -1318,16 +1318,16 @@ static int wm8993_hw_params(struct snd_pcm_substream *substream, } s = &wm8993->pdata.retune_configs[best];

- dev_dbg(codec->dev, "ReTune Mobile %s tuned for %dHz\n", + dev_dbg(component->dev, "ReTune Mobile %s tuned for %dHz\n", s->name, s->rate);

/* Disable EQ while we reconfigure */ - snd_soc_update_bits(codec, WM8993_EQ1, WM8993_EQ_ENA, 0); + snd_soc_component_update_bits(component, WM8993_EQ1, WM8993_EQ_ENA, 0);

for (i = 1; i < ARRAY_SIZE(s->config); i++) - snd_soc_write(codec, WM8993_EQ1 + i, s->config[i]); + snd_soc_component_write(component, WM8993_EQ1 + i, s->config[i]);

- snd_soc_update_bits(codec, WM8993_EQ1, WM8993_EQ_ENA, eq1); + snd_soc_component_update_bits(component, WM8993_EQ1, WM8993_EQ_ENA, eq1); }

return 0; @@ -1335,17 +1335,17 @@ static int wm8993_hw_params(struct snd_pcm_substream *substream,

static int wm8993_digital_mute(struct snd_soc_dai *codec_dai, int mute) { - struct snd_soc_codec *codec = codec_dai->codec; + struct snd_soc_component *component = codec_dai->component; unsigned int reg;

- reg = snd_soc_read(codec, WM8993_DAC_CTRL); + reg = snd_soc_component_read32(component, WM8993_DAC_CTRL);

if (mute) reg |= WM8993_DAC_MUTE; else reg &= ~WM8993_DAC_MUTE;

- snd_soc_write(codec, WM8993_DAC_CTRL, reg); + snd_soc_component_write(component, WM8993_DAC_CTRL, reg);

return 0; } @@ -1353,8 +1353,8 @@ static int wm8993_digital_mute(struct snd_soc_dai *codec_dai, int mute) static int wm8993_set_tdm_slot(struct snd_soc_dai *dai, unsigned int tx_mask, unsigned int rx_mask, int slots, int slot_width) { - struct snd_soc_codec *codec = dai->codec; - struct wm8993_priv *wm8993 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = dai->component; + struct wm8993_priv *wm8993 = snd_soc_component_get_drvdata(component); int aif1 = 0; int aif2 = 0;

@@ -1396,9 +1396,9 @@ static int wm8993_set_tdm_slot(struct snd_soc_dai *dai, unsigned int tx_mask, wm8993->tdm_width = slot_width; wm8993->tdm_slots = slots / 2;

- snd_soc_update_bits(codec, WM8993_AUDIO_INTERFACE_1, + snd_soc_component_update_bits(component, WM8993_AUDIO_INTERFACE_1, WM8993_AIFADC_TDM | WM8993_AIFADC_TDM_CHAN, aif1); - snd_soc_update_bits(codec, WM8993_AUDIO_INTERFACE_2, + snd_soc_component_update_bits(component, WM8993_AUDIO_INTERFACE_2, WM8993_AIFDAC_TDM | WM8993_AIFDAC_TDM_CHAN, aif2);

return 0; @@ -1481,10 +1481,10 @@ static irqreturn_t wm8993_irq(int irq, void *data) .symmetric_rates = 1, };

-static int wm8993_probe(struct snd_soc_codec *codec) +static int wm8993_probe(struct snd_soc_component *component) { - struct wm8993_priv *wm8993 = snd_soc_codec_get_drvdata(codec); - struct snd_soc_dapm_context *dapm = snd_soc_codec_get_dapm(codec); + struct wm8993_priv *wm8993 = snd_soc_component_get_drvdata(component); + struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(component);

wm8993->hubs_data.hp_startup_mode = 1; wm8993->hubs_data.dcs_codes_l = -2; @@ -1492,20 +1492,20 @@ static int wm8993_probe(struct snd_soc_codec *codec) wm8993->hubs_data.series_startup = 1;

/* Latch volume update bits and default ZC on */ - snd_soc_update_bits(codec, WM8993_RIGHT_DAC_DIGITAL_VOLUME, + snd_soc_component_update_bits(component, WM8993_RIGHT_DAC_DIGITAL_VOLUME, WM8993_DAC_VU, WM8993_DAC_VU); - snd_soc_update_bits(codec, WM8993_RIGHT_ADC_DIGITAL_VOLUME, + snd_soc_component_update_bits(component, WM8993_RIGHT_ADC_DIGITAL_VOLUME, WM8993_ADC_VU, WM8993_ADC_VU);

/* Manualy manage the HPOUT sequencing for independent stereo * control. */ - snd_soc_update_bits(codec, WM8993_ANALOGUE_HP_0, + snd_soc_component_update_bits(component, WM8993_ANALOGUE_HP_0, WM8993_HPOUT1_AUTO_PU, 0);

/* Use automatic clock configuration */ - snd_soc_update_bits(codec, WM8993_CLOCKING_4, WM8993_SR_MODE, 0); + snd_soc_component_update_bits(component, WM8993_CLOCKING_4, WM8993_SR_MODE, 0);

- wm_hubs_handle_analogue_pdata(codec, wm8993->pdata.lineout1_diff, + wm_hubs_handle_analogue_pdata(component, wm8993->pdata.lineout1_diff, wm8993->pdata.lineout2_diff, wm8993->pdata.lineout1fb, wm8993->pdata.lineout2fb, @@ -1516,22 +1516,22 @@ static int wm8993_probe(struct snd_soc_codec *codec) wm8993->pdata.micbias1_lvl, wm8993->pdata.micbias2_lvl);

- snd_soc_add_codec_controls(codec, wm8993_snd_controls, + snd_soc_add_component_controls(component, wm8993_snd_controls, ARRAY_SIZE(wm8993_snd_controls)); if (wm8993->pdata.num_retune_configs != 0) { - dev_dbg(codec->dev, "Using ReTune Mobile\n"); + dev_dbg(component->dev, "Using ReTune Mobile\n"); } else { - dev_dbg(codec->dev, "No ReTune Mobile, using normal EQ\n"); - snd_soc_add_codec_controls(codec, wm8993_eq_controls, + dev_dbg(component->dev, "No ReTune Mobile, using normal EQ\n"); + snd_soc_add_component_controls(component, wm8993_eq_controls, ARRAY_SIZE(wm8993_eq_controls)); }

snd_soc_dapm_new_controls(dapm, wm8993_dapm_widgets, ARRAY_SIZE(wm8993_dapm_widgets)); - wm_hubs_add_analogue_controls(codec); + wm_hubs_add_analogue_controls(component);

snd_soc_dapm_add_routes(dapm, routes, ARRAY_SIZE(routes)); - wm_hubs_add_analogue_routes(codec, wm8993->pdata.lineout1_diff, + wm_hubs_add_analogue_routes(component, wm8993->pdata.lineout1_diff, wm8993->pdata.lineout2_diff);

/* If the line outputs are differential then we aren't presenting @@ -1545,34 +1545,34 @@ static int wm8993_probe(struct snd_soc_codec *codec) }

#ifdef CONFIG_PM -static int wm8993_suspend(struct snd_soc_codec *codec) +static int wm8993_suspend(struct snd_soc_component *component) { - struct wm8993_priv *wm8993 = snd_soc_codec_get_drvdata(codec); + struct wm8993_priv *wm8993 = snd_soc_component_get_drvdata(component); int fll_fout = wm8993->fll_fout; int fll_fref = wm8993->fll_fref; int ret;

/* Stop the FLL in an orderly fashion */ - ret = _wm8993_set_fll(codec, 0, 0, 0, 0); + ret = _wm8993_set_fll(component, 0, 0, 0, 0); if (ret != 0) { - dev_err(codec->dev, "Failed to stop FLL\n"); + dev_err(component->dev, "Failed to stop FLL\n"); return ret; }

wm8993->fll_fout = fll_fout; wm8993->fll_fref = fll_fref;

- snd_soc_codec_force_bias_level(codec, SND_SOC_BIAS_OFF); + snd_soc_component_force_bias_level(component, SND_SOC_BIAS_OFF);

return 0; }

-static int wm8993_resume(struct snd_soc_codec *codec) +static int wm8993_resume(struct snd_soc_component *component) { - struct wm8993_priv *wm8993 = snd_soc_codec_get_drvdata(codec); + struct wm8993_priv *wm8993 = snd_soc_component_get_drvdata(component); int ret;

- snd_soc_codec_force_bias_level(codec, SND_SOC_BIAS_STANDBY); + snd_soc_component_force_bias_level(component, SND_SOC_BIAS_STANDBY);

/* Restart the FLL? */ if (wm8993->fll_fout) { @@ -1582,10 +1582,10 @@ static int wm8993_resume(struct snd_soc_codec *codec) wm8993->fll_fref = 0; wm8993->fll_fout = 0;

- ret = _wm8993_set_fll(codec, 0, wm8993->fll_src, + ret = _wm8993_set_fll(component, 0, wm8993->fll_src, fll_fref, fll_fout); if (ret != 0) - dev_err(codec->dev, "Failed to restart FLL\n"); + dev_err(component->dev, "Failed to restart FLL\n"); }

return 0; @@ -1615,11 +1615,15 @@ static int wm8993_resume(struct snd_soc_codec *codec) .num_reg_defaults = ARRAY_SIZE(wm8993_reg_defaults), };

-static const struct snd_soc_codec_driver soc_codec_dev_wm8993 = { - .probe = wm8993_probe, - .sus