ASoC: Add support for AN7581 PCM driver
Subsystems (3)
v6 cover ASoC: Add support for AN7581 PCM driver
The Airoha AN7581 SoC provides a PCM interface for VoIP applications, supporting playback and capture at sample rates of 8 kHz and 16 kHz. The driver configures the PCM bit clock to 2.048 MHz and supports 8-bit and 16-bit samples, with up to 32 channels.
Add YAML and driver. This has been verified with loopback and confirmed by Airoha with ZSI voice chip.
Changes v6:
- Better handle IRQ with IRQ_NONE
- Drop wrong DPCM values
- Add comments about CHBF_OFFSET
- Add comments for HW pointer reset
- Validate that slot fit in the BCLK
- Add INFO_BATCH
- Fix wrong define name for 2048KHz
- Drop unused header
- Select CONFIG_REGMAP_MMIO
Changes v5:
- Use local reset variable
- Fix validation for channel and bit mask
- Drop use of threaded IRQ
- Return if snd_pcm_hw_constraint_integer errors out
Changes v4:
- Add review by tag for DT patch
- Address shashiko bot comments
- Better protext tx pos
- Set DMA mask for coherent DMA
- Use more managed resource
- Increase users in startup
Changes v3:
- Out of RFC
- Add Documentation patch
- Drop SLIC testing code
- Add MAINTAINERS entry
- Follow normal pattern for commit title
- Improve commit description
Changes v2:
- Rentirely rework IRQ handling
- Fix problem for timeslow configuration
- Better support duplex mode
- Better handle descriptor tracking
- Move to Soc directory
- General code fixup and cleanup
Christian Marangi (2):
ASoC: dt-bindings: airoha: Add AN7581 PCM controller
ASoC: airoha: Add support for AN7581 PCM driver
.../bindings/sound/airoha,an7581-pcm.yaml | 52 + MAINTAINERS | 7 + sound/soc/Kconfig | 1 + sound/soc/Makefile | 1 + sound/soc/airoha/Kconfig | 11 + sound/soc/airoha/Makefile | 3 + sound/soc/airoha/an7581-pcm.c | 931 ++++++++++++++++++ 7 files changed, 1006 insertions(+) create mode 100644 Documentation/devicetree/bindings/sound/airoha,an7581-pcm.yaml create mode 100644 sound/soc/airoha/Kconfig create mode 100644 sound/soc/airoha/Makefile create mode 100644 sound/soc/airoha/an7581-pcm.c
Signature · 1 line
2.55.0
PATCH v6 1/2 ASoC: dt-bindings: airoha: Add AN7581 PCM controller
The Airoha AN7581 SoC provides a PCM interface for VoIP applications, supporting playback and capture at sample rates of 8 kHz and 16 kHz. The driver configures the PCM bit clock to 2.048 MHz and supports 8-bit and 16-bit samples, with up to 32 channels.
Document the related compatible and required interrupt/reset and provide an example for it.
--- .../bindings/sound/airoha,an7581-pcm.yaml | 52 +++++++++++++++++++ 1 file changed, 52 insertions(+) create mode 100644 Documentation/devicetree/bindings/sound/airoha,an7581-pcm.yaml
Documentation/devicetree/bindings/sound/airoha,an7581-pcm.yaml new file +52 -0
@@ -0,0 +1,52 @@ +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/sound/airoha,an7581-pcm.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: Airoha PCM controller for AN7581 SoC + +maintainers: + - Christian Marangi <[email protected]> + +properties: + compatible: + const: airoha,an7581-pcm + + reg: + maxItems: 1 + + interrupts: + maxItems: 1 + + resets: + maxItems: 1 + + reset-names: + const: pcm1 + +required: + - compatible + - reg + - interrupts + - resets + - reset-names + +additionalProperties: false + +examples: + - | + #include <dt-bindings/interrupt-controller/arm-gic.h> + #include <dt-bindings/interrupt-controller/irq.h> + #include <dt-bindings/reset/airoha,en7581-reset.h> + + pcm@1fbd0000 { + compatible = "airoha,an7581-pcm"; + reg = <0x1fbd0000 0x10000>; + + interrupts = <GIC_SPI 27 IRQ_TYPE_LEVEL_HIGH>; + resets = <&scuclk EN7581_PCM1_RST>; + reset-names = "pcm1"; + }; + +...
Signature · 1 line
2.55.0
PATCH v6 2/2 ASoC: airoha: Add support for AN7581 PCM driver
In reply to Christian MarangiThe Airoha AN7581 SoC provides a PCM interface for VoIP applications, supporting playback and capture at sample rates of 8 kHz and 16 kHz. The driver configures the PCM bit clock to 2.048 KHz and supports 8-bit and 16-bit samples, with up to 32 channels.
Add an ASoC platform driver for the AN7581 PCM controller configured for ZSI attached voice chip.
--- MAINTAINERS | 7 + sound/soc/Kconfig | 1 + sound/soc/Makefile | 1 + sound/soc/airoha/Kconfig | 11 + sound/soc/airoha/Makefile | 3 + sound/soc/airoha/an7581-pcm.c | 931 ++++++++++++++++++++++++++++++++++ 6 files changed, 954 insertions(+) create mode 100644 sound/soc/airoha/Kconfig create mode 100644 sound/soc/airoha/Makefile create mode 100644 sound/soc/airoha/an7581-pcm.c
MAINTAINERS +7 -0
@@ -775,6 +775,13 @@ F: Documentation/devicetree/bindings/sound/airoha,an7581-afe.yaml F: Documentation/devicetree/bindings/sound/airoha,an7581-wm8960.yaml F: sound/soc/mediatek/an7581/* +AIROHA PCM CONTROLLER DRIVER +M: Christian Marangi <[email protected]> +L: [email protected] +S: Maintained +F: Documentation/devicetree/bindings/sound/airoha,an7581-pcm.yaml +F: sound/soc/airoha/* + AIROHA SPI SNFI DRIVER M: Lorenzo Bianconi <[email protected]> M: Ray Liu <[email protected]>
sound/soc/Kconfig +1 -0
@@ -103,6 +103,7 @@ config SND_SOC_USB # All the supported SoCs source "sound/soc/adi/Kconfig" +source "sound/soc/airoha/Kconfig" source "sound/soc/amd/Kconfig" source "sound/soc/apple/Kconfig" source "sound/soc/atmel/Kconfig"
sound/soc/Makefile +1 -0
@@ -46,6 +46,7 @@ obj-$(CONFIG_SND_SOC) += codecs/ obj-$(CONFIG_SND_SOC) += generic/ obj-$(CONFIG_SND_SOC) += apple/ obj-$(CONFIG_SND_SOC) += adi/ +obj-$(CONFIG_SND_SOC) += airoha/ obj-$(CONFIG_SND_SOC) += amd/ obj-$(CONFIG_SND_SOC) += atmel/ obj-$(CONFIG_SND_SOC) += au1x/
sound/soc/airoha/Kconfig new file +11 -0
@@ -0,0 +1,11 @@ +# SPDX-License-Identifier: GPL-2.0-only + +config SND_SOC_AN7581_PCM + tristate "PCM support for Airoha AN7581 chip" + depends on ARCH_AIROHA || COMPILE_TEST + select REGMAP_MMIO + help + This adds PCM driver for Airoha AN7581 boards + that can be used with other codecs. + Select Y if you have such device. + If unsure select "N".
sound/soc/airoha/Makefile new file +3 -0
@@ -0,0 +1,3 @@ +# SPDX-License-Identifier: GPL-2.0 + +obj-$(CONFIG_SND_SOC_AN7581_PCM) += an7581-pcm.o
sound/soc/airoha/an7581-pcm.c new file +931 -0
931 lines not on this page · raw message
Signature · 1 line
2.55.0
[email protected]
AI reviewRe: [PATCH v6 2/2] ASoC: airoha: Add support for AN7581 PCM driver
Thank you for your contribution! Sashiko AI review found 10 potential issues to consider: - [High] ASoC: airoha: broken full-duplex state tracking in an7581_pcm_hw_params() - [High] ASoC: airoha…
Thank you for your contribution! Sashiko AI review found 10 potential issues to consider:
- [High] ASoC: airoha: broken full-duplex state tracking in an7581_pcm_hw_params()
- [High] ASoC: airoha: broken hw_avail check and DMA polling in an7581_pcm_irq_handler()
- [High] ASoC: airoha: premature devm_request_irq() ordering in an7581_pcm_probe()
- [High] ASoC: airoha: unsynchronized substream lifetime in an7581_pcm_irq_handler()
- [Medium] ASoC: airoha: uninitialized ret and IRQ_NONE return in an7581_pcm_irq_handler()
- [Medium] ASoC: airoha: tx_pos and rx_pos overflow and wrap jump in an7581_pcm_pointer()
- [Medium] ASoC: airoha: positive return from an7581_pcm_startup() breaks rollback
- [Medium] ASoC: airoha: missing check for 0 from of_irq_get() in an7581_pcm_probe()
- [Medium] ASoC: airoha: unlocked descriptor and ring updates in an7581_pcm_irq_handler()
- [Low] ASoC: airoha: unsorted MAINTAINERS entry and wrong BCLK unit in commit message
--
commit 09235bd500296f2b66ed726582858bf27dd4183c
Author: Christian Marangi <[email protected]>
ASoC: airoha: Add support for AN7581 PCM driver
This commit adds an ASoC platform driver for the Airoha AN7581 SoC PCM controller supporting up to 32 channels at 8 kHz and 16 kHz.
Quoted 8 lines
MAINTAINERS +0
-0@@ -796,6 +796,13 @@ F: Documentation/devicetree/bindings/sound/airoha,an7581-afe.yaml F: Documentation/devicetree/bindings/sound/airoha,an7581-wm8960.yaml F: sound/soc/mediatek/an7581/*
MAINTAINERS F: Documentation/devicetree/bindings/sound/airoha,an7581-afe.yaml · line 808
Quoted 10 lines
MAINTAINERS +7
-0+AIROHA PCM CONTROLLER DRIVER +M: Christian Marangi <[email protected]> +L: [email protected] +S: Maintained +F: Documentation/devicetree/bindings/sound/airoha,an7581-pcm.yaml +F: sound/soc/airoha/* + AIROHA SPI SNFI DRIVER M: Lorenzo Bianconi <[email protected]> M: Ray Liu <[email protected]>
[Severity: Low]
This isn't a bug, but AIROHA PCM CONTROLLER DRIVER is placed after AIROHA SOUND DRIVER instead of in alphabetical order after AIROHA PCIE PHY DRIVER. Also, the commit message says the bit clock is configured to "2.048 KHz", whereas an7581_pcm_hw_params() sets AN7581_PCM_BIT_CLK_2048KHZ (2048 kHz / 2.048 MHz).
Quoted 5 lines
sound/soc/airoha/an7581-pcm.c new file +0
-0
[ ... ]
Quoted 47 lines
sound/soc/airoha/an7581-pcm.c new file +47
-0+static int an7581_pcm_startup (struct snd_pcm_substream *substream, +struct snd_soc_dai *dai) +{ +struct snd_soc_pcm_runtime *rtd =snd_soc_substream_to_rtd (substream); +struct an7581_pcm_priv *priv =snd_soc_card_get_drvdata (rtd->card); +struct snd_pcm_runtime *runtime = substream->runtime; +int ret; + +snd_soc_set_runtime_hwparams (substream, &an7581_pcm_hardware); + + ret =snd_pcm_hw_constraint_minmax (runtime,SNDRV_PCM_HW_PARAM_PERIOD_SIZE , +AN7581_PCM_FRAMES_PER_DESC , +AN7581_PCM_FRAMES_PER_DESC ); +if (ret <0 ) { +dev_err (rtd->card->dev,"failed to constrain period to 80 frames\n" ); +return ret; + } + + ret =snd_pcm_hw_constraint_integer (runtime,SNDRV_PCM_HW_PARAM_PERIODS ); +if (ret <0 ) { +dev_err (rtd->card->dev,"snd_pcm_hw_constraint_integer failed\n" ); +return ret; + } + +/* Cache stream substream for IRQ handling */ + priv->stream[substream->stream] = substream; + +/* On open mask interrupt and disable DMA */ +if (substream->stream ==SNDRV_PCM_STREAM_PLAYBACK ) { +regmap_clear_bits (priv->map,AN7581_PCM_IMR , +AN7581_PCM_IMR_TDESC_UPDATE_INT ); +regmap_clear_bits (priv->map,AN7581_PCM_TRDCR , +AN7581_PCM_TXDMA_ENABLE ); + }else { +regmap_clear_bits (priv->map,AN7581_PCM_IMR , +AN7581_PCM_IMR_RDESC_UPDATE_INT ); +regmap_clear_bits (priv->map,AN7581_PCM_TRDCR , +AN7581_PCM_RXDMA_ENABLE ); + } + +usleep_range (10000 ,20000 ); + +mutex_lock (&priv->user_lock); + +if (!priv->users) { +regmap_clear_bits (priv->map,AN7581_PCM_PICR , +AN7581_PCM_CFG_VALID );
sound/soc/airoha/an7581-pcm.c line 324
Quoted 10 lines
sound/soc/airoha/an7581-pcm.c new file +10
-0+ +usleep_range (5000 ,10000 ); + } + + priv->users++; + +mutex_unlock (&priv->user_lock); + +return ret; +}
[Severity: Medium]
Does an7581_pcm_startup() return 1 instead of 0 on success?
snd_pcm_hw_constraint_integer() returns positive 1 when it modifies the SNDRV_PCM_HW_PARAM_PERIODS interval, and snd_soc_dai_startup() only marks the DAI as started when the callback returns 0:
sound/soc/soc-dai.c:snd_soc_dai_startup() {
...
/* mark substream if succeeded */
if (ret == 0)
soc_dai_mark_push(dai, substream, startup);
...
}If a later step in __soc_pcm_open() fails, snd_soc_dai_shutdown() skips calling an7581_pcm_shutdown() on rollback, leaking priv->users and leaving priv->stream[substream->stream] pointing to a freed substream.
Quoted 24 lines
sound/soc/airoha/an7581-pcm.c new file +24
-0+static void an7581_pcm_shutdown (struct snd_pcm_substream *substream, +struct snd_soc_dai *dai) +{ +struct snd_soc_pcm_runtime *rtd =snd_soc_substream_to_rtd (substream); +struct an7581_pcm_priv *priv =snd_soc_card_get_drvdata (rtd->card); + +/* On close mask interrupt and disable DMA */ +if (substream->stream ==SNDRV_PCM_STREAM_PLAYBACK ) { +regmap_clear_bits (priv->map,AN7581_PCM_IMR , +AN7581_PCM_IMR_TDESC_UPDATE_INT ); +regmap_clear_bits (priv->map,AN7581_PCM_TRDCR , +AN7581_PCM_TXDMA_ENABLE ); + }else { +regmap_clear_bits (priv->map,AN7581_PCM_IMR , +AN7581_PCM_IMR_RDESC_UPDATE_INT ); +regmap_clear_bits (priv->map,AN7581_PCM_TRDCR , +AN7581_PCM_RXDMA_ENABLE ); + } + + priv->stream[substream->stream] =NULL ; + +usleep_range (10000 ,20000 ); + +mutex_lock (&priv->user_lock);
sound/soc/airoha/an7581-pcm.c line 359
Quoted 10 lines
sound/soc/airoha/an7581-pcm.c new file +10
-0+ +if (priv->users) + priv->users--; + +if (!priv->users) +regmap_clear_bits (priv->map,AN7581_PCM_PICR , +AN7581_PCM_CFG_VALID ); + +mutex_unlock (&priv->user_lock); +}
[Severity: High]
Can an7581_pcm_irq_handler() race with an7581_pcm_shutdown() and dereference a freed substream->runtime?
CPU0 CPU1an7581_pcm_irq_handler()
substream = priv->stream[...]
snd_pcm_release_substream()
...
an7581_pcm_shutdown()
priv->stream[...] = NULL
snd_pcm_detach_substream()
substream->runtime = NULL
kfree(runtime) runtime = substream->runtime
frames_to_bytes(runtime, ...) <-- NULL deref / use-after-free
The driver neither sets card->snd_card->sync_irq nor synchronizes with the IRQ handler before clearing priv->stream[]. Similarly, on SNDRV_PCM_IOCTL_DROP an in-flight IRQ waiting on pcm_stream_lock inside snd_pcm_period_elapsed() can resume after an7581_pcm_trigger(SNDRV_PCM_TRIGGER_STOP) finishes and write AN7581_PCM_TPDR or AN7581_PCM_RPDR to re-trigger DMA polling on the stopped stream. In addition, an7581_pcm_startup() publishes priv->stream[] before hw_params() and prepare() initialize runtime and descriptors, while an7581_pcm_irq_handler() does not mask AN7581_PCM_ISR with AN7581_PCM_IMR.
Quoted 28 lines
sound/soc/airoha/an7581-pcm.c new file +28
-0+/* +* Hardware position is always reset to the start when a TX/RX polling is +* triggered. This is handled in trigger. +*/ +static int an7581_pcm_prepare (struct snd_pcm_substream *substream, +struct snd_soc_dai *dai) +{ +struct snd_soc_pcm_runtime *rtd =snd_soc_substream_to_rtd (substream); +struct an7581_pcm_priv *priv =snd_soc_card_get_drvdata (rtd->card); +struct snd_pcm_runtime *runtime = substream->runtime; +struct an7581_pcm_desc *desc; +unsigned int period_bytes; +unsigned long flags; +int num_desc, i; + +spin_lock_irqsave (&priv->desc_lock, flags); +if (substream->stream ==SNDRV_PCM_STREAM_PLAYBACK ) { + priv->tx_pos =0 ; + priv->tx_desc_idx =0 ; + desc = priv->tx_descs; + num_desc =AN7581_PCM_TX_DESCRIPTORS ; + }else { + priv->rx_pos =0 ; + priv->rx_desc_idx =0 ; + desc = priv->rx_descs; + num_desc =AN7581_PCM_RX_DESCRIPTORS ; + } +spin_unlock_irqrestore (&priv->desc_lock, flags);
sound/soc/airoha/an7581-pcm.c line 398
Quoted 10 lines
sound/soc/airoha/an7581-pcm.c new file +10
-0+ + period_bytes =frames_to_bytes (runtime,AN7581_PCM_FRAMES_PER_DESC ); +for (i =0 ; i < num_desc; i++) { + desc->status |=AN7581_PCM_DESC_STATUS_OWNERSHIP_DMA ; + desc->dma_addr = runtime->dma_addr + i * period_bytes; + desc++; + } + +return 0 ; +}
[Severity: Medium]
Can an in-flight an7581_pcm_irq_handler() race with an7581_pcm_prepare() or an7581_pcm_hw_params() on descriptor state?
CPU0 CPU1an7581_pcm_irq_handler()
spin_unlock_irqrestore(&priv->desc_lock, ...)
snd_pcm_period_elapsed(substream)
an7581_pcm_hw_params()
desc[0].status = ... /* OWNERSHIP_CPU */
an7581_pcm_prepare()
spin_lock_irqsave(&priv->desc_lock, ...)
priv->tx_pos = 0
priv->tx_desc_idx = 0
spin_unlock_irqrestore(&priv->desc_lock, ...) /* next loop iteration i = 1 */
spin_lock_irqsave(&priv->desc_lock, ...)
desc = &priv->tx_descs[priv->tx_desc_idx]
/* sees OWNERSHIP_CPU from hw_params */
priv->tx_pos += ...
priv->tx_desc_idx++ <-- corrupts reset ring state
an7581_pcm_irq_handler() drops priv->desc_lock before calling snd_pcm_period_elapsed() and setting AN7581_PCM_DESC_STATUS_OWNERSHIP_DMA, and both an7581_pcm_prepare() and an7581_pcm_hw_params() modify desc->status outside priv->desc_lock without IRQ synchronization. In addition, an7581_pcm_irq_handler() calls snd_pcm_capture_hw_avail() and snd_pcm_playback_hw_avail() without holding the PCM substream lock.
Quoted 28 lines
sound/soc/airoha/an7581-pcm.c new file +28
-0+static int an7581_pcm_hw_params (struct snd_pcm_substream *substream, +struct snd_pcm_hw_params *params, +struct snd_soc_dai *dai) +{ +struct snd_soc_pcm_runtime *rtd =snd_soc_substream_to_rtd (substream); +struct an7581_pcm_priv *priv =snd_soc_card_get_drvdata (rtd->card); +unsigned int channels =params_channels (params); +unsigned int rate =params_rate (params); +int bit_width =params_width (params); +struct an7581_pcm_desc *desc; +int num_desc, i; + +if (substream->stream ==SNDRV_PCM_STREAM_PLAYBACK ) { + desc = priv->tx_descs; + num_desc =AN7581_PCM_TX_DESCRIPTORS ; + }else { + desc = priv->rx_descs; + num_desc =AN7581_PCM_RX_DESCRIPTORS ; + } + +mutex_lock (&priv->user_lock); +if (priv->users >1 && + (priv->current_rate != rate || + priv->current_channels != channels)) { +dev_err (rtd->card->dev,"playback/capture rates/channels must match in full-duplex mode\n" ); +mutex_unlock (&priv->user_lock); +return -EBUSY ; + }
[ ... ]
Quoted 8 lines
sound/soc/airoha/an7581-pcm.c new file +8
-0+if (priv->users <=1 ) { +/* Enable channels */ +regmap_update_bits (priv->map,AN7581_PCM_DCHENR , +AN7581_PCM_CHAN_EN , +FIELD_PREP (AN7581_PCM_CHAN_EN ,GENMASK (channels -1 ,0 ))); + +/* Signal PCM configuration is now valid */ + regmap_set_bits(priv->map, AN7581_PCM_PICR,
sound/soc/airoha/an7581-pcm.c line 518
Quoted 10 lines
sound/soc/airoha/an7581-pcm.c new file +10
-0+ AN7581_PCM_CFG_VALID); + } + + priv->current_rate = rate; + priv->current_channels = channels; + +mutex_unlock (&priv->user_lock); + +return 0 ; +}
[Severity: High]
Does opening both playback and capture substreams before calling hw_params() break full-duplex setup?
an7581_pcm_startup() increments priv->users on open, so priv->users is already 2 when a full-duplex application opens both streams before configuring them. On the first call to an7581_pcm_hw_params(), priv->current_rate and priv->current_channels are still 0 (or stale from an earlier session), causing the priv->users > 1 check to reject hw_params() with -EBUSY; even if the values match a prior session, all shared register writes (AN7581_PCM_PICR including AN7581_PCM_CFG_VALID, AN7581_PCM_TRDRSR, AN7581_PCM_CHBFOSR and AN7581_PCM_DCHENR) are guarded by priv->users <= 1 and get skipped on both streams. Also, AN7581_PCM_CHBFOSR is a single shared register programmed from bit_width, but full-duplex compatibility does not check that bit_width matches between playback and capture.
[ ... ]
Quoted 10 lines
sound/soc/airoha/an7581-pcm.c new file +10
-0+static snd_pcm_uframes_t an7581_pcm_pointer (struct snd_soc_component *component, +struct snd_pcm_substream *substream) +{ +struct snd_soc_card *card = component->card; +struct snd_pcm_runtime *runtime = substream->runtime; +struct an7581_pcm_priv *priv; +unsigned long flags; +unsigned int pos; + + priv =snd_soc_card_get_drvdata (card);
sound/soc/airoha/an7581-pcm.c line 631
Quoted 10 lines
sound/soc/airoha/an7581-pcm.c new file +10
-0+ +spin_lock_irqsave (&priv->desc_lock, flags); +if (substream->stream ==SNDRV_PCM_STREAM_PLAYBACK ) + pos =bytes_to_frames (runtime, priv->tx_pos); +else + pos =bytes_to_frames (runtime, priv->rx_pos); +spin_unlock_irqrestore (&priv->desc_lock, flags); + +return pos % runtime->buffer_size; +}
[Severity: Medium]
Can priv->tx_pos and priv->rx_pos overflow in an7581_pcm_pointer() during sustained streaming?
an7581_pcm_irq_handler() increments priv->tx_pos and priv->rx_pos without wrapping at the buffer byte size. On 32-bit builds, bytes_to_frames() computes size * 8 / runtime->frame_bits in signed 32-bit ssize_t, which overflows once 256 MiB is transferred; and when the 32-bit unsigned int counter wraps at 4 GiB, pos % runtime->buffer_size (1200 frames) jumps discontinuously because 2^32 is not a multiple of 1200. Wrapping tx_pos and rx_pos modulo snd_pcm_lib_buffer_bytes(substream) when updating them avoids both issues.
[ ... ]
Quoted 110 lines
sound/soc/airoha/an7581-pcm.c new file +110
-0+static irqreturn_t an7581_pcm_irq_handler (int irq,void *data) +{ +struct snd_pcm_substream *substream; +struct an7581_pcm_priv *priv = data; +unsigned long flags; +u32 status, isr =0 ; +int ret; + +regmap_read (priv->map,AN7581_PCM_ISR , &isr); + +/* Scan descriptor on receiving RX desc update interrupt */ +if (isr &AN7581_PCM_IMR_RDESC_UPDATE_INT ) { +struct snd_pcm_runtime *runtime; +struct an7581_pcm_desc *desc; +unsigned int sample_size; +bool rx_poll = false; +int i; + + ret =IRQ_HANDLED ; + + substream = priv->stream[SNDRV_PCM_STREAM_CAPTURE ]; +if (!substream) { + ret =IRQ_NONE ; + goto handle_tx; + } + + runtime = substream->runtime; + +for (i =0 ; i <AN7581_PCM_RX_DESCRIPTORS ; i++) { +spin_lock_irqsave (&priv->desc_lock, flags); + + desc = &priv->rx_descs[priv->rx_desc_idx]; + status = desc->status; +if ((status &AN7581_PCM_DESC_STATUS_OWNERSHIP ) == +AN7581_PCM_DESC_STATUS_OWNERSHIP_DMA ) { +spin_unlock_irqrestore (&priv->desc_lock, + flags); +break ; + } + + sample_size =FIELD_GET (AN7581_PCM_DESC_STATUS_SAMPLE_SIZE , + status); + + priv->rx_pos +=frames_to_bytes (runtime, sample_size); + priv->rx_desc_idx++; +if (priv->rx_desc_idx ==AN7581_PCM_RX_DESCRIPTORS ) + priv->rx_desc_idx =0 ; + +spin_unlock_irqrestore (&priv->desc_lock, flags); + +snd_pcm_period_elapsed (substream); + + desc->status |=AN7581_PCM_DESC_STATUS_OWNERSHIP_DMA ; + +if (snd_pcm_capture_hw_avail (runtime) < runtime->period_size) + goto handle_tx; + + rx_poll = true; + } + +if (rx_poll) +regmap_write (priv->map,AN7581_PCM_RPDR ,AN7581_PCM_RX_POLLING ); + } + +handle_tx: +/* Scan descriptor on receiving TX desc update interrupt */ +if (isr &AN7581_PCM_IMR_TDESC_UPDATE_INT ) { +struct snd_pcm_runtime *runtime; +struct an7581_pcm_desc *desc; +unsigned int sample_size; +bool tx_poll = false; +int i; + + ret =IRQ_HANDLED ; + + substream = priv->stream[SNDRV_PCM_STREAM_PLAYBACK ]; +if (!substream) +return IRQ_NONE ; + + runtime = substream->runtime; + +for (i =0 ; i <AN7581_PCM_TX_DESCRIPTORS ; i++) { +spin_lock_irqsave (&priv->desc_lock, flags); + + desc = &priv->tx_descs[priv->tx_desc_idx]; + status = desc->status; +if ((status &AN7581_PCM_DESC_STATUS_OWNERSHIP ) == +AN7581_PCM_DESC_STATUS_OWNERSHIP_DMA ) { +spin_unlock_irqrestore (&priv->desc_lock, + flags); +break ; + } + + sample_size =FIELD_GET (AN7581_PCM_DESC_STATUS_SAMPLE_SIZE , + status); + + priv->tx_pos +=frames_to_bytes (runtime, sample_size); + priv->tx_desc_idx++; +if (priv->tx_desc_idx ==AN7581_PCM_TX_DESCRIPTORS ) + priv->tx_desc_idx =0 ; + +spin_unlock_irqrestore (&priv->desc_lock, flags); + +snd_pcm_period_elapsed (substream); + + desc->status |=AN7581_PCM_DESC_STATUS_OWNERSHIP_DMA ; + +if (snd_pcm_playback_hw_avail (runtime) < runtime->period_size) +return IRQ_HANDLED ; +
sound/soc/airoha/an7581-pcm.c line 802
Quoted 10 lines
sound/soc/airoha/an7581-pcm.c new file +10
-0+ tx_poll = true; + } + +if (tx_poll) +regmap_write (priv->map,AN7581_PCM_TPDR , +AN7581_PCM_TX_POLLING ); + } + +return ret; +}
[Severity: Medium]
As reported by Mark Brown on v5 [1], can an7581_pcm_irq_handler() return an uninitialized ret or clobber IRQ_HANDLED with IRQ_NONE?
If neither AN7581_PCM_IMR_RDESC_UPDATE_INT nor AN7581_PCM_IMR_TDESC_UPDATE_INT is set in isr, an7581_pcm_irq_handler() returns ret without initializing it. Also, if the RX path handles an interrupt (setting ret = IRQ_HANDLED) and AN7581_PCM_IMR_TDESC_UPDATE_INT is also set while the playback substream is NULL, the TX path returns IRQ_NONE instead of preserving IRQ_HANDLED.
[Severity: High]
Does jumping out of the descriptor loops when hw_avail < runtime->period_size stall DMA polling and mishandle XRUNs?
If an earlier descriptor in the same interrupt set rx_poll or tx_poll and the next descriptor sees hw_avail < runtime->period_size, jumping to handle_tx or returning IRQ_HANDLED skips the AN7581_PCM_RPDR / AN7581_PCM_TPDR write and leaves any remaining completed descriptors unexamined; even on the first descriptor, skipping the poll write while the stream is still running stalls DMA because there is no .ack callback to restart polling. In addition, snd_pcm_capture_hw_avail() and snd_pcm_playback_hw_avail() return signed snd_pcm_sframes_t whereas runtime->period_size is unsigned snd_pcm_uframes_t, so negative values on overrun or underrun promote to large unsigned values and re-trigger DMA polling after snd_pcm_period_elapsed() has stopped the stream.
[ ... ]
Quoted 11 lines
sound/soc/airoha/an7581-pcm.c new file +11
-0+static int an7581_pcm_probe (struct platform_device *pdev) +{ +struct snd_soc_card *card = &an7581_pcm_card; +struct snd_soc_dai_link *dai_link; +struct device *dev = &pdev->dev; +struct an7581_pcm_priv *priv; +struct reset_control *reset; +void __iomem *base; +int irq; +int ret; +int i;
[ ... ]
sound/soc/airoha/an7581-pcm.c line 844
Quoted 3 lines
sound/soc/airoha/an7581-pcm.c new file +3
-0+ irq =of_irq_get (dev_of_node (dev),0 ); +if (irq <0 ) +return irq;
[Severity: Medium]
Does this miss IRQ mapping failures when of_irq_get() returns 0?
of_irq_get() returns 0 on mapping failure (or when CONFIG_OF_IRQ is disabled), so checking only irq < 0 passes irq == 0 to devm_request_irq(). Using platform_get_irq(pdev, 0) handles this and returns a negative errno.
Quoted 30 lines
sound/soc/airoha/an7581-pcm.c new file +30
-0+ + ret =devm_request_irq (dev, irq, an7581_pcm_irq_handler, +0 ,dev_name (dev), priv); +if (ret) +return ret; + +spin_lock_init (&priv->desc_lock); +mutex_init (&priv->user_lock); + +/* Reset the PCM interface */ +reset_control_assert (reset); +usleep_range (5000 ,10000 ); +reset_control_deassert (reset); +usleep_range (5000 ,10000 ); + + ret =dma_set_coherent_mask (dev,DMA_BIT_MASK (32 )); +if (ret) +return ret; + + priv->tx_descs =dmam_alloc_coherent (dev,sizeof (struct an7581_pcm_desc ) * +AN7581_PCM_TX_DESCRIPTORS , &priv->tx_dma, +GFP_KERNEL ); +if (!priv->tx_descs) +return -ENOMEM ; + + priv->rx_descs =dmam_alloc_coherent (dev,sizeof (struct an7581_pcm_desc ) * +AN7581_PCM_RX_DESCRIPTORS , &priv->rx_dma, +GFP_KERNEL ); +if (!priv->rx_descs) +return -ENOMEM ;
[ ... ]
Quoted 10 lines
sound/soc/airoha/an7581-pcm.c new file +10
-0+ ret =devm_snd_soc_register_card (dev, card); +if (ret) +return dev_err_probe (dev, ret,"%s snd_soc_register_card fail\n" , __func__); + +return 0 ; +} + +static void an7581_pcm_remove (struct platform_device *pdev) +{ +struct snd_soc_card *card = &an7581_pcm_card;
sound/soc/airoha/an7581-pcm.c line 911
Quoted 10 lines
sound/soc/airoha/an7581-pcm.c new file +10
-0+struct an7581_pcm_priv *priv; + + priv =snd_soc_card_get_drvdata (card); +regmap_clear_bits (priv->map,AN7581_PCM_IMR , +AN7581_PCM_IMR_TDESC_UPDATE_INT | +AN7581_PCM_IMR_RDESC_UPDATE_INT ); +regmap_clear_bits (priv->map,AN7581_PCM_TRDCR , +AN7581_PCM_TXDMA_ENABLE | +AN7581_PCM_RXDMA_ENABLE ); +}
[Severity: High]
Can requesting the IRQ before initializing locks, resetting the hardware, and allocating descriptors cause an7581_pcm_irq_handler() to run against uninitialized state or during reset?
devm_request_irq() enables the interrupt before priv->desc_lock is initialized, before reset_control_assert() holds the PCM block in reset across a 5-10 ms sleep, and before priv->tx_descs and priv->rx_descs are allocated. Because devres tears down resources in reverse registration order, this also causes dmam_alloc_coherent() to free priv->rx_descs and priv->tx_descs before devm_request_irq() frees and synchronizes the IRQ, while an7581_pcm_remove() runs before devm_snd_soc_register_card() unregisters the card.
[1] https://lore.kernel.org/r/179425987829.3711751.2911706702501919873.b4-review@b4
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=2
Mark Brown
maintainerRe: [PATCH v6 2/2] ASoC: airoha: Add support for AN7581 PCM driver
In reply to Christian MarangiQuoted 21 lines
The Airoha AN7581 SoC provides a PCM interface for VoIP applications, supporting playback and capture at sample rates of 8 kHz and 16 kHz. The driver configures the PCM bit clock to 2.048 KHz and supports 8-bit and 16-bit samples, with up to 32 channels.
+++ b/MAINTAINERS
MAINTAINERS +7
-0@@ -796,6 +796,13 @@ F: Documentation/devicetree/bindings/sound/airoha,an7581-afe.yaml F: Documentation/devicetree/bindings/sound/airoha,an7581-wm8960.yaml F: sound/soc/mediatek/an7581/* +AIROHA PCM CONTROLLER DRIVER +M: Christian Marangi <[email protected]> +L: [email protected] +S: Maintained +F: Documentation/devicetree/bindings/sound/airoha,an7581-pcm.yaml +F: sound/soc/airoha/* +
sound/soc/airoha/an7581-pcm.c line 6
Quoted 6 lines
sound/soc/airoha/an7581-pcm.c new file +6
-0@@ -0,0 +1,931 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* Airoha ALSA SoC PCM platform driver for AN7581 +* +* Copyright (C) 2026 Christian Marangi <[email protected]> +*/
Please keep the entire comment block C++.
sound/soc/airoha/an7581-pcm.c line 689
Quoted 7 lines
sound/soc/airoha/an7581-pcm.c new file +7
-0+static irqreturn_t an7581_pcm_irq_handler (int irq,void *data) +{ +struct snd_pcm_substream *substream; +struct an7581_pcm_priv *priv = data; +unsigned long flags; +u32 status, isr =0 ; +int ret;
This should be irqreturn_t and needs to be initialized in case we didn't see anything we recognise.
sound/soc/airoha/an7581-pcm.c line 927
Quoted 9 lines
sound/soc/airoha/an7581-pcm.c new file +9
-0+static struct platform_driver an7581_pcm_driver = { + .driver = { + .name ="an7581-pcm" , + .of_match_table = an7581_pcm_dt_match, + }, + .probe = an7581_pcm_probe, + .remove = an7581_pcm_remove, +}; +module_platform_driver (an7581_pcm_driver);
You should set snd_soc_pm_ops too.
Signature · 1 line
Mark Brown <[email protected]>