Changes in v3:
- Changed prefix from RFC to PATCH
- Rebased entire series to usb-next
- Updated copyright years
XHCI:
- Rebased changes on top of XHCI changes merged into usb-next, and only added
changes that were still under discussion.
- Added change to read in the "num-hc-interrupters" device property.
ASoC:
- qusb6 USB backend
- Incorporated suggestions to fetch iommu information with existing APIs
- Added two new sound kcontrols to fetch offload status and offload device
selection.
- offload status - will return the card and pcm device in use
tinymix -D 0 get 1 --> 1, 0 (offload in progress on card#1 pcm#0)
- device selection - set the card and pcm device to enable offload on. Ex.:
tinymix -D 0 set 1 2 0 --> sets offload on card#2 pcm#0
(this should be the USB card)
USB SND:
- Fixed up some locking related concerns for registering platform ops.
- Moved callbacks under the register_mutex, so that
- Modified APIs to properly pass more information about the USB SND device, so
that the Q6USB backend can build a device list/map, in order to monitor offload
status and device selection.
Changes in v2:
XHCI:
- Replaced XHCI and HCD changes with Mathias' XHCI interrupter changes
in his tree:
https://git.kernel.org/pub/scm/linux/kernel/git/mnyman/xhci.git/log/?h=feature_interrupters
Adjustments made to Mathias' changes:
- Created xhci-intr.h to export/expose interrupter APIs versus exposing xhci.h.
Moved dependent structures to this file as well. (so clients can parse out
information from "struct xhci_interrupter")
- Added some basic locking when requesting interrupters.
- Fixed up some sanity checks.
- Removed clearing of the ERSTBA during freeing of the interrupter. (pending
issue where SMMU fault occurs if DMA addr returned is 64b - TODO)
- Clean up pending events in the XHCI secondary interrupter. While testing USB
bus suspend, it was seen that on bus resume, the xHCI HC would run into a command
timeout.
- Added offloading APIs to xHCI to fetch transfer and event ring information.
ASoC:
- Modified soc-usb to allow for multiple USB port additions. For this to work,
the USB offload driver has to have a reference to the USB backend by adding
a "usb-soc-be" DT entry to the device saved into XHCI sysdev.
- Created separate dt-bindings for defining USB_RX port.
- Increased APR timeout to accommodate the situation where the AFE port start
command could be delayed due to having to issue a USB bus resume while
handling the QMI stream start command.
USB SND:
- Added a platform ops during usb_audio_suspend(). This allows for the USB
offload driver to halt the audio stream when system enters PM suspend. This
ensures the audio DSP is not issuing transfers on the USB bus.
- Do not override platform ops if they are already populated.
- Introduce a shared status variable between the USB offload and USB SND layers,
to ensure that only one path is active at a time. If the USB bus is occupied,
then userspace is notified that the path is busy.
Several Qualcomm based chipsets can support USB audio offloading to a
dedicated audio DSP, which can take over issuing transfers to the USB
host controller. The intention is to reduce the load on the main
processors in the SoC, and allow them to be placed into lower power modes.
There are several parts to this design:
1. Adding ASoC binding layer
2. Create a USB backend for Q6DSP
3. Introduce XHCI interrupter support
4. Create vendor ops for the USB SND driver
Adding ASoC binding layer:
soc-usb: Intention is to treat a USB port similar to a headphone jack.
The port is always present on the device, but cable/pin status can be
enabled/disabled. Expose mechanisms for USB backend ASoC drivers to
communicate with USB SND.
Create a USB backend for Q6DSP:
q6usb: Basic backend driver that will be responsible for maintaining the
resources needed to initiate a playback stream using the Q6DSP. Will
be the entity that checks to make sure the connected USB audio device
supports the requested PCM format. If it does not, the PCM open call will
fail, and userpsace ALSA can take action accordingly.
Introduce XHCI interrupter support:
XHCI HCD supports multiple interrupters, which allows for events to be routed
to different event rings. This is determined by "Interrupter Target" field
specified in Section "6.4.1.1 Normal TRB" of the XHCI specification.
Events in the offloading case will be routed to an event ring that is assigned
to the audio DSP.
Create vendor ops for the USB SND driver:
qc_audio_offload: This particular driver has several components associated
with it:
- QMI stream request handler
- XHCI interrupter and resource management
- audio DSP memory management
When the audio DSP wants to enable a playback stream, the request is first
received by the ASoC platform sound card. Depending on the selected route,
ASoC will bring up the individual DAIs in the path. The Q6USB backend DAI
will send an AFE port start command (with enabling the USB playback path), and
the audio DSP will handle the request accordingly.
Part of the AFE USB port start handling will have an exchange of control
messages using the QMI protocol. The qc_audio_offload driver will populate the
buffer information:
- Event ring base address
- EP transfer ring base address
and pass it along to the audio DSP. All endpoint management will now be handed
over to the DSP, and the main processor is not involved in transfers.
Overall, implementing this feature will still expose separate sound card and PCM
devices for both the platorm card and USB audio device:
0 [SM8250MTPWCD938]: sm8250 - SM8250-MTP-WCD9380-WSA8810-VA-D
SM8250-MTP-WCD9380-WSA8810-VA-DMIC
1 [Audio ]: USB-Audio - USB Audio
Generic USB Audio at usb-xhci-hcd.1.auto-1.4, high speed
This is to ensure that userspace ALSA entities can decide which route to take
when executing the audio playback. In the above, if card#1 is selected, then
USB audio data will take the legacy path over the USB PCM drivers, etc...
This feature was validated using:
- tinymix: set/enable the multimedia path to route to USB backend
- tinyplay: issue playback on platform card
Mathias Nyman (1):
xhci: Add support to allocate several interrupters
Wesley Cheng (27):
usb: xhci: Add XHCI APIs to support USB offloading
usb: host: xhci-mem: Cleanup pending secondary event ring events
ASoC: Add SOC USB APIs for adding an USB backend
ASoC: dt-bindings: qcom,q6dsp-lpass-ports: Add USB_RX port
ASoC: qcom: qdsp6: Introduce USB AFE port to q6dsp
ASoC: qdsp6: q6afe: Increase APR timeout
ASoC: qcom: Add USB backend ASoC driver for Q6
sound: usb: card: Introduce USB SND platform op callbacks
sound: usb: Export USB SND APIs for modules
dt-bindings: usb: dwc3: Add snps,num-hc-interrupters definition
usb: dwc3: Add DT parameter to specify maximum number of interrupters
usb: host: xhci-plat: Set XHCI max interrupters if property is present
sound: usb: pcm: Export fixed rate check USB SND API
sound: usb: Introduce QC USB SND offloading support
sound: usb: card: Check for support for requested audio format
sound: soc: soc-usb: Add PCM format check API for USB backend
sound: soc: qcom: qusb6: Ensure PCM format is supported by USB audio
device
sound: usb: Prevent starting of audio stream if in use
ASoC: dt-bindings: Add Q6USB backend bindings
ASoC: dt-bindings: Update example for enabling USB offload on SM8250
ASoC: qcom: qdsp6: q6afe: Split USB AFE dev_token param into separate
API
sound: Pass USB SND card and PCM information to SOC USB
sound: soc: qdsp6: Add SND kcontrol to select offload device
sound: soc: qdsp6: Add SND kcontrol for fetching offload status
sound: usb: qc_audio_offload: Use card and PCM index from QMI request
sound: usb: card: Allow for rediscovery of connected USB SND devices
sound: soc: soc-usb: Rediscover USB SND devices on USB port add
.../bindings/sound/qcom,q6usb-dais.yaml | 49 +
.../bindings/sound/qcom,sm8250.yaml | 15 +
.../devicetree/bindings/usb/snps,dwc3.yaml | 13 +
drivers/usb/dwc3/core.c | 12 +
drivers/usb/dwc3/core.h | 2 +
drivers/usb/dwc3/host.c | 5 +-
drivers/usb/host/xhci-debugfs.c | 2 +-
drivers/usb/host/xhci-mem.c | 171 +-
drivers/usb/host/xhci-plat.c | 2 +
drivers/usb/host/xhci-ring.c | 2 +-
drivers/usb/host/xhci.c | 181 +-
drivers/usb/host/xhci.h | 2 +-
.../sound/qcom,q6dsp-lpass-ports.h | 1 +
include/linux/usb/xhci-intr.h | 94 +
include/sound/pcm_params.h | 4 +
include/sound/q6usboffload.h | 20 +
include/sound/soc-usb.h | 39 +
sound/core/oss/pcm_oss.c | 58 -
sound/core/pcm_lib.c | 65 +
sound/soc/Makefile | 2 +-
sound/soc/qcom/Kconfig | 4 +
sound/soc/qcom/qdsp6/Makefile | 1 +
sound/soc/qcom/qdsp6/q6afe-dai.c | 50 +
sound/soc/qcom/qdsp6/q6afe.c | 208 +-
sound/soc/qcom/qdsp6/q6afe.h | 47 +-
sound/soc/qcom/qdsp6/q6dsp-lpass-ports.c | 23 +
sound/soc/qcom/qdsp6/q6dsp-lpass-ports.h | 1 +
sound/soc/qcom/qdsp6/q6routing.c | 9 +
sound/soc/qcom/qdsp6/q6usb.c | 445 ++++
sound/soc/soc-usb.c | 197 ++
sound/usb/Kconfig | 14 +
sound/usb/Makefile | 2 +-
sound/usb/card.c | 85 +
sound/usb/card.h | 31 +
sound/usb/endpoint.c | 2 +
sound/usb/helper.c | 1 +
sound/usb/pcm.c | 29 +-
sound/usb/pcm.h | 12 +
sound/usb/qcom/Makefile | 2 +
sound/usb/qcom/qc_audio_offload.c | 1790 +++++++++++++++++
sound/usb/qcom/usb_audio_qmi_v01.c | 892 ++++++++
sound/usb/qcom/usb_audio_qmi_v01.h | 162 ++
42 files changed, 4646 insertions(+), 100 deletions(-)
create mode 100644 Documentation/devicetree/bindings/sound/qcom,q6usb-dais.yaml
create mode 100644 include/linux/usb/xhci-intr.h
create mode 100644 include/sound/q6usboffload.h
create mode 100644 include/sound/soc-usb.h
create mode 100644 sound/soc/qcom/qdsp6/q6usb.c
create mode 100644 sound/soc/soc-usb.c
create mode 100644 sound/usb/qcom/Makefile
create mode 100644 sound/usb/qcom/qc_audio_offload.c
create mode 100644 sound/usb/qcom/usb_audio_qmi_v01.c
create mode 100644 sound/usb/qcom/usb_audio_qmi_v01.h
Q6DSP supports handling of USB playback audio data if USB audio offloading
is enabled. Add a new definition for the USB_RX AFE port, which is
referenced when the AFE port is started.
Acked-by: Krzysztof Kozlowski <[email protected]>
Signed-off-by: Wesley Cheng <[email protected]>
---
include/dt-bindings/sound/qcom,q6dsp-lpass-ports.h | 1 +
1 file changed, 1 insertion(+)
diff --git a/include/dt-bindings/sound/qcom,q6dsp-lpass-ports.h b/include/dt-bindings/sound/qcom,q6dsp-lpass-ports.h
index 9f7c5103bc82..746bc462bb2e 100644
--- a/include/dt-bindings/sound/qcom,q6dsp-lpass-ports.h
+++ b/include/dt-bindings/sound/qcom,q6dsp-lpass-ports.h
@@ -131,6 +131,7 @@
#define RX_CODEC_DMA_RX_7 126
#define QUINARY_MI2S_RX 127
#define QUINARY_MI2S_TX 128
+#define USB_RX 129
#define LPASS_CLK_ID_PRI_MI2S_IBIT 1
#define LPASS_CLK_ID_PRI_MI2S_EBIT 2
Utilize the card and PCM index coming from the USB QMI stream request.
This field follows what is set by the ASoC USB backend, and could
potentially carry information about a specific device selected through the
ASoC USB backend. The backend also has information about the last USB
sound device plugged in, so it can choose to select the last device plugged
in, accordingly.
Signed-off-by: Wesley Cheng <[email protected]>
---
sound/usb/qcom/qc_audio_offload.c | 8 ++------
1 file changed, 2 insertions(+), 6 deletions(-)
diff --git a/sound/usb/qcom/qc_audio_offload.c b/sound/usb/qcom/qc_audio_offload.c
index 7d6e7f946a47..51241c4eafab 100644
--- a/sound/usb/qcom/qc_audio_offload.c
+++ b/sound/usb/qcom/qc_audio_offload.c
@@ -114,8 +114,6 @@ struct uaudio_qmi_dev {
bool er_mapped;
/* reference count to number of possible consumers */
atomic_t qdev_in_use;
- /* idx to last udev card number plugged in */
- unsigned int last_card_num;
};
struct uaudio_dev {
@@ -990,7 +988,7 @@ static int prepare_qmi_response(struct snd_usb_substream *subs,
assoc = iface->intf_assoc;
pcm_dev_num = (req_msg->usb_token & SND_PCM_DEV_NUM_MASK) >> 8;
xfer_buf_len = req_msg->xfer_buff_size;
- card_num = uaudio_qdev->last_card_num;
+ card_num = (req_msg->usb_token & SND_PCM_CARD_NUM_MASK) >> 16;
alts = &iface->altsetting[subs->cur_audiofmt->altset_idx];
altsd = get_iface_desc(alts);
@@ -1375,8 +1373,7 @@ static void handle_uaudio_stream_req(struct qmi_handle *handle,
direction = (req_msg->usb_token & SND_PCM_STREAM_DIRECTION);
pcm_dev_num = (req_msg->usb_token & SND_PCM_DEV_NUM_MASK) >> 8;
- pcm_card_num = req_msg->enable ? uaudio_qdev->last_card_num :
- ffs(uaudio_qdev->card_slot) - 1;
+ pcm_card_num = (req_msg->usb_token & SND_PCM_CARD_NUM_MASK) >> 16;
if (pcm_card_num >= SNDRV_CARDS) {
ret = -EINVAL;
goto response;
@@ -1560,7 +1557,6 @@ static void qc_usb_audio_offload_probe(struct snd_usb_audio *chip)
mutex_unlock(&qdev_mutex);
uadev[chip->card->number].chip = chip;
- uaudio_qdev->last_card_num = chip->card->number;
snd_soc_usb_connect(usb_get_usb_backend(udev), chip->card->number,
chip->index, chip->pcm_devs);
Introduce a check for if a particular PCM format is supported by the USB
audio device connected. If the USB audio device does not have an audio
profile which can support the requested format, then notify the USB
backend.
Signed-off-by: Wesley Cheng <[email protected]>
---
include/sound/soc-usb.h | 3 +++
sound/soc/soc-usb.c | 13 +++++++++++++
2 files changed, 16 insertions(+)
diff --git a/include/sound/soc-usb.h b/include/sound/soc-usb.h
index 378992ea07bd..71e6e75e600a 100644
--- a/include/sound/soc-usb.h
+++ b/include/sound/soc-usb.h
@@ -23,6 +23,9 @@ struct snd_soc_usb {
void *priv_data;
};
+int snd_soc_usb_find_format(int card_idx, struct snd_pcm_hw_params *params,
+ int direction);
+
int snd_soc_usb_connect(struct device *usbdev, int card_idx);
int snd_soc_usb_disconnect(struct device *usbdev);
void snd_soc_usb_set_priv_data(struct device *dev, void *priv);
diff --git a/sound/soc/soc-usb.c b/sound/soc/soc-usb.c
index 4293451cdd49..cdce1bb42df5 100644
--- a/sound/soc/soc-usb.c
+++ b/sound/soc/soc-usb.c
@@ -70,6 +70,19 @@ void *snd_soc_usb_get_priv_data(struct device *dev)
}
EXPORT_SYMBOL_GPL(snd_soc_usb_get_priv_data);
+int snd_soc_usb_find_format(int card_idx, struct snd_pcm_hw_params *params,
+ int direction)
+{
+ struct snd_usb_stream *as;
+
+ as = snd_usb_find_suppported_substream(card_idx, params, direction);
+ if (!as)
+ return -EOPNOTSUPP;
+
+ return 0;
+}
+EXPORT_SYMBOL_GPL(snd_soc_usb_find_format);
+
/**
* snd_soc_usb_add_port() - Add a USB backend port
* @dev: USB backend device
Add a kcontrol to the platform sound card to fetch the current offload
status. This can allow for userspace to ensure/check which USB SND
resources are actually busy versus having to attempt opening the USB SND
devices, which will result in an error if offloading is active.
Signed-off-by: Wesley Cheng <[email protected]>
---
sound/soc/qcom/qdsp6/q6usb.c | 104 ++++++++++++++++++++++++++++++++++-
1 file changed, 101 insertions(+), 3 deletions(-)
diff --git a/sound/soc/qcom/qdsp6/q6usb.c b/sound/soc/qcom/qdsp6/q6usb.c
index 55f9bcd928f3..89a2351f4cfa 100644
--- a/sound/soc/qcom/qdsp6/q6usb.c
+++ b/sound/soc/qcom/qdsp6/q6usb.c
@@ -30,6 +30,8 @@ struct q6usb_status {
unsigned int num_pcm;
unsigned int chip_index;
unsigned int pcm_index;
+ bool prepared;
+ bool running;
};
struct q6usb_port_data {
@@ -52,6 +54,17 @@ static const struct snd_soc_dapm_route q6usb_dapm_routes[] = {
{"USB Playback", NULL, "USB_RX_BE"},
};
+static int q6usb_find_running(struct q6usb_port_data *data)
+{
+ int i;
+
+ for (i = 0; i < SNDRV_CARDS; i++) {
+ if (data->status[i].running)
+ return i;
+ }
+ return -ENODEV;
+}
+
static int q6usb_hw_params(struct snd_pcm_substream *substream,
struct snd_pcm_hw_params *params,
struct snd_soc_dai *dai)
@@ -81,14 +94,40 @@ static int q6usb_hw_params(struct snd_pcm_substream *substream,
goto out;
data->status[data->sel_card_idx].pcm_index = data->sel_pcm_idx;
+ data->status[data->sel_card_idx].prepared = true;
out:
mutex_unlock(&data->mutex);
return ret;
}
+static int q6usb_prepare(struct snd_pcm_substream *substream,
+ struct snd_soc_dai *dai)
+{
+ struct q6usb_port_data *data = dev_get_drvdata(dai->dev);
+
+ mutex_lock(&data->mutex);
+ data->status[data->sel_card_idx].running = true;
+ mutex_unlock(&data->mutex);
+
+ return 0;
+}
+
+static void q6usb_shutdown(struct snd_pcm_substream *substream,
+ struct snd_soc_dai *dai)
+{
+ struct q6usb_port_data *data = dev_get_drvdata(dai->dev);
+
+ mutex_lock(&data->mutex);
+ data->status[data->sel_card_idx].running = false;
+ data->status[data->sel_card_idx].prepared = false;
+ mutex_unlock(&data->mutex);
+}
+
static const struct snd_soc_dai_ops q6usb_ops = {
.hw_params = q6usb_hw_params,
+ .prepare = q6usb_prepare,
+ .shutdown = q6usb_shutdown,
};
static struct snd_soc_dai_driver q6usb_be_dais[] = {
@@ -148,10 +187,15 @@ static int q6usb_put_offload_dev(struct snd_kcontrol *kcontrol,
int pcmidx;
int cardidx;
+ mutex_lock(&data->mutex);
+
+ /* Don't allow changes to the offloading devices if session is busy */
+ if (data->sel_card_idx >= 0 && data->status[data->sel_card_idx].prepared)
+ goto out;
+
cardidx = ucontrol->value.integer.value[0];
pcmidx = ucontrol->value.integer.value[1];
- mutex_lock(&data->mutex);
if ((cardidx >= 0 && test_bit(cardidx, &data->available_card_slot))) {
data->sel_card_idx = cardidx;
changed = 1;
@@ -162,6 +206,8 @@ static int q6usb_put_offload_dev(struct snd_kcontrol *kcontrol,
data->idx_valid = true;
changed = 1;
}
+
+out:
mutex_unlock(&data->mutex);
return changed;
@@ -187,11 +233,59 @@ static const struct snd_kcontrol_new q6usb_offload_dev_ctrl = {
.put = q6usb_put_offload_dev,
};
+static int q6usb_mixer_get_offload_status(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
+{
+ struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
+ struct q6usb_port_data *data = dev_get_drvdata(component->dev);
+ int running;
+ int card_idx;
+ int pcm_idx;
+
+ running = q6usb_find_running(data);
+ if (running < 0) {
+ card_idx = -1;
+ pcm_idx = -1;
+ } else {
+ card_idx = running;
+ pcm_idx = data->status[running].pcm_index;
+ }
+
+ ucontrol->value.integer.value[0] = card_idx;
+ ucontrol->value.integer.value[1] = pcm_idx;
+ return 0;
+}
+
+static int q6usb_offload_ctl_info(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_info *uinfo)
+{
+ uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
+ uinfo->count = 2;
+ uinfo->value.integer.min = 0;
+ uinfo->value.integer.max = SNDRV_CARDS;
+
+ return 0;
+}
+
+static const struct snd_kcontrol_new q6usb_offload_control = {
+ .iface = SNDRV_CTL_ELEM_IFACE_CARD,
+ .access = SNDRV_CTL_ELEM_ACCESS_READ,
+ .name = "Q6USB offload status",
+ .info = q6usb_offload_ctl_info,
+ .get = q6usb_mixer_get_offload_status,
+ .put = NULL,
+};
+
/* Build a mixer control for a UAC connector control (jack-detect) */
static void q6usb_connector_control_init(struct snd_soc_component *component)
{
int ret;
+ ret = snd_ctl_add(component->card->snd_card,
+ snd_ctl_new1(&q6usb_offload_control, component));
+ if (ret < 0)
+ return;
+
ret = snd_ctl_add(component->card->snd_card,
snd_ctl_new1(&q6usb_offload_dev_ctrl, component));
if (ret < 0)
@@ -229,8 +323,12 @@ static int q6usb_alsa_connection_cb(struct snd_soc_usb *usb, int card_idx,
mutex_lock(&data->mutex);
if (connected) {
snd_soc_dapm_enable_pin(dapm, "USB_RX_BE");
- /* We only track the latest USB headset plugged in */
- if (!data->idx_valid || data->sel_card_idx < 0)
+ /*
+ * Update the latest USB headset plugged in, if session is
+ * idle.
+ */
+ if ((!data->idx_valid || data->sel_card_idx < 0) &&
+ !data->status[data->sel_card_idx].prepared)
data->sel_card_idx = card_idx;
set_bit(card_idx, &data->available_card_slot);
Add an example on enabling of USB offload for the Q6DSP. The routing can
be done by the mixer, which can pass the multimedia stream to the USB
backend.
Signed-off-by: Wesley Cheng <[email protected]>
---
.../devicetree/bindings/sound/qcom,sm8250.yaml | 15 +++++++++++++++
1 file changed, 15 insertions(+)
diff --git a/Documentation/devicetree/bindings/sound/qcom,sm8250.yaml b/Documentation/devicetree/bindings/sound/qcom,sm8250.yaml
index 262de7a60a73..13145e010ddf 100644
--- a/Documentation/devicetree/bindings/sound/qcom,sm8250.yaml
+++ b/Documentation/devicetree/bindings/sound/qcom,sm8250.yaml
@@ -220,6 +220,21 @@ examples:
sound-dai = <&vamacro 0>;
};
};
+
+ usb-dai-link {
+ link-name = "USB Playback";
+ cpu {
+ sound-dai = <&q6afedai USB_RX>;
+ };
+
+ codec {
+ sound-dai = <&usbdai USB_RX>;
+ };
+
+ platform {
+ sound-dai = <&q6routing>;
+ };
+ };
};
- |
The Q6USB backend can carry information about the available USB SND cards
and PCM devices discovered on the USB bus. The dev_token field is used by
the audio DSP to notify the USB offload driver of which card and PCM index
to enable playback on. Separate this into a dedicated API, so the USB
backend can set the dev_token accordingly. The audio DSP does not utilize
this information until the AFE port start command is sent, which is done
during the PCM prepare phase.
Signed-off-by: Wesley Cheng <[email protected]>
---
sound/soc/qcom/qdsp6/q6afe.c | 49 +++++++++++++++++++++++++-----------
sound/soc/qcom/qdsp6/q6afe.h | 1 +
2 files changed, 36 insertions(+), 14 deletions(-)
diff --git a/sound/soc/qcom/qdsp6/q6afe.c b/sound/soc/qcom/qdsp6/q6afe.c
index e9d5fa6b6b0d..505371c96987 100644
--- a/sound/soc/qcom/qdsp6/q6afe.c
+++ b/sound/soc/qcom/qdsp6/q6afe.c
@@ -1394,10 +1394,42 @@ void q6afe_tdm_port_prepare(struct q6afe_port *port,
}
EXPORT_SYMBOL_GPL(q6afe_tdm_port_prepare);
-static int afe_port_send_usb_dev_param(struct q6afe_port *port, struct q6afe_usb_cfg *cfg)
+/**
+ * afe_port_send_usb_dev_param() - Send USB dev token
+ *
+ * @port: Instance of afe port
+ * @cardidx: USB SND card index to reference
+ * @pcmidx: USB SND PCM device index to reference
+ *
+ * The USB dev token carries information about which USB SND card instance and
+ * PCM device to execute the offload on. This information is carried through
+ * to the stream enable QMI request, which is handled by the offload class
+ * driver. The information is parsed to determine which USB device to query
+ * the required resources for.
+ */
+int afe_port_send_usb_dev_param(struct q6afe_port *port, int cardidx, int pcmidx)
{
- union afe_port_config *pcfg = &port->port_cfg;
struct afe_param_id_usb_audio_dev_params usb_dev;
+ int ret;
+
+ memset(&usb_dev, 0, sizeof(usb_dev));
+
+ usb_dev.cfg_minor_version = AFE_API_MINOR_VERSION_USB_AUDIO_CONFIG;
+ usb_dev.dev_token = (cardidx << 16) | (pcmidx << 8);
+ ret = q6afe_port_set_param_v2(port, &usb_dev,
+ AFE_PARAM_ID_USB_AUDIO_DEV_PARAMS,
+ AFE_MODULE_AUDIO_DEV_INTERFACE, sizeof(usb_dev));
+ if (ret)
+ dev_err(port->afe->dev, "%s: AFE device param cmd failed %d\n",
+ __func__, ret);
+
+ return ret;
+}
+EXPORT_SYMBOL_GPL(afe_port_send_usb_dev_param);
+
+static int afe_port_send_usb_params(struct q6afe_port *port, struct q6afe_usb_cfg *cfg)
+{
+ union afe_port_config *pcfg = &port->port_cfg;
struct afe_param_id_usb_audio_dev_lpcm_fmt lpcm_fmt;
struct afe_param_id_usb_audio_svc_interval svc_int;
int ret = 0;
@@ -1408,20 +1440,9 @@ static int afe_port_send_usb_dev_param(struct q6afe_port *port, struct q6afe_usb
goto exit;
}
- memset(&usb_dev, 0, sizeof(usb_dev));
memset(&lpcm_fmt, 0, sizeof(lpcm_fmt));
memset(&svc_int, 0, sizeof(svc_int));
- usb_dev.cfg_minor_version = AFE_API_MINOR_VERSION_USB_AUDIO_CONFIG;
- q6afe_port_set_param_v2(port, &usb_dev,
- AFE_PARAM_ID_USB_AUDIO_DEV_PARAMS,
- AFE_MODULE_AUDIO_DEV_INTERFACE, sizeof(usb_dev));
- if (ret) {
- dev_err(port->afe->dev, "%s: AFE device param cmd failed %d\n",
- __func__, ret);
- goto exit;
- }
-
lpcm_fmt.cfg_minor_version = AFE_API_MINOR_VERSION_USB_AUDIO_CONFIG;
lpcm_fmt.endian = pcfg->usb_cfg.endian;
ret = q6afe_port_set_param_v2(port, &lpcm_fmt,
@@ -1465,7 +1486,7 @@ void q6afe_usb_port_prepare(struct q6afe_port *port,
pcfg->usb_cfg.num_channels = cfg->num_channels;
pcfg->usb_cfg.bit_width = cfg->bit_width;
- afe_port_send_usb_dev_param(port, cfg);
+ afe_port_send_usb_params(port, cfg);
}
EXPORT_SYMBOL_GPL(q6afe_usb_port_prepare);
diff --git a/sound/soc/qcom/qdsp6/q6afe.h b/sound/soc/qcom/qdsp6/q6afe.h
index e098a3e15135..7980416275e9 100644
--- a/sound/soc/qcom/qdsp6/q6afe.h
+++ b/sound/soc/qcom/qdsp6/q6afe.h
@@ -274,6 +274,7 @@ void q6afe_tdm_port_prepare(struct q6afe_port *port, struct q6afe_tdm_cfg *cfg);
void q6afe_cdc_dma_port_prepare(struct q6afe_port *port,
struct q6afe_cdc_dma_cfg *cfg);
+int afe_port_send_usb_dev_param(struct q6afe_port *port, int cardidx, int pcmidx);
int q6afe_port_set_sysclk(struct q6afe_port *port, int clk_id,
int clk_src, int clk_root,
unsigned int freq, int dir);
Some platforms may have support for offloading USB audio devices to a
dedicated audio DSP. Introduce a set of APIs that allow for management of
USB sound card and PCM devices enumerated by the USB SND class driver.
This allows for the ASoC components to be aware of what USB devices are
available for offloading.
Signed-off-by: Wesley Cheng <[email protected]>
---
include/sound/soc-usb.h | 35 ++++++++
sound/soc/Makefile | 2 +-
sound/soc/soc-usb.c | 180 ++++++++++++++++++++++++++++++++++++++++
3 files changed, 216 insertions(+), 1 deletion(-)
create mode 100644 include/sound/soc-usb.h
create mode 100644 sound/soc/soc-usb.c
diff --git a/include/sound/soc-usb.h b/include/sound/soc-usb.h
new file mode 100644
index 000000000000..378992ea07bd
--- /dev/null
+++ b/include/sound/soc-usb.h
@@ -0,0 +1,35 @@
+/* SPDX-License-Identifier: GPL-2.0
+ *
+ * Copyright (c) 2022-2023 Qualcomm Innovation Center, Inc. All rights reserved.
+ */
+
+#ifndef __LINUX_SND_SOC_USB_H
+#define __LINUX_SND_SOC_USB_H
+
+/**
+ * struct snd_soc_usb
+ * @list - list head for SND SOC struct list
+ * @dev - USB backend device reference
+ * @component - reference to DAPM component
+ * @connection_status_cb - callback to notify connection events
+ * @priv_data - driver data
+ **/
+struct snd_soc_usb {
+ struct list_head list;
+ struct device *dev;
+ struct snd_soc_component *component;
+ int (*connection_status_cb)(struct snd_soc_usb *usb, int card_idx,
+ int connected);
+ void *priv_data;
+};
+
+int snd_soc_usb_connect(struct device *usbdev, int card_idx);
+int snd_soc_usb_disconnect(struct device *usbdev);
+void snd_soc_usb_set_priv_data(struct device *dev, void *priv);
+void *snd_soc_usb_get_priv_data(struct device *usbdev);
+
+struct snd_soc_usb *snd_soc_usb_add_port(struct device *dev, void *priv,
+ int (*connection_cb)(struct snd_soc_usb *usb, int card_idx,
+ int connected));
+int snd_soc_usb_remove_port(struct device *dev);
+#endif
diff --git a/sound/soc/Makefile b/sound/soc/Makefile
index 507eaed1d6a1..3305ceb59d84 100644
--- a/sound/soc/Makefile
+++ b/sound/soc/Makefile
@@ -1,5 +1,5 @@
# SPDX-License-Identifier: GPL-2.0
-snd-soc-core-objs := soc-core.o soc-dapm.o soc-jack.o soc-utils.o soc-dai.o soc-component.o
+snd-soc-core-objs := soc-core.o soc-dapm.o soc-jack.o soc-usb.o soc-utils.o soc-dai.o soc-component.o
snd-soc-core-objs += soc-pcm.o soc-devres.o soc-ops.o soc-link.o soc-card.o
snd-soc-core-$(CONFIG_SND_SOC_COMPRESS) += soc-compress.o
diff --git a/sound/soc/soc-usb.c b/sound/soc/soc-usb.c
new file mode 100644
index 000000000000..4293451cdd49
--- /dev/null
+++ b/sound/soc/soc-usb.c
@@ -0,0 +1,180 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (c) 2022-2023 Qualcomm Innovation Center, Inc. All rights reserved.
+ */
+#include <linux/of.h>
+#include <linux/usb.h>
+#include <sound/soc.h>
+#include <sound/soc-usb.h>
+#include "../usb/card.h"
+
+static DEFINE_MUTEX(ctx_mutex);
+static LIST_HEAD(usb_ctx_list);
+
+static struct device_node *snd_soc_find_phandle(struct device *dev)
+{
+ struct device_node *node;
+
+ node = of_parse_phandle(dev->of_node, "usb-soc-be", 0);
+ if (!node)
+ return ERR_PTR(-ENODEV);
+
+ return node;
+}
+
+static struct snd_soc_usb *snd_soc_find_usb_ctx(struct device *dev)
+{
+ struct device_node *node;
+ struct snd_soc_usb *ctx = NULL;
+
+ node = snd_soc_find_phandle(dev);
+ if (IS_ERR(node))
+ return NULL;
+
+ mutex_lock(&ctx_mutex);
+ list_for_each_entry(ctx, &usb_ctx_list, list) {
+ if (ctx->dev->of_node == node) {
+ of_node_put(node);
+ mutex_unlock(&ctx_mutex);
+ return ctx;
+ }
+ }
+ of_node_put(node);
+ mutex_unlock(&ctx_mutex);
+
+ return NULL;
+}
+
+/**
+ * snd_soc_usb_get_priv_data() - Retrieve private data stored
+ * @dev: device reference
+ *
+ * Fetch the private data stored in the USB SND SOC structure.
+ *
+ */
+void *snd_soc_usb_get_priv_data(struct device *dev)
+{
+ struct snd_soc_usb *ctx;
+
+ ctx = snd_soc_find_usb_ctx(dev);
+ if (!ctx) {
+ /* Check if backend device */
+ list_for_each_entry(ctx, &usb_ctx_list, list) {
+ if (dev->of_node == ctx->dev->of_node)
+ goto out;
+ }
+ ctx = NULL;
+ }
+out:
+ return ctx ? ctx->priv_data : NULL;
+}
+EXPORT_SYMBOL_GPL(snd_soc_usb_get_priv_data);
+
+/**
+ * snd_soc_usb_add_port() - Add a USB backend port
+ * @dev: USB backend device
+ * @priv: private data
+ * @connection_cb: connection status callback
+ *
+ * Register a USB backend device to the SND USB SOC framework. Memory is
+ * allocated as part of the USB backend device.
+ *
+ */
+struct snd_soc_usb *snd_soc_usb_add_port(struct device *dev, void *priv,
+ int (*connection_cb)(struct snd_soc_usb *usb, int card_idx,
+ int connected))
+{
+ struct snd_soc_usb *usb;
+
+ usb = devm_kzalloc(dev, sizeof(*usb), GFP_KERNEL);
+ if (!usb)
+ return ERR_PTR(-ENOMEM);
+
+ usb->connection_status_cb = connection_cb;
+ usb->dev = dev;
+ usb->priv_data = priv;
+
+ mutex_lock(&ctx_mutex);
+ list_add_tail(&usb->list, &usb_ctx_list);
+ mutex_unlock(&ctx_mutex);
+
+ return usb;
+}
+EXPORT_SYMBOL_GPL(snd_soc_usb_add_port);
+
+/**
+ * snd_soc_usb_remove_port() - Remove a USB backend port
+ * @dev: USB backend device
+ *
+ * Remove a USB backend device from USB SND SOC. Memory is freed when USB
+ * backend is removed.
+ *
+ */
+int snd_soc_usb_remove_port(struct device *dev)
+{
+ struct snd_soc_usb *ctx, *tmp;
+
+ mutex_lock(&ctx_mutex);
+ list_for_each_entry_safe(ctx, tmp, &usb_ctx_list, list) {
+ if (ctx->dev == dev) {
+ list_del(&ctx->list);
+ break;
+ }
+ }
+ mutex_unlock(&ctx_mutex);
+
+ return 0;
+}
+EXPORT_SYMBOL_GPL(snd_soc_usb_remove_port);
+
+/**
+ * snd_soc_usb_connect() - Notification of USB device connection
+ * @usbdev: USB bus device
+ * @card_idx: USB SND card instance
+ *
+ * Notify of a new USB SND device connection. The card_idx can be used to
+ * handle how the USB backend selects, which device to enable offloading on.
+ *
+ */
+int snd_soc_usb_connect(struct device *usbdev, int card_idx)
+{
+ struct snd_soc_usb *ctx;
+
+ if (!usbdev)
+ return -ENODEV;
+
+ ctx = snd_soc_find_usb_ctx(usbdev);
+ if (!ctx)
+ return -ENODEV;
+
+ if (ctx->connection_status_cb)
+ ctx->connection_status_cb(ctx, card_idx, 1);
+
+ return 0;
+}
+EXPORT_SYMBOL_GPL(snd_soc_usb_connect);
+
+/**
+ * snd_soc_usb_disconnect() - Notification of USB device disconnection
+ * @usbdev: USB bus device
+ *
+ * Notify of a new USB SND device disconnection to the USB backend.
+ *
+ */
+int snd_soc_usb_disconnect(struct device *usbdev)
+{
+ struct snd_soc_usb *ctx;
+
+ if (!usbdev)
+ return -ENODEV;
+
+ ctx = snd_soc_find_usb_ctx(usbdev);
+ if (!ctx)
+ return -ENODEV;
+
+ if (ctx->connection_status_cb)
+ ctx->connection_status_cb(ctx, -1, 0);
+
+ return 0;
+}
+EXPORT_SYMBOL_GPL(snd_soc_usb_disconnect);
For USB offloading situations, the AFE port start command will result in a
QMI handshake between the Q6DSP and the main processor. Depending on if
the USB bus is suspended, this routine would require more time to complete,
as resuming the USB bus has some overhead associated with it. Increase the
timeout to 3s to allow for sufficient time for the USB QMI stream enable
handshake to complete.
Reviewed-by: Srinivas Kandagatla <[email protected]>
Signed-off-by: Wesley Cheng <[email protected]>
---
sound/soc/qcom/qdsp6/q6afe.c | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/sound/soc/qcom/qdsp6/q6afe.c b/sound/soc/qcom/qdsp6/q6afe.c
index 43baf93f9c89..e9d5fa6b6b0d 100644
--- a/sound/soc/qcom/qdsp6/q6afe.c
+++ b/sound/soc/qcom/qdsp6/q6afe.c
@@ -365,7 +365,7 @@
#define AFE_API_VERSION_SLOT_MAPPING_CONFIG 1
#define AFE_API_VERSION_CODEC_DMA_CONFIG 1
-#define TIMEOUT_MS 1000
+#define TIMEOUT_MS 3000
#define AFE_CMD_RESP_AVAIL 0
#define AFE_CMD_RESP_NONE 1
#define AFE_CLK_TOKEN 1024
With USB audio offloading, an audio session is started from the ASoC
platform sound card and PCM devices. Likewise, the USB SND path is still
readily available for use, in case the non-offload path is desired. In
order to prevent the two entities from attempting to use the USB bus,
introduce a flag that determines when either paths are in use.
If a PCM device is already in use, the check will return an error to
userspace notifying that the stream is currently busy. This ensures that
only one path is using the USB substream.
Signed-off-by: Wesley Cheng <[email protected]>
---
sound/usb/card.h | 1 +
sound/usb/pcm.c | 19 +++++++++++++++++--
sound/usb/qcom/qc_audio_offload.c | 15 ++++++++++++++-
3 files changed, 32 insertions(+), 3 deletions(-)
diff --git a/sound/usb/card.h b/sound/usb/card.h
index 4535b48edd1b..922868d2dccd 100644
--- a/sound/usb/card.h
+++ b/sound/usb/card.h
@@ -164,6 +164,7 @@ struct snd_usb_substream {
unsigned int pkt_offset_adj; /* Bytes to drop from beginning of packets (for non-compliant devices) */
unsigned int stream_offset_adj; /* Bytes to drop from beginning of stream (for non-compliant devices) */
+ unsigned int opened:1; /* pcm device opened */
unsigned int running: 1; /* running status */
unsigned int period_elapsed_pending; /* delay period handling */
diff --git a/sound/usb/pcm.c b/sound/usb/pcm.c
index 482c160cbc17..c8590ff78d11 100644
--- a/sound/usb/pcm.c
+++ b/sound/usb/pcm.c
@@ -1208,8 +1208,15 @@ static int snd_usb_pcm_open(struct snd_pcm_substream *substream)
struct snd_usb_stream *as = snd_pcm_substream_chip(substream);
struct snd_pcm_runtime *runtime = substream->runtime;
struct snd_usb_substream *subs = &as->substream[direction];
+ struct snd_usb_audio *chip = subs->stream->chip;
int ret;
+ mutex_lock(&chip->mutex);
+ if (subs->opened) {
+ mutex_unlock(&chip->mutex);
+ return -EBUSY;
+ }
+
runtime->hw = snd_usb_hardware;
/* need an explicit sync to catch applptr update in low-latency mode */
if (direction == SNDRV_PCM_STREAM_PLAYBACK &&
@@ -1226,13 +1233,17 @@ static int snd_usb_pcm_open(struct snd_pcm_substream *substream)
ret = setup_hw_info(runtime, subs);
if (ret < 0)
- return ret;
+ goto out;
ret = snd_usb_autoresume(subs->stream->chip);
if (ret < 0)
- return ret;
+ goto out;
ret = snd_media_stream_init(subs, as->pcm, direction);
if (ret < 0)
snd_usb_autosuspend(subs->stream->chip);
+ subs->opened = 1;
+out:
+ mutex_unlock(&chip->mutex);
+
return ret;
}
@@ -1241,6 +1252,7 @@ static int snd_usb_pcm_close(struct snd_pcm_substream *substream)
int direction = substream->stream;
struct snd_usb_stream *as = snd_pcm_substream_chip(substream);
struct snd_usb_substream *subs = &as->substream[direction];
+ struct snd_usb_audio *chip = subs->stream->chip;
int ret;
snd_media_stop_pipeline(subs);
@@ -1254,6 +1266,9 @@ static int snd_usb_pcm_close(struct snd_pcm_substream *substream)
subs->pcm_substream = NULL;
snd_usb_autosuspend(subs->stream->chip);
+ mutex_lock(&chip->mutex);
+ subs->opened = 0;
+ mutex_unlock(&chip->mutex);
return 0;
}
diff --git a/sound/usb/qcom/qc_audio_offload.c b/sound/usb/qcom/qc_audio_offload.c
index 2663906644f2..2c8dd5605849 100644
--- a/sound/usb/qcom/qc_audio_offload.c
+++ b/sound/usb/qcom/qc_audio_offload.c
@@ -1402,12 +1402,17 @@ static void handle_uaudio_stream_req(struct qmi_handle *handle,
goto response;
}
+ mutex_lock(&chip->mutex);
if (req_msg->enable) {
- if (info_idx < 0 || chip->system_suspend) {
+ if (info_idx < 0 || chip->system_suspend || subs->opened) {
ret = -EBUSY;
+ mutex_unlock(&chip->mutex);
+
goto response;
}
+ subs->opened = 1;
}
+ mutex_unlock(&chip->mutex);
if (req_msg->service_interval_valid) {
ret = get_data_interval_from_si(subs,
@@ -1429,6 +1434,11 @@ static void handle_uaudio_stream_req(struct qmi_handle *handle,
if (!ret)
ret = prepare_qmi_response(subs, req_msg, &resp,
info_idx);
+ if (ret < 0) {
+ mutex_lock(&chip->mutex);
+ subs->opened = 0;
+ mutex_unlock(&chip->mutex);
+ }
} else {
info = &uadev[pcm_card_num].info[info_idx];
if (info->data_ep_pipe) {
@@ -1450,6 +1460,9 @@ static void handle_uaudio_stream_req(struct qmi_handle *handle,
}
disable_audio_stream(subs);
+ mutex_lock(&chip->mutex);
+ subs->opened = 0;
+ mutex_unlock(&chip->mutex);
}
response:
Some use cases, such as USB audio offloading, will allow for a DSP to take
over issuing USB transfers to the host controller. In order for the DSP to
submit transfers for a particular endpoint, and to handle its events, the
client driver will need to query for some parameters allocated by XHCI.
- XHCI secondary interrupter event ring address
- XHCI transfer ring address (for a particular EP)
- Stop endpoint command API
Once the resources are handed off to the DSP, the offload begins, and the
main processor can enter idle. When stopped, since there are no URBs
submitted from the main processor, the client will just issue a stop
endpoint command to halt any pending transfers.
Signed-off-by: Wesley Cheng <[email protected]>
---
drivers/usb/host/xhci.c | 130 ++++++++++++++++++++++++++++++++++
include/linux/usb/xhci-intr.h | 8 +++
2 files changed, 138 insertions(+)
diff --git a/drivers/usb/host/xhci.c b/drivers/usb/host/xhci.c
index 88435b9cd66e..5c6b3d8f834c 100644
--- a/drivers/usb/host/xhci.c
+++ b/drivers/usb/host/xhci.c
@@ -1603,6 +1603,136 @@ static int xhci_check_args(struct usb_hcd *hcd, struct usb_device *udev,
return 1;
}
+int xhci_stop_endpoint(struct usb_device *udev,
+ struct usb_host_endpoint *ep)
+{
+ struct usb_hcd *hcd = bus_to_hcd(udev->bus);
+ struct xhci_hcd *xhci = hcd_to_xhci(hcd);
+ unsigned int ep_index;
+ struct xhci_virt_device *virt_dev;
+ struct xhci_command *cmd;
+ unsigned long flags;
+ int ret = 0;
+
+ ret = xhci_check_args(hcd, udev, ep, 1, true, __func__);
+ if (ret <= 0)
+ return ret;
+
+ cmd = xhci_alloc_command(xhci, true, GFP_NOIO);
+ if (!cmd)
+ return -ENOMEM;
+
+ spin_lock_irqsave(&xhci->lock, flags);
+ virt_dev = xhci->devs[udev->slot_id];
+ if (!virt_dev) {
+ ret = -ENODEV;
+ goto err;
+ }
+
+ ep_index = xhci_get_endpoint_index(&ep->desc);
+ if (virt_dev->eps[ep_index].ring &&
+ virt_dev->eps[ep_index].ring->dequeue) {
+ ret = xhci_queue_stop_endpoint(xhci, cmd, udev->slot_id,
+ ep_index, 0);
+ if (ret)
+ goto err;
+
+ xhci_ring_cmd_db(xhci);
+ spin_unlock_irqrestore(&xhci->lock, flags);
+
+ /* Wait for stop endpoint command to finish */
+ wait_for_completion(cmd->completion);
+
+ if (cmd->status == COMP_COMMAND_ABORTED ||
+ cmd->status == COMP_STOPPED) {
+ xhci_warn(xhci,
+ "stop endpoint command timeout for ep%d%s\n",
+ usb_endpoint_num(&ep->desc),
+ usb_endpoint_dir_in(&ep->desc) ? "in" : "out");
+ ret = -ETIME;
+ }
+ goto free_cmd;
+ }
+
+err:
+ spin_unlock_irqrestore(&xhci->lock, flags);
+free_cmd:
+ xhci_free_command(xhci, cmd);
+
+ return ret;
+}
+EXPORT_SYMBOL_GPL(xhci_stop_endpoint);
+
+/* Retrieve the transfer ring base address for a specific endpoint. */
+phys_addr_t xhci_get_xfer_resource(struct usb_device *udev,
+ struct usb_host_endpoint *ep, dma_addr_t *dma)
+{
+ struct usb_hcd *hcd = bus_to_hcd(udev->bus);
+ struct device *dev = hcd->self.sysdev;
+ struct xhci_hcd *xhci = hcd_to_xhci(hcd);
+ struct sg_table sgt;
+ phys_addr_t pa;
+ int ret;
+ unsigned int ep_index;
+ struct xhci_virt_device *virt_dev;
+ unsigned long flags;
+
+ if (!HCD_RH_RUNNING(hcd))
+ return 0;
+
+ ret = xhci_check_args(hcd, udev, ep, 1, true, __func__);
+ if (ret <= 0) {
+ xhci_err(xhci, "%s: invalid args\n", __func__);
+ return 0;
+ }
+
+ spin_lock_irqsave(&xhci->lock, flags);
+
+ virt_dev = xhci->devs[udev->slot_id];
+ ep_index = xhci_get_endpoint_index(&ep->desc);
+
+ if (virt_dev->eps[ep_index].ring &&
+ virt_dev->eps[ep_index].ring->first_seg) {
+
+ dma_get_sgtable(dev, &sgt,
+ virt_dev->eps[ep_index].ring->first_seg->trbs,
+ virt_dev->eps[ep_index].ring->first_seg->dma,
+ TRB_SEGMENT_SIZE);
+
+ *dma = virt_dev->eps[ep_index].ring->first_seg->dma;
+
+ pa = page_to_phys(sg_page(sgt.sgl));
+ sg_free_table(&sgt);
+ spin_unlock_irqrestore(&xhci->lock, flags);
+
+ return pa;
+ }
+ spin_unlock_irqrestore(&xhci->lock, flags);
+
+ return 0;
+}
+EXPORT_SYMBOL_GPL(xhci_get_xfer_resource);
+
+phys_addr_t xhci_get_ir_resource(struct usb_device *udev, struct xhci_interrupter *ir)
+{
+ struct usb_hcd *hcd = bus_to_hcd(udev->bus);
+ struct device *dev = hcd->self.sysdev;
+ struct sg_table sgt;
+ phys_addr_t pa;
+
+ if (!ir)
+ return 0;
+
+ dma_get_sgtable(dev, &sgt, ir->event_ring->first_seg->trbs,
+ ir->event_ring->first_seg->dma, TRB_SEGMENT_SIZE);
+
+ pa = page_to_phys(sg_page(sgt.sgl));
+ sg_free_table(&sgt);
+
+ return pa;
+}
+EXPORT_SYMBOL_GPL(xhci_get_ir_resource);
+
static int xhci_configure_endpoint(struct xhci_hcd *xhci,
struct usb_device *udev, struct xhci_command *command,
bool ctx_change, bool must_succeed);
diff --git a/include/linux/usb/xhci-intr.h b/include/linux/usb/xhci-intr.h
index 738b0f0481a6..d42cc9a1e698 100644
--- a/include/linux/usb/xhci-intr.h
+++ b/include/linux/usb/xhci-intr.h
@@ -80,7 +80,15 @@ struct xhci_interrupter {
u64 s3_erst_dequeue;
};
+/* Secondary interrupter */
struct xhci_interrupter *
xhci_create_secondary_interrupter(struct usb_hcd *hcd, int intr_num);
void xhci_remove_secondary_interrupter(struct usb_hcd *hcd, struct xhci_interrupter *ir);
+
+/* Offload */
+int xhci_stop_endpoint(struct usb_device *udev,
+ struct usb_host_endpoint *ep);
+phys_addr_t xhci_get_xfer_resource(struct usb_device *udev,
+ struct usb_host_endpoint *ep, dma_addr_t *dma);
+phys_addr_t xhci_get_ir_resource(struct usb_device *udev, struct xhci_interrupter *ir);
#endif
Some vendor modules will utilize useful parsing and endpoint management
APIs to start audio playback/capture.
Signed-off-by: Wesley Cheng <[email protected]>
---
include/sound/pcm_params.h | 4 +++
sound/core/oss/pcm_oss.c | 58 ----------------------------------
sound/core/pcm_lib.c | 65 ++++++++++++++++++++++++++++++++++++++
sound/usb/card.c | 2 ++
sound/usb/endpoint.c | 2 ++
sound/usb/helper.c | 1 +
sound/usb/pcm.c | 9 ++++--
sound/usb/pcm.h | 12 +++++++
8 files changed, 92 insertions(+), 61 deletions(-)
diff --git a/include/sound/pcm_params.h b/include/sound/pcm_params.h
index ba184f49f7e1..407557b72700 100644
--- a/include/sound/pcm_params.h
+++ b/include/sound/pcm_params.h
@@ -17,6 +17,10 @@ int snd_pcm_hw_param_last(struct snd_pcm_substream *pcm,
snd_pcm_hw_param_t var, int *dir);
int snd_pcm_hw_param_value(const struct snd_pcm_hw_params *params,
snd_pcm_hw_param_t var, int *dir);
+int _snd_pcm_hw_param_set(struct snd_pcm_hw_params *params,
+ snd_pcm_hw_param_t var, unsigned int val,
+ int dir);
+int snd_interval_refine_set(struct snd_interval *i, unsigned int val);
#define SNDRV_MASK_BITS 64 /* we use so far 64bits only */
#define SNDRV_MASK_SIZE (SNDRV_MASK_BITS / 32)
diff --git a/sound/core/oss/pcm_oss.c b/sound/core/oss/pcm_oss.c
index 728c211142d1..fc9ce709412d 100644
--- a/sound/core/oss/pcm_oss.c
+++ b/sound/core/oss/pcm_oss.c
@@ -103,16 +103,6 @@ static int snd_interval_refine_max(struct snd_interval *i, unsigned int max, int
return changed;
}
-static int snd_interval_refine_set(struct snd_interval *i, unsigned int val)
-{
- struct snd_interval t;
- t.empty = 0;
- t.min = t.max = val;
- t.openmin = t.openmax = 0;
- t.integer = 1;
- return snd_interval_refine(i, &t);
-}
-
/**
* snd_pcm_hw_param_value_min
* @params: the hw_params instance
@@ -443,54 +433,6 @@ static int snd_pcm_hw_param_near(struct snd_pcm_substream *pcm,
return v;
}
-static int _snd_pcm_hw_param_set(struct snd_pcm_hw_params *params,
- snd_pcm_hw_param_t var, unsigned int val,
- int dir)
-{
- int changed;
- if (hw_is_mask(var)) {
- struct snd_mask *m = hw_param_mask(params, var);
- if (val == 0 && dir < 0) {
- changed = -EINVAL;
- snd_mask_none(m);
- } else {
- if (dir > 0)
- val++;
- else if (dir < 0)
- val--;
- changed = snd_mask_refine_set(hw_param_mask(params, var), val);
- }
- } else if (hw_is_interval(var)) {
- struct snd_interval *i = hw_param_interval(params, var);
- if (val == 0 && dir < 0) {
- changed = -EINVAL;
- snd_interval_none(i);
- } else if (dir == 0)
- changed = snd_interval_refine_set(i, val);
- else {
- struct snd_interval t;
- t.openmin = 1;
- t.openmax = 1;
- t.empty = 0;
- t.integer = 0;
- if (dir < 0) {
- t.min = val - 1;
- t.max = val;
- } else {
- t.min = val;
- t.max = val+1;
- }
- changed = snd_interval_refine(i, &t);
- }
- } else
- return -EINVAL;
- if (changed > 0) {
- params->cmask |= 1 << var;
- params->rmask |= 1 << var;
- }
- return changed;
-}
-
/**
* snd_pcm_hw_param_set
* @pcm: PCM instance
diff --git a/sound/core/pcm_lib.c b/sound/core/pcm_lib.c
index 8b6aeb8a78f7..8305fd0860ad 100644
--- a/sound/core/pcm_lib.c
+++ b/sound/core/pcm_lib.c
@@ -2532,3 +2532,68 @@ int snd_pcm_add_chmap_ctls(struct snd_pcm *pcm, int stream,
return 0;
}
EXPORT_SYMBOL_GPL(snd_pcm_add_chmap_ctls);
+
+int snd_interval_refine_set(struct snd_interval *i, unsigned int val)
+{
+ struct snd_interval t;
+
+ t.empty = 0;
+ t.min = t.max = val;
+ t.openmin = t.openmax = 0;
+ t.integer = 1;
+ return snd_interval_refine(i, &t);
+}
+EXPORT_SYMBOL_GPL(snd_interval_refine_set);
+
+int _snd_pcm_hw_param_set(struct snd_pcm_hw_params *params,
+ snd_pcm_hw_param_t var, unsigned int val,
+ int dir)
+{
+ int changed;
+
+ if (hw_is_mask(var)) {
+ struct snd_mask *m = hw_param_mask(params, var);
+
+ if (val == 0 && dir < 0) {
+ changed = -EINVAL;
+ snd_mask_none(m);
+ } else {
+ if (dir > 0)
+ val++;
+ else if (dir < 0)
+ val--;
+ changed = snd_mask_refine_set(hw_param_mask(params, var), val);
+ }
+ } else if (hw_is_interval(var)) {
+ struct snd_interval *i = hw_param_interval(params, var);
+
+ if (val == 0 && dir < 0) {
+ changed = -EINVAL;
+ snd_interval_none(i);
+ } else if (dir == 0)
+ changed = snd_interval_refine_set(i, val);
+ else {
+ struct snd_interval t;
+
+ t.openmin = 1;
+ t.openmax = 1;
+ t.empty = 0;
+ t.integer = 0;
+ if (dir < 0) {
+ t.min = val - 1;
+ t.max = val;
+ } else {
+ t.min = val;
+ t.max = val+1;
+ }
+ changed = snd_interval_refine(i, &t);
+ }
+ } else
+ return -EINVAL;
+ if (changed > 0) {
+ params->cmask |= 1 << var;
+ params->rmask |= 1 << var;
+ }
+ return changed;
+}
+EXPORT_SYMBOL_GPL(_snd_pcm_hw_param_set);
diff --git a/sound/usb/card.c b/sound/usb/card.c
index 9bcbaa0c0a55..e5d5c0f04c85 100644
--- a/sound/usb/card.c
+++ b/sound/usb/card.c
@@ -1077,6 +1077,7 @@ int snd_usb_autoresume(struct snd_usb_audio *chip)
}
return 0;
}
+EXPORT_SYMBOL_GPL(snd_usb_autoresume);
void snd_usb_autosuspend(struct snd_usb_audio *chip)
{
@@ -1090,6 +1091,7 @@ void snd_usb_autosuspend(struct snd_usb_audio *chip)
for (i = 0; i < chip->num_interfaces; i++)
usb_autopm_put_interface(chip->intf[i]);
}
+EXPORT_SYMBOL_GPL(snd_usb_autosuspend);
static int usb_audio_suspend(struct usb_interface *intf, pm_message_t message)
{
diff --git a/sound/usb/endpoint.c b/sound/usb/endpoint.c
index 419302e2057e..207869dc95f0 100644
--- a/sound/usb/endpoint.c
+++ b/sound/usb/endpoint.c
@@ -860,6 +860,7 @@ snd_usb_endpoint_open(struct snd_usb_audio *chip,
mutex_unlock(&chip->mutex);
return ep;
}
+EXPORT_SYMBOL_GPL(snd_usb_endpoint_open);
/*
* snd_usb_endpoint_set_sync: Link data and sync endpoints
@@ -1510,6 +1511,7 @@ int snd_usb_endpoint_prepare(struct snd_usb_audio *chip,
mutex_unlock(&chip->mutex);
return err;
}
+EXPORT_SYMBOL_GPL(snd_usb_endpoint_prepare);
/* get the current rate set to the given clock by any endpoint */
int snd_usb_endpoint_get_clock_rate(struct snd_usb_audio *chip, int clock)
diff --git a/sound/usb/helper.c b/sound/usb/helper.c
index a4410267bf70..b4ed9ef3eeb3 100644
--- a/sound/usb/helper.c
+++ b/sound/usb/helper.c
@@ -62,6 +62,7 @@ void *snd_usb_find_csint_desc(void *buffer, int buflen, void *after, u8 dsubtype
}
return NULL;
}
+EXPORT_SYMBOL_GPL(snd_usb_find_csint_desc);
/*
* Wrapper for usb_control_msg().
diff --git a/sound/usb/pcm.c b/sound/usb/pcm.c
index d959da7a1afb..4576a36dc9b2 100644
--- a/sound/usb/pcm.c
+++ b/sound/usb/pcm.c
@@ -87,7 +87,7 @@ static snd_pcm_uframes_t snd_usb_pcm_pointer(struct snd_pcm_substream *substream
/*
* find a matching audio format
*/
-static const struct audioformat *
+const struct audioformat *
find_format(struct list_head *fmt_list_head, snd_pcm_format_t format,
unsigned int rate, unsigned int channels, bool strict_match,
struct snd_usb_substream *subs)
@@ -147,8 +147,9 @@ find_format(struct list_head *fmt_list_head, snd_pcm_format_t format,
}
return found;
}
+EXPORT_SYMBOL_GPL(find_format);
-static const struct audioformat *
+const struct audioformat *
find_substream_format(struct snd_usb_substream *subs,
const struct snd_pcm_hw_params *params)
{
@@ -156,6 +157,7 @@ find_substream_format(struct snd_usb_substream *subs,
params_rate(params), params_channels(params),
true, subs);
}
+EXPORT_SYMBOL_GPL(find_substream_format);
bool snd_usb_pcm_has_fixed_rate(struct snd_usb_substream *subs)
{
@@ -446,7 +448,7 @@ int snd_usb_pcm_resume(struct snd_usb_stream *as)
return 0;
}
-static void close_endpoints(struct snd_usb_audio *chip,
+void close_endpoints(struct snd_usb_audio *chip,
struct snd_usb_substream *subs)
{
if (subs->data_endpoint) {
@@ -460,6 +462,7 @@ static void close_endpoints(struct snd_usb_audio *chip,
subs->sync_endpoint = NULL;
}
}
+EXPORT_SYMBOL(close_endpoints);
/*
* hw_params callback
diff --git a/sound/usb/pcm.h b/sound/usb/pcm.h
index 388fe2ba346d..b5216cb19e75 100644
--- a/sound/usb/pcm.h
+++ b/sound/usb/pcm.h
@@ -15,4 +15,16 @@ void snd_usb_preallocate_buffer(struct snd_usb_substream *subs);
int snd_usb_audioformat_set_sync_ep(struct snd_usb_audio *chip,
struct audioformat *fmt);
+void close_endpoints(struct snd_usb_audio *chip,
+ struct snd_usb_substream *subs);
+int configure_endpoints(struct snd_usb_audio *chip,
+ struct snd_usb_substream *subs);
+
+const struct audioformat *
+find_format(struct list_head *fmt_list_head, snd_pcm_format_t format,
+ unsigned int rate, unsigned int channels, bool strict_match,
+ struct snd_usb_substream *subs);
+const struct audioformat *
+find_substream_format(struct snd_usb_substream *subs,
+ const struct snd_pcm_hw_params *params);
#endif /* __USBAUDIO_PCM_H */
The QC ADSP is able to support USB playback endpoints, so that the main
application processor can be placed into lower CPU power modes. This adds
the required AFE port configurations and port start command to start an
audio session.
Specifically, the QC ADSP can support all potential endpoints that are
exposed by the audio data interface. This includes, feedback endpoints
(both implicit and explicit) as well as the isochronous (data) endpoints.
The size of audio samples sent per USB frame (microframe) will be adjusted
based on information received on the feedback endpoint.
Signed-off-by: Wesley Cheng <[email protected]>
---
sound/soc/qcom/qdsp6/q6afe-dai.c | 50 ++++++
sound/soc/qcom/qdsp6/q6afe.c | 185 ++++++++++++++++++++++-
sound/soc/qcom/qdsp6/q6afe.h | 46 +++++-
sound/soc/qcom/qdsp6/q6dsp-lpass-ports.c | 23 +++
sound/soc/qcom/qdsp6/q6dsp-lpass-ports.h | 1 +
sound/soc/qcom/qdsp6/q6routing.c | 9 ++
6 files changed, 312 insertions(+), 2 deletions(-)
diff --git a/sound/soc/qcom/qdsp6/q6afe-dai.c b/sound/soc/qcom/qdsp6/q6afe-dai.c
index 8bb7452b8f18..bda79d77c8d8 100644
--- a/sound/soc/qcom/qdsp6/q6afe-dai.c
+++ b/sound/soc/qcom/qdsp6/q6afe-dai.c
@@ -111,6 +111,40 @@ static int q6hdmi_hw_params(struct snd_pcm_substream *substream,
return 0;
}
+static int q6usb_hw_params(struct snd_pcm_substream *substream,
+ struct snd_pcm_hw_params *params,
+ struct snd_soc_dai *dai)
+{
+ struct q6afe_dai_data *dai_data = dev_get_drvdata(dai->dev);
+ int channels = params_channels(params);
+ int rate = params_rate(params);
+ struct q6afe_usb_cfg *usb = &dai_data->port_config[dai->id].usb_audio;
+
+ usb->sample_rate = rate;
+ usb->num_channels = channels;
+
+ switch (params_format(params)) {
+ case SNDRV_PCM_FORMAT_U16_LE:
+ case SNDRV_PCM_FORMAT_S16_LE:
+ case SNDRV_PCM_FORMAT_SPECIAL:
+ usb->bit_width = 16;
+ break;
+ case SNDRV_PCM_FORMAT_S24_LE:
+ case SNDRV_PCM_FORMAT_S24_3LE:
+ usb->bit_width = 24;
+ break;
+ case SNDRV_PCM_FORMAT_S32_LE:
+ usb->bit_width = 32;
+ break;
+ default:
+ dev_err(dai->dev, "%s: invalid format %d\n",
+ __func__, params_format(params));
+ return -EINVAL;
+ }
+
+ return 0;
+}
+
static int q6i2s_hw_params(struct snd_pcm_substream *substream,
struct snd_pcm_hw_params *params,
struct snd_soc_dai *dai)
@@ -411,6 +445,10 @@ static int q6afe_dai_prepare(struct snd_pcm_substream *substream,
q6afe_cdc_dma_port_prepare(dai_data->port[dai->id],
&dai_data->port_config[dai->id].dma_cfg);
break;
+ case USB_RX:
+ q6afe_usb_port_prepare(dai_data->port[dai->id],
+ &dai_data->port_config[dai->id].usb_audio);
+ break;
default:
return -EINVAL;
}
@@ -637,6 +675,15 @@ static const struct snd_soc_dapm_route q6afe_dapm_routes[] = {
{"TX_CODEC_DMA_TX_5", NULL, "TX_CODEC_DMA_TX_5 Capture"},
{"RX_CODEC_DMA_RX_6 Playback", NULL, "RX_CODEC_DMA_RX_6"},
{"RX_CODEC_DMA_RX_7 Playback", NULL, "RX_CODEC_DMA_RX_7"},
+
+ /* USB playback AFE port receives data for playback, hence use the RX port */
+ {"USB Playback", NULL, "USB_RX"},
+};
+
+static const struct snd_soc_dai_ops q6usb_ops = {
+ .prepare = q6afe_dai_prepare,
+ .hw_params = q6usb_hw_params,
+ .shutdown = q6afe_dai_shutdown,
};
static const struct snd_soc_dai_ops q6hdmi_ops = {
@@ -952,6 +999,8 @@ static const struct snd_soc_dapm_widget q6afe_dai_widgets[] = {
0, SND_SOC_NOPM, 0, 0),
SND_SOC_DAPM_AIF_IN("RX_CODEC_DMA_RX_7", "NULL",
0, SND_SOC_NOPM, 0, 0),
+
+ SND_SOC_DAPM_AIF_IN("USB_RX", NULL, 0, SND_SOC_NOPM, 0, 0),
};
static const struct snd_soc_component_driver q6afe_dai_component = {
@@ -1068,6 +1117,7 @@ static int q6afe_dai_dev_probe(struct platform_device *pdev)
cfg.q6i2s_ops = &q6i2s_ops;
cfg.q6tdm_ops = &q6tdm_ops;
cfg.q6dma_ops = &q6dma_ops;
+ cfg.q6usb_ops = &q6usb_ops;
dais = q6dsp_audio_ports_set_config(dev, &cfg, &num_dais);
return devm_snd_soc_register_component(dev, &q6afe_dai_component, dais, num_dais);
diff --git a/sound/soc/qcom/qdsp6/q6afe.c b/sound/soc/qcom/qdsp6/q6afe.c
index 919e326b9462..43baf93f9c89 100644
--- a/sound/soc/qcom/qdsp6/q6afe.c
+++ b/sound/soc/qcom/qdsp6/q6afe.c
@@ -34,6 +34,8 @@
#define AFE_MODULE_TDM 0x0001028A
#define AFE_PARAM_ID_CDC_SLIMBUS_SLAVE_CFG 0x00010235
+#define AFE_PARAM_ID_USB_AUDIO_DEV_PARAMS 0x000102A5
+#define AFE_PARAM_ID_USB_AUDIO_DEV_LPCM_FMT 0x000102AA
#define AFE_PARAM_ID_LPAIF_CLK_CONFIG 0x00010238
#define AFE_PARAM_ID_INT_DIGITAL_CDC_CLK_CONFIG 0x00010239
@@ -43,6 +45,7 @@
#define AFE_PARAM_ID_TDM_CONFIG 0x0001029D
#define AFE_PARAM_ID_PORT_SLOT_MAPPING_CONFIG 0x00010297
#define AFE_PARAM_ID_CODEC_DMA_CONFIG 0x000102B8
+#define AFE_PARAM_ID_USB_AUDIO_CONFIG 0x000102A4
#define AFE_CMD_REMOTE_LPASS_CORE_HW_VOTE_REQUEST 0x000100f4
#define AFE_CMD_RSP_REMOTE_LPASS_CORE_HW_VOTE_REQUEST 0x000100f5
#define AFE_CMD_REMOTE_LPASS_CORE_HW_DEVOTE_REQUEST 0x000100f6
@@ -71,12 +74,16 @@
#define AFE_PORT_CONFIG_I2S_WS_SRC_INTERNAL 0x1
#define AFE_LINEAR_PCM_DATA 0x0
+#define AFE_API_MINOR_VERSION_USB_AUDIO_CONFIG 0x1
/* Port IDs */
#define AFE_API_VERSION_HDMI_CONFIG 0x1
#define AFE_PORT_ID_MULTICHAN_HDMI_RX 0x100E
#define AFE_PORT_ID_HDMI_OVER_DP_RX 0x6020
+/* USB AFE port */
+#define AFE_PORT_ID_USB_RX 0x7000
+
#define AFE_API_VERSION_SLIMBUS_CONFIG 0x1
/* Clock set API version */
#define AFE_API_VERSION_CLOCK_SET 1
@@ -512,12 +519,109 @@ struct afe_param_id_cdc_dma_cfg {
u16 active_channels_mask;
} __packed;
+struct afe_param_id_usb_cfg {
+/* Minor version used for tracking USB audio device configuration.
+ * Supported values: AFE_API_MINOR_VERSION_USB_AUDIO_CONFIG
+ */
+ u32 cfg_minor_version;
+/* Sampling rate of the port.
+ * Supported values:
+ * - AFE_PORT_SAMPLE_RATE_8K
+ * - AFE_PORT_SAMPLE_RATE_11025
+ * - AFE_PORT_SAMPLE_RATE_12K
+ * - AFE_PORT_SAMPLE_RATE_16K
+ * - AFE_PORT_SAMPLE_RATE_22050
+ * - AFE_PORT_SAMPLE_RATE_24K
+ * - AFE_PORT_SAMPLE_RATE_32K
+ * - AFE_PORT_SAMPLE_RATE_44P1K
+ * - AFE_PORT_SAMPLE_RATE_48K
+ * - AFE_PORT_SAMPLE_RATE_96K
+ * - AFE_PORT_SAMPLE_RATE_192K
+ */
+ u32 sample_rate;
+/* Bit width of the sample.
+ * Supported values: 16, 24
+ */
+ u16 bit_width;
+/* Number of channels.
+ * Supported values: 1 and 2
+ */
+ u16 num_channels;
+/* Data format supported by the USB. The supported value is
+ * 0 (#AFE_USB_AUDIO_DATA_FORMAT_LINEAR_PCM).
+ */
+ u16 data_format;
+/* this field must be 0 */
+ u16 reserved;
+/* device token of actual end USB aduio device */
+ u32 dev_token;
+/* endianness of this interface */
+ u32 endian;
+/* service interval */
+ u32 service_interval;
+} __packed;
+
+/**
+ * struct afe_param_id_usb_audio_dev_params
+ * @cfg_minor_version: Minor version used for tracking USB audio device
+ * configuration.
+ * Supported values:
+ * AFE_API_MINOR_VERSION_USB_AUDIO_CONFIG
+ * @dev_token: device token of actual end USB aduio device
+ **/
+struct afe_param_id_usb_audio_dev_params {
+ u32 cfg_minor_version;
+ u32 dev_token;
+} __packed;
+
+/**
+ * struct afe_param_id_usb_audio_dev_lpcm_fmt
+ * @cfg_minor_version: Minor version used for tracking USB audio device
+ * configuration.
+ * Supported values:
+ * AFE_API_MINOR_VERSION_USB_AUDIO_CONFIG
+ * @endian: endianness of this interface
+ **/
+struct afe_param_id_usb_audio_dev_lpcm_fmt {
+ u32 cfg_minor_version;
+ u32 endian;
+} __packed;
+
+/**
+ * struct afe_param_id_usb_audio_dev_latency_mode
+ * @cfg_minor_version: Minor version used for tracking USB audio device
+ * configuration.
+ * Supported values:
+ * AFE_API_MINOR_VERSION_USB_AUDIO_LATENCY_MODE
+ * @mode: latency mode for the USB audio device
+ **/
+struct afe_param_id_usb_audio_dev_latency_mode {
+ u32 minor_version;
+ u32 mode;
+} __packed;
+
+#define AFE_PARAM_ID_USB_AUDIO_SVC_INTERVAL 0x000102B7
+
+/**
+ * struct afe_param_id_usb_audio_svc_interval
+ * @cfg_minor_version: Minor version used for tracking USB audio device
+ * configuration.
+ * Supported values:
+ * AFE_API_MINOR_VERSION_USB_AUDIO_CONFIG
+ * @svc_interval: service interval
+ **/
+struct afe_param_id_usb_audio_svc_interval {
+ u32 cfg_minor_version;
+ u32 svc_interval;
+} __packed;
+
union afe_port_config {
struct afe_param_id_hdmi_multi_chan_audio_cfg hdmi_multi_ch;
struct afe_param_id_slimbus_cfg slim_cfg;
struct afe_param_id_i2s_cfg i2s_cfg;
struct afe_param_id_tdm_cfg tdm_cfg;
struct afe_param_id_cdc_dma_cfg dma_cfg;
+ struct afe_param_id_usb_cfg usb_cfg;
} __packed;
@@ -832,6 +936,7 @@ static struct afe_port_map port_maps[AFE_PORT_MAX] = {
RX_CODEC_DMA_RX_6, 1, 1},
[RX_CODEC_DMA_RX_7] = { AFE_PORT_ID_RX_CODEC_DMA_RX_7,
RX_CODEC_DMA_RX_7, 1, 1},
+ [USB_RX] = { AFE_PORT_ID_USB_RX, USB_RX, 1, 1},
};
static void q6afe_port_free(struct kref *ref)
@@ -1289,6 +1394,81 @@ void q6afe_tdm_port_prepare(struct q6afe_port *port,
}
EXPORT_SYMBOL_GPL(q6afe_tdm_port_prepare);
+static int afe_port_send_usb_dev_param(struct q6afe_port *port, struct q6afe_usb_cfg *cfg)
+{
+ union afe_port_config *pcfg = &port->port_cfg;
+ struct afe_param_id_usb_audio_dev_params usb_dev;
+ struct afe_param_id_usb_audio_dev_lpcm_fmt lpcm_fmt;
+ struct afe_param_id_usb_audio_svc_interval svc_int;
+ int ret = 0;
+
+ if (!pcfg) {
+ dev_err(port->afe->dev, "%s: Error, no configuration data\n", __func__);
+ ret = -EINVAL;
+ goto exit;
+ }
+
+ memset(&usb_dev, 0, sizeof(usb_dev));
+ memset(&lpcm_fmt, 0, sizeof(lpcm_fmt));
+ memset(&svc_int, 0, sizeof(svc_int));
+
+ usb_dev.cfg_minor_version = AFE_API_MINOR_VERSION_USB_AUDIO_CONFIG;
+ q6afe_port_set_param_v2(port, &usb_dev,
+ AFE_PARAM_ID_USB_AUDIO_DEV_PARAMS,
+ AFE_MODULE_AUDIO_DEV_INTERFACE, sizeof(usb_dev));
+ if (ret) {
+ dev_err(port->afe->dev, "%s: AFE device param cmd failed %d\n",
+ __func__, ret);
+ goto exit;
+ }
+
+ lpcm_fmt.cfg_minor_version = AFE_API_MINOR_VERSION_USB_AUDIO_CONFIG;
+ lpcm_fmt.endian = pcfg->usb_cfg.endian;
+ ret = q6afe_port_set_param_v2(port, &lpcm_fmt,
+ AFE_PARAM_ID_USB_AUDIO_DEV_LPCM_FMT,
+ AFE_MODULE_AUDIO_DEV_INTERFACE, sizeof(lpcm_fmt));
+ if (ret) {
+ dev_err(port->afe->dev, "%s: AFE device param cmd LPCM_FMT failed %d\n",
+ __func__, ret);
+ goto exit;
+ }
+
+ svc_int.cfg_minor_version = AFE_API_MINOR_VERSION_USB_AUDIO_CONFIG;
+ svc_int.svc_interval = pcfg->usb_cfg.service_interval;
+ ret = q6afe_port_set_param_v2(port, &svc_int,
+ AFE_PARAM_ID_USB_AUDIO_SVC_INTERVAL,
+ AFE_MODULE_AUDIO_DEV_INTERFACE, sizeof(svc_int));
+ if (ret) {
+ dev_err(port->afe->dev, "%s: AFE device param cmd svc_interval failed %d\n",
+ __func__, ret);
+ ret = -EINVAL;
+ goto exit;
+ }
+exit:
+ return ret;
+}
+
+/**
+ * q6afe_usb_port_prepare() - Prepare usb afe port.
+ *
+ * @port: Instance of afe port
+ * @cfg: USB configuration for the afe port
+ *
+ */
+void q6afe_usb_port_prepare(struct q6afe_port *port,
+ struct q6afe_usb_cfg *cfg)
+{
+ union afe_port_config *pcfg = &port->port_cfg;
+
+ pcfg->usb_cfg.cfg_minor_version = AFE_API_MINOR_VERSION_USB_AUDIO_CONFIG;
+ pcfg->usb_cfg.sample_rate = cfg->sample_rate;
+ pcfg->usb_cfg.num_channels = cfg->num_channels;
+ pcfg->usb_cfg.bit_width = cfg->bit_width;
+
+ afe_port_send_usb_dev_param(port, cfg);
+}
+EXPORT_SYMBOL_GPL(q6afe_usb_port_prepare);
+
/**
* q6afe_hdmi_port_prepare() - Prepare hdmi afe port.
*
@@ -1611,7 +1791,10 @@ struct q6afe_port *q6afe_port_get_from_id(struct device *dev, int id)
break;
case AFE_PORT_ID_WSA_CODEC_DMA_RX_0 ... AFE_PORT_ID_RX_CODEC_DMA_RX_7:
cfg_type = AFE_PARAM_ID_CODEC_DMA_CONFIG;
- break;
+ break;
+ case AFE_PORT_ID_USB_RX:
+ cfg_type = AFE_PARAM_ID_USB_AUDIO_CONFIG;
+ break;
default:
dev_err(dev, "Invalid port id 0x%x\n", port_id);
return ERR_PTR(-EINVAL);
diff --git a/sound/soc/qcom/qdsp6/q6afe.h b/sound/soc/qcom/qdsp6/q6afe.h
index 30fd77e2f458..e098a3e15135 100644
--- a/sound/soc/qcom/qdsp6/q6afe.h
+++ b/sound/soc/qcom/qdsp6/q6afe.h
@@ -5,7 +5,7 @@
#include <dt-bindings/sound/qcom,q6afe.h>
-#define AFE_PORT_MAX 129
+#define AFE_PORT_MAX 130
#define MSM_AFE_PORT_TYPE_RX 0
#define MSM_AFE_PORT_TYPE_TX 1
@@ -205,6 +205,47 @@ struct q6afe_cdc_dma_cfg {
u16 active_channels_mask;
};
+/**
+ * struct q6afe_usb_cfg
+ * @cfg_minor_version: Minor version used for tracking USB audio device
+ * configuration.
+ * Supported values:
+ * AFE_API_MINOR_VERSION_USB_AUDIO_CONFIG
+ * @sample_rate: Sampling rate of the port
+ * Supported values:
+ * AFE_PORT_SAMPLE_RATE_8K
+ * AFE_PORT_SAMPLE_RATE_11025
+ * AFE_PORT_SAMPLE_RATE_12K
+ * AFE_PORT_SAMPLE_RATE_16K
+ * AFE_PORT_SAMPLE_RATE_22050
+ * AFE_PORT_SAMPLE_RATE_24K
+ * AFE_PORT_SAMPLE_RATE_32K
+ * AFE_PORT_SAMPLE_RATE_44P1K
+ * AFE_PORT_SAMPLE_RATE_48K
+ * AFE_PORT_SAMPLE_RATE_96K
+ * AFE_PORT_SAMPLE_RATE_192K
+ * @bit_width: Bit width of the sample.
+ * Supported values: 16, 24
+ * @num_channels: Number of channels
+ * Supported values: 1, 2
+ * @data_format: Data format supported by the USB
+ * Supported values: 0
+ * @reserved: this field must be 0
+ * @dev_token: device token of actual end USB audio device
+ * @endian: endianness of this interface
+ * @service_interval: service interval
+ **/
+struct q6afe_usb_cfg {
+ u32 cfg_minor_version;
+ u32 sample_rate;
+ u16 bit_width;
+ u16 num_channels;
+ u16 data_format;
+ u16 reserved;
+ u32 dev_token;
+ u32 endian;
+ u32 service_interval;
+};
struct q6afe_port_config {
struct q6afe_hdmi_cfg hdmi;
@@ -212,6 +253,7 @@ struct q6afe_port_config {
struct q6afe_i2s_cfg i2s_cfg;
struct q6afe_tdm_cfg tdm;
struct q6afe_cdc_dma_cfg dma_cfg;
+ struct q6afe_usb_cfg usb_audio;
};
struct q6afe_port;
@@ -221,6 +263,8 @@ int q6afe_port_start(struct q6afe_port *port);
int q6afe_port_stop(struct q6afe_port *port);
void q6afe_port_put(struct q6afe_port *port);
int q6afe_get_port_id(int index);
+void q6afe_usb_port_prepare(struct q6afe_port *port,
+ struct q6afe_usb_cfg *cfg);
void q6afe_hdmi_port_prepare(struct q6afe_port *port,
struct q6afe_hdmi_cfg *cfg);
void q6afe_slim_port_prepare(struct q6afe_port *port,
diff --git a/sound/soc/qcom/qdsp6/q6dsp-lpass-ports.c b/sound/soc/qcom/qdsp6/q6dsp-lpass-ports.c
index f67c16fd90b9..39719c3f1767 100644
--- a/sound/soc/qcom/qdsp6/q6dsp-lpass-ports.c
+++ b/sound/soc/qcom/qdsp6/q6dsp-lpass-ports.c
@@ -81,6 +81,26 @@
static struct snd_soc_dai_driver q6dsp_audio_fe_dais[] = {
+ {
+ .playback = {
+ .stream_name = "USB Playback",
+ .rates = SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_11025 |
+ SNDRV_PCM_RATE_16000 | SNDRV_PCM_RATE_22050 |
+ SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 |
+ SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_96000 |
+ SNDRV_PCM_RATE_192000,
+ .formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S16_BE |
+ SNDRV_PCM_FMTBIT_U16_LE | SNDRV_PCM_FMTBIT_U16_BE |
+ SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S24_BE |
+ SNDRV_PCM_FMTBIT_U24_LE | SNDRV_PCM_FMTBIT_U24_BE,
+ .channels_min = 1,
+ .channels_max = 2,
+ .rate_min = 8000,
+ .rate_max = 192000,
+ },
+ .id = USB_RX,
+ .name = "USB_RX",
+ },
{
.playback = {
.stream_name = "HDMI Playback",
@@ -616,6 +636,9 @@ struct snd_soc_dai_driver *q6dsp_audio_ports_set_config(struct device *dev,
case WSA_CODEC_DMA_RX_0 ... RX_CODEC_DMA_RX_7:
q6dsp_audio_fe_dais[i].ops = cfg->q6dma_ops;
break;
+ case USB_RX:
+ q6dsp_audio_fe_dais[i].ops = cfg->q6usb_ops;
+ break;
default:
break;
}
diff --git a/sound/soc/qcom/qdsp6/q6dsp-lpass-ports.h b/sound/soc/qcom/qdsp6/q6dsp-lpass-ports.h
index 7f052c8a1257..d8dde6dd0aca 100644
--- a/sound/soc/qcom/qdsp6/q6dsp-lpass-ports.h
+++ b/sound/soc/qcom/qdsp6/q6dsp-lpass-ports.h
@@ -11,6 +11,7 @@ struct q6dsp_audio_port_dai_driver_config {
const struct snd_soc_dai_ops *q6i2s_ops;
const struct snd_soc_dai_ops *q6tdm_ops;
const struct snd_soc_dai_ops *q6dma_ops;
+ const struct snd_soc_dai_ops *q6usb_ops;
};
struct snd_soc_dai_driver *q6dsp_audio_ports_set_config(struct device *dev,
diff --git a/sound/soc/qcom/qdsp6/q6routing.c b/sound/soc/qcom/qdsp6/q6routing.c
index 928fd23e2c27..dc2357b4b2c7 100644
--- a/sound/soc/qcom/qdsp6/q6routing.c
+++ b/sound/soc/qcom/qdsp6/q6routing.c
@@ -514,6 +514,9 @@ static int msm_routing_put_audio_mixer(struct snd_kcontrol *kcontrol,
return 1;
}
+static const struct snd_kcontrol_new usb_mixer_controls[] = {
+ Q6ROUTING_RX_MIXERS(USB_RX) };
+
static const struct snd_kcontrol_new hdmi_mixer_controls[] = {
Q6ROUTING_RX_MIXERS(HDMI_RX) };
@@ -949,6 +952,10 @@ static const struct snd_soc_dapm_widget msm_qdsp6_widgets[] = {
SND_SOC_DAPM_MIXER("MultiMedia8 Mixer", SND_SOC_NOPM, 0, 0,
mmul8_mixer_controls, ARRAY_SIZE(mmul8_mixer_controls)),
+ SND_SOC_DAPM_MIXER("USB Mixer", SND_SOC_NOPM, 0, 0,
+ usb_mixer_controls,
+ ARRAY_SIZE(usb_mixer_controls)),
+
};
static const struct snd_soc_dapm_route intercon[] = {
@@ -1042,6 +1049,8 @@ static const struct snd_soc_dapm_route intercon[] = {
{"MM_UL6", NULL, "MultiMedia6 Mixer"},
{"MM_UL7", NULL, "MultiMedia7 Mixer"},
{"MM_UL8", NULL, "MultiMedia8 Mixer"},
+
+ Q6ROUTING_RX_DAPM_ROUTE("USB Mixer", "USB_RX"),
};
static int routing_hw_params(struct snd_soc_component *component,
In case the USB backend device has not been initialized/probed, USB SND
device connections can still occur. When the USB backend is eventually
made available, previous USB SND device connections are not communicated to
the USB backend. Call snd_usb_rediscover_devices() to generate the connect
callbacks for all USB SND devices connected. This will allow for the USB
backend to be updated with the current set of devices available.
Signed-off-by: Wesley Cheng <[email protected]>
---
sound/soc/soc-usb.c | 2 ++
1 file changed, 2 insertions(+)
diff --git a/sound/soc/soc-usb.c b/sound/soc/soc-usb.c
index 84dc6d0b2eab..a9413e3d18df 100644
--- a/sound/soc/soc-usb.c
+++ b/sound/soc/soc-usb.c
@@ -111,6 +111,8 @@ struct snd_soc_usb *snd_soc_usb_add_port(struct device *dev, void *priv,
list_add_tail(&usb->list, &usb_ctx_list);
mutex_unlock(&ctx_mutex);
+ snd_usb_rediscover_devices();
+
return usb;
}
EXPORT_SYMBOL_GPL(snd_soc_usb_add_port);
In case of notifying SND platform drivers of connection events, some of
these use cases, such as offloading, require an ASoC USB backend device to
be initialized before the events can be handled. If the USB backend device
has not yet been probed, this leads to missing initial USB audio device
connection events.
Expose an API that traverses the usb_chip array for connected devices, and
to call the respective connection callback registered to the SND platform
driver.
Signed-off-by: Wesley Cheng <[email protected]>
---
sound/usb/card.c | 19 +++++++++++++++++++
sound/usb/card.h | 2 ++
2 files changed, 21 insertions(+)
diff --git a/sound/usb/card.c b/sound/usb/card.c
index e51461ac33cd..25267c1cc64e 100644
--- a/sound/usb/card.c
+++ b/sound/usb/card.c
@@ -170,6 +170,25 @@ struct snd_usb_stream *snd_usb_find_suppported_substream(int card_idx,
}
EXPORT_SYMBOL_GPL(snd_usb_find_suppported_substream);
+/*
+ * in case the platform driver was not ready at the time of USB SND
+ * device connect, expose an API to discover all connected USB devices
+ * so it can populate any dependent resources/structures.
+ */
+void snd_usb_rediscover_devices(void)
+{
+ int i;
+
+ mutex_lock(®ister_mutex);
+ for (i = 0; i < SNDRV_CARDS; i++) {
+ if (usb_chip[i])
+ if (platform_ops && platform_ops->connect_cb)
+ platform_ops->connect_cb(usb_chip[i]);
+ }
+ mutex_unlock(®ister_mutex);
+}
+EXPORT_SYMBOL_GPL(snd_usb_rediscover_devices);
+
/*
* disconnect streams
* called from usb_audio_disconnect()
diff --git a/sound/usb/card.h b/sound/usb/card.h
index 922868d2dccd..7bbaee87a48a 100644
--- a/sound/usb/card.h
+++ b/sound/usb/card.h
@@ -219,6 +219,7 @@ int snd_usb_register_platform_ops(struct snd_usb_platform_ops *ops);
int snd_usb_unregister_platform_ops(void);
struct snd_usb_stream *snd_usb_find_suppported_substream(int card_idx,
struct snd_pcm_hw_params *params, int direction);
+void snd_usb_rediscover_devices(void);
#else
int snd_usb_register_platform_ops(struct snd_usb_platform_ops *ops)
{
@@ -235,5 +236,6 @@ struct snd_usb_stream *snd_usb_find_suppported_substream(int card_idx,
{
return NULL;
}
+void snd_usb_rediscover_devices(void) { }
#endif /* IS_ENABLED(CONFIG_SND_USB_AUDIO) */
#endif /* __USBAUDIO_CARD_H */
Allow for the DWC3 host driver to pass along a XHCI property that defines
how many interrupters to allocate. This is in relation for the number of
event rings that can be potentially used by other processors within the
system.
Signed-off-by: Wesley Cheng <[email protected]>
---
drivers/usb/dwc3/core.c | 12 ++++++++++++
drivers/usb/dwc3/core.h | 2 ++
drivers/usb/dwc3/host.c | 5 ++++-
3 files changed, 18 insertions(+), 1 deletion(-)
diff --git a/drivers/usb/dwc3/core.c b/drivers/usb/dwc3/core.c
index 476b63618511..01eafb6eb4f6 100644
--- a/drivers/usb/dwc3/core.c
+++ b/drivers/usb/dwc3/core.c
@@ -1446,6 +1446,7 @@ static void dwc3_get_properties(struct dwc3 *dwc)
u8 tx_thr_num_pkt_prd = 0;
u8 tx_max_burst_prd = 0;
u8 tx_fifo_resize_max_num;
+ u16 num_hc_interrupters;
const char *usb_psy_name;
int ret;
@@ -1468,6 +1469,9 @@ static void dwc3_get_properties(struct dwc3 *dwc)
*/
tx_fifo_resize_max_num = 6;
+ /* default to a single XHCI interrupter */
+ num_hc_interrupters = 1;
+
dwc->maximum_speed = usb_get_maximum_speed(dev);
dwc->max_ssp_rate = usb_get_maximum_ssp_rate(dev);
dwc->dr_mode = usb_get_dr_mode(dev);
@@ -1511,6 +1515,12 @@ static void dwc3_get_properties(struct dwc3 *dwc)
&tx_thr_num_pkt_prd);
device_property_read_u8(dev, "snps,tx-max-burst-prd",
&tx_max_burst_prd);
+ device_property_read_u16(dev, "snps,num-hc-interrupters",
+ &num_hc_interrupters);
+ /* DWC3 core allowed to have a max of 8 interrupters */
+ if (num_hc_interrupters > 8)
+ num_hc_interrupters = 8;
+
dwc->do_fifo_resize = device_property_read_bool(dev,
"tx-fifo-resize");
if (dwc->do_fifo_resize)
@@ -1589,6 +1599,8 @@ static void dwc3_get_properties(struct dwc3 *dwc)
dwc->imod_interval = 0;
dwc->tx_fifo_resize_max_num = tx_fifo_resize_max_num;
+
+ dwc->num_hc_interrupters = num_hc_interrupters;
}
/* check whether the core supports IMOD */
diff --git a/drivers/usb/dwc3/core.h b/drivers/usb/dwc3/core.h
index 582ebd9cf9c2..f37c3d860600 100644
--- a/drivers/usb/dwc3/core.h
+++ b/drivers/usb/dwc3/core.h
@@ -1050,6 +1050,7 @@ struct dwc3_scratchpad_array {
* @tx_max_burst_prd: max periodic ESS transmit burst size
* @tx_fifo_resize_max_num: max number of fifos allocated during txfifo resize
* @clear_stall_protocol: endpoint number that requires a delayed status phase
+ * @num_hc_interrupters: number of host controller interrupters
* @hsphy_interface: "utmi" or "ulpi"
* @connected: true when we're connected to a host, false otherwise
* @softconnect: true when gadget connect is called, false when disconnect runs
@@ -1276,6 +1277,7 @@ struct dwc3 {
u8 tx_max_burst_prd;
u8 tx_fifo_resize_max_num;
u8 clear_stall_protocol;
+ u16 num_hc_interrupters;
const char *hsphy_interface;
diff --git a/drivers/usb/dwc3/host.c b/drivers/usb/dwc3/host.c
index f6f13e7f1ba1..cac219f8238d 100644
--- a/drivers/usb/dwc3/host.c
+++ b/drivers/usb/dwc3/host.c
@@ -66,7 +66,7 @@ static int dwc3_host_get_irq(struct dwc3 *dwc)
int dwc3_host_init(struct dwc3 *dwc)
{
- struct property_entry props[4];
+ struct property_entry props[5];
struct platform_device *xhci;
int ret, irq;
int prop_idx = 0;
@@ -112,6 +112,9 @@ int dwc3_host_init(struct dwc3 *dwc)
if (DWC3_VER_IS_WITHIN(DWC3, ANY, 300A))
props[prop_idx++] = PROPERTY_ENTRY_BOOL("quirk-broken-port-ped");
+ props[prop_idx++] = PROPERTY_ENTRY_U16("num-hc-interrupters",
+ dwc->num_hc_interrupters);
+
if (prop_idx) {
ret = device_create_managed_software_node(&xhci->dev, props, NULL);
if (ret) {
Check for if the PCM format is supported during the hw_params callback. If
the profile is not supported then the userspace ALSA entity will receive an
error, and can take further action.
Signed-off-by: Wesley Cheng <[email protected]>
---
sound/soc/qcom/qdsp6/q6usb.c | 5 ++++-
1 file changed, 4 insertions(+), 1 deletion(-)
diff --git a/sound/soc/qcom/qdsp6/q6usb.c b/sound/soc/qcom/qdsp6/q6usb.c
index 3d480550b3f3..c9d5c9eecf89 100644
--- a/sound/soc/qcom/qdsp6/q6usb.c
+++ b/sound/soc/qcom/qdsp6/q6usb.c
@@ -44,7 +44,10 @@ static int q6usb_hw_params(struct snd_pcm_substream *substream,
struct snd_pcm_hw_params *params,
struct snd_soc_dai *dai)
{
- return 0;
+ struct q6usb_port_data *data = dev_get_drvdata(dai->dev);
+ int direction = substream->stream;
+
+ return snd_soc_usb_find_format(data->active_idx, params, direction);
}
static const struct snd_soc_dai_ops q6usb_ops = {
.hw_params = q6usb_hw_params,
Several Qualcomm SoCs have a dedicated audio DSP, which has the ability to
support USB sound devices. This vendor driver will implement the required
handshaking with the DSP, in order to pass along required resources that
will be utilized by the DSP's USB SW. The communication channel used for
this handshaking will be using the QMI protocol. Required resources
include:
- Allocated secondary event ring address
- EP transfer ring address
- Interrupter number
The above information will allow for the audio DSP to execute USB transfers
over the USB bus. It will also be able to support devices that have an
implicit feedback and sync endpoint as well. Offloading these data
transfers will allow the main/applications processor to enter lower CPU
power modes, and sustain a longer duration in those modes.
Audio offloading is initiated with the following sequence:
1. Userspace configures to route audio playback to USB backend and starts
playback on the platform soundcard.
2. The Q6DSP AFE will communicate to the audio DSP to start the USB AFE
port.
3. This results in a QMI packet with a STREAM enable command.
4. The QC audio offload driver will fetch the required resources, and pass
this information as part of the QMI response to the STREAM enable command.
5. Once the QMI response is received the audio DSP will start queuing data
on the USB bus.
Signed-off-by: Wesley Cheng <[email protected]>
---
sound/usb/Kconfig | 14 +
sound/usb/Makefile | 2 +-
sound/usb/qcom/Makefile | 2 +
sound/usb/qcom/qc_audio_offload.c | 1780 ++++++++++++++++++++++++++++
sound/usb/qcom/usb_audio_qmi_v01.c | 892 ++++++++++++++
sound/usb/qcom/usb_audio_qmi_v01.h | 162 +++
6 files changed, 2851 insertions(+), 1 deletion(-)
create mode 100644 sound/usb/qcom/Makefile
create mode 100644 sound/usb/qcom/qc_audio_offload.c
create mode 100644 sound/usb/qcom/usb_audio_qmi_v01.c
create mode 100644 sound/usb/qcom/usb_audio_qmi_v01.h
diff --git a/sound/usb/Kconfig b/sound/usb/Kconfig
index 059242f15d75..18d65a0d905a 100644
--- a/sound/usb/Kconfig
+++ b/sound/usb/Kconfig
@@ -165,6 +165,20 @@ config SND_BCD2000
To compile this driver as a module, choose M here: the module
will be called snd-bcd2000.
+config QC_USB_AUDIO_OFFLOAD
+ tristate "Qualcomm Audio Offload driver"
+ select SND_PCM
+ help
+ Say Y here to enable the Qualcomm USB audio offloading feature
+
+ This module sets up the required QMI stream enable/disable
+ responses to requests generated by the audio DSP. It passes the
+ USB transfer resource references, so that the audio DSP can issue
+ USB transfers to the host controller.
+
+ To compile this driver as a module, choose M here: the module
+ will be called qc-audio-offload.
+
source "sound/usb/line6/Kconfig"
endif # SND_USB
diff --git a/sound/usb/Makefile b/sound/usb/Makefile
index 9ccb21a4ff8a..2243ae333ec9 100644
--- a/sound/usb/Makefile
+++ b/sound/usb/Makefile
@@ -33,5 +33,5 @@ obj-$(CONFIG_SND_USB_UA101) += snd-usbmidi-lib.o
obj-$(CONFIG_SND_USB_USX2Y) += snd-usbmidi-lib.o
obj-$(CONFIG_SND_USB_US122L) += snd-usbmidi-lib.o
-obj-$(CONFIG_SND) += misc/ usx2y/ caiaq/ 6fire/ hiface/ bcd2000/
+obj-$(CONFIG_SND) += misc/ usx2y/ caiaq/ 6fire/ hiface/ bcd2000/ qcom/
obj-$(CONFIG_SND_USB_LINE6) += line6/
diff --git a/sound/usb/qcom/Makefile b/sound/usb/qcom/Makefile
new file mode 100644
index 000000000000..d27d39beb8ce
--- /dev/null
+++ b/sound/usb/qcom/Makefile
@@ -0,0 +1,2 @@
+snd-usb-audio-qmi-objs := usb_audio_qmi_v01.o qc_audio_offload.o
+obj-$(CONFIG_QC_USB_AUDIO_OFFLOAD) += snd-usb-audio-qmi.o
\ No newline at end of file
diff --git a/sound/usb/qcom/qc_audio_offload.c b/sound/usb/qcom/qc_audio_offload.c
new file mode 100644
index 000000000000..2663906644f2
--- /dev/null
+++ b/sound/usb/qcom/qc_audio_offload.c
@@ -0,0 +1,1780 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (c) 2022-2023 Qualcomm Innovation Center, Inc. All rights reserved.
+ */
+
+#include <linux/ctype.h>
+#include <linux/moduleparam.h>
+#include <linux/module.h>
+#include <linux/usb.h>
+#include <linux/init.h>
+#include <linux/usb/hcd.h>
+#include <linux/usb/xhci-intr.h>
+#include <linux/usb/quirks.h>
+#include <linux/usb/audio.h>
+#include <linux/usb/audio-v2.h>
+#include <linux/usb/audio-v3.h>
+#include <linux/soc/qcom/qmi.h>
+#include <linux/iommu.h>
+#include <linux/dma-mapping.h>
+#include <linux/dma-map-ops.h>
+#include <sound/q6usboffload.h>
+
+#include <sound/control.h>
+#include <sound/core.h>
+#include <sound/info.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include <sound/initval.h>
+
+#include <sound/soc.h>
+#include <sound/soc-usb.h>
+#include "../usbaudio.h"
+#include "../card.h"
+#include "../midi.h"
+#include "../mixer.h"
+#include "../proc.h"
+#include "../quirks.h"
+#include "../endpoint.h"
+#include "../helper.h"
+#include "../pcm.h"
+#include "../format.h"
+#include "../power.h"
+#include "../stream.h"
+#include "../media.h"
+#include "usb_audio_qmi_v01.h"
+
+/* Stream disable request timeout during USB device disconnect */
+#define DEV_RELEASE_WAIT_TIMEOUT 10000 /* in ms */
+
+/* Data interval calculation parameters */
+#define BUS_INTERVAL_FULL_SPEED 1000 /* in us */
+#define BUS_INTERVAL_HIGHSPEED_AND_ABOVE 125 /* in us */
+#define MAX_BINTERVAL_ISOC_EP 16
+
+#define SND_PCM_CARD_NUM_MASK 0xffff0000
+#define SND_PCM_DEV_NUM_MASK 0xff00
+#define SND_PCM_STREAM_DIRECTION 0xff
+
+/* iommu resource parameters and management */
+#define PREPEND_SID_TO_IOVA(iova, sid) ((u64)(((u64)(iova)) | \
+ (((u64)sid) << 32)))
+#define IOVA_BASE 0x1000
+#define IOVA_XFER_RING_BASE (IOVA_BASE + PAGE_SIZE * (SNDRV_CARDS + 1))
+#define IOVA_XFER_BUF_BASE (IOVA_XFER_RING_BASE + PAGE_SIZE * SNDRV_CARDS * 32)
+#define IOVA_XFER_RING_MAX (IOVA_XFER_BUF_BASE - PAGE_SIZE)
+#define IOVA_XFER_BUF_MAX (0xfffff000 - PAGE_SIZE)
+
+#define MAX_XFER_BUFF_LEN (24 * PAGE_SIZE)
+
+struct iova_info {
+ struct list_head list;
+ unsigned long start_iova;
+ size_t size;
+ bool in_use;
+};
+
+struct intf_info {
+ unsigned long data_xfer_ring_va;
+ size_t data_xfer_ring_size;
+ unsigned long sync_xfer_ring_va;
+ size_t sync_xfer_ring_size;
+ unsigned long xfer_buf_va;
+ size_t xfer_buf_size;
+ phys_addr_t xfer_buf_pa;
+ unsigned int data_ep_pipe;
+ unsigned int sync_ep_pipe;
+ u8 *xfer_buf;
+ u8 intf_num;
+ u8 pcm_card_num;
+ u8 pcm_dev_num;
+ u8 direction;
+ bool in_use;
+};
+
+struct uaudio_qmi_dev {
+ struct device *dev;
+ u32 sid;
+ u32 intr_num;
+ struct xhci_interrupter *ir;
+ struct xhci_ring *sec_ring;
+ struct iommu_domain *domain;
+
+ /* list to keep track of available iova */
+ struct list_head xfer_ring_list;
+ size_t xfer_ring_iova_size;
+ unsigned long curr_xfer_ring_iova;
+ struct list_head xfer_buf_list;
+ size_t xfer_buf_iova_size;
+ unsigned long curr_xfer_buf_iova;
+
+ /* bit fields representing pcm card enabled */
+ unsigned long card_slot;
+ /* indicate event ring mapped or not */
+ bool er_mapped;
+ /* reference count to number of possible consumers */
+ atomic_t qdev_in_use;
+ /* idx to last udev card number plugged in */
+ unsigned int last_card_num;
+};
+
+struct uaudio_dev {
+ struct usb_device *udev;
+ /* audio control interface */
+ struct usb_host_interface *ctrl_intf;
+ unsigned int card_num;
+ unsigned int usb_core_id;
+ atomic_t in_use;
+ struct kref kref;
+ wait_queue_head_t disconnect_wq;
+
+ /* interface specific */
+ int num_intf;
+ struct intf_info *info;
+ struct snd_usb_audio *chip;
+};
+
+static struct uaudio_dev uadev[SNDRV_CARDS];
+static struct uaudio_qmi_dev *uaudio_qdev;
+static struct uaudio_qmi_svc *uaudio_svc;
+static DEFINE_MUTEX(qdev_mutex);
+
+struct uaudio_qmi_svc {
+ struct qmi_handle *uaudio_svc_hdl;
+ struct work_struct qmi_disconnect_work;
+ struct workqueue_struct *uaudio_wq;
+ struct sockaddr_qrtr client_sq;
+ bool client_connected;
+};
+
+enum mem_type {
+ MEM_EVENT_RING,
+ MEM_XFER_RING,
+ MEM_XFER_BUF,
+};
+
+/* Supported audio formats */
+enum usb_qmi_audio_format {
+ USB_QMI_PCM_FORMAT_S8 = 0,
+ USB_QMI_PCM_FORMAT_U8,
+ USB_QMI_PCM_FORMAT_S16_LE,
+ USB_QMI_PCM_FORMAT_S16_BE,
+ USB_QMI_PCM_FORMAT_U16_LE,
+ USB_QMI_PCM_FORMAT_U16_BE,
+ USB_QMI_PCM_FORMAT_S24_LE,
+ USB_QMI_PCM_FORMAT_S24_BE,
+ USB_QMI_PCM_FORMAT_U24_LE,
+ USB_QMI_PCM_FORMAT_U24_BE,
+ USB_QMI_PCM_FORMAT_S24_3LE,
+ USB_QMI_PCM_FORMAT_S24_3BE,
+ USB_QMI_PCM_FORMAT_U24_3LE,
+ USB_QMI_PCM_FORMAT_U24_3BE,
+ USB_QMI_PCM_FORMAT_S32_LE,
+ USB_QMI_PCM_FORMAT_S32_BE,
+ USB_QMI_PCM_FORMAT_U32_LE,
+ USB_QMI_PCM_FORMAT_U32_BE,
+};
+
+static enum usb_audio_device_speed_enum_v01
+get_speed_info(enum usb_device_speed udev_speed)
+{
+ switch (udev_speed) {
+ case USB_SPEED_LOW:
+ return USB_AUDIO_DEVICE_SPEED_LOW_V01;
+ case USB_SPEED_FULL:
+ return USB_AUDIO_DEVICE_SPEED_FULL_V01;
+ case USB_SPEED_HIGH:
+ return USB_AUDIO_DEVICE_SPEED_HIGH_V01;
+ case USB_SPEED_SUPER:
+ return USB_AUDIO_DEVICE_SPEED_SUPER_V01;
+ case USB_SPEED_SUPER_PLUS:
+ return USB_AUDIO_DEVICE_SPEED_SUPER_PLUS_V01;
+ default:
+ return USB_AUDIO_DEVICE_SPEED_INVALID_V01;
+ }
+}
+
+static struct snd_usb_substream *find_substream(unsigned int card_num,
+ unsigned int pcm_idx, unsigned int direction)
+{
+ struct snd_usb_stream *as;
+ struct snd_usb_substream *subs = NULL;
+ struct snd_usb_audio *chip;
+
+ chip = uadev[card_num].chip;
+ if (!chip || atomic_read(&chip->shutdown))
+ goto done;
+
+ if (pcm_idx >= chip->pcm_devs)
+ goto done;
+
+ if (direction > SNDRV_PCM_STREAM_CAPTURE)
+ goto done;
+
+ list_for_each_entry(as, &chip->pcm_list, list) {
+ if (as->pcm_index == pcm_idx) {
+ subs = &as->substream[direction];
+ goto done;
+ }
+ }
+
+done:
+ return subs;
+}
+
+static int info_idx_from_ifnum(int card_num, int intf_num, bool enable)
+{
+ int i;
+
+ /*
+ * default index 0 is used when info is allocated upon
+ * first enable audio stream req for a pcm device
+ */
+ if (enable && !uadev[card_num].info)
+ return 0;
+
+ for (i = 0; i < uadev[card_num].num_intf; i++) {
+ if (enable && !uadev[card_num].info[i].in_use)
+ return i;
+ else if (!enable &&
+ uadev[card_num].info[i].intf_num == intf_num)
+ return i;
+ }
+
+ return -EINVAL;
+}
+
+static int get_data_interval_from_si(struct snd_usb_substream *subs,
+ u32 service_interval)
+{
+ unsigned int bus_intval, bus_intval_mult, binterval;
+
+ if (subs->dev->speed >= USB_SPEED_HIGH)
+ bus_intval = BUS_INTERVAL_HIGHSPEED_AND_ABOVE;
+ else
+ bus_intval = BUS_INTERVAL_FULL_SPEED;
+
+ if (service_interval % bus_intval)
+ return -EINVAL;
+
+ bus_intval_mult = service_interval / bus_intval;
+ binterval = ffs(bus_intval_mult);
+ if (!binterval || binterval > MAX_BINTERVAL_ISOC_EP)
+ return -EINVAL;
+
+ /* check if another bit is set then bail out */
+ bus_intval_mult = bus_intval_mult >> binterval;
+ if (bus_intval_mult)
+ return -EINVAL;
+
+ return (binterval - 1);
+}
+
+/* maps audio format received over QMI to asound.h based pcm format */
+static snd_pcm_format_t map_pcm_format(enum usb_qmi_audio_format fmt_received)
+{
+ switch (fmt_received) {
+ case USB_QMI_PCM_FORMAT_S8:
+ return SNDRV_PCM_FORMAT_S8;
+ case USB_QMI_PCM_FORMAT_U8:
+ return SNDRV_PCM_FORMAT_U8;
+ case USB_QMI_PCM_FORMAT_S16_LE:
+ return SNDRV_PCM_FORMAT_S16_LE;
+ case USB_QMI_PCM_FORMAT_S16_BE:
+ return SNDRV_PCM_FORMAT_S16_BE;
+ case USB_QMI_PCM_FORMAT_U16_LE:
+ return SNDRV_PCM_FORMAT_U16_LE;
+ case USB_QMI_PCM_FORMAT_U16_BE:
+ return SNDRV_PCM_FORMAT_U16_BE;
+ case USB_QMI_PCM_FORMAT_S24_LE:
+ return SNDRV_PCM_FORMAT_S24_LE;
+ case USB_QMI_PCM_FORMAT_S24_BE:
+ return SNDRV_PCM_FORMAT_S24_BE;
+ case USB_QMI_PCM_FORMAT_U24_LE:
+ return SNDRV_PCM_FORMAT_U24_LE;
+ case USB_QMI_PCM_FORMAT_U24_BE:
+ return SNDRV_PCM_FORMAT_U24_BE;
+ case USB_QMI_PCM_FORMAT_S24_3LE:
+ return SNDRV_PCM_FORMAT_S24_3LE;
+ case USB_QMI_PCM_FORMAT_S24_3BE:
+ return SNDRV_PCM_FORMAT_S24_3BE;
+ case USB_QMI_PCM_FORMAT_U24_3LE:
+ return SNDRV_PCM_FORMAT_U24_3LE;
+ case USB_QMI_PCM_FORMAT_U24_3BE:
+ return SNDRV_PCM_FORMAT_U24_3BE;
+ case USB_QMI_PCM_FORMAT_S32_LE:
+ return SNDRV_PCM_FORMAT_S32_LE;
+ case USB_QMI_PCM_FORMAT_S32_BE:
+ return SNDRV_PCM_FORMAT_S32_BE;
+ case USB_QMI_PCM_FORMAT_U32_LE:
+ return SNDRV_PCM_FORMAT_U32_LE;
+ case USB_QMI_PCM_FORMAT_U32_BE:
+ return SNDRV_PCM_FORMAT_U32_BE;
+ default:
+ /*
+ * We expect the caller to do input validation so we should
+ * never hit this. But we do have to return a proper
+ * snd_pcm_format_t value due to the __bitwise attribute; so
+ * just return the equivalent of 0 in case of bad input.
+ */
+ return SNDRV_PCM_FORMAT_S8;
+ }
+}
+
+/* Offloading IOMMU management */
+static unsigned long uaudio_get_iova(unsigned long *curr_iova,
+ size_t *curr_iova_size, struct list_head *head, size_t size)
+{
+ struct iova_info *info, *new_info = NULL;
+ struct list_head *curr_head;
+ unsigned long va = 0;
+ size_t tmp_size = size;
+ bool found = false;
+
+ if (size % PAGE_SIZE) {
+ dev_err(uaudio_qdev->dev, "size %zu is not page size multiple\n",
+ size);
+ goto done;
+ }
+
+ if (size > *curr_iova_size) {
+ dev_err(uaudio_qdev->dev, "size %zu > curr size %zu\n",
+ size, *curr_iova_size);
+ goto done;
+ }
+ if (*curr_iova_size == 0) {
+ dev_err(uaudio_qdev->dev, "iova mapping is full\n");
+ goto done;
+ }
+
+ list_for_each_entry(info, head, list) {
+ /* exact size iova_info */
+ if (!info->in_use && info->size == size) {
+ info->in_use = true;
+ va = info->start_iova;
+ *curr_iova_size -= size;
+ found = true;
+ dev_dbg(uaudio_qdev->dev, "exact size: %zu found\n", size);
+ goto done;
+ } else if (!info->in_use && tmp_size >= info->size) {
+ if (!new_info)
+ new_info = info;
+ dev_dbg(uaudio_qdev->dev, "partial size: %zu found\n",
+ info->size);
+ tmp_size -= info->size;
+ if (tmp_size)
+ continue;
+
+ va = new_info->start_iova;
+ for (curr_head = &new_info->list; curr_head !=
+ &info->list; curr_head = curr_head->next) {
+ new_info = list_entry(curr_head, struct
+ iova_info, list);
+ new_info->in_use = true;
+ }
+ info->in_use = true;
+ *curr_iova_size -= size;
+ found = true;
+ goto done;
+ } else {
+ /* iova region in use */
+ new_info = NULL;
+ tmp_size = size;
+ }
+ }
+
+ info = kzalloc(sizeof(struct iova_info), GFP_KERNEL);
+ if (!info) {
+ va = 0;
+ goto done;
+ }
+
+ va = info->start_iova = *curr_iova;
+ info->size = size;
+ info->in_use = true;
+ *curr_iova += size;
+ *curr_iova_size -= size;
+ found = true;
+ list_add_tail(&info->list, head);
+
+done:
+ if (!found)
+ dev_err(uaudio_qdev->dev, "unable to find %zu size iova\n",
+ size);
+ else
+ dev_dbg(uaudio_qdev->dev,
+ "va:0x%08lx curr_iova:0x%08lx curr_iova_size:%zu\n",
+ va, *curr_iova, *curr_iova_size);
+
+ return va;
+}
+
+static void uaudio_put_iova(unsigned long va, size_t size, struct list_head
+ *head, size_t *curr_iova_size)
+{
+ struct iova_info *info;
+ size_t tmp_size = size;
+ bool found = false;
+
+ list_for_each_entry(info, head, list) {
+ if (info->start_iova == va) {
+ if (!info->in_use) {
+ dev_err(uaudio_qdev->dev, "va %lu is not in use\n",
+ va);
+ return;
+ }
+ found = true;
+ info->in_use = false;
+ if (info->size == size)
+ goto done;
+ }
+
+ if (found && tmp_size >= info->size) {
+ info->in_use = false;
+ tmp_size -= info->size;
+ if (!tmp_size)
+ goto done;
+ }
+ }
+
+ if (!found) {
+ dev_err(uaudio_qdev->dev, "unable to find the va %lu\n", va);
+ return;
+ }
+done:
+ *curr_iova_size += size;
+ dev_dbg(uaudio_qdev->dev, "curr_iova_size %zu\n", *curr_iova_size);
+}
+
+/**
+ * uaudio_iommu_unmap() - unmaps iommu memory for adsp
+ * @mtype: ring type
+ * @va: virtual address to unmap
+ * @iova_size: region size
+ * @mapped_iova_size: mapped region size
+ *
+ * Unmaps the memory region that was previously assigned to the adsp.
+ *
+ */
+static void uaudio_iommu_unmap(enum mem_type mtype, unsigned long va,
+ size_t iova_size, size_t mapped_iova_size)
+{
+ size_t umap_size;
+ bool unmap = true;
+
+ if (!va || !iova_size)
+ return;
+
+ switch (mtype) {
+ case MEM_EVENT_RING:
+ if (uaudio_qdev->er_mapped)
+ uaudio_qdev->er_mapped = false;
+ else
+ unmap = false;
+ break;
+
+ case MEM_XFER_RING:
+ uaudio_put_iova(va, iova_size, &uaudio_qdev->xfer_ring_list,
+ &uaudio_qdev->xfer_ring_iova_size);
+ break;
+ case MEM_XFER_BUF:
+ uaudio_put_iova(va, iova_size, &uaudio_qdev->xfer_buf_list,
+ &uaudio_qdev->xfer_buf_iova_size);
+ break;
+ default:
+ dev_err(uaudio_qdev->dev, "unknown mem type %d\n", mtype);
+ unmap = false;
+ }
+
+ if (!unmap || !mapped_iova_size)
+ return;
+
+ dev_dbg(uaudio_qdev->dev, "type %d: unmap iova 0x%08lx size %zu\n",
+ mtype, va, mapped_iova_size);
+
+ umap_size = iommu_unmap(uaudio_qdev->domain, va, mapped_iova_size);
+ if (umap_size != mapped_iova_size)
+ dev_err(uaudio_qdev->dev,
+ "unmapped size %zu for iova 0x%08lx of mapped size %zu\n",
+ umap_size, va, mapped_iova_size);
+}
+
+/**
+ * uaudio_iommu_map() - maps iommu memory for adsp
+ * @mtype: ring type
+ * @dma_coherent: dma coherent
+ * @pa: physical address for ring/buffer
+ * @size: size of memory region
+ * @sgt: sg table for memory region
+ *
+ * Maps the XHCI related resources to a memory region that is assigned to be
+ * used by the adsp. This will be mapped to the domain, which is created by
+ * the ASoC USB backend driver.
+ *
+ */
+static unsigned long uaudio_iommu_map(enum mem_type mtype, bool dma_coherent,
+ phys_addr_t pa, size_t size, struct sg_table *sgt)
+{
+ unsigned long va_sg, va = 0;
+ bool map = true;
+ int i, ret;
+ size_t sg_len, total_len = 0;
+ struct scatterlist *sg;
+ phys_addr_t pa_sg;
+ int prot = IOMMU_READ | IOMMU_WRITE;
+
+ if (dma_coherent)
+ prot |= IOMMU_CACHE;
+
+ switch (mtype) {
+ case MEM_EVENT_RING:
+ va = IOVA_BASE;
+ /* er already mapped */
+ if (uaudio_qdev->er_mapped)
+ map = false;
+ break;
+ case MEM_XFER_RING:
+ va = uaudio_get_iova(&uaudio_qdev->curr_xfer_ring_iova,
+ &uaudio_qdev->xfer_ring_iova_size, &uaudio_qdev->xfer_ring_list,
+ size);
+ break;
+ case MEM_XFER_BUF:
+ va = uaudio_get_iova(&uaudio_qdev->curr_xfer_buf_iova,
+ &uaudio_qdev->xfer_buf_iova_size, &uaudio_qdev->xfer_buf_list,
+ size);
+ break;
+ default:
+ dev_err(uaudio_qdev->dev, "unknown mem type %d\n", mtype);
+ }
+
+ if (!va || !map)
+ goto done;
+
+ if (!sgt)
+ goto skip_sgt_map;
+
+ va_sg = va;
+ for_each_sg(sgt->sgl, sg, sgt->nents, i) {
+ sg_len = PAGE_ALIGN(sg->offset + sg->length);
+ pa_sg = page_to_phys(sg_page(sg));
+ ret = iommu_map(uaudio_qdev->domain, va_sg, pa_sg, sg_len,
+ prot, GFP_KERNEL);
+ if (ret) {
+ dev_err(uaudio_qdev->dev, "mapping failed ret%d\n", ret);
+ dev_err(uaudio_qdev->dev,
+ "type:%d, pa:%pa iova:0x%08lx sg_len:%zu\n",
+ mtype, &pa_sg, va_sg, sg_len);
+ uaudio_iommu_unmap(MEM_XFER_BUF, va, size, total_len);
+ va = 0;
+ goto done;
+ }
+ dev_dbg(uaudio_qdev->dev,
+ "type:%d map pa:%pa to iova:0x%08lx len:%zu offset:%u\n",
+ mtype, &pa_sg, va_sg, sg_len, sg->offset);
+ va_sg += sg_len;
+ total_len += sg_len;
+ }
+
+ if (size != total_len) {
+ dev_err(uaudio_qdev->dev, "iova size %zu != mapped iova size %zu\n",
+ size, total_len);
+ uaudio_iommu_unmap(MEM_XFER_BUF, va, size, total_len);
+ va = 0;
+ }
+ return va;
+
+skip_sgt_map:
+ dev_dbg(uaudio_qdev->dev, "type:%d map pa:%pa to iova:0x%08lx size:%zu\n",
+ mtype, &pa, va, size);
+
+ ret = iommu_map(uaudio_qdev->domain, va, pa, size, prot, GFP_KERNEL);
+ if (ret)
+ dev_err(uaudio_qdev->dev,
+ "failed to map pa:%pa iova:0x%lx type:%d ret:%d\n",
+ &pa, va, mtype, ret);
+done:
+ return va;
+}
+
+/* looks up alias, if any, for controller DT node and returns the index */
+static int usb_get_controller_id(struct usb_device *udev)
+{
+ if (udev->bus->sysdev && udev->bus->sysdev->of_node)
+ return of_alias_get_id(udev->bus->sysdev->of_node, "usb");
+
+ return -ENODEV;
+}
+
+/**
+ * uaudio_dev_intf_cleanup() - cleanup transfer resources
+ * @udev: usb device
+ * @info: usb offloading interface
+ *
+ * Cleans up the transfer ring related resources which are assigned per
+ * endpoint from XHCI. This is invoked when the USB endpoints are no
+ * longer in use by the adsp.
+ *
+ */
+static void uaudio_dev_intf_cleanup(struct usb_device *udev,
+ struct intf_info *info)
+{
+ uaudio_iommu_unmap(MEM_XFER_RING, info->data_xfer_ring_va,
+ info->data_xfer_ring_size, info->data_xfer_ring_size);
+ info->data_xfer_ring_va = 0;
+ info->data_xfer_ring_size = 0;
+
+ uaudio_iommu_unmap(MEM_XFER_RING, info->sync_xfer_ring_va,
+ info->sync_xfer_ring_size, info->sync_xfer_ring_size);
+ info->sync_xfer_ring_va = 0;
+ info->sync_xfer_ring_size = 0;
+
+ uaudio_iommu_unmap(MEM_XFER_BUF, info->xfer_buf_va,
+ info->xfer_buf_size, info->xfer_buf_size);
+ info->xfer_buf_va = 0;
+
+ usb_free_coherent(udev, info->xfer_buf_size,
+ info->xfer_buf, info->xfer_buf_pa);
+ info->xfer_buf_size = 0;
+ info->xfer_buf = NULL;
+ info->xfer_buf_pa = 0;
+
+ info->in_use = false;
+}
+
+/**
+ * uaudio_event_ring_cleanup_free() - cleanup secondary event ring
+ * @dev: usb offload device
+ *
+ * Cleans up the secondary event ring that was requested. This will
+ * occur when the adsp is no longer transferring data on the USB bus
+ * across all endpoints.
+ *
+ */
+static void uaudio_event_ring_cleanup_free(struct uaudio_dev *dev)
+{
+ struct usb_hcd *hcd = bus_to_hcd(dev->udev->bus);
+
+ clear_bit(dev->card_num, &uaudio_qdev->card_slot);
+ /* all audio devices are disconnected */
+ if (!uaudio_qdev->card_slot) {
+ uaudio_iommu_unmap(MEM_EVENT_RING, IOVA_BASE, PAGE_SIZE,
+ PAGE_SIZE);
+ xhci_remove_secondary_interrupter(hcd, uaudio_qdev->ir);
+ uaudio_qdev->ir = NULL;
+ }
+}
+
+static void uaudio_dev_cleanup(struct uaudio_dev *dev)
+{
+ int if_idx;
+
+ if (!dev->udev)
+ return;
+
+ /* free xfer buffer and unmap xfer ring and buf per interface */
+ for (if_idx = 0; if_idx < dev->num_intf; if_idx++) {
+ if (!dev->info[if_idx].in_use)
+ continue;
+ uaudio_dev_intf_cleanup(dev->udev, &dev->info[if_idx]);
+ dev_dbg(uaudio_qdev->dev, "release resources: intf# %d card# %d\n",
+ dev->info[if_idx].intf_num, dev->card_num);
+ }
+
+ dev->num_intf = 0;
+
+ /* free interface info */
+ kfree(dev->info);
+ dev->info = NULL;
+ uaudio_event_ring_cleanup_free(dev);
+ dev->udev = NULL;
+}
+
+/**
+ * disable_audio_stream() - disable usb snd endpoints
+ * @subs: usb substream
+ *
+ * Closes the USB SND endpoints associated with the current audio stream
+ * used. This will decrement the USB SND endpoint opened reference count.
+ *
+ */
+static void disable_audio_stream(struct snd_usb_substream *subs)
+{
+ struct snd_usb_audio *chip = subs->stream->chip;
+
+ if (subs->data_endpoint || subs->sync_endpoint) {
+ close_endpoints(chip, subs);
+
+ mutex_lock(&chip->mutex);
+ subs->cur_audiofmt = NULL;
+ mutex_unlock(&chip->mutex);
+ }
+
+ snd_usb_autosuspend(chip);
+}
+
+/* QMI service disconnect handlers */
+static void qmi_disconnect_work(struct work_struct *w)
+{
+ struct intf_info *info;
+ int idx, if_idx;
+ struct snd_usb_substream *subs;
+ struct snd_usb_audio *chip;
+
+ /* find all active intf for set alt 0 and cleanup usb audio dev */
+ for (idx = 0; idx < SNDRV_CARDS; idx++) {
+ if (!atomic_read(&uadev[idx].in_use))
+ continue;
+
+ chip = uadev[idx].chip;
+ for (if_idx = 0; if_idx < uadev[idx].num_intf; if_idx++) {
+ if (!uadev[idx].info || !uadev[idx].info[if_idx].in_use)
+ continue;
+ info = &uadev[idx].info[if_idx];
+ subs = find_substream(info->pcm_card_num,
+ info->pcm_dev_num,
+ info->direction);
+ if (!subs || !chip || atomic_read(&chip->shutdown)) {
+ dev_err(&subs->dev->dev,
+ "no sub for c#%u dev#%u dir%u\n",
+ info->pcm_card_num,
+ info->pcm_dev_num,
+ info->direction);
+ continue;
+ }
+ disable_audio_stream(subs);
+ }
+ atomic_set(&uadev[idx].in_use, 0);
+ mutex_lock(&chip->mutex);
+ uaudio_dev_cleanup(&uadev[idx]);
+ mutex_unlock(&chip->mutex);
+ }
+}
+
+/**
+ * qmi_bye_cb() - qmi bye message callback
+ * @handle: QMI handle
+ * @node: id of the dying node
+ *
+ * This callback is invoked when the QMI bye control message is received
+ * from the QMI client. Handle the message accordingly by ensuring that
+ * the USB offload path is disabled and cleaned up. At this point, ADSP
+ * is not utilizing the USB bus.
+ *
+ */
+static void qmi_bye_cb(struct qmi_handle *handle, unsigned int node)
+{
+ struct uaudio_qmi_svc *svc = uaudio_svc;
+
+ if (svc->uaudio_svc_hdl != handle)
+ return;
+
+ if (svc->client_connected && svc->client_sq.sq_node == node) {
+ queue_work(svc->uaudio_wq, &svc->qmi_disconnect_work);
+ svc->client_sq.sq_node = 0;
+ svc->client_sq.sq_port = 0;
+ svc->client_sq.sq_family = 0;
+ svc->client_connected = false;
+ }
+}
+
+/**
+ * qmi_svc_disconnect_cb() - qmi client disconnected
+ * @handle: QMI handle
+ * @node: id of the dying node
+ * @port: port of the dying client
+ *
+ * Invoked when the remote QMI client is disconnected. Handle this event
+ * the same way as when the QMI bye message is received. This will ensure
+ * the USB offloading path is disabled and cleaned up.
+ *
+ */
+static void qmi_svc_disconnect_cb(struct qmi_handle *handle,
+ unsigned int node, unsigned int port)
+{
+ struct uaudio_qmi_svc *svc;
+
+ if (uaudio_svc == NULL)
+ return;
+
+ svc = uaudio_svc;
+ if (svc->uaudio_svc_hdl != handle)
+ return;
+
+ if (svc->client_connected && svc->client_sq.sq_node == node &&
+ svc->client_sq.sq_port == port) {
+ queue_work(svc->uaudio_wq, &svc->qmi_disconnect_work);
+ svc->client_sq.sq_node = 0;
+ svc->client_sq.sq_port = 0;
+ svc->client_sq.sq_family = 0;
+ svc->client_connected = false;
+ }
+}
+
+/* QMI client callback handlers from QMI interface */
+static struct qmi_ops uaudio_svc_ops_options = {
+ .bye = qmi_bye_cb,
+ .del_client = qmi_svc_disconnect_cb,
+};
+
+/* kref release callback when all streams are disabled */
+static void uaudio_dev_release(struct kref *kref)
+{
+ struct uaudio_dev *dev = container_of(kref, struct uaudio_dev, kref);
+
+ uaudio_event_ring_cleanup_free(dev);
+ atomic_set(&dev->in_use, 0);
+ wake_up(&dev->disconnect_wq);
+}
+
+/**
+ * enable_audio_stream() - enable usb snd endpoints
+ * @subs: usb substream
+ * @pcm_format: pcm format requested
+ * @channels: number of channels
+ * @cur_rate: sample rate
+ * @datainterval: interval
+ *
+ * Opens all USB SND endpoints used for the data interface. This will increment
+ * the USB SND endpoint's opened count. Requests to keep the interface resumed
+ * until the audio stream is stopped. Will issue the USB set interface control
+ * message to enable the data interface.
+ *
+ */
+static int enable_audio_stream(struct snd_usb_substream *subs,
+ snd_pcm_format_t pcm_format,
+ unsigned int channels, unsigned int cur_rate,
+ int datainterval)
+{
+ struct snd_usb_audio *chip = subs->stream->chip;
+ struct snd_pcm_hw_params params;
+ const struct audioformat *fmt;
+ int ret;
+ bool fixed_rate;
+
+ _snd_pcm_hw_params_any(¶ms);
+ _snd_pcm_hw_param_set(¶ms, SNDRV_PCM_HW_PARAM_FORMAT,
+ (__force int) pcm_format, 0);
+ _snd_pcm_hw_param_set(¶ms, SNDRV_PCM_HW_PARAM_CHANNELS,
+ channels, 0);
+ _snd_pcm_hw_param_set(¶ms, SNDRV_PCM_HW_PARAM_RATE,
+ cur_rate, 0);
+
+ pm_runtime_barrier(&chip->intf[0]->dev);
+ snd_usb_autoresume(chip);
+
+ fmt = find_format(&subs->fmt_list, pcm_format, cur_rate,
+ channels, datainterval, subs);
+ if (!fmt) {
+ dev_err(uaudio_qdev->dev,
+ "cannot find format: format = %#x, rate = %d, ch = %d\n",
+ pcm_format, cur_rate, channels);
+ return -EINVAL;
+ }
+
+ if (atomic_read(&chip->shutdown)) {
+ dev_err(uaudio_qdev->dev, "chip already shutdown\n");
+ ret = -ENODEV;
+ } else {
+ if (subs->data_endpoint)
+ close_endpoints(chip, subs);
+
+ fixed_rate = snd_usb_pcm_has_fixed_rate(subs);
+ subs->data_endpoint = snd_usb_endpoint_open(chip, fmt,
+ ¶ms, false, fixed_rate);
+ if (!subs->data_endpoint) {
+ dev_err(uaudio_qdev->dev, "failed to open data endpoint\n");
+ return -EINVAL;
+ }
+
+ if (fmt->sync_ep) {
+ subs->sync_endpoint = snd_usb_endpoint_open(chip,
+ fmt, ¶ms, true, fixed_rate);
+ if (!subs->sync_endpoint) {
+ dev_err(uaudio_qdev->dev,
+ "failed to open sync endpoint\n");
+ return -EINVAL;
+ }
+
+ subs->data_endpoint->sync_source = subs->sync_endpoint;
+ }
+
+ mutex_lock(&chip->mutex);
+ subs->cur_audiofmt = fmt;
+ mutex_unlock(&chip->mutex);
+
+ if (subs->sync_endpoint) {
+ ret = snd_usb_endpoint_prepare(chip, subs->sync_endpoint);
+ if (ret < 0)
+ return ret;
+ }
+
+ ret = snd_usb_endpoint_prepare(chip, subs->data_endpoint);
+ if (ret < 0)
+ return ret;
+
+ dev_dbg(uaudio_qdev->dev,
+ "selected %s iface:%d altsetting:%d datainterval:%dus\n",
+ subs->direction ? "capture" : "playback",
+ fmt->iface, fmt->altsetting,
+ (1 << fmt->datainterval) *
+ (subs->dev->speed >= USB_SPEED_HIGH ?
+ BUS_INTERVAL_HIGHSPEED_AND_ABOVE :
+ BUS_INTERVAL_FULL_SPEED));
+ }
+
+ return 0;
+}
+
+/* returns usb hcd sysdev */
+static struct device *usb_get_usb_backend(struct usb_device *udev)
+{
+ if (udev->bus->sysdev && udev->bus->sysdev->of_node)
+ return udev->bus->sysdev;
+
+ return NULL;
+}
+
+/**
+ * prepare_qmi_response() - prepare stream enable response
+ * @subs: usb substream
+ * @req_msg: QMI request message
+ * @resp: QMI response buffer
+ * @info_idx: usb interface array index
+ *
+ * Prepares the QMI response for a USB QMI stream enable request. Will parse
+ * out the parameters within the stream enable request, in order to match
+ * requested audio profile to the ones exposed by the USB device connected.
+ *
+ * In addition, will fetch the XHCI transfer resources needed for the handoff to
+ * happen. This includes, transfer ring and buffer addresses and secondary event
+ * ring address. These parameters will be communicated as part of the USB QMI
+ * stream enable response.
+ *
+ */
+static int prepare_qmi_response(struct snd_usb_substream *subs,
+ struct qmi_uaudio_stream_req_msg_v01 *req_msg,
+ struct qmi_uaudio_stream_resp_msg_v01 *resp, int info_idx)
+{
+ struct usb_interface *iface;
+ struct usb_host_interface *alts;
+ struct usb_interface_descriptor *altsd;
+ struct usb_interface_assoc_descriptor *assoc;
+ struct usb_host_endpoint *ep;
+ struct uac_format_type_i_continuous_descriptor *fmt;
+ struct uac_format_type_i_discrete_descriptor *fmt_v1;
+ struct uac_format_type_i_ext_descriptor *fmt_v2;
+ struct uac1_as_header_descriptor *as;
+ struct xhci_interrupter *ir;
+ struct q6usb_offload *data;
+ struct usb_hcd *hcd;
+ int ret;
+ int protocol, card_num, pcm_dev_num;
+ void *hdr_ptr;
+ u8 *xfer_buf;
+ unsigned int data_ep_pipe = 0, sync_ep_pipe = 0;
+ u32 len, mult, remainder, xfer_buf_len;
+ unsigned long va, tr_data_va = 0, tr_sync_va = 0;
+ phys_addr_t xhci_pa, xfer_buf_pa, tr_data_pa = 0, tr_sync_pa = 0;
+ dma_addr_t dma;
+ struct sg_table sgt;
+ bool dma_coherent;
+
+ iface = usb_ifnum_to_if(subs->dev, subs->cur_audiofmt->iface);
+ if (!iface) {
+ dev_err(uaudio_qdev->dev, "interface # %d does not exist\n",
+ subs->cur_audiofmt->iface);
+ ret = -ENODEV;
+ goto err;
+ }
+
+ assoc = iface->intf_assoc;
+ pcm_dev_num = (req_msg->usb_token & SND_PCM_DEV_NUM_MASK) >> 8;
+ xfer_buf_len = req_msg->xfer_buff_size;
+ card_num = uaudio_qdev->last_card_num;
+
+ alts = &iface->altsetting[subs->cur_audiofmt->altset_idx];
+ altsd = get_iface_desc(alts);
+ protocol = altsd->bInterfaceProtocol;
+
+ /* get format type */
+ if (protocol != UAC_VERSION_3) {
+ fmt = snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL,
+ UAC_FORMAT_TYPE);
+ if (!fmt) {
+ dev_err(uaudio_qdev->dev,
+ "%u:%d : no UAC_FORMAT_TYPE desc\n",
+ subs->cur_audiofmt->iface,
+ subs->cur_audiofmt->altset_idx);
+ ret = -ENODEV;
+ goto err;
+ }
+ }
+
+ if (!uadev[card_num].ctrl_intf) {
+ dev_err(uaudio_qdev->dev, "audio ctrl intf info not cached\n");
+ ret = -ENODEV;
+ goto err;
+ }
+
+ if (protocol != UAC_VERSION_3) {
+ hdr_ptr = snd_usb_find_csint_desc(uadev[card_num].ctrl_intf->extra,
+ uadev[card_num].ctrl_intf->extralen, NULL,
+ UAC_HEADER);
+ if (!hdr_ptr) {
+ dev_err(uaudio_qdev->dev, "no UAC_HEADER desc\n");
+ ret = -ENODEV;
+ goto err;
+ }
+ }
+
+ if (protocol == UAC_VERSION_1) {
+ struct uac1_ac_header_descriptor *uac1_hdr = hdr_ptr;
+
+ as = snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL,
+ UAC_AS_GENERAL);
+ if (!as) {
+ dev_err(uaudio_qdev->dev,
+ "%u:%d : no UAC_AS_GENERAL desc\n",
+ subs->cur_audiofmt->iface,
+ subs->cur_audiofmt->altset_idx);
+ ret = -ENODEV;
+ goto err;
+ }
+ resp->data_path_delay = as->bDelay;
+ resp->data_path_delay_valid = 1;
+ fmt_v1 = (struct uac_format_type_i_discrete_descriptor *)fmt;
+ resp->usb_audio_subslot_size = fmt_v1->bSubframeSize;
+ resp->usb_audio_subslot_size_valid = 1;
+
+ resp->usb_audio_spec_revision = le16_to_cpu(uac1_hdr->bcdADC);
+ resp->usb_audio_spec_revision_valid = 1;
+ } else if (protocol == UAC_VERSION_2) {
+ struct uac2_ac_header_descriptor *uac2_hdr = hdr_ptr;
+
+ fmt_v2 = (struct uac_format_type_i_ext_descriptor *)fmt;
+ resp->usb_audio_subslot_size = fmt_v2->bSubslotSize;
+ resp->usb_audio_subslot_size_valid = 1;
+
+ resp->usb_audio_spec_revision = le16_to_cpu(uac2_hdr->bcdADC);
+ resp->usb_audio_spec_revision_valid = 1;
+ } else if (protocol == UAC_VERSION_3) {
+ if (assoc->bFunctionSubClass ==
+ UAC3_FUNCTION_SUBCLASS_FULL_ADC_3_0) {
+ dev_err(uaudio_qdev->dev, "full adc is not supported\n");
+ ret = -EINVAL;
+ }
+
+ switch (le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize)) {
+ case UAC3_BADD_EP_MAXPSIZE_SYNC_MONO_16:
+ case UAC3_BADD_EP_MAXPSIZE_SYNC_STEREO_16:
+ case UAC3_BADD_EP_MAXPSIZE_ASYNC_MONO_16:
+ case UAC3_BADD_EP_MAXPSIZE_ASYNC_STEREO_16: {
+ resp->usb_audio_subslot_size = 0x2;
+ break;
+ }
+
+ case UAC3_BADD_EP_MAXPSIZE_SYNC_MONO_24:
+ case UAC3_BADD_EP_MAXPSIZE_SYNC_STEREO_24:
+ case UAC3_BADD_EP_MAXPSIZE_ASYNC_MONO_24:
+ case UAC3_BADD_EP_MAXPSIZE_ASYNC_STEREO_24: {
+ resp->usb_audio_subslot_size = 0x3;
+ break;
+ }
+
+ default:
+ dev_err(uaudio_qdev->dev,
+ "%d: %u: Invalid wMaxPacketSize\n",
+ subs->cur_audiofmt->iface,
+ subs->cur_audiofmt->altset_idx);
+ ret = -EINVAL;
+ goto err;
+ }
+ resp->usb_audio_subslot_size_valid = 1;
+ } else {
+ dev_err(uaudio_qdev->dev, "unknown protocol version %x\n",
+ protocol);
+ ret = -ENODEV;
+ goto err;
+ }
+
+ resp->slot_id = subs->dev->slot_id;
+ resp->slot_id_valid = 1;
+
+ memcpy(&resp->std_as_opr_intf_desc, &alts->desc, sizeof(alts->desc));
+ resp->std_as_opr_intf_desc_valid = 1;
+
+ ep = usb_pipe_endpoint(subs->dev, subs->data_endpoint->pipe);
+ if (!ep) {
+ dev_err(uaudio_qdev->dev, "data ep # %d context is null\n",
+ subs->data_endpoint->ep_num);
+ ret = -ENODEV;
+ goto err;
+ }
+ data_ep_pipe = subs->data_endpoint->pipe;
+ memcpy(&resp->std_as_data_ep_desc, &ep->desc, sizeof(ep->desc));
+ resp->std_as_data_ep_desc_valid = 1;
+
+ tr_data_pa = xhci_get_xfer_resource(subs->dev, ep, &dma);
+ if (!tr_data_pa) {
+ dev_err(uaudio_qdev->dev, "failed to get data ep ring address\n");
+ ret = -ENODEV;
+ goto err;
+ }
+ resp->xhci_mem_info.tr_data.pa = dma;
+
+ if (subs->sync_endpoint) {
+ ep = usb_pipe_endpoint(subs->dev, subs->sync_endpoint->pipe);
+ if (!ep) {
+ dev_err(uaudio_qdev->dev, "implicit fb on data ep\n");
+ goto skip_sync_ep;
+ }
+ sync_ep_pipe = subs->sync_endpoint->pipe;
+ memcpy(&resp->std_as_sync_ep_desc, &ep->desc, sizeof(ep->desc));
+ resp->std_as_sync_ep_desc_valid = 1;
+
+ tr_sync_pa = xhci_get_xfer_resource(subs->dev, ep, &dma);
+ if (!tr_sync_pa) {
+ dev_err(uaudio_qdev->dev,
+ "failed to get sync ep ring address\n");
+ ret = -ENODEV;
+ goto err;
+ }
+ resp->xhci_mem_info.tr_sync.pa = dma;
+ }
+
+skip_sync_ep:
+ resp->interrupter_num_valid = 1;
+ resp->controller_num_valid = 0;
+ ret = usb_get_controller_id(subs->dev);
+ if (ret >= 0) {
+ resp->controller_num = ret;
+ resp->controller_num_valid = 1;
+ }
+ /* map xhci data structures PA memory to iova */
+ dma_coherent = dev_is_dma_coherent(subs->dev->bus->sysdev);
+
+ /* event ring */
+ hcd = bus_to_hcd(subs->dev->bus);
+ ir = xhci_create_secondary_interrupter(hcd, uaudio_qdev->intr_num);
+ if (!ir) {
+ dev_err(uaudio_qdev->dev, "failed to fetch interrupter\n");
+ ret = -ENODEV;
+ goto err;
+ }
+
+ xhci_pa = xhci_get_ir_resource(subs->dev, ir);
+ if (!xhci_pa) {
+ dev_err(uaudio_qdev->dev,
+ "failed to get sec event ring address\n");
+ ret = -ENODEV;
+ goto free_sec_ring;
+ }
+
+ uaudio_qdev->ir = ir;
+ resp->interrupter_num = ir->intr_num;
+
+ data = snd_soc_usb_get_priv_data(usb_get_usb_backend(subs->dev));
+ if (!data)
+ goto free_sec_ring;
+
+ uaudio_qdev->domain = data->domain;
+ uaudio_qdev->sid = data->sid;
+ uaudio_qdev->intr_num = data->intr_num;
+ uaudio_qdev->dev = data->dev;
+
+ va = uaudio_iommu_map(MEM_EVENT_RING, dma_coherent, xhci_pa, PAGE_SIZE,
+ NULL);
+ if (!va) {
+ ret = -ENOMEM;
+ goto free_sec_ring;
+ }
+
+ resp->xhci_mem_info.evt_ring.va = PREPEND_SID_TO_IOVA(va,
+ uaudio_qdev->sid);
+ resp->xhci_mem_info.evt_ring.pa = ir->event_ring->first_seg->dma;
+ resp->xhci_mem_info.evt_ring.size = PAGE_SIZE;
+ uaudio_qdev->er_mapped = true;
+
+ resp->speed_info = get_speed_info(subs->dev->speed);
+ if (resp->speed_info == USB_AUDIO_DEVICE_SPEED_INVALID_V01) {
+ ret = -ENODEV;
+ goto unmap_er;
+ }
+
+ resp->speed_info_valid = 1;
+
+ /* data transfer ring */
+ va = uaudio_iommu_map(MEM_XFER_RING, dma_coherent, tr_data_pa,
+ PAGE_SIZE, NULL);
+ if (!va) {
+ ret = -ENOMEM;
+ goto unmap_er;
+ }
+
+ tr_data_va = va;
+ resp->xhci_mem_info.tr_data.va = PREPEND_SID_TO_IOVA(va,
+ uaudio_qdev->sid);
+ resp->xhci_mem_info.tr_data.size = PAGE_SIZE;
+
+ /* sync transfer ring */
+ if (!resp->xhci_mem_info.tr_sync.pa)
+ goto skip_sync;
+
+ xhci_pa = resp->xhci_mem_info.tr_sync.pa;
+ va = uaudio_iommu_map(MEM_XFER_RING, dma_coherent, tr_sync_pa,
+ PAGE_SIZE, NULL);
+ if (!va) {
+ ret = -ENOMEM;
+ goto unmap_data;
+ }
+
+ tr_sync_va = va;
+ resp->xhci_mem_info.tr_sync.va = PREPEND_SID_TO_IOVA(va,
+ uaudio_qdev->sid);
+ resp->xhci_mem_info.tr_sync.size = PAGE_SIZE;
+
+skip_sync:
+ /* xfer buffer, multiple of 4K only */
+ if (!xfer_buf_len)
+ xfer_buf_len = PAGE_SIZE;
+
+ mult = xfer_buf_len / PAGE_SIZE;
+ remainder = xfer_buf_len % PAGE_SIZE;
+ len = mult * PAGE_SIZE;
+ len += remainder ? PAGE_SIZE : 0;
+
+ if (len > MAX_XFER_BUFF_LEN) {
+ dev_err(uaudio_qdev->dev,
+ "req buf len %d > max buf len %lu, setting %lu\n",
+ len, MAX_XFER_BUFF_LEN, MAX_XFER_BUFF_LEN);
+ len = MAX_XFER_BUFF_LEN;
+ }
+
+ xfer_buf = usb_alloc_coherent(subs->dev, len, GFP_KERNEL, &xfer_buf_pa);
+ if (!xfer_buf) {
+ ret = -ENOMEM;
+ goto unmap_sync;
+ }
+
+ dma_get_sgtable(subs->dev->bus->sysdev, &sgt, xfer_buf, xfer_buf_pa,
+ len);
+ va = uaudio_iommu_map(MEM_XFER_BUF, dma_coherent, xfer_buf_pa, len,
+ &sgt);
+ if (!va) {
+ ret = -ENOMEM;
+ goto unmap_sync;
+ }
+
+ resp->xhci_mem_info.xfer_buff.pa = xfer_buf_pa;
+ resp->xhci_mem_info.xfer_buff.size = len;
+
+ resp->xhci_mem_info.xfer_buff.va = PREPEND_SID_TO_IOVA(va,
+ uaudio_qdev->sid);
+
+ resp->xhci_mem_info_valid = 1;
+
+ sg_free_table(&sgt);
+
+ if (!atomic_read(&uadev[card_num].in_use)) {
+ kref_init(&uadev[card_num].kref);
+ init_waitqueue_head(&uadev[card_num].disconnect_wq);
+ uadev[card_num].num_intf =
+ subs->dev->config->desc.bNumInterfaces;
+ uadev[card_num].info = kcalloc(uadev[card_num].num_intf,
+ sizeof(struct intf_info), GFP_KERNEL);
+ if (!uadev[card_num].info) {
+ ret = -ENOMEM;
+ goto unmap_sync;
+ }
+ uadev[card_num].udev = subs->dev;
+ atomic_set(&uadev[card_num].in_use, 1);
+ } else {
+ kref_get(&uadev[card_num].kref);
+ }
+
+ uadev[card_num].card_num = card_num;
+ uadev[card_num].usb_core_id = resp->controller_num;
+
+ /* cache intf specific info to use it for unmap and free xfer buf */
+ uadev[card_num].info[info_idx].data_xfer_ring_va = tr_data_va;
+ uadev[card_num].info[info_idx].data_xfer_ring_size = PAGE_SIZE;
+ uadev[card_num].info[info_idx].sync_xfer_ring_va = tr_sync_va;
+ uadev[card_num].info[info_idx].sync_xfer_ring_size = PAGE_SIZE;
+ uadev[card_num].info[info_idx].xfer_buf_va = va;
+ uadev[card_num].info[info_idx].xfer_buf_pa = xfer_buf_pa;
+ uadev[card_num].info[info_idx].xfer_buf_size = len;
+ uadev[card_num].info[info_idx].data_ep_pipe = data_ep_pipe;
+ uadev[card_num].info[info_idx].sync_ep_pipe = sync_ep_pipe;
+ uadev[card_num].info[info_idx].xfer_buf = xfer_buf;
+ uadev[card_num].info[info_idx].pcm_card_num = card_num;
+ uadev[card_num].info[info_idx].pcm_dev_num = pcm_dev_num;
+ uadev[card_num].info[info_idx].direction = subs->direction;
+ uadev[card_num].info[info_idx].intf_num = subs->cur_audiofmt->iface;
+ uadev[card_num].info[info_idx].in_use = true;
+
+ set_bit(card_num, &uaudio_qdev->card_slot);
+
+ return 0;
+
+unmap_sync:
+ usb_free_coherent(subs->dev, len, xfer_buf, xfer_buf_pa);
+ uaudio_iommu_unmap(MEM_XFER_RING, tr_sync_va, PAGE_SIZE, PAGE_SIZE);
+unmap_data:
+ uaudio_iommu_unmap(MEM_XFER_RING, tr_data_va, PAGE_SIZE, PAGE_SIZE);
+unmap_er:
+ uaudio_iommu_unmap(MEM_EVENT_RING, IOVA_BASE, PAGE_SIZE, PAGE_SIZE);
+free_sec_ring:
+ xhci_remove_secondary_interrupter(hcd, uaudio_qdev->ir);
+err:
+ return ret;
+}
+
+/**
+ * handle_uaudio_stream_req() - handle stream enable/disable request
+ * @handle: QMI client handle
+ * @sq: qrtr socket
+ * @txn: QMI transaction context
+ * @decoded_msg: decoded QMI message
+ *
+ * Main handler for the QMI stream enable/disable requests. This executes the
+ * corresponding enable/disable stream apis, respectively.
+ *
+ */
+static void handle_uaudio_stream_req(struct qmi_handle *handle,
+ struct sockaddr_qrtr *sq,
+ struct qmi_txn *txn,
+ const void *decoded_msg)
+{
+ struct qmi_uaudio_stream_req_msg_v01 *req_msg;
+ struct qmi_uaudio_stream_resp_msg_v01 resp = {{0}, 0};
+ struct snd_usb_substream *subs;
+ struct snd_usb_audio *chip = NULL;
+ struct uaudio_qmi_svc *svc = uaudio_svc;
+ struct intf_info *info;
+ struct usb_host_endpoint *ep;
+ u8 pcm_card_num, pcm_dev_num, direction;
+ int info_idx = -EINVAL, datainterval = -EINVAL, ret = 0;
+
+ if (!svc->client_connected) {
+ svc->client_sq = *sq;
+ svc->client_connected = true;
+ }
+
+ mutex_lock(&qdev_mutex);
+ req_msg = (struct qmi_uaudio_stream_req_msg_v01 *)decoded_msg;
+ if (!req_msg->audio_format_valid || !req_msg->bit_rate_valid ||
+ !req_msg->number_of_ch_valid || !req_msg->xfer_buff_size_valid) {
+ ret = -EINVAL;
+ goto response;
+ }
+
+ if (!uaudio_qdev) {
+ ret = -EINVAL;
+ goto response;
+ }
+
+ direction = (req_msg->usb_token & SND_PCM_STREAM_DIRECTION);
+ pcm_dev_num = (req_msg->usb_token & SND_PCM_DEV_NUM_MASK) >> 8;
+ pcm_card_num = req_msg->enable ? uaudio_qdev->last_card_num :
+ ffs(uaudio_qdev->card_slot) - 1;
+ if (pcm_card_num >= SNDRV_CARDS) {
+ ret = -EINVAL;
+ goto response;
+ }
+
+ if (req_msg->audio_format > USB_QMI_PCM_FORMAT_U32_BE) {
+ ret = -EINVAL;
+ goto response;
+ }
+
+ subs = find_substream(pcm_card_num, pcm_dev_num, direction);
+ chip = uadev[pcm_card_num].chip;
+ if (!subs || !chip || atomic_read(&chip->shutdown)) {
+ ret = -ENODEV;
+ goto response;
+ }
+
+ info_idx = info_idx_from_ifnum(pcm_card_num, subs->cur_audiofmt ?
+ subs->cur_audiofmt->iface : -1, req_msg->enable);
+ if (atomic_read(&chip->shutdown) || !subs->stream || !subs->stream->pcm
+ || !subs->stream->chip) {
+ ret = -ENODEV;
+ goto response;
+ }
+
+ if (req_msg->enable) {
+ if (info_idx < 0 || chip->system_suspend) {
+ ret = -EBUSY;
+ goto response;
+ }
+ }
+
+ if (req_msg->service_interval_valid) {
+ ret = get_data_interval_from_si(subs,
+ req_msg->service_interval);
+ if (ret == -EINVAL)
+ goto response;
+
+ datainterval = ret;
+ }
+
+ uadev[pcm_card_num].ctrl_intf = chip->ctrl_intf;
+
+ if (req_msg->enable) {
+ ret = enable_audio_stream(subs,
+ map_pcm_format(req_msg->audio_format),
+ req_msg->number_of_ch, req_msg->bit_rate,
+ datainterval);
+
+ if (!ret)
+ ret = prepare_qmi_response(subs, req_msg, &resp,
+ info_idx);
+ } else {
+ info = &uadev[pcm_card_num].info[info_idx];
+ if (info->data_ep_pipe) {
+ ep = usb_pipe_endpoint(uadev[pcm_card_num].udev,
+ info->data_ep_pipe);
+ if (ep)
+ xhci_stop_endpoint(uadev[pcm_card_num].udev,
+ ep);
+ info->data_ep_pipe = 0;
+ }
+
+ if (info->sync_ep_pipe) {
+ ep = usb_pipe_endpoint(uadev[pcm_card_num].udev,
+ info->sync_ep_pipe);
+ if (ep)
+ xhci_stop_endpoint(uadev[pcm_card_num].udev,
+ ep);
+ info->sync_ep_pipe = 0;
+ }
+
+ disable_audio_stream(subs);
+ }
+
+response:
+ if (!req_msg->enable && ret != -EINVAL && ret != -ENODEV) {
+ mutex_lock(&chip->mutex);
+ if (info_idx >= 0) {
+ info = &uadev[pcm_card_num].info[info_idx];
+ uaudio_dev_intf_cleanup(
+ uadev[pcm_card_num].udev,
+ info);
+ }
+ if (atomic_read(&uadev[pcm_card_num].in_use))
+ kref_put(&uadev[pcm_card_num].kref,
+ uaudio_dev_release);
+ mutex_unlock(&chip->mutex);
+ }
+ mutex_unlock(&qdev_mutex);
+
+ resp.usb_token = req_msg->usb_token;
+ resp.usb_token_valid = 1;
+ resp.internal_status = ret;
+ resp.internal_status_valid = 1;
+ resp.status = ret ? USB_AUDIO_STREAM_REQ_FAILURE_V01 : ret;
+ resp.status_valid = 1;
+ ret = qmi_send_response(svc->uaudio_svc_hdl, sq, txn,
+ QMI_UAUDIO_STREAM_RESP_V01,
+ QMI_UAUDIO_STREAM_RESP_MSG_V01_MAX_MSG_LEN,
+ qmi_uaudio_stream_resp_msg_v01_ei, &resp);
+}
+
+static struct qmi_msg_handler uaudio_stream_req_handlers = {
+ .type = QMI_REQUEST,
+ .msg_id = QMI_UAUDIO_STREAM_REQ_V01,
+ .ei = qmi_uaudio_stream_req_msg_v01_ei,
+ .decoded_size = QMI_UAUDIO_STREAM_REQ_MSG_V01_MAX_MSG_LEN,
+ .fn = handle_uaudio_stream_req,
+};
+
+/**
+ * qc_usb_audio_offload_init_qmi_dev() - initializes qmi dev
+ *
+ * Initializes the USB qdev, which is used to carry information pertaining to
+ * the offloading resources. This device is freed only when there are no longer
+ * any offloading candidates. (i.e, when all audio devices are disconnected)
+ *
+ */
+static int qc_usb_audio_offload_init_qmi_dev(struct usb_device *udev)
+{
+ uaudio_qdev = kzalloc(sizeof(struct uaudio_qmi_dev),
+ GFP_KERNEL);
+ if (!uaudio_qdev)
+ return -ENOMEM;
+
+ /* initialize xfer ring and xfer buf iova list */
+ INIT_LIST_HEAD(&uaudio_qdev->xfer_ring_list);
+ uaudio_qdev->curr_xfer_ring_iova = IOVA_XFER_RING_BASE;
+ uaudio_qdev->xfer_ring_iova_size =
+ IOVA_XFER_RING_MAX - IOVA_XFER_RING_BASE;
+
+ INIT_LIST_HEAD(&uaudio_qdev->xfer_buf_list);
+ uaudio_qdev->curr_xfer_buf_iova = IOVA_XFER_BUF_BASE;
+ uaudio_qdev->xfer_buf_iova_size =
+ IOVA_XFER_BUF_MAX - IOVA_XFER_BUF_BASE;
+
+ return 0;
+}
+
+/**
+ * qc_usb_audio_offload_probe() - platform op connect handler
+ * @chip: USB SND device
+ *
+ * Platform connect handler when a USB SND device is detected. Will
+ * notify SOC USB about the connection to enable the USB ASoC backend
+ * and populate internal USB chip array.
+ *
+ */
+static void qc_usb_audio_offload_probe(struct snd_usb_audio *chip)
+{
+ struct usb_device *udev = chip->dev;
+
+ /*
+ * If there is no priv_data, the connected device is on a USB bus
+ * that doesn't support offloading. Avoid populating entries for
+ * this device.
+ */
+ if (!snd_soc_usb_get_priv_data(usb_get_usb_backend(udev)))
+ return;
+
+ mutex_lock(&chip->mutex);
+ mutex_lock(&qdev_mutex);
+ if (!uaudio_qdev)
+ qc_usb_audio_offload_init_qmi_dev(udev);
+
+ atomic_inc(&uaudio_qdev->qdev_in_use);
+ mutex_unlock(&qdev_mutex);
+
+ uadev[chip->card->number].chip = chip;
+ uaudio_qdev->last_card_num = chip->card->number;
+
+ snd_soc_usb_connect(usb_get_usb_backend(udev), chip->index);
+ mutex_unlock(&chip->mutex);
+}
+
+/**
+ * qc_usb_audio_cleanup_qmi_dev() - release qmi device
+ *
+ * Frees the USB qdev. Only occurs when there are no longer any potential
+ * devices that can utilize USB audio offloading.
+ *
+ */
+static void qc_usb_audio_cleanup_qmi_dev(void)
+{
+ kfree(uaudio_qdev);
+ uaudio_qdev = NULL;
+}
+
+/**
+ * qc_usb_audio_offload_disconnect() - platform op disconnect handler
+ * @chip: USB SND device
+ *
+ * Platform disconnect handler. Will ensure that any pending stream is
+ * halted by issuing a QMI disconnect indication packet to the adsp.
+ *
+ */
+static void qc_usb_audio_offload_disconnect(struct snd_usb_audio *chip)
+{
+ struct usb_device *udev = chip->dev;
+ struct qmi_uaudio_stream_ind_msg_v01 disconnect_ind = {0};
+ struct uaudio_qmi_svc *svc = uaudio_svc;
+ struct uaudio_dev *dev;
+ int card_num;
+ int ret;
+
+ if (!chip)
+ return;
+
+ card_num = chip->card->number;
+ if (card_num >= SNDRV_CARDS)
+ return;
+
+ mutex_lock(&chip->mutex);
+ dev = &uadev[card_num];
+
+ /* Device has already been cleaned up, or never populated */
+ if (!dev->chip)
+ return;
+
+ /* clean up */
+ if (!dev->udev)
+ goto done;
+
+ if (atomic_read(&dev->in_use)) {
+ mutex_unlock(&chip->mutex);
+ dev_dbg(uaudio_qdev->dev, "sending qmi indication disconnect\n");
+ disconnect_ind.dev_event = USB_AUDIO_DEV_DISCONNECT_V01;
+ disconnect_ind.slot_id = dev->udev->slot_id;
+ disconnect_ind.controller_num = dev->usb_core_id;
+ disconnect_ind.controller_num_valid = 1;
+ ret = qmi_send_indication(svc->uaudio_svc_hdl, &svc->client_sq,
+ QMI_UAUDIO_STREAM_IND_V01,
+ QMI_UAUDIO_STREAM_IND_MSG_V01_MAX_MSG_LEN,
+ qmi_uaudio_stream_ind_msg_v01_ei,
+ &disconnect_ind);
+ if (ret < 0)
+ dev_err(uaudio_qdev->dev,
+ "qmi send failed with err: %d\n", ret);
+
+ ret = wait_event_interruptible_timeout(dev->disconnect_wq,
+ !atomic_read(&dev->in_use),
+ msecs_to_jiffies(DEV_RELEASE_WAIT_TIMEOUT));
+ if (!ret) {
+ dev_err(uaudio_qdev->dev,
+ "timeout while waiting for dev_release\n");
+ atomic_set(&dev->in_use, 0);
+ } else if (ret < 0) {
+ dev_err(uaudio_qdev->dev, "failed with ret %d\n", ret);
+ atomic_set(&dev->in_use, 0);
+ }
+ mutex_lock(&chip->mutex);
+ }
+
+ uaudio_dev_cleanup(dev);
+done:
+ uadev[card_num].chip = NULL;
+ mutex_unlock(&chip->mutex);
+
+ mutex_lock(&qdev_mutex);
+ atomic_dec(&uaudio_qdev->qdev_in_use);
+ if (!atomic_read(&uaudio_qdev->qdev_in_use)) {
+ snd_soc_usb_disconnect(usb_get_usb_backend(udev));
+ qc_usb_audio_cleanup_qmi_dev();
+ }
+ mutex_unlock(&qdev_mutex);
+}
+
+/**
+ * qc_usb_audio_offload_suspend() - USB offload PM suspend handler
+ * @intf: USB interface
+ * @message: suspend type
+ *
+ * PM suspend handler to ensure that the USB offloading driver is able to stop
+ * any pending traffic, so that the bus can be suspended.
+ *
+ */
+static void qc_usb_audio_offload_suspend(struct usb_interface *intf, pm_message_t message)
+{
+ struct snd_usb_audio *chip = usb_get_intfdata(intf);
+ struct qmi_uaudio_stream_ind_msg_v01 disconnect_ind = {0};
+ struct uaudio_qmi_svc *svc = uaudio_svc;
+ struct uaudio_dev *dev;
+ int card_num;
+ int ret;
+
+ if (!chip)
+ return;
+
+ card_num = chip->card->number;
+ if (card_num >= SNDRV_CARDS)
+ return;
+
+
+ mutex_lock(&chip->mutex);
+ dev = &uadev[card_num];
+
+ if (atomic_read(&dev->in_use)) {
+ mutex_unlock(&chip->mutex);
+ dev_dbg(uaudio_qdev->dev, "sending qmi indication suspend\n");
+ disconnect_ind.dev_event = USB_AUDIO_DEV_DISCONNECT_V01;
+ disconnect_ind.slot_id = dev->udev->slot_id;
+ disconnect_ind.controller_num = dev->usb_core_id;
+ disconnect_ind.controller_num_valid = 1;
+ ret = qmi_send_indication(svc->uaudio_svc_hdl, &svc->client_sq,
+ QMI_UAUDIO_STREAM_IND_V01,
+ QMI_UAUDIO_STREAM_IND_MSG_V01_MAX_MSG_LEN,
+ qmi_uaudio_stream_ind_msg_v01_ei,
+ &disconnect_ind);
+ if (ret < 0)
+ dev_err(uaudio_qdev->dev,
+ "qmi send failed with err: %d\n", ret);
+
+ ret = wait_event_interruptible_timeout(dev->disconnect_wq,
+ !atomic_read(&dev->in_use),
+ msecs_to_jiffies(DEV_RELEASE_WAIT_TIMEOUT));
+ if (!ret) {
+ dev_err(uaudio_qdev->dev,
+ "timeout while waiting for dev_release\n");
+ atomic_set(&dev->in_use, 0);
+ } else if (ret < 0) {
+ dev_err(uaudio_qdev->dev, "failed with ret %d\n", ret);
+ atomic_set(&dev->in_use, 0);
+ }
+ mutex_lock(&chip->mutex);
+ }
+ mutex_unlock(&chip->mutex);
+}
+
+static struct snd_usb_platform_ops offload_ops = {
+ .connect_cb = qc_usb_audio_offload_probe,
+ .disconnect_cb = qc_usb_audio_offload_disconnect,
+ .suspend_cb = qc_usb_audio_offload_suspend,
+};
+
+static int __init qc_usb_audio_offload_init(void)
+{
+ struct uaudio_qmi_svc *svc;
+ int ret;
+
+ ret = snd_usb_register_platform_ops(&offload_ops);
+ if (ret < 0)
+ return ret;
+
+ svc = kzalloc(sizeof(struct uaudio_qmi_svc), GFP_KERNEL);
+ if (!svc) {
+ ret = -ENOMEM;
+ goto unreg_ops;
+ }
+
+ svc->uaudio_wq = create_singlethread_workqueue("uaudio_svc");
+ if (!svc->uaudio_wq) {
+ ret = -ENOMEM;
+ goto free_svc;
+ }
+
+ svc->uaudio_svc_hdl = kzalloc(sizeof(struct qmi_handle), GFP_KERNEL);
+ if (!svc->uaudio_svc_hdl) {
+ ret = -ENOMEM;
+ goto free_wq;
+ }
+
+ ret = qmi_handle_init(svc->uaudio_svc_hdl,
+ QMI_UAUDIO_STREAM_REQ_MSG_V01_MAX_MSG_LEN,
+ &uaudio_svc_ops_options,
+ &uaudio_stream_req_handlers);
+ ret = qmi_add_server(svc->uaudio_svc_hdl, UAUDIO_STREAM_SERVICE_ID_V01,
+ UAUDIO_STREAM_SERVICE_VERS_V01, 0);
+
+ INIT_WORK(&svc->qmi_disconnect_work, qmi_disconnect_work);
+ uaudio_svc = svc;
+
+ return 0;
+
+free_wq:
+ destroy_workqueue(svc->uaudio_wq);
+free_svc:
+ kfree(svc);
+unreg_ops:
+ snd_usb_unregister_platform_ops();
+
+ return ret;
+}
+
+static void __exit qc_usb_audio_offload_exit(void)
+{
+ struct uaudio_qmi_svc *svc = uaudio_svc;
+
+ qmi_handle_release(svc->uaudio_svc_hdl);
+ flush_workqueue(svc->uaudio_wq);
+ destroy_workqueue(svc->uaudio_wq);
+ kfree(svc);
+ uaudio_svc = NULL;
+ snd_usb_unregister_platform_ops();
+}
+
+module_init(qc_usb_audio_offload_init);
+module_exit(qc_usb_audio_offload_exit);
+
+MODULE_DESCRIPTION("QC USB Audio Offloading");
+MODULE_LICENSE("GPL");
diff --git a/sound/usb/qcom/usb_audio_qmi_v01.c b/sound/usb/qcom/usb_audio_qmi_v01.c
new file mode 100644
index 000000000000..1a0f2f579786
--- /dev/null
+++ b/sound/usb/qcom/usb_audio_qmi_v01.c
@@ -0,0 +1,892 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (c) 2022-2023 Qualcomm Innovation Center, Inc. All rights reserved.
+ */
+
+#include <linux/soc/qcom/qmi.h>
+
+#include "usb_audio_qmi_v01.h"
+
+static struct qmi_elem_info mem_info_v01_ei[] = {
+ {
+ .data_type = QMI_UNSIGNED_8_BYTE,
+ .elem_len = 1,
+ .elem_size = sizeof(u64),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0,
+ .offset = offsetof(struct mem_info_v01, va),
+ },
+ {
+ .data_type = QMI_UNSIGNED_8_BYTE,
+ .elem_len = 1,
+ .elem_size = sizeof(u64),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0,
+ .offset = offsetof(struct mem_info_v01, pa),
+ },
+ {
+ .data_type = QMI_UNSIGNED_4_BYTE,
+ .elem_len = 1,
+ .elem_size = sizeof(u32),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0,
+ .offset = offsetof(struct mem_info_v01, size),
+ },
+ {
+ .data_type = QMI_EOTI,
+ .array_type = NO_ARRAY,
+ .tlv_type = QMI_COMMON_TLV_TYPE,
+ },
+};
+
+static struct qmi_elem_info apps_mem_info_v01_ei[] = {
+ {
+ .data_type = QMI_STRUCT,
+ .elem_len = 1,
+ .elem_size = sizeof(struct mem_info_v01),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0,
+ .offset = offsetof(struct apps_mem_info_v01, evt_ring),
+ .ei_array = mem_info_v01_ei,
+ },
+ {
+ .data_type = QMI_STRUCT,
+ .elem_len = 1,
+ .elem_size = sizeof(struct mem_info_v01),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0,
+ .offset = offsetof(struct apps_mem_info_v01, tr_data),
+ .ei_array = mem_info_v01_ei,
+ },
+ {
+ .data_type = QMI_STRUCT,
+ .elem_len = 1,
+ .elem_size = sizeof(struct mem_info_v01),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0,
+ .offset = offsetof(struct apps_mem_info_v01, tr_sync),
+ .ei_array = mem_info_v01_ei,
+ },
+ {
+ .data_type = QMI_STRUCT,
+ .elem_len = 1,
+ .elem_size = sizeof(struct mem_info_v01),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0,
+ .offset = offsetof(struct apps_mem_info_v01, xfer_buff),
+ .ei_array = mem_info_v01_ei,
+ },
+ {
+ .data_type = QMI_STRUCT,
+ .elem_len = 1,
+ .elem_size = sizeof(struct mem_info_v01),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0,
+ .offset = offsetof(struct apps_mem_info_v01, dcba),
+ .ei_array = mem_info_v01_ei,
+ },
+ {
+ .data_type = QMI_EOTI,
+ .array_type = NO_ARRAY,
+ .tlv_type = QMI_COMMON_TLV_TYPE,
+ },
+};
+
+static struct qmi_elem_info usb_endpoint_descriptor_v01_ei[] = {
+ {
+ .data_type = QMI_UNSIGNED_1_BYTE,
+ .elem_len = 1,
+ .elem_size = sizeof(u8),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0,
+ .offset = offsetof(struct usb_endpoint_descriptor_v01,
+ bLength),
+ },
+ {
+ .data_type = QMI_UNSIGNED_1_BYTE,
+ .elem_len = 1,
+ .elem_size = sizeof(u8),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0,
+ .offset = offsetof(struct usb_endpoint_descriptor_v01,
+ bDescriptorType),
+ },
+ {
+ .data_type = QMI_UNSIGNED_1_BYTE,
+ .elem_len = 1,
+ .elem_size = sizeof(u8),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0,
+ .offset = offsetof(struct usb_endpoint_descriptor_v01,
+ bEndpointAddress),
+ },
+ {
+ .data_type = QMI_UNSIGNED_1_BYTE,
+ .elem_len = 1,
+ .elem_size = sizeof(u8),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0,
+ .offset = offsetof(struct usb_endpoint_descriptor_v01,
+ bmAttributes),
+ },
+ {
+ .data_type = QMI_UNSIGNED_2_BYTE,
+ .elem_len = 1,
+ .elem_size = sizeof(u16),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0,
+ .offset = offsetof(struct usb_endpoint_descriptor_v01,
+ wMaxPacketSize),
+ },
+ {
+ .data_type = QMI_UNSIGNED_1_BYTE,
+ .elem_len = 1,
+ .elem_size = sizeof(u8),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0,
+ .offset = offsetof(struct usb_endpoint_descriptor_v01,
+ bInterval),
+ },
+ {
+ .data_type = QMI_UNSIGNED_1_BYTE,
+ .elem_len = 1,
+ .elem_size = sizeof(u8),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0,
+ .offset = offsetof(struct usb_endpoint_descriptor_v01,
+ bRefresh),
+ },
+ {
+ .data_type = QMI_UNSIGNED_1_BYTE,
+ .elem_len = 1,
+ .elem_size = sizeof(u8),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0,
+ .offset = offsetof(struct usb_endpoint_descriptor_v01,
+ bSynchAddress),
+ },
+ {
+ .data_type = QMI_EOTI,
+ .array_type = NO_ARRAY,
+ .tlv_type = QMI_COMMON_TLV_TYPE,
+ },
+};
+
+static struct qmi_elem_info usb_interface_descriptor_v01_ei[] = {
+ {
+ .data_type = QMI_UNSIGNED_1_BYTE,
+ .elem_len = 1,
+ .elem_size = sizeof(u8),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0,
+ .offset = offsetof(struct usb_interface_descriptor_v01,
+ bLength),
+ },
+ {
+ .data_type = QMI_UNSIGNED_1_BYTE,
+ .elem_len = 1,
+ .elem_size = sizeof(u8),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0,
+ .offset = offsetof(struct usb_interface_descriptor_v01,
+ bDescriptorType),
+ },
+ {
+ .data_type = QMI_UNSIGNED_1_BYTE,
+ .elem_len = 1,
+ .elem_size = sizeof(u8),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0,
+ .offset = offsetof(struct usb_interface_descriptor_v01,
+ bInterfaceNumber),
+ },
+ {
+ .data_type = QMI_UNSIGNED_1_BYTE,
+ .elem_len = 1,
+ .elem_size = sizeof(u8),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0,
+ .offset = offsetof(struct usb_interface_descriptor_v01,
+ bAlternateSetting),
+ },
+ {
+ .data_type = QMI_UNSIGNED_1_BYTE,
+ .elem_len = 1,
+ .elem_size = sizeof(u8),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0,
+ .offset = offsetof(struct usb_interface_descriptor_v01,
+ bNumEndpoints),
+ },
+ {
+ .data_type = QMI_UNSIGNED_1_BYTE,
+ .elem_len = 1,
+ .elem_size = sizeof(u8),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0,
+ .offset = offsetof(struct usb_interface_descriptor_v01,
+ bInterfaceClass),
+ },
+ {
+ .data_type = QMI_UNSIGNED_1_BYTE,
+ .elem_len = 1,
+ .elem_size = sizeof(u8),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0,
+ .offset = offsetof(struct usb_interface_descriptor_v01,
+ bInterfaceSubClass),
+ },
+ {
+ .data_type = QMI_UNSIGNED_1_BYTE,
+ .elem_len = 1,
+ .elem_size = sizeof(u8),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0,
+ .offset = offsetof(struct usb_interface_descriptor_v01,
+ bInterfaceProtocol),
+ },
+ {
+ .data_type = QMI_UNSIGNED_1_BYTE,
+ .elem_len = 1,
+ .elem_size = sizeof(u8),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0,
+ .offset = offsetof(struct usb_interface_descriptor_v01,
+ iInterface),
+ },
+ {
+ .data_type = QMI_EOTI,
+ .array_type = NO_ARRAY,
+ .tlv_type = QMI_COMMON_TLV_TYPE,
+ },
+};
+
+struct qmi_elem_info qmi_uaudio_stream_req_msg_v01_ei[] = {
+ {
+ .data_type = QMI_UNSIGNED_1_BYTE,
+ .elem_len = 1,
+ .elem_size = sizeof(u8),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0x01,
+ .offset = offsetof(struct qmi_uaudio_stream_req_msg_v01,
+ enable),
+ },
+ {
+ .data_type = QMI_UNSIGNED_4_BYTE,
+ .elem_len = 1,
+ .elem_size = sizeof(u32),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0x02,
+ .offset = offsetof(struct qmi_uaudio_stream_req_msg_v01,
+ usb_token),
+ },
+ {
+ .data_type = QMI_OPT_FLAG,
+ .elem_len = 1,
+ .elem_size = sizeof(u8),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0x10,
+ .offset = offsetof(struct qmi_uaudio_stream_req_msg_v01,
+ audio_format_valid),
+ },
+ {
+ .data_type = QMI_UNSIGNED_4_BYTE,
+ .elem_len = 1,
+ .elem_size = sizeof(u32),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0x10,
+ .offset = offsetof(struct qmi_uaudio_stream_req_msg_v01,
+ audio_format),
+ },
+ {
+ .data_type = QMI_OPT_FLAG,
+ .elem_len = 1,
+ .elem_size = sizeof(u8),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0x11,
+ .offset = offsetof(struct qmi_uaudio_stream_req_msg_v01,
+ number_of_ch_valid),
+ },
+ {
+ .data_type = QMI_UNSIGNED_4_BYTE,
+ .elem_len = 1,
+ .elem_size = sizeof(u32),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0x11,
+ .offset = offsetof(struct qmi_uaudio_stream_req_msg_v01,
+ number_of_ch),
+ },
+ {
+ .data_type = QMI_OPT_FLAG,
+ .elem_len = 1,
+ .elem_size = sizeof(u8),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0x12,
+ .offset = offsetof(struct qmi_uaudio_stream_req_msg_v01,
+ bit_rate_valid),
+ },
+ {
+ .data_type = QMI_UNSIGNED_4_BYTE,
+ .elem_len = 1,
+ .elem_size = sizeof(u32),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0x12,
+ .offset = offsetof(struct qmi_uaudio_stream_req_msg_v01,
+ bit_rate),
+ },
+ {
+ .data_type = QMI_OPT_FLAG,
+ .elem_len = 1,
+ .elem_size = sizeof(u8),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0x13,
+ .offset = offsetof(struct qmi_uaudio_stream_req_msg_v01,
+ xfer_buff_size_valid),
+ },
+ {
+ .data_type = QMI_UNSIGNED_4_BYTE,
+ .elem_len = 1,
+ .elem_size = sizeof(u32),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0x13,
+ .offset = offsetof(struct qmi_uaudio_stream_req_msg_v01,
+ xfer_buff_size),
+ },
+ {
+ .data_type = QMI_OPT_FLAG,
+ .elem_len = 1,
+ .elem_size = sizeof(u8),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0x14,
+ .offset = offsetof(struct qmi_uaudio_stream_req_msg_v01,
+ service_interval_valid),
+ },
+ {
+ .data_type = QMI_UNSIGNED_4_BYTE,
+ .elem_len = 1,
+ .elem_size = sizeof(u32),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0x14,
+ .offset = offsetof(struct qmi_uaudio_stream_req_msg_v01,
+ service_interval),
+ },
+ {
+ .data_type = QMI_EOTI,
+ .array_type = NO_ARRAY,
+ .tlv_type = QMI_COMMON_TLV_TYPE,
+ },
+};
+
+struct qmi_elem_info qmi_uaudio_stream_resp_msg_v01_ei[] = {
+ {
+ .data_type = QMI_STRUCT,
+ .elem_len = 1,
+ .elem_size = sizeof(struct qmi_response_type_v01),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0x02,
+ .offset = offsetof(
+ struct qmi_uaudio_stream_resp_msg_v01,
+ resp),
+ .ei_array = qmi_response_type_v01_ei,
+ },
+ {
+ .data_type = QMI_OPT_FLAG,
+ .elem_len = 1,
+ .elem_size = sizeof(u8),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0x10,
+ .offset = offsetof(
+ struct qmi_uaudio_stream_resp_msg_v01,
+ status_valid),
+ },
+ {
+ .data_type = QMI_SIGNED_4_BYTE_ENUM,
+ .elem_len = 1,
+ .elem_size = sizeof(enum usb_audio_stream_status_enum_v01),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0x10,
+ .offset = offsetof(
+ struct qmi_uaudio_stream_resp_msg_v01,
+ status),
+ },
+ {
+ .data_type = QMI_OPT_FLAG,
+ .elem_len = 1,
+ .elem_size = sizeof(u8),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0x11,
+ .offset = offsetof(
+ struct qmi_uaudio_stream_resp_msg_v01,
+ internal_status_valid),
+ },
+ {
+ .data_type = QMI_UNSIGNED_4_BYTE,
+ .elem_len = 1,
+ .elem_size = sizeof(u32),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0x11,
+ .offset = offsetof(
+ struct qmi_uaudio_stream_resp_msg_v01,
+ internal_status),
+ },
+ {
+ .data_type = QMI_OPT_FLAG,
+ .elem_len = 1,
+ .elem_size = sizeof(u8),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0x12,
+ .offset = offsetof(
+ struct qmi_uaudio_stream_resp_msg_v01,
+ slot_id_valid),
+ },
+ {
+ .data_type = QMI_UNSIGNED_4_BYTE,
+ .elem_len = 1,
+ .elem_size = sizeof(u32),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0x12,
+ .offset = offsetof(
+ struct qmi_uaudio_stream_resp_msg_v01,
+ slot_id),
+ },
+ {
+ .data_type = QMI_OPT_FLAG,
+ .elem_len = 1,
+ .elem_size = sizeof(u8),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0x13,
+ .offset = offsetof(
+ struct qmi_uaudio_stream_resp_msg_v01,
+ usb_token_valid),
+ },
+ {
+ .data_type = QMI_UNSIGNED_4_BYTE,
+ .elem_len = 1,
+ .elem_size = sizeof(u32),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0x13,
+ .offset = offsetof(
+ struct qmi_uaudio_stream_resp_msg_v01,
+ usb_token),
+ },
+ {
+ .data_type = QMI_OPT_FLAG,
+ .elem_len = 1,
+ .elem_size = sizeof(u8),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0x14,
+ .offset = offsetof(
+ struct qmi_uaudio_stream_resp_msg_v01,
+ std_as_opr_intf_desc_valid),
+ },
+ {
+ .data_type = QMI_STRUCT,
+ .elem_len = 1,
+ .elem_size = sizeof(struct usb_interface_descriptor_v01),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0x14,
+ .offset = offsetof(
+ struct qmi_uaudio_stream_resp_msg_v01,
+ std_as_opr_intf_desc),
+ .ei_array = usb_interface_descriptor_v01_ei,
+ },
+ {
+ .data_type = QMI_OPT_FLAG,
+ .elem_len = 1,
+ .elem_size = sizeof(u8),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0x15,
+ .offset = offsetof(
+ struct qmi_uaudio_stream_resp_msg_v01,
+ std_as_data_ep_desc_valid),
+ },
+ {
+ .data_type = QMI_STRUCT,
+ .elem_len = 1,
+ .elem_size = sizeof(struct usb_endpoint_descriptor_v01),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0x15,
+ .offset = offsetof(
+ struct qmi_uaudio_stream_resp_msg_v01,
+ std_as_data_ep_desc),
+ .ei_array = usb_endpoint_descriptor_v01_ei,
+ },
+ {
+ .data_type = QMI_OPT_FLAG,
+ .elem_len = 1,
+ .elem_size = sizeof(u8),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0x16,
+ .offset = offsetof(
+ struct qmi_uaudio_stream_resp_msg_v01,
+ std_as_sync_ep_desc_valid),
+ },
+ {
+ .data_type = QMI_STRUCT,
+ .elem_len = 1,
+ .elem_size = sizeof(struct usb_endpoint_descriptor_v01),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0x16,
+ .offset = offsetof(
+ struct qmi_uaudio_stream_resp_msg_v01,
+ std_as_sync_ep_desc),
+ .ei_array = usb_endpoint_descriptor_v01_ei,
+ },
+ {
+ .data_type = QMI_OPT_FLAG,
+ .elem_len = 1,
+ .elem_size = sizeof(u8),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0x17,
+ .offset = offsetof(
+ struct qmi_uaudio_stream_resp_msg_v01,
+ usb_audio_spec_revision_valid),
+ },
+ {
+ .data_type = QMI_UNSIGNED_2_BYTE,
+ .elem_len = 1,
+ .elem_size = sizeof(u16),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0x17,
+ .offset = offsetof(
+ struct qmi_uaudio_stream_resp_msg_v01,
+ usb_audio_spec_revision),
+ },
+ {
+ .data_type = QMI_OPT_FLAG,
+ .elem_len = 1,
+ .elem_size = sizeof(u8),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0x18,
+ .offset = offsetof(
+ struct qmi_uaudio_stream_resp_msg_v01,
+ data_path_delay_valid),
+ },
+ {
+ .data_type = QMI_UNSIGNED_1_BYTE,
+ .elem_len = 1,
+ .elem_size = sizeof(u8),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0x18,
+ .offset = offsetof(
+ struct qmi_uaudio_stream_resp_msg_v01,
+ data_path_delay),
+ },
+ {
+ .data_type = QMI_OPT_FLAG,
+ .elem_len = 1,
+ .elem_size = sizeof(u8),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0x19,
+ .offset = offsetof(
+ struct qmi_uaudio_stream_resp_msg_v01,
+ usb_audio_subslot_size_valid),
+ },
+ {
+ .data_type = QMI_UNSIGNED_1_BYTE,
+ .elem_len = 1,
+ .elem_size = sizeof(u8),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0x19,
+ .offset = offsetof(
+ struct qmi_uaudio_stream_resp_msg_v01,
+ usb_audio_subslot_size),
+ },
+ {
+ .data_type = QMI_OPT_FLAG,
+ .elem_len = 1,
+ .elem_size = sizeof(u8),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0x1A,
+ .offset = offsetof(
+ struct qmi_uaudio_stream_resp_msg_v01,
+ xhci_mem_info_valid),
+ },
+ {
+ .data_type = QMI_STRUCT,
+ .elem_len = 1,
+ .elem_size = sizeof(struct apps_mem_info_v01),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0x1A,
+ .offset = offsetof(
+ struct qmi_uaudio_stream_resp_msg_v01,
+ xhci_mem_info),
+ .ei_array = apps_mem_info_v01_ei,
+ },
+ {
+ .data_type = QMI_OPT_FLAG,
+ .elem_len = 1,
+ .elem_size = sizeof(u8),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0x1B,
+ .offset = offsetof(
+ struct qmi_uaudio_stream_resp_msg_v01,
+ interrupter_num_valid),
+ },
+ {
+ .data_type = QMI_UNSIGNED_1_BYTE,
+ .elem_len = 1,
+ .elem_size = sizeof(u8),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0x1B,
+ .offset = offsetof(
+ struct qmi_uaudio_stream_resp_msg_v01,
+ interrupter_num),
+ },
+ {
+ .data_type = QMI_OPT_FLAG,
+ .elem_len = 1,
+ .elem_size = sizeof(u8),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0x1C,
+ .offset = offsetof(
+ struct qmi_uaudio_stream_resp_msg_v01,
+ speed_info_valid),
+ },
+ {
+ .data_type = QMI_SIGNED_4_BYTE_ENUM,
+ .elem_len = 1,
+ .elem_size = sizeof(enum usb_audio_device_speed_enum_v01),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0x1C,
+ .offset = offsetof(
+ struct qmi_uaudio_stream_resp_msg_v01,
+ speed_info),
+ },
+ {
+ .data_type = QMI_OPT_FLAG,
+ .elem_len = 1,
+ .elem_size = sizeof(u8),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0x1D,
+ .offset = offsetof(
+ struct qmi_uaudio_stream_resp_msg_v01,
+ controller_num_valid),
+ },
+ {
+ .data_type = QMI_UNSIGNED_1_BYTE,
+ .elem_len = 1,
+ .elem_size = sizeof(u8),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0x1D,
+ .offset = offsetof(
+ struct qmi_uaudio_stream_resp_msg_v01,
+ controller_num),
+ },
+ {
+ .data_type = QMI_EOTI,
+ .array_type = NO_ARRAY,
+ .tlv_type = QMI_COMMON_TLV_TYPE,
+ },
+};
+
+struct qmi_elem_info qmi_uaudio_stream_ind_msg_v01_ei[] = {
+ {
+ .data_type = QMI_SIGNED_4_BYTE_ENUM,
+ .elem_len = 1,
+ .elem_size = sizeof(
+ enum usb_audio_device_indication_enum_v01),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0x01,
+ .offset = offsetof(struct qmi_uaudio_stream_ind_msg_v01,
+ dev_event),
+ },
+ {
+ .data_type = QMI_UNSIGNED_4_BYTE,
+ .elem_len = 1,
+ .elem_size = sizeof(u32),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0x02,
+ .offset = offsetof(struct qmi_uaudio_stream_ind_msg_v01,
+ slot_id),
+ },
+ {
+ .data_type = QMI_OPT_FLAG,
+ .elem_len = 1,
+ .elem_size = sizeof(u8),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0x10,
+ .offset = offsetof(struct qmi_uaudio_stream_ind_msg_v01,
+ usb_token_valid),
+ },
+ {
+ .data_type = QMI_UNSIGNED_4_BYTE,
+ .elem_len = 1,
+ .elem_size = sizeof(u32),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0x10,
+ .offset = offsetof(struct qmi_uaudio_stream_ind_msg_v01,
+ usb_token),
+ },
+ {
+ .data_type = QMI_OPT_FLAG,
+ .elem_len = 1,
+ .elem_size = sizeof(u8),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0x11,
+ .offset = offsetof(struct qmi_uaudio_stream_ind_msg_v01,
+ std_as_opr_intf_desc_valid),
+ },
+ {
+ .data_type = QMI_STRUCT,
+ .elem_len = 1,
+ .elem_size = sizeof(struct usb_interface_descriptor_v01),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0x11,
+ .offset = offsetof(struct qmi_uaudio_stream_ind_msg_v01,
+ std_as_opr_intf_desc),
+ .ei_array = usb_interface_descriptor_v01_ei,
+ },
+ {
+ .data_type = QMI_OPT_FLAG,
+ .elem_len = 1,
+ .elem_size = sizeof(u8),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0x12,
+ .offset = offsetof(struct qmi_uaudio_stream_ind_msg_v01,
+ std_as_data_ep_desc_valid),
+ },
+ {
+ .data_type = QMI_STRUCT,
+ .elem_len = 1,
+ .elem_size = sizeof(struct usb_endpoint_descriptor_v01),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0x12,
+ .offset = offsetof(struct qmi_uaudio_stream_ind_msg_v01,
+ std_as_data_ep_desc),
+ .ei_array = usb_endpoint_descriptor_v01_ei,
+ },
+ {
+ .data_type = QMI_OPT_FLAG,
+ .elem_len = 1,
+ .elem_size = sizeof(u8),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0x13,
+ .offset = offsetof(struct qmi_uaudio_stream_ind_msg_v01,
+ std_as_sync_ep_desc_valid),
+ },
+ {
+ .data_type = QMI_STRUCT,
+ .elem_len = 1,
+ .elem_size = sizeof(struct usb_endpoint_descriptor_v01),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0x13,
+ .offset = offsetof(struct qmi_uaudio_stream_ind_msg_v01,
+ std_as_sync_ep_desc),
+ .ei_array = usb_endpoint_descriptor_v01_ei,
+ },
+ {
+ .data_type = QMI_OPT_FLAG,
+ .elem_len = 1,
+ .elem_size = sizeof(u8),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0x14,
+ .offset = offsetof(struct qmi_uaudio_stream_ind_msg_v01,
+ usb_audio_spec_revision_valid),
+ },
+ {
+ .data_type = QMI_UNSIGNED_2_BYTE,
+ .elem_len = 1,
+ .elem_size = sizeof(u16),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0x14,
+ .offset = offsetof(struct qmi_uaudio_stream_ind_msg_v01,
+ usb_audio_spec_revision),
+ },
+ {
+ .data_type = QMI_OPT_FLAG,
+ .elem_len = 1,
+ .elem_size = sizeof(u8),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0x15,
+ .offset = offsetof(struct qmi_uaudio_stream_ind_msg_v01,
+ data_path_delay_valid),
+ },
+ {
+ .data_type = QMI_UNSIGNED_1_BYTE,
+ .elem_len = 1,
+ .elem_size = sizeof(u8),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0x15,
+ .offset = offsetof(struct qmi_uaudio_stream_ind_msg_v01,
+ data_path_delay),
+ },
+ {
+ .data_type = QMI_OPT_FLAG,
+ .elem_len = 1,
+ .elem_size = sizeof(u8),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0x16,
+ .offset = offsetof(struct qmi_uaudio_stream_ind_msg_v01,
+ usb_audio_subslot_size_valid),
+ },
+ {
+ .data_type = QMI_UNSIGNED_1_BYTE,
+ .elem_len = 1,
+ .elem_size = sizeof(u8),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0x16,
+ .offset = offsetof(struct qmi_uaudio_stream_ind_msg_v01,
+ usb_audio_subslot_size),
+ },
+ {
+ .data_type = QMI_OPT_FLAG,
+ .elem_len = 1,
+ .elem_size = sizeof(u8),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0x17,
+ .offset = offsetof(struct qmi_uaudio_stream_ind_msg_v01,
+ xhci_mem_info_valid),
+ },
+ {
+ .data_type = QMI_STRUCT,
+ .elem_len = 1,
+ .elem_size = sizeof(struct apps_mem_info_v01),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0x17,
+ .offset = offsetof(struct qmi_uaudio_stream_ind_msg_v01,
+ xhci_mem_info),
+ .ei_array = apps_mem_info_v01_ei,
+ },
+ {
+ .data_type = QMI_OPT_FLAG,
+ .elem_len = 1,
+ .elem_size = sizeof(u8),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0x18,
+ .offset = offsetof(struct qmi_uaudio_stream_ind_msg_v01,
+ interrupter_num_valid),
+ },
+ {
+ .data_type = QMI_UNSIGNED_1_BYTE,
+ .elem_len = 1,
+ .elem_size = sizeof(u8),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0x18,
+ .offset = offsetof(struct qmi_uaudio_stream_ind_msg_v01,
+ interrupter_num),
+ },
+ {
+ .data_type = QMI_OPT_FLAG,
+ .elem_len = 1,
+ .elem_size = sizeof(u8),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0x19,
+ .offset = offsetof(struct qmi_uaudio_stream_ind_msg_v01,
+ controller_num_valid),
+ },
+ {
+ .data_type = QMI_UNSIGNED_1_BYTE,
+ .elem_len = 1,
+ .elem_size = sizeof(u8),
+ .array_type = NO_ARRAY,
+ .tlv_type = 0x19,
+ .offset = offsetof(struct qmi_uaudio_stream_ind_msg_v01,
+ controller_num),
+ },
+ {
+ .data_type = QMI_EOTI,
+ .array_type = NO_ARRAY,
+ .tlv_type = QMI_COMMON_TLV_TYPE,
+ },
+};
diff --git a/sound/usb/qcom/usb_audio_qmi_v01.h b/sound/usb/qcom/usb_audio_qmi_v01.h
new file mode 100644
index 000000000000..a30ae2618b95
--- /dev/null
+++ b/sound/usb/qcom/usb_audio_qmi_v01.h
@@ -0,0 +1,162 @@
+/* SPDX-License-Identifier: GPL-2.0
+ *
+ * Copyright (c) 2022-2023 Qualcomm Innovation Center, Inc. All rights reserved.
+ */
+
+#ifndef USB_QMI_V01_H
+#define USB_QMI_V01_H
+
+#define UAUDIO_STREAM_SERVICE_ID_V01 0x41D
+#define UAUDIO_STREAM_SERVICE_VERS_V01 0x01
+
+#define QMI_UAUDIO_STREAM_RESP_V01 0x0001
+#define QMI_UAUDIO_STREAM_REQ_V01 0x0001
+#define QMI_UAUDIO_STREAM_IND_V01 0x0001
+
+
+struct mem_info_v01 {
+ u64 va;
+ u64 pa;
+ u32 size;
+};
+
+struct apps_mem_info_v01 {
+ struct mem_info_v01 evt_ring;
+ struct mem_info_v01 tr_data;
+ struct mem_info_v01 tr_sync;
+ struct mem_info_v01 xfer_buff;
+ struct mem_info_v01 dcba;
+};
+
+struct usb_endpoint_descriptor_v01 {
+ u8 bLength;
+ u8 bDescriptorType;
+ u8 bEndpointAddress;
+ u8 bmAttributes;
+ u16 wMaxPacketSize;
+ u8 bInterval;
+ u8 bRefresh;
+ u8 bSynchAddress;
+};
+
+struct usb_interface_descriptor_v01 {
+ u8 bLength;
+ u8 bDescriptorType;
+ u8 bInterfaceNumber;
+ u8 bAlternateSetting;
+ u8 bNumEndpoints;
+ u8 bInterfaceClass;
+ u8 bInterfaceSubClass;
+ u8 bInterfaceProtocol;
+ u8 iInterface;
+};
+
+enum usb_audio_stream_status_enum_v01 {
+ USB_AUDIO_STREAM_STATUS_ENUM_MIN_VAL_V01 = INT_MIN,
+ USB_AUDIO_STREAM_REQ_SUCCESS_V01 = 0,
+ USB_AUDIO_STREAM_REQ_FAILURE_V01 = 1,
+ USB_AUDIO_STREAM_REQ_FAILURE_NOT_FOUND_V01 = 2,
+ USB_AUDIO_STREAM_REQ_FAILURE_INVALID_PARAM_V01 = 3,
+ USB_AUDIO_STREAM_REQ_FAILURE_MEMALLOC_V01 = 4,
+ USB_AUDIO_STREAM_STATUS_ENUM_MAX_VAL_V01 = INT_MAX,
+};
+
+enum usb_audio_device_indication_enum_v01 {
+ USB_AUDIO_DEVICE_INDICATION_ENUM_MIN_VAL_V01 = INT_MIN,
+ USB_AUDIO_DEV_CONNECT_V01 = 0,
+ USB_AUDIO_DEV_DISCONNECT_V01 = 1,
+ USB_AUDIO_DEV_SUSPEND_V01 = 2,
+ USB_AUDIO_DEV_RESUME_V01 = 3,
+ USB_AUDIO_DEVICE_INDICATION_ENUM_MAX_VAL_V01 = INT_MAX,
+};
+
+enum usb_audio_device_speed_enum_v01 {
+ USB_AUDIO_DEVICE_SPEED_ENUM_MIN_VAL_V01 = INT_MIN,
+ USB_AUDIO_DEVICE_SPEED_INVALID_V01 = 0,
+ USB_AUDIO_DEVICE_SPEED_LOW_V01 = 1,
+ USB_AUDIO_DEVICE_SPEED_FULL_V01 = 2,
+ USB_AUDIO_DEVICE_SPEED_HIGH_V01 = 3,
+ USB_AUDIO_DEVICE_SPEED_SUPER_V01 = 4,
+ USB_AUDIO_DEVICE_SPEED_SUPER_PLUS_V01 = 5,
+ USB_AUDIO_DEVICE_SPEED_ENUM_MAX_VAL_V01 = INT_MAX,
+};
+
+struct qmi_uaudio_stream_req_msg_v01 {
+ u8 enable;
+ u32 usb_token;
+ u8 audio_format_valid;
+ u32 audio_format;
+ u8 number_of_ch_valid;
+ u32 number_of_ch;
+ u8 bit_rate_valid;
+ u32 bit_rate;
+ u8 xfer_buff_size_valid;
+ u32 xfer_buff_size;
+ u8 service_interval_valid;
+ u32 service_interval;
+};
+#define QMI_UAUDIO_STREAM_REQ_MSG_V01_MAX_MSG_LEN 46
+extern struct qmi_elem_info qmi_uaudio_stream_req_msg_v01_ei[];
+
+struct qmi_uaudio_stream_resp_msg_v01 {
+ struct qmi_response_type_v01 resp;
+ u8 status_valid;
+ enum usb_audio_stream_status_enum_v01 status;
+ u8 internal_status_valid;
+ u32 internal_status;
+ u8 slot_id_valid;
+ u32 slot_id;
+ u8 usb_token_valid;
+ u32 usb_token;
+ u8 std_as_opr_intf_desc_valid;
+ struct usb_interface_descriptor_v01 std_as_opr_intf_desc;
+ u8 std_as_data_ep_desc_valid;
+ struct usb_endpoint_descriptor_v01 std_as_data_ep_desc;
+ u8 std_as_sync_ep_desc_valid;
+ struct usb_endpoint_descriptor_v01 std_as_sync_ep_desc;
+ u8 usb_audio_spec_revision_valid;
+ u16 usb_audio_spec_revision;
+ u8 data_path_delay_valid;
+ u8 data_path_delay;
+ u8 usb_audio_subslot_size_valid;
+ u8 usb_audio_subslot_size;
+ u8 xhci_mem_info_valid;
+ struct apps_mem_info_v01 xhci_mem_info;
+ u8 interrupter_num_valid;
+ u8 interrupter_num;
+ u8 speed_info_valid;
+ enum usb_audio_device_speed_enum_v01 speed_info;
+ u8 controller_num_valid;
+ u8 controller_num;
+};
+#define QMI_UAUDIO_STREAM_RESP_MSG_V01_MAX_MSG_LEN 202
+extern struct qmi_elem_info qmi_uaudio_stream_resp_msg_v01_ei[];
+
+struct qmi_uaudio_stream_ind_msg_v01 {
+ enum usb_audio_device_indication_enum_v01 dev_event;
+ u32 slot_id;
+ u8 usb_token_valid;
+ u32 usb_token;
+ u8 std_as_opr_intf_desc_valid;
+ struct usb_interface_descriptor_v01 std_as_opr_intf_desc;
+ u8 std_as_data_ep_desc_valid;
+ struct usb_endpoint_descriptor_v01 std_as_data_ep_desc;
+ u8 std_as_sync_ep_desc_valid;
+ struct usb_endpoint_descriptor_v01 std_as_sync_ep_desc;
+ u8 usb_audio_spec_revision_valid;
+ u16 usb_audio_spec_revision;
+ u8 data_path_delay_valid;
+ u8 data_path_delay;
+ u8 usb_audio_subslot_size_valid;
+ u8 usb_audio_subslot_size;
+ u8 xhci_mem_info_valid;
+ struct apps_mem_info_v01 xhci_mem_info;
+ u8 interrupter_num_valid;
+ u8 interrupter_num;
+ u8 controller_num_valid;
+ u8 controller_num;
+};
+#define QMI_UAUDIO_STREAM_IND_MSG_V01_MAX_MSG_LEN 181
+extern struct qmi_elem_info qmi_uaudio_stream_ind_msg_v01_ei[];
+
+#endif
Some modules will handle calling snd_usb_endpoint_open() instead of the USB
SND framework. The USB SND endpoint open function added a new argument to
determine if the connect USB device can support multiple sampling rates.
Signed-off-by: Wesley Cheng <[email protected]>
---
sound/usb/pcm.c | 1 +
1 file changed, 1 insertion(+)
diff --git a/sound/usb/pcm.c b/sound/usb/pcm.c
index 4576a36dc9b2..482c160cbc17 100644
--- a/sound/usb/pcm.c
+++ b/sound/usb/pcm.c
@@ -186,6 +186,7 @@ bool snd_usb_pcm_has_fixed_rate(struct snd_usb_substream *subs)
}
return true;
}
+EXPORT_SYMBOL_GPL(snd_usb_pcm_has_fixed_rate);
static int init_pitch_v1(struct snd_usb_audio *chip, int ep)
{
On Wed, Mar 08, 2023 at 03:57:33PM -0800, Wesley Cheng wrote:
> -static const struct audioformat *
> +const struct audioformat *
> find_format(struct list_head *fmt_list_head, snd_pcm_format_t format,
> unsigned int rate, unsigned int channels, bool strict_match,
> struct snd_usb_substream *subs)
> @@ -147,8 +147,9 @@ find_format(struct list_head *fmt_list_head, snd_pcm_format_t format,
> }
> return found;
> }
> +EXPORT_SYMBOL_GPL(find_format);
This is a horrible name for the global symbol namespace, right?
It needs a "snd_" prefix at the very least, maybe even more.
>
> -static const struct audioformat *
> +const struct audioformat *
> find_substream_format(struct snd_usb_substream *subs,
> const struct snd_pcm_hw_params *params)
> {
> @@ -156,6 +157,7 @@ find_substream_format(struct snd_usb_substream *subs,
> params_rate(params), params_channels(params),
> true, subs);
> }
> +EXPORT_SYMBOL_GPL(find_substream_format);
Same here.
>
> bool snd_usb_pcm_has_fixed_rate(struct snd_usb_substream *subs)
> {
> @@ -446,7 +448,7 @@ int snd_usb_pcm_resume(struct snd_usb_stream *as)
> return 0;
> }
>
> -static void close_endpoints(struct snd_usb_audio *chip,
> +void close_endpoints(struct snd_usb_audio *chip,
> struct snd_usb_substream *subs)
> {
> if (subs->data_endpoint) {
> @@ -460,6 +462,7 @@ static void close_endpoints(struct snd_usb_audio *chip,
> subs->sync_endpoint = NULL;
> }
> }
> +EXPORT_SYMBOL(close_endpoints);
Same here.
thanks,
greg k-h
On Wed, Mar 08, 2023 at 03:57:25PM -0800, Wesley Cheng wrote:
> Some use cases, such as USB audio offloading, will allow for a DSP to take
> over issuing USB transfers to the host controller. In order for the DSP to
> submit transfers for a particular endpoint, and to handle its events, the
> client driver will need to query for some parameters allocated by XHCI.
>
> - XHCI secondary interrupter event ring address
> - XHCI transfer ring address (for a particular EP)
> - Stop endpoint command API
>
> Once the resources are handed off to the DSP, the offload begins, and the
> main processor can enter idle. When stopped, since there are no URBs
> submitted from the main processor, the client will just issue a stop
> endpoint command to halt any pending transfers.
>
> Signed-off-by: Wesley Cheng <[email protected]>
> ---
> drivers/usb/host/xhci.c | 130 ++++++++++++++++++++++++++++++++++
> include/linux/usb/xhci-intr.h | 8 +++
> 2 files changed, 138 insertions(+)
Please use checkpatch.pl on your patches before sending them out :(
Some other minor comments:
> diff --git a/drivers/usb/host/xhci.c b/drivers/usb/host/xhci.c
> index 88435b9cd66e..5c6b3d8f834c 100644
> --- a/drivers/usb/host/xhci.c
> +++ b/drivers/usb/host/xhci.c
> @@ -1603,6 +1603,136 @@ static int xhci_check_args(struct usb_hcd *hcd, struct usb_device *udev,
> return 1;
> }
>
> +int xhci_stop_endpoint(struct usb_device *udev,
> + struct usb_host_endpoint *ep)
That all can be on one line, right?
And no documentation for a global function?
> +{
> + struct usb_hcd *hcd = bus_to_hcd(udev->bus);
> + struct xhci_hcd *xhci = hcd_to_xhci(hcd);
> + unsigned int ep_index;
> + struct xhci_virt_device *virt_dev;
> + struct xhci_command *cmd;
> + unsigned long flags;
> + int ret = 0;
> +
> + ret = xhci_check_args(hcd, udev, ep, 1, true, __func__);
> + if (ret <= 0)
> + return ret;
> +
> + cmd = xhci_alloc_command(xhci, true, GFP_NOIO);
> + if (!cmd)
> + return -ENOMEM;
> +
> + spin_lock_irqsave(&xhci->lock, flags);
> + virt_dev = xhci->devs[udev->slot_id];
> + if (!virt_dev) {
> + ret = -ENODEV;
> + goto err;
> + }
> +
> + ep_index = xhci_get_endpoint_index(&ep->desc);
> + if (virt_dev->eps[ep_index].ring &&
> + virt_dev->eps[ep_index].ring->dequeue) {
> + ret = xhci_queue_stop_endpoint(xhci, cmd, udev->slot_id,
> + ep_index, 0);
> + if (ret)
> + goto err;
> +
> + xhci_ring_cmd_db(xhci);
> + spin_unlock_irqrestore(&xhci->lock, flags);
> +
> + /* Wait for stop endpoint command to finish */
> + wait_for_completion(cmd->completion);
> +
> + if (cmd->status == COMP_COMMAND_ABORTED ||
> + cmd->status == COMP_STOPPED) {
> + xhci_warn(xhci,
> + "stop endpoint command timeout for ep%d%s\n",
> + usb_endpoint_num(&ep->desc),
> + usb_endpoint_dir_in(&ep->desc) ? "in" : "out");
> + ret = -ETIME;
> + }
> + goto free_cmd;
> + }
> +
> +err:
> + spin_unlock_irqrestore(&xhci->lock, flags);
> +free_cmd:
> + xhci_free_command(xhci, cmd);
> +
> + return ret;
> +}
> +EXPORT_SYMBOL_GPL(xhci_stop_endpoint);
> +
> +/* Retrieve the transfer ring base address for a specific endpoint. */
At least some comment, but not much for a global function.
> +phys_addr_t xhci_get_xfer_resource(struct usb_device *udev,
> + struct usb_host_endpoint *ep, dma_addr_t *dma)
> +{
> + struct usb_hcd *hcd = bus_to_hcd(udev->bus);
> + struct device *dev = hcd->self.sysdev;
> + struct xhci_hcd *xhci = hcd_to_xhci(hcd);
> + struct sg_table sgt;
> + phys_addr_t pa;
> + int ret;
> + unsigned int ep_index;
> + struct xhci_virt_device *virt_dev;
> + unsigned long flags;
> +
> + if (!HCD_RH_RUNNING(hcd))
> + return 0;
Isn't 0 a valid address?
> +
> + ret = xhci_check_args(hcd, udev, ep, 1, true, __func__);
> + if (ret <= 0) {
> + xhci_err(xhci, "%s: invalid args\n", __func__);
> + return 0;
> + }
> +
> + spin_lock_irqsave(&xhci->lock, flags);
> +
> + virt_dev = xhci->devs[udev->slot_id];
> + ep_index = xhci_get_endpoint_index(&ep->desc);
> +
> + if (virt_dev->eps[ep_index].ring &&
> + virt_dev->eps[ep_index].ring->first_seg) {
> +
> + dma_get_sgtable(dev, &sgt,
> + virt_dev->eps[ep_index].ring->first_seg->trbs,
> + virt_dev->eps[ep_index].ring->first_seg->dma,
> + TRB_SEGMENT_SIZE);
> +
> + *dma = virt_dev->eps[ep_index].ring->first_seg->dma;
> +
> + pa = page_to_phys(sg_page(sgt.sgl));
> + sg_free_table(&sgt);
> + spin_unlock_irqrestore(&xhci->lock, flags);
> +
> + return pa;
> + }
> + spin_unlock_irqrestore(&xhci->lock, flags);
> +
> + return 0;
> +}
> +EXPORT_SYMBOL_GPL(xhci_get_xfer_resource);
> +
> +phys_addr_t xhci_get_ir_resource(struct usb_device *udev, struct xhci_interrupter *ir)
kerneldoc for global functions?
> +{
> + struct usb_hcd *hcd = bus_to_hcd(udev->bus);
> + struct device *dev = hcd->self.sysdev;
> + struct sg_table sgt;
> + phys_addr_t pa;
> +
> + if (!ir)
> + return 0;
How can ir ever be NULL? You control the callers, just don't do that.
> +
> + dma_get_sgtable(dev, &sgt, ir->event_ring->first_seg->trbs,
> + ir->event_ring->first_seg->dma, TRB_SEGMENT_SIZE);
> +
> + pa = page_to_phys(sg_page(sgt.sgl));
> + sg_free_table(&sgt);
> +
> + return pa;
> +}
> +EXPORT_SYMBOL_GPL(xhci_get_ir_resource);
> +
> static int xhci_configure_endpoint(struct xhci_hcd *xhci,
> struct usb_device *udev, struct xhci_command *command,
> bool ctx_change, bool must_succeed);
> diff --git a/include/linux/usb/xhci-intr.h b/include/linux/usb/xhci-intr.h
> index 738b0f0481a6..d42cc9a1e698 100644
> --- a/include/linux/usb/xhci-intr.h
> +++ b/include/linux/usb/xhci-intr.h
> @@ -80,7 +80,15 @@ struct xhci_interrupter {
> u64 s3_erst_dequeue;
> };
>
> +/* Secondary interrupter */
> struct xhci_interrupter *
> xhci_create_secondary_interrupter(struct usb_hcd *hcd, int intr_num);
> void xhci_remove_secondary_interrupter(struct usb_hcd *hcd, struct xhci_interrupter *ir);
> +
> +/* Offload */
> +int xhci_stop_endpoint(struct usb_device *udev,
> + struct usb_host_endpoint *ep);
> +phys_addr_t xhci_get_xfer_resource(struct usb_device *udev,
> + struct usb_host_endpoint *ep, dma_addr_t *dma);
> +phys_addr_t xhci_get_ir_resource(struct usb_device *udev, struct xhci_interrupter *ir);
Why are these functions unique to offload?
thanks,
greg k-h
On Wed, Mar 08, 2023 at 03:57:27PM -0800, Wesley Cheng wrote:
> Some platforms may have support for offloading USB audio devices to a
> dedicated audio DSP. Introduce a set of APIs that allow for management of
> USB sound card and PCM devices enumerated by the USB SND class driver.
> This allows for the ASoC components to be aware of what USB devices are
> available for offloading.
>
> Signed-off-by: Wesley Cheng <[email protected]>
> ---
> include/sound/soc-usb.h | 35 ++++++++
> sound/soc/Makefile | 2 +-
> sound/soc/soc-usb.c | 180 ++++++++++++++++++++++++++++++++++++++++
> 3 files changed, 216 insertions(+), 1 deletion(-)
> create mode 100644 include/sound/soc-usb.h
> create mode 100644 sound/soc/soc-usb.c
>
> diff --git a/include/sound/soc-usb.h b/include/sound/soc-usb.h
> new file mode 100644
> index 000000000000..378992ea07bd
> --- /dev/null
> +++ b/include/sound/soc-usb.h
> @@ -0,0 +1,35 @@
> +/* SPDX-License-Identifier: GPL-2.0
> + *
> + * Copyright (c) 2022-2023 Qualcomm Innovation Center, Inc. All rights reserved.
> + */
> +
> +#ifndef __LINUX_SND_SOC_USB_H
> +#define __LINUX_SND_SOC_USB_H
> +
> +/**
> + * struct snd_soc_usb
> + * @list - list head for SND SOC struct list
> + * @dev - USB backend device reference
> + * @component - reference to DAPM component
> + * @connection_status_cb - callback to notify connection events
> + * @priv_data - driver data
> + **/
> +struct snd_soc_usb {
> + struct list_head list;
> + struct device *dev;
If this is a USB device, then make it a pointer to the real structure,
not just struct device.
> + struct snd_soc_component *component;
> + int (*connection_status_cb)(struct snd_soc_usb *usb, int card_idx,
> + int connected);
> + void *priv_data;
> +};
> +
> +int snd_soc_usb_connect(struct device *usbdev, int card_idx);
> +int snd_soc_usb_disconnect(struct device *usbdev);
> +void snd_soc_usb_set_priv_data(struct device *dev, void *priv);
> +void *snd_soc_usb_get_priv_data(struct device *usbdev);
Same here, you mix "dev" and "usbdev" in the names, make them real USB
devices please.
> +
> +struct snd_soc_usb *snd_soc_usb_add_port(struct device *dev, void *priv,
And here.
> + int (*connection_cb)(struct snd_soc_usb *usb, int card_idx,
> + int connected));
> +int snd_soc_usb_remove_port(struct device *dev);
> +#endif
> diff --git a/sound/soc/Makefile b/sound/soc/Makefile
> index 507eaed1d6a1..3305ceb59d84 100644
> --- a/sound/soc/Makefile
> +++ b/sound/soc/Makefile
> @@ -1,5 +1,5 @@
> # SPDX-License-Identifier: GPL-2.0
> -snd-soc-core-objs := soc-core.o soc-dapm.o soc-jack.o soc-utils.o soc-dai.o soc-component.o
> +snd-soc-core-objs := soc-core.o soc-dapm.o soc-jack.o soc-usb.o soc-utils.o soc-dai.o soc-component.o
> snd-soc-core-objs += soc-pcm.o soc-devres.o soc-ops.o soc-link.o soc-card.o
> snd-soc-core-$(CONFIG_SND_SOC_COMPRESS) += soc-compress.o
>
> diff --git a/sound/soc/soc-usb.c b/sound/soc/soc-usb.c
> new file mode 100644
> index 000000000000..4293451cdd49
> --- /dev/null
> +++ b/sound/soc/soc-usb.c
> @@ -0,0 +1,180 @@
> +// SPDX-License-Identifier: GPL-2.0
> +/*
> + * Copyright (c) 2022-2023 Qualcomm Innovation Center, Inc. All rights reserved.
> + */
> +#include <linux/of.h>
> +#include <linux/usb.h>
> +#include <sound/soc.h>
> +#include <sound/soc-usb.h>
> +#include "../usb/card.h"
> +
> +static DEFINE_MUTEX(ctx_mutex);
> +static LIST_HEAD(usb_ctx_list);
> +
> +static struct device_node *snd_soc_find_phandle(struct device *dev)
> +{
> + struct device_node *node;
> +
> + node = of_parse_phandle(dev->of_node, "usb-soc-be", 0);
> + if (!node)
> + return ERR_PTR(-ENODEV);
> +
> + return node;
> +}
> +
> +static struct snd_soc_usb *snd_soc_find_usb_ctx(struct device *dev)
> +{
> + struct device_node *node;
> + struct snd_soc_usb *ctx = NULL;
> +
> + node = snd_soc_find_phandle(dev);
> + if (IS_ERR(node))
> + return NULL;
> +
> + mutex_lock(&ctx_mutex);
> + list_for_each_entry(ctx, &usb_ctx_list, list) {
> + if (ctx->dev->of_node == node) {
> + of_node_put(node);
> + mutex_unlock(&ctx_mutex);
> + return ctx;
> + }
> + }
> + of_node_put(node);
> + mutex_unlock(&ctx_mutex);
> +
> + return NULL;
> +}
> +
> +/**
> + * snd_soc_usb_get_priv_data() - Retrieve private data stored
> + * @dev: device reference
> + *
> + * Fetch the private data stored in the USB SND SOC structure.
> + *
> + */
> +void *snd_soc_usb_get_priv_data(struct device *dev)
> +{
> + struct snd_soc_usb *ctx;
> +
> + ctx = snd_soc_find_usb_ctx(dev);
> + if (!ctx) {
> + /* Check if backend device */
> + list_for_each_entry(ctx, &usb_ctx_list, list) {
> + if (dev->of_node == ctx->dev->of_node)
> + goto out;
No locking for this list traversal?
thanks,
greg k-h
On Wed, Mar 08, 2023 at 03:57:23PM -0800, Wesley Cheng wrote:
> Changes in v3:
> - Changed prefix from RFC to PATCH
> - Rebased entire series to usb-next
> - Updated copyright years
This is much better, thanks. I've done some very brief high-level
skimming and found minor issues, and one major one. I'll let others
review this in more depth right now, as I am way behind in reviewing
other USB patches and need to get to them first.
thanks,
greg k-h
Hi,
On Wed, Mar 08, 2023 at 03:57:38PM -0800, Wesley Cheng wrote:
> diff --git a/sound/usb/qcom/qc_audio_offload.c b/sound/usb/qcom/qc_audio_offload.c
> new file mode 100644
> index 000000000000..2663906644f2
> --- /dev/null
> +++ b/sound/usb/qcom/qc_audio_offload.c
> ...
> +static int enable_audio_stream(struct snd_usb_substream *subs,
> + snd_pcm_format_t pcm_format,
> + unsigned int channels, unsigned int cur_rate,
> + int datainterval)
> +{
> + struct snd_usb_audio *chip = subs->stream->chip;
> + struct snd_pcm_hw_params params;
> + const struct audioformat *fmt;
> + int ret;
> + bool fixed_rate;
> +
> + _snd_pcm_hw_params_any(¶ms);
> + _snd_pcm_hw_param_set(¶ms, SNDRV_PCM_HW_PARAM_FORMAT,
> + (__force int) pcm_format, 0);
> + _snd_pcm_hw_param_set(¶ms, SNDRV_PCM_HW_PARAM_CHANNELS,
> + channels, 0);
> + _snd_pcm_hw_param_set(¶ms, SNDRV_PCM_HW_PARAM_RATE,
> + cur_rate, 0);
I think the above code is equivalent to below code.
```
// 1. Initialize the hardware parameter so that it expresses
// the maximum flags of mask parameters and the maximum range of integer
// parameters.
_snd_pcm_hw_params_any(¶ms);
// 2. Then shrink the mask parameters and integer parameters.
struct snd_mask *mask;
struct snd_interval *interval;
mask = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
snd_mask_leave(mask, pcm_format);
interval = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
snd_interval_setinteger(&interval);
interval.min = interval.max = channels;
interval = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
snd_interval_setinteger(&interval);
interval.min = interval.max = cur_rate;
```
In '[PATCH v3 10/28] sound: usb: Export USB SND APIs for modules', some
codes moved from ALSA Open Sound System compatibility layer to ALSA core
to export some kernel APIs. The '_snd_pcm_hw_param_set()' is one of
them. If they were needed just for the above operations, it would be
exaggerating just for the driver.
Of course, we can assume that the similar kernel API would be required
for the other drivers (OSS PCM, USB gadget, and so on.). However, at
present, it is preferable to focus just on your driver.
(I note that typical sound PCM driver has code to shrink hardware
parameters in PCM rule. It consists of a set of test and refine API.)
Regards
Takashi Sakamoto
On 08/03/2023 23:57, Wesley Cheng wrote:
> Q6DSP supports handling of USB playback audio data if USB audio offloading
> is enabled. Add a new definition for the USB_RX AFE port, which is
> referenced when the AFE port is started.
>
> Acked-by: Krzysztof Kozlowski <[email protected]>
> Signed-off-by: Wesley Cheng <[email protected]>
Reviewed-by: Srinivas Kandagatla <[email protected]>
> ---
> include/dt-bindings/sound/qcom,q6dsp-lpass-ports.h | 1 +
> 1 file changed, 1 insertion(+)
>
> diff --git a/include/dt-bindings/sound/qcom,q6dsp-lpass-ports.h b/include/dt-bindings/sound/qcom,q6dsp-lpass-ports.h
> index 9f7c5103bc82..746bc462bb2e 100644
> --- a/include/dt-bindings/sound/qcom,q6dsp-lpass-ports.h
> +++ b/include/dt-bindings/sound/qcom,q6dsp-lpass-ports.h
> @@ -131,6 +131,7 @@
> #define RX_CODEC_DMA_RX_7 126
> #define QUINARY_MI2S_RX 127
> #define QUINARY_MI2S_TX 128
> +#define USB_RX 129
>
> #define LPASS_CLK_ID_PRI_MI2S_IBIT 1
> #define LPASS_CLK_ID_PRI_MI2S_EBIT 2
On 08/03/2023 23:57, Wesley Cheng wrote:
> The QC ADSP is able to support USB playback endpoints, so that the main
> application processor can be placed into lower CPU power modes. This adds
> the required AFE port configurations and port start command to start an
> audio session.
>
> Specifically, the QC ADSP can support all potential endpoints that are
> exposed by the audio data interface. This includes, feedback endpoints
> (both implicit and explicit) as well as the isochronous (data) endpoints.
> The size of audio samples sent per USB frame (microframe) will be adjusted
> based on information received on the feedback endpoint.
>
> Signed-off-by: Wesley Cheng <[email protected]>
thanks for the work,
Reviewed-by: Srinivas Kandagatla <[email protected]>
> ---
> sound/soc/qcom/qdsp6/q6afe-dai.c | 50 ++++++
> sound/soc/qcom/qdsp6/q6afe.c | 185 ++++++++++++++++++++++-
> sound/soc/qcom/qdsp6/q6afe.h | 46 +++++-
> sound/soc/qcom/qdsp6/q6dsp-lpass-ports.c | 23 +++
> sound/soc/qcom/qdsp6/q6dsp-lpass-ports.h | 1 +
> sound/soc/qcom/qdsp6/q6routing.c | 9 ++
> 6 files changed, 312 insertions(+), 2 deletions(-)
>
> diff --git a/sound/soc/qcom/qdsp6/q6afe-dai.c b/sound/soc/qcom/qdsp6/q6afe-dai.c
> index 8bb7452b8f18..bda79d77c8d8 100644
> --- a/sound/soc/qcom/qdsp6/q6afe-dai.c
> +++ b/sound/soc/qcom/qdsp6/q6afe-dai.c
> @@ -111,6 +111,40 @@ static int q6hdmi_hw_params(struct snd_pcm_substream *substream,
> return 0;
> }
>
> +static int q6usb_hw_params(struct snd_pcm_substream *substream,
> + struct snd_pcm_hw_params *params,
> + struct snd_soc_dai *dai)
> +{
> + struct q6afe_dai_data *dai_data = dev_get_drvdata(dai->dev);
> + int channels = params_channels(params);
> + int rate = params_rate(params);
> + struct q6afe_usb_cfg *usb = &dai_data->port_config[dai->id].usb_audio;
> +
> + usb->sample_rate = rate;
> + usb->num_channels = channels;
> +
> + switch (params_format(params)) {
> + case SNDRV_PCM_FORMAT_U16_LE:
> + case SNDRV_PCM_FORMAT_S16_LE:
> + case SNDRV_PCM_FORMAT_SPECIAL:
> + usb->bit_width = 16;
> + break;
> + case SNDRV_PCM_FORMAT_S24_LE:
> + case SNDRV_PCM_FORMAT_S24_3LE:
> + usb->bit_width = 24;
> + break;
> + case SNDRV_PCM_FORMAT_S32_LE:
> + usb->bit_width = 32;
> + break;
> + default:
> + dev_err(dai->dev, "%s: invalid format %d\n",
> + __func__, params_format(params));
> + return -EINVAL;
> + }
> +
> + return 0;
> +}
> +
> static int q6i2s_hw_params(struct snd_pcm_substream *substream,
> struct snd_pcm_hw_params *params,
> struct snd_soc_dai *dai)
> @@ -411,6 +445,10 @@ static int q6afe_dai_prepare(struct snd_pcm_substream *substream,
> q6afe_cdc_dma_port_prepare(dai_data->port[dai->id],
> &dai_data->port_config[dai->id].dma_cfg);
> break;
> + case USB_RX:
> + q6afe_usb_port_prepare(dai_data->port[dai->id],
> + &dai_data->port_config[dai->id].usb_audio);
> + break;
> default:
> return -EINVAL;
> }
> @@ -637,6 +675,15 @@ static const struct snd_soc_dapm_route q6afe_dapm_routes[] = {
> {"TX_CODEC_DMA_TX_5", NULL, "TX_CODEC_DMA_TX_5 Capture"},
> {"RX_CODEC_DMA_RX_6 Playback", NULL, "RX_CODEC_DMA_RX_6"},
> {"RX_CODEC_DMA_RX_7 Playback", NULL, "RX_CODEC_DMA_RX_7"},
> +
> + /* USB playback AFE port receives data for playback, hence use the RX port */
> + {"USB Playback", NULL, "USB_RX"},
> +};
> +
> +static const struct snd_soc_dai_ops q6usb_ops = {
> + .prepare = q6afe_dai_prepare,
> + .hw_params = q6usb_hw_params,
> + .shutdown = q6afe_dai_shutdown,
> };
>
> static const struct snd_soc_dai_ops q6hdmi_ops = {
> @@ -952,6 +999,8 @@ static const struct snd_soc_dapm_widget q6afe_dai_widgets[] = {
> 0, SND_SOC_NOPM, 0, 0),
> SND_SOC_DAPM_AIF_IN("RX_CODEC_DMA_RX_7", "NULL",
> 0, SND_SOC_NOPM, 0, 0),
> +
> + SND_SOC_DAPM_AIF_IN("USB_RX", NULL, 0, SND_SOC_NOPM, 0, 0),
> };
>
> static const struct snd_soc_component_driver q6afe_dai_component = {
> @@ -1068,6 +1117,7 @@ static int q6afe_dai_dev_probe(struct platform_device *pdev)
> cfg.q6i2s_ops = &q6i2s_ops;
> cfg.q6tdm_ops = &q6tdm_ops;
> cfg.q6dma_ops = &q6dma_ops;
> + cfg.q6usb_ops = &q6usb_ops;
> dais = q6dsp_audio_ports_set_config(dev, &cfg, &num_dais);
>
> return devm_snd_soc_register_component(dev, &q6afe_dai_component, dais, num_dais);
> diff --git a/sound/soc/qcom/qdsp6/q6afe.c b/sound/soc/qcom/qdsp6/q6afe.c
> index 919e326b9462..43baf93f9c89 100644
> --- a/sound/soc/qcom/qdsp6/q6afe.c
> +++ b/sound/soc/qcom/qdsp6/q6afe.c
> @@ -34,6 +34,8 @@
> #define AFE_MODULE_TDM 0x0001028A
>
> #define AFE_PARAM_ID_CDC_SLIMBUS_SLAVE_CFG 0x00010235
> +#define AFE_PARAM_ID_USB_AUDIO_DEV_PARAMS 0x000102A5
> +#define AFE_PARAM_ID_USB_AUDIO_DEV_LPCM_FMT 0x000102AA
>
> #define AFE_PARAM_ID_LPAIF_CLK_CONFIG 0x00010238
> #define AFE_PARAM_ID_INT_DIGITAL_CDC_CLK_CONFIG 0x00010239
> @@ -43,6 +45,7 @@
> #define AFE_PARAM_ID_TDM_CONFIG 0x0001029D
> #define AFE_PARAM_ID_PORT_SLOT_MAPPING_CONFIG 0x00010297
> #define AFE_PARAM_ID_CODEC_DMA_CONFIG 0x000102B8
> +#define AFE_PARAM_ID_USB_AUDIO_CONFIG 0x000102A4
> #define AFE_CMD_REMOTE_LPASS_CORE_HW_VOTE_REQUEST 0x000100f4
> #define AFE_CMD_RSP_REMOTE_LPASS_CORE_HW_VOTE_REQUEST 0x000100f5
> #define AFE_CMD_REMOTE_LPASS_CORE_HW_DEVOTE_REQUEST 0x000100f6
> @@ -71,12 +74,16 @@
> #define AFE_PORT_CONFIG_I2S_WS_SRC_INTERNAL 0x1
> #define AFE_LINEAR_PCM_DATA 0x0
>
> +#define AFE_API_MINOR_VERSION_USB_AUDIO_CONFIG 0x1
>
> /* Port IDs */
> #define AFE_API_VERSION_HDMI_CONFIG 0x1
> #define AFE_PORT_ID_MULTICHAN_HDMI_RX 0x100E
> #define AFE_PORT_ID_HDMI_OVER_DP_RX 0x6020
>
> +/* USB AFE port */
> +#define AFE_PORT_ID_USB_RX 0x7000
> +
> #define AFE_API_VERSION_SLIMBUS_CONFIG 0x1
> /* Clock set API version */
> #define AFE_API_VERSION_CLOCK_SET 1
> @@ -512,12 +519,109 @@ struct afe_param_id_cdc_dma_cfg {
> u16 active_channels_mask;
> } __packed;
>
> +struct afe_param_id_usb_cfg {
> +/* Minor version used for tracking USB audio device configuration.
> + * Supported values: AFE_API_MINOR_VERSION_USB_AUDIO_CONFIG
> + */
> + u32 cfg_minor_version;
> +/* Sampling rate of the port.
> + * Supported values:
> + * - AFE_PORT_SAMPLE_RATE_8K
> + * - AFE_PORT_SAMPLE_RATE_11025
> + * - AFE_PORT_SAMPLE_RATE_12K
> + * - AFE_PORT_SAMPLE_RATE_16K
> + * - AFE_PORT_SAMPLE_RATE_22050
> + * - AFE_PORT_SAMPLE_RATE_24K
> + * - AFE_PORT_SAMPLE_RATE_32K
> + * - AFE_PORT_SAMPLE_RATE_44P1K
> + * - AFE_PORT_SAMPLE_RATE_48K
> + * - AFE_PORT_SAMPLE_RATE_96K
> + * - AFE_PORT_SAMPLE_RATE_192K
> + */
> + u32 sample_rate;
> +/* Bit width of the sample.
> + * Supported values: 16, 24
> + */
> + u16 bit_width;
> +/* Number of channels.
> + * Supported values: 1 and 2
> + */
> + u16 num_channels;
> +/* Data format supported by the USB. The supported value is
> + * 0 (#AFE_USB_AUDIO_DATA_FORMAT_LINEAR_PCM).
> + */
> + u16 data_format;
> +/* this field must be 0 */
> + u16 reserved;
> +/* device token of actual end USB aduio device */
> + u32 dev_token;
> +/* endianness of this interface */
> + u32 endian;
> +/* service interval */
> + u32 service_interval;
> +} __packed;
> +
> +/**
> + * struct afe_param_id_usb_audio_dev_params
> + * @cfg_minor_version: Minor version used for tracking USB audio device
> + * configuration.
> + * Supported values:
> + * AFE_API_MINOR_VERSION_USB_AUDIO_CONFIG
> + * @dev_token: device token of actual end USB aduio device
> + **/
> +struct afe_param_id_usb_audio_dev_params {
> + u32 cfg_minor_version;
> + u32 dev_token;
> +} __packed;
> +
> +/**
> + * struct afe_param_id_usb_audio_dev_lpcm_fmt
> + * @cfg_minor_version: Minor version used for tracking USB audio device
> + * configuration.
> + * Supported values:
> + * AFE_API_MINOR_VERSION_USB_AUDIO_CONFIG
> + * @endian: endianness of this interface
> + **/
> +struct afe_param_id_usb_audio_dev_lpcm_fmt {
> + u32 cfg_minor_version;
> + u32 endian;
> +} __packed;
> +
> +/**
> + * struct afe_param_id_usb_audio_dev_latency_mode
> + * @cfg_minor_version: Minor version used for tracking USB audio device
> + * configuration.
> + * Supported values:
> + * AFE_API_MINOR_VERSION_USB_AUDIO_LATENCY_MODE
> + * @mode: latency mode for the USB audio device
> + **/
> +struct afe_param_id_usb_audio_dev_latency_mode {
> + u32 minor_version;
> + u32 mode;
> +} __packed;
> +
> +#define AFE_PARAM_ID_USB_AUDIO_SVC_INTERVAL 0x000102B7
> +
> +/**
> + * struct afe_param_id_usb_audio_svc_interval
> + * @cfg_minor_version: Minor version used for tracking USB audio device
> + * configuration.
> + * Supported values:
> + * AFE_API_MINOR_VERSION_USB_AUDIO_CONFIG
> + * @svc_interval: service interval
> + **/
> +struct afe_param_id_usb_audio_svc_interval {
> + u32 cfg_minor_version;
> + u32 svc_interval;
> +} __packed;
> +
> union afe_port_config {
> struct afe_param_id_hdmi_multi_chan_audio_cfg hdmi_multi_ch;
> struct afe_param_id_slimbus_cfg slim_cfg;
> struct afe_param_id_i2s_cfg i2s_cfg;
> struct afe_param_id_tdm_cfg tdm_cfg;
> struct afe_param_id_cdc_dma_cfg dma_cfg;
> + struct afe_param_id_usb_cfg usb_cfg;
> } __packed;
>
>
> @@ -832,6 +936,7 @@ static struct afe_port_map port_maps[AFE_PORT_MAX] = {
> RX_CODEC_DMA_RX_6, 1, 1},
> [RX_CODEC_DMA_RX_7] = { AFE_PORT_ID_RX_CODEC_DMA_RX_7,
> RX_CODEC_DMA_RX_7, 1, 1},
> + [USB_RX] = { AFE_PORT_ID_USB_RX, USB_RX, 1, 1},
> };
>
> static void q6afe_port_free(struct kref *ref)
> @@ -1289,6 +1394,81 @@ void q6afe_tdm_port_prepare(struct q6afe_port *port,
> }
> EXPORT_SYMBOL_GPL(q6afe_tdm_port_prepare);
>
> +static int afe_port_send_usb_dev_param(struct q6afe_port *port, struct q6afe_usb_cfg *cfg)
> +{
> + union afe_port_config *pcfg = &port->port_cfg;
> + struct afe_param_id_usb_audio_dev_params usb_dev;
> + struct afe_param_id_usb_audio_dev_lpcm_fmt lpcm_fmt;
> + struct afe_param_id_usb_audio_svc_interval svc_int;
> + int ret = 0;
> +
> + if (!pcfg) {
> + dev_err(port->afe->dev, "%s: Error, no configuration data\n", __func__);
> + ret = -EINVAL;
> + goto exit;
> + }
> +
> + memset(&usb_dev, 0, sizeof(usb_dev));
> + memset(&lpcm_fmt, 0, sizeof(lpcm_fmt));
> + memset(&svc_int, 0, sizeof(svc_int));
> +
> + usb_dev.cfg_minor_version = AFE_API_MINOR_VERSION_USB_AUDIO_CONFIG;
> + q6afe_port_set_param_v2(port, &usb_dev,
> + AFE_PARAM_ID_USB_AUDIO_DEV_PARAMS,
> + AFE_MODULE_AUDIO_DEV_INTERFACE, sizeof(usb_dev));
> + if (ret) {
> + dev_err(port->afe->dev, "%s: AFE device param cmd failed %d\n",
> + __func__, ret);
> + goto exit;
> + }
> +
> + lpcm_fmt.cfg_minor_version = AFE_API_MINOR_VERSION_USB_AUDIO_CONFIG;
> + lpcm_fmt.endian = pcfg->usb_cfg.endian;
> + ret = q6afe_port_set_param_v2(port, &lpcm_fmt,
> + AFE_PARAM_ID_USB_AUDIO_DEV_LPCM_FMT,
> + AFE_MODULE_AUDIO_DEV_INTERFACE, sizeof(lpcm_fmt));
> + if (ret) {
> + dev_err(port->afe->dev, "%s: AFE device param cmd LPCM_FMT failed %d\n",
> + __func__, ret);
> + goto exit;
> + }
> +
> + svc_int.cfg_minor_version = AFE_API_MINOR_VERSION_USB_AUDIO_CONFIG;
> + svc_int.svc_interval = pcfg->usb_cfg.service_interval;
> + ret = q6afe_port_set_param_v2(port, &svc_int,
> + AFE_PARAM_ID_USB_AUDIO_SVC_INTERVAL,
> + AFE_MODULE_AUDIO_DEV_INTERFACE, sizeof(svc_int));
> + if (ret) {
> + dev_err(port->afe->dev, "%s: AFE device param cmd svc_interval failed %d\n",
> + __func__, ret);
> + ret = -EINVAL;
> + goto exit;
> + }
> +exit:
> + return ret;
> +}
> +
> +/**
> + * q6afe_usb_port_prepare() - Prepare usb afe port.
> + *
> + * @port: Instance of afe port
> + * @cfg: USB configuration for the afe port
> + *
> + */
> +void q6afe_usb_port_prepare(struct q6afe_port *port,
> + struct q6afe_usb_cfg *cfg)
> +{
> + union afe_port_config *pcfg = &port->port_cfg;
> +
> + pcfg->usb_cfg.cfg_minor_version = AFE_API_MINOR_VERSION_USB_AUDIO_CONFIG;
> + pcfg->usb_cfg.sample_rate = cfg->sample_rate;
> + pcfg->usb_cfg.num_channels = cfg->num_channels;
> + pcfg->usb_cfg.bit_width = cfg->bit_width;
> +
> + afe_port_send_usb_dev_param(port, cfg);
> +}
> +EXPORT_SYMBOL_GPL(q6afe_usb_port_prepare);
> +
> /**
> * q6afe_hdmi_port_prepare() - Prepare hdmi afe port.
> *
> @@ -1611,7 +1791,10 @@ struct q6afe_port *q6afe_port_get_from_id(struct device *dev, int id)
> break;
> case AFE_PORT_ID_WSA_CODEC_DMA_RX_0 ... AFE_PORT_ID_RX_CODEC_DMA_RX_7:
> cfg_type = AFE_PARAM_ID_CODEC_DMA_CONFIG;
> - break;
> + break;
> + case AFE_PORT_ID_USB_RX:
> + cfg_type = AFE_PARAM_ID_USB_AUDIO_CONFIG;
> + break;
> default:
> dev_err(dev, "Invalid port id 0x%x\n", port_id);
> return ERR_PTR(-EINVAL);
> diff --git a/sound/soc/qcom/qdsp6/q6afe.h b/sound/soc/qcom/qdsp6/q6afe.h
> index 30fd77e2f458..e098a3e15135 100644
> --- a/sound/soc/qcom/qdsp6/q6afe.h
> +++ b/sound/soc/qcom/qdsp6/q6afe.h
> @@ -5,7 +5,7 @@
>
> #include <dt-bindings/sound/qcom,q6afe.h>
>
> -#define AFE_PORT_MAX 129
> +#define AFE_PORT_MAX 130
>
> #define MSM_AFE_PORT_TYPE_RX 0
> #define MSM_AFE_PORT_TYPE_TX 1
> @@ -205,6 +205,47 @@ struct q6afe_cdc_dma_cfg {
> u16 active_channels_mask;
> };
>
> +/**
> + * struct q6afe_usb_cfg
> + * @cfg_minor_version: Minor version used for tracking USB audio device
> + * configuration.
> + * Supported values:
> + * AFE_API_MINOR_VERSION_USB_AUDIO_CONFIG
> + * @sample_rate: Sampling rate of the port
> + * Supported values:
> + * AFE_PORT_SAMPLE_RATE_8K
> + * AFE_PORT_SAMPLE_RATE_11025
> + * AFE_PORT_SAMPLE_RATE_12K
> + * AFE_PORT_SAMPLE_RATE_16K
> + * AFE_PORT_SAMPLE_RATE_22050
> + * AFE_PORT_SAMPLE_RATE_24K
> + * AFE_PORT_SAMPLE_RATE_32K
> + * AFE_PORT_SAMPLE_RATE_44P1K
> + * AFE_PORT_SAMPLE_RATE_48K
> + * AFE_PORT_SAMPLE_RATE_96K
> + * AFE_PORT_SAMPLE_RATE_192K
> + * @bit_width: Bit width of the sample.
> + * Supported values: 16, 24
> + * @num_channels: Number of channels
> + * Supported values: 1, 2
> + * @data_format: Data format supported by the USB
> + * Supported values: 0
> + * @reserved: this field must be 0
> + * @dev_token: device token of actual end USB audio device
> + * @endian: endianness of this interface
> + * @service_interval: service interval
> + **/
> +struct q6afe_usb_cfg {
> + u32 cfg_minor_version;
> + u32 sample_rate;
> + u16 bit_width;
> + u16 num_channels;
> + u16 data_format;
> + u16 reserved;
> + u32 dev_token;
> + u32 endian;
> + u32 service_interval;
> +};
>
> struct q6afe_port_config {
> struct q6afe_hdmi_cfg hdmi;
> @@ -212,6 +253,7 @@ struct q6afe_port_config {
> struct q6afe_i2s_cfg i2s_cfg;
> struct q6afe_tdm_cfg tdm;
> struct q6afe_cdc_dma_cfg dma_cfg;
> + struct q6afe_usb_cfg usb_audio;
> };
>
> struct q6afe_port;
> @@ -221,6 +263,8 @@ int q6afe_port_start(struct q6afe_port *port);
> int q6afe_port_stop(struct q6afe_port *port);
> void q6afe_port_put(struct q6afe_port *port);
> int q6afe_get_port_id(int index);
> +void q6afe_usb_port_prepare(struct q6afe_port *port,
> + struct q6afe_usb_cfg *cfg);
> void q6afe_hdmi_port_prepare(struct q6afe_port *port,
> struct q6afe_hdmi_cfg *cfg);
> void q6afe_slim_port_prepare(struct q6afe_port *port,
> diff --git a/sound/soc/qcom/qdsp6/q6dsp-lpass-ports.c b/sound/soc/qcom/qdsp6/q6dsp-lpass-ports.c
> index f67c16fd90b9..39719c3f1767 100644
> --- a/sound/soc/qcom/qdsp6/q6dsp-lpass-ports.c
> +++ b/sound/soc/qcom/qdsp6/q6dsp-lpass-ports.c
> @@ -81,6 +81,26 @@
>
>
> static struct snd_soc_dai_driver q6dsp_audio_fe_dais[] = {
> + {
> + .playback = {
> + .stream_name = "USB Playback",
> + .rates = SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_11025 |
> + SNDRV_PCM_RATE_16000 | SNDRV_PCM_RATE_22050 |
> + SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 |
> + SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_96000 |
> + SNDRV_PCM_RATE_192000,
> + .formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S16_BE |
> + SNDRV_PCM_FMTBIT_U16_LE | SNDRV_PCM_FMTBIT_U16_BE |
> + SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S24_BE |
> + SNDRV_PCM_FMTBIT_U24_LE | SNDRV_PCM_FMTBIT_U24_BE,
> + .channels_min = 1,
> + .channels_max = 2,
> + .rate_min = 8000,
> + .rate_max = 192000,
> + },
> + .id = USB_RX,
> + .name = "USB_RX",
> + },
> {
> .playback = {
> .stream_name = "HDMI Playback",
> @@ -616,6 +636,9 @@ struct snd_soc_dai_driver *q6dsp_audio_ports_set_config(struct device *dev,
> case WSA_CODEC_DMA_RX_0 ... RX_CODEC_DMA_RX_7:
> q6dsp_audio_fe_dais[i].ops = cfg->q6dma_ops;
> break;
> + case USB_RX:
> + q6dsp_audio_fe_dais[i].ops = cfg->q6usb_ops;
> + break;
> default:
> break;
> }
> diff --git a/sound/soc/qcom/qdsp6/q6dsp-lpass-ports.h b/sound/soc/qcom/qdsp6/q6dsp-lpass-ports.h
> index 7f052c8a1257..d8dde6dd0aca 100644
> --- a/sound/soc/qcom/qdsp6/q6dsp-lpass-ports.h
> +++ b/sound/soc/qcom/qdsp6/q6dsp-lpass-ports.h
> @@ -11,6 +11,7 @@ struct q6dsp_audio_port_dai_driver_config {
> const struct snd_soc_dai_ops *q6i2s_ops;
> const struct snd_soc_dai_ops *q6tdm_ops;
> const struct snd_soc_dai_ops *q6dma_ops;
> + const struct snd_soc_dai_ops *q6usb_ops;
> };
>
> struct snd_soc_dai_driver *q6dsp_audio_ports_set_config(struct device *dev,
> diff --git a/sound/soc/qcom/qdsp6/q6routing.c b/sound/soc/qcom/qdsp6/q6routing.c
> index 928fd23e2c27..dc2357b4b2c7 100644
> --- a/sound/soc/qcom/qdsp6/q6routing.c
> +++ b/sound/soc/qcom/qdsp6/q6routing.c
> @@ -514,6 +514,9 @@ static int msm_routing_put_audio_mixer(struct snd_kcontrol *kcontrol,
> return 1;
> }
>
> +static const struct snd_kcontrol_new usb_mixer_controls[] = {
> + Q6ROUTING_RX_MIXERS(USB_RX) };
> +
> static const struct snd_kcontrol_new hdmi_mixer_controls[] = {
> Q6ROUTING_RX_MIXERS(HDMI_RX) };
>
> @@ -949,6 +952,10 @@ static const struct snd_soc_dapm_widget msm_qdsp6_widgets[] = {
> SND_SOC_DAPM_MIXER("MultiMedia8 Mixer", SND_SOC_NOPM, 0, 0,
> mmul8_mixer_controls, ARRAY_SIZE(mmul8_mixer_controls)),
>
> + SND_SOC_DAPM_MIXER("USB Mixer", SND_SOC_NOPM, 0, 0,
> + usb_mixer_controls,
> + ARRAY_SIZE(usb_mixer_controls)),
> +
> };
>
> static const struct snd_soc_dapm_route intercon[] = {
> @@ -1042,6 +1049,8 @@ static const struct snd_soc_dapm_route intercon[] = {
> {"MM_UL6", NULL, "MultiMedia6 Mixer"},
> {"MM_UL7", NULL, "MultiMedia7 Mixer"},
> {"MM_UL8", NULL, "MultiMedia8 Mixer"},
> +
> + Q6ROUTING_RX_DAPM_ROUTE("USB Mixer", "USB_RX"),
> };
>
> static int routing_hw_params(struct snd_soc_component *component,
On 08/03/2023 23:57, Wesley Cheng wrote:
> The Q6USB backend can carry information about the available USB SND cards
> and PCM devices discovered on the USB bus. The dev_token field is used by
> the audio DSP to notify the USB offload driver of which card and PCM index
> to enable playback on. Separate this into a dedicated API, so the USB
> backend can set the dev_token accordingly. The audio DSP does not utilize
> this information until the AFE port start command is sent, which is done
> during the PCM prepare phase.
>
> Signed-off-by: Wesley Cheng <[email protected]>
> ---
> sound/soc/qcom/qdsp6/q6afe.c | 49 +++++++++++++++++++++++++-----------
> sound/soc/qcom/qdsp6/q6afe.h | 1 +
> 2 files changed, 36 insertions(+), 14 deletions(-)
>
Looks like this could be part of [06/28] ASoC: qcom: qdsp6: Introduce
USB AFE port to q6dsp
you are modifying the 06/28 patch in this patch.
other than that it looks fine to me.
--srini
> diff --git a/sound/soc/qcom/qdsp6/q6afe.c b/sound/soc/qcom/qdsp6/q6afe.c
> index e9d5fa6b6b0d..505371c96987 100644
> --- a/sound/soc/qcom/qdsp6/q6afe.c
> +++ b/sound/soc/qcom/qdsp6/q6afe.c
> @@ -1394,10 +1394,42 @@ void q6afe_tdm_port_prepare(struct q6afe_port *port,
> }
> EXPORT_SYMBOL_GPL(q6afe_tdm_port_prepare);
>
> -static int afe_port_send_usb_dev_param(struct q6afe_port *port, struct q6afe_usb_cfg *cfg)
> +/**
> + * afe_port_send_usb_dev_param() - Send USB dev token
> + *
> + * @port: Instance of afe port
> + * @cardidx: USB SND card index to reference
> + * @pcmidx: USB SND PCM device index to reference
> + *
> + * The USB dev token carries information about which USB SND card instance and
> + * PCM device to execute the offload on. This information is carried through
> + * to the stream enable QMI request, which is handled by the offload class
> + * driver. The information is parsed to determine which USB device to query
> + * the required resources for.
> + */
> +int afe_port_send_usb_dev_param(struct q6afe_port *port, int cardidx, int pcmidx)
> {
> - union afe_port_config *pcfg = &port->port_cfg;
> struct afe_param_id_usb_audio_dev_params usb_dev;
> + int ret;
> +
> + memset(&usb_dev, 0, sizeof(usb_dev));
> +
> + usb_dev.cfg_minor_version = AFE_API_MINOR_VERSION_USB_AUDIO_CONFIG;
> + usb_dev.dev_token = (cardidx << 16) | (pcmidx << 8);
> + ret = q6afe_port_set_param_v2(port, &usb_dev,
> + AFE_PARAM_ID_USB_AUDIO_DEV_PARAMS,
> + AFE_MODULE_AUDIO_DEV_INTERFACE, sizeof(usb_dev));
> + if (ret)
> + dev_err(port->afe->dev, "%s: AFE device param cmd failed %d\n",
> + __func__, ret);
> +
> + return ret;
> +}
> +EXPORT_SYMBOL_GPL(afe_port_send_usb_dev_param);
> +
> +static int afe_port_send_usb_params(struct q6afe_port *port, struct q6afe_usb_cfg *cfg)
> +{
> + union afe_port_config *pcfg = &port->port_cfg;
> struct afe_param_id_usb_audio_dev_lpcm_fmt lpcm_fmt;
> struct afe_param_id_usb_audio_svc_interval svc_int;
> int ret = 0;
> @@ -1408,20 +1440,9 @@ static int afe_port_send_usb_dev_param(struct q6afe_port *port, struct q6afe_usb
> goto exit;
> }
>
> - memset(&usb_dev, 0, sizeof(usb_dev));
> memset(&lpcm_fmt, 0, sizeof(lpcm_fmt));
> memset(&svc_int, 0, sizeof(svc_int));
>
> - usb_dev.cfg_minor_version = AFE_API_MINOR_VERSION_USB_AUDIO_CONFIG;
> - q6afe_port_set_param_v2(port, &usb_dev,
> - AFE_PARAM_ID_USB_AUDIO_DEV_PARAMS,
> - AFE_MODULE_AUDIO_DEV_INTERFACE, sizeof(usb_dev));
> - if (ret) {
> - dev_err(port->afe->dev, "%s: AFE device param cmd failed %d\n",
> - __func__, ret);
> - goto exit;
> - }
> -
> lpcm_fmt.cfg_minor_version = AFE_API_MINOR_VERSION_USB_AUDIO_CONFIG;
> lpcm_fmt.endian = pcfg->usb_cfg.endian;
> ret = q6afe_port_set_param_v2(port, &lpcm_fmt,
> @@ -1465,7 +1486,7 @@ void q6afe_usb_port_prepare(struct q6afe_port *port,
> pcfg->usb_cfg.num_channels = cfg->num_channels;
> pcfg->usb_cfg.bit_width = cfg->bit_width;
>
> - afe_port_send_usb_dev_param(port, cfg);
> + afe_port_send_usb_params(port, cfg);
> }
> EXPORT_SYMBOL_GPL(q6afe_usb_port_prepare);
>
> diff --git a/sound/soc/qcom/qdsp6/q6afe.h b/sound/soc/qcom/qdsp6/q6afe.h
> index e098a3e15135..7980416275e9 100644
> --- a/sound/soc/qcom/qdsp6/q6afe.h
> +++ b/sound/soc/qcom/qdsp6/q6afe.h
> @@ -274,6 +274,7 @@ void q6afe_tdm_port_prepare(struct q6afe_port *port, struct q6afe_tdm_cfg *cfg);
> void q6afe_cdc_dma_port_prepare(struct q6afe_port *port,
> struct q6afe_cdc_dma_cfg *cfg);
>
> +int afe_port_send_usb_dev_param(struct q6afe_port *port, int cardidx, int pcmidx);
> int q6afe_port_set_sysclk(struct q6afe_port *port, int clk_id,
> int clk_src, int clk_root,
> unsigned int freq, int dir);
On 09.03.23 00:57, Wesley Cheng wrote:
> +/*
> + * in case the platform driver was not ready at the time of USB SND
> + * device connect, expose an API to discover all connected USB devices
> + * so it can populate any dependent resources/structures.
> + */
> +void snd_usb_rediscover_devices(void)
> +{
> + int i;
> +
> + mutex_lock(®ister_mutex);
> + for (i = 0; i < SNDRV_CARDS; i++) {
> + if (usb_chip[i])
> + if (platform_ops && platform_ops->connect_cb)
Really check this every time?
Regards
Oliver
On 3/8/23 17:57, Wesley Cheng wrote:
> Changes in v3:
> - Changed prefix from RFC to PATCH
> - Rebased entire series to usb-next
> - Updated copyright years
You may want to move the per-version changes after the description of
this patchset.
> XHCI:
> - Rebased changes on top of XHCI changes merged into usb-next, and only added
> changes that were still under discussion.
> - Added change to read in the "num-hc-interrupters" device property.
>
> ASoC:
> - qusb6 USB backend
> - Incorporated suggestions to fetch iommu information with existing APIs
> - Added two new sound kcontrols to fetch offload status and offload device
> selection.
> - offload status - will return the card and pcm device in use
> tinymix -D 0 get 1 --> 1, 0 (offload in progress on card#1 pcm#0)
>
> - device selection - set the card and pcm device to enable offload on. Ex.:
> tinymix -D 0 set 1 2 0 --> sets offload on card#2 pcm#0
> (this should be the USB card)
>
> USB SND:
> - Fixed up some locking related concerns for registering platform ops.
> - Moved callbacks under the register_mutex, so that
> - Modified APIs to properly pass more information about the USB SND device, so
> that the Q6USB backend can build a device list/map, in order to monitor offload
> status and device selection.
>
> Changes in v2:
>
> XHCI:
> - Replaced XHCI and HCD changes with Mathias' XHCI interrupter changes
> in his tree:
> https://git.kernel.org/pub/scm/linux/kernel/git/mnyman/xhci.git/log/?h=feature_interrupters
>
> Adjustments made to Mathias' changes:
> - Created xhci-intr.h to export/expose interrupter APIs versus exposing xhci.h.
> Moved dependent structures to this file as well. (so clients can parse out
> information from "struct xhci_interrupter")
> - Added some basic locking when requesting interrupters.
> - Fixed up some sanity checks.
> - Removed clearing of the ERSTBA during freeing of the interrupter. (pending
> issue where SMMU fault occurs if DMA addr returned is 64b - TODO)
>
> - Clean up pending events in the XHCI secondary interrupter. While testing USB
> bus suspend, it was seen that on bus resume, the xHCI HC would run into a command
> timeout.
> - Added offloading APIs to xHCI to fetch transfer and event ring information.
>
> ASoC:
> - Modified soc-usb to allow for multiple USB port additions. For this to work,
> the USB offload driver has to have a reference to the USB backend by adding
> a "usb-soc-be" DT entry to the device saved into XHCI sysdev.
> - Created separate dt-bindings for defining USB_RX port.
> - Increased APR timeout to accommodate the situation where the AFE port start
> command could be delayed due to having to issue a USB bus resume while
> handling the QMI stream start command.
>
> USB SND:
> - Added a platform ops during usb_audio_suspend(). This allows for the USB
> offload driver to halt the audio stream when system enters PM suspend. This
> ensures the audio DSP is not issuing transfers on the USB bus.
> - Do not override platform ops if they are already populated.
> - Introduce a shared status variable between the USB offload and USB SND layers,
> to ensure that only one path is active at a time. If the USB bus is occupied,
> then userspace is notified that the path is busy.
---> start of the cover letter:
> Several Qualcomm based chipsets can support USB audio offloading to a
> dedicated audio DSP, which can take over issuing transfers to the USB
> host controller. The intention is to reduce the load on the main
> processors in the SoC, and allow them to be placed into lower power modes.
> There are several parts to this design:
> 1. Adding ASoC binding layer
> 2. Create a USB backend for Q6DSP
clarify what 'backend' means. I would guess you are referring to the
ASoC DPCM concept of Back-End, which typically exposes an audio
interface controlled by a DSP?
If yes, the description should be
"Create a Q6DSP ASoC DPCM BackEnd for USB audio playback/record".
> 3. Introduce XHCI interrupter support
> 4. Create vendor ops for the USB SND driver
Add an introduction as to why this would be needed? which 'vendor' are
we talking about, is this on the SOC side or the USB device side?
> Adding ASoC binding layer:
> soc-usb: Intention is to treat a USB port similar to a headphone jack.
> The port is always present on the device, but cable/pin status can be
> enabled/disabled. Expose mechanisms for USB backend ASoC drivers to
> communicate with USB SND.
port == backend?
Using different words for the same concept is a sure way to lose the
reviewers, and not describing different concepts isn't much better.
> Create a USB backend for Q6DSP:
> q6usb: Basic backend driver that will be responsible for maintaining the
What does this mean? Is this a module that registers a set of ASoC DAIs?
It's not clear to me what a 'backend driver' means either in a USB or
ASoC context.
> resources needed to initiate a playback stream using the Q6DSP. Will
> be the entity that checks to make sure the connected USB audio device
> supports the requested PCM format. If it does not, the PCM open call will
> fail, and userpsace ALSA can take action accordingly.
If it's an ASoC backend, there is no PCM open call. You're probably
referring to the hw_params, not the open/startup anyways.
>
> Introduce XHCI interrupter support:
> XHCI HCD supports multiple interrupters, which allows for events to be routed
> to different event rings. This is determined by "Interrupter Target" field
> specified in Section "6.4.1.1 Normal TRB" of the XHCI specification.
>
> Events in the offloading case will be routed to an event ring that is assigned
> to the audio DSP.
>
> Create vendor ops for the USB SND driver:
> qc_audio_offload: This particular driver has several components associated
> with it:
> - QMI stream request handler
> - XHCI interrupter and resource management
> - audio DSP memory management
so how does this 'qc_audio_offload' interface with 'q6usb' described
above? how are the roles different or complementary?
> When the audio DSP wants to enable a playback stream, the request is first
> received by the ASoC platform sound card. Depending on the selected route,
> ASoC will bring up the individual DAIs in the path. The Q6USB backend DAI
> will send an AFE port start command (with enabling the USB playback path), and
> the audio DSP will handle the request accordingly.
>
> Part of the AFE USB port start handling will have an exchange of control
> messages using the QMI protocol. The qc_audio_offload driver will populate the
> buffer information:
> - Event ring base address
> - EP transfer ring base address
>
> and pass it along to the audio DSP. All endpoint management will now be handed
> over to the DSP, and the main processor is not involved in transfers.
>
> Overall, implementing this feature will still expose separate sound card and PCM
> devices for both the platorm card and USB audio device:
> 0 [SM8250MTPWCD938]: sm8250 - SM8250-MTP-WCD9380-WSA8810-VA-D
> SM8250-MTP-WCD9380-WSA8810-VA-DMIC
> 1 [Audio ]: USB-Audio - USB Audio
> Generic USB Audio at usb-xhci-hcd.1.auto-1.4, high speed
>
> This is to ensure that userspace ALSA entities can decide which route to take
> when executing the audio playback. In the above, if card#1 is selected, then
> USB audio data will take the legacy path over the USB PCM drivers, etc...
I already voiced my concerns about exposing two cards, each with their
own set of volume controls with the same device. It would be much better
to have an additional offloaded PCM device for card0...
But if the consensus is to have two cards, it's still not clear how the
routing would be selected. In the case where there are two USB audio
devices attached, the offloaded path would only support one of the two.
How would userspace know which of the two is selected?
And how would userspace know the difference anyways between two physical
devices attached to the platform with no offload, and one physical
device with one additional offload path? The names you selected can't be
used to identify that card1 is the optimized version of card0.
Before we review low-level kernel plumbing, it would be good to give a
better overview of how userspace applications are supposed to interact
with the cards and identify the offloaded path. Testing with
tinyplay/tinymix is fine, but that's a developer-level or CI unit test.
we've got to see the broader picture of how a sound server would use
this USB offload capability.
> +config QC_USB_AUDIO_OFFLOAD
> + tristate "Qualcomm Audio Offload driver"
"Qualcomm USB Audio Offload driver"
> + select SND_PCM
depends on SND_USB_AUDIO ?
> + help
> + Say Y here to enable the Qualcomm USB audio offloading feature
> +
> + This module sets up the required QMI stream enable/disable
> + responses to requests generated by the audio DSP. It passes the
> + USB transfer resource references, so that the audio DSP can issue
> + USB transfers to the host controller.
> +
> + To compile this driver as a module, choose M here: the module
> + will be called qc-audio-offload.
> +#include <linux/ctype.h>
> +#include <linux/moduleparam.h>
> +#include <linux/module.h>
> +#include <linux/usb.h>
> +#include <linux/init.h>
alphabetical order?
> +#include <linux/usb/hcd.h>
> +#include <linux/usb/xhci-intr.h>
> +#include <linux/usb/quirks.h>
> +#include <linux/usb/audio.h>
> +#include <linux/usb/audio-v2.h>
> +#include <linux/usb/audio-v3.h>
> +#include <linux/soc/qcom/qmi.h>
> +#include <linux/iommu.h>
> +#include <linux/dma-mapping.h>
> +#include <linux/dma-map-ops.h>
> +#include <sound/q6usboffload.h>
> +
> +#include <sound/control.h>
> +#include <sound/core.h>
> +#include <sound/info.h>
> +#include <sound/pcm.h>
> +#include <sound/pcm_params.h>
> +#include <sound/initval.h>
> +
> +#include <sound/soc.h>
> +#include <sound/soc-usb.h>
> +#include "../usbaudio.h"
> +#include "../card.h"
> +#include "../midi.h"
> +#include "../mixer.h"
> +#include "../proc.h"
> +#include "../quirks.h"
> +#include "../endpoint.h"
> +#include "../helper.h"
> +#include "../pcm.h"
> +#include "../format.h"
> +#include "../power.h"
> +#include "../stream.h"
> +#include "../media.h"
this looks weird, are all these needed?
> +
> +#define SND_PCM_CARD_NUM_MASK 0xffff0000
> +#define SND_PCM_DEV_NUM_MASK 0xff00
> +#define SND_PCM_STREAM_DIRECTION 0xff
The prefix looks wrong, or it duplicates SND_PCM stuff?
> +
> +/* iommu resource parameters and management */
> +#define PREPEND_SID_TO_IOVA(iova, sid) ((u64)(((u64)(iova)) | \
> + (((u64)sid) << 32)))
> +#define IOVA_BASE 0x1000
> +#define IOVA_XFER_RING_BASE (IOVA_BASE + PAGE_SIZE * (SNDRV_CARDS + 1))
> +#define IOVA_XFER_BUF_BASE (IOVA_XFER_RING_BASE + PAGE_SIZE * SNDRV_CARDS * 32)
> +#define IOVA_XFER_RING_MAX (IOVA_XFER_BUF_BASE - PAGE_SIZE)
> +#define IOVA_XFER_BUF_MAX (0xfffff000 - PAGE_SIZE)
> +
> +#define MAX_XFER_BUFF_LEN (24 * PAGE_SIZE)
> +
> +struct iova_info {
> + struct list_head list;
> + unsigned long start_iova;
> + size_t size;
> + bool in_use;
> +};
> +
> +struct intf_info {
> + unsigned long data_xfer_ring_va;
> + size_t data_xfer_ring_size;
> + unsigned long sync_xfer_ring_va;
> + size_t sync_xfer_ring_size;
> + unsigned long xfer_buf_va;
> + size_t xfer_buf_size;
> + phys_addr_t xfer_buf_pa;
> + unsigned int data_ep_pipe;
> + unsigned int sync_ep_pipe;
> + u8 *xfer_buf;
> + u8 intf_num;
> + u8 pcm_card_num;
> + u8 pcm_dev_num;
> + u8 direction;
> + bool in_use;
> +};
> +
> +struct uaudio_qmi_dev {
> + struct device *dev;
> + u32 sid;
> + u32 intr_num;
> + struct xhci_interrupter *ir;
> + struct xhci_ring *sec_ring;
> + struct iommu_domain *domain;
> +
> + /* list to keep track of available iova */
> + struct list_head xfer_ring_list;
> + size_t xfer_ring_iova_size;
> + unsigned long curr_xfer_ring_iova;
> + struct list_head xfer_buf_list;
> + size_t xfer_buf_iova_size;
> + unsigned long curr_xfer_buf_iova;
> +
> + /* bit fields representing pcm card enabled */
> + unsigned long card_slot;
> + /* indicate event ring mapped or not */
> + bool er_mapped;
> + /* reference count to number of possible consumers */
> + atomic_t qdev_in_use;
> + /* idx to last udev card number plugged in */
> + unsigned int last_card_num;
> +};
> +
> +struct uaudio_dev {
> + struct usb_device *udev;
> + /* audio control interface */
> + struct usb_host_interface *ctrl_intf;
> + unsigned int card_num;
> + unsigned int usb_core_id;
> + atomic_t in_use;
> + struct kref kref;
> + wait_queue_head_t disconnect_wq;
> +
> + /* interface specific */
> + int num_intf;
> + struct intf_info *info;
> + struct snd_usb_audio *chip;
> +};
This looks too detailed, isnt' that a duplication of other structures
that exist in the regular USB audio part?
There's nothing that looks QCOM-specific anyways.
> +
> +static struct uaudio_dev uadev[SNDRV_CARDS];
> +static struct uaudio_qmi_dev *uaudio_qdev;
> +static struct uaudio_qmi_svc *uaudio_svc;
> +static DEFINE_MUTEX(qdev_mutex);
> +
> +struct uaudio_qmi_svc {
> + struct qmi_handle *uaudio_svc_hdl;
> + struct work_struct qmi_disconnect_work;
> + struct workqueue_struct *uaudio_wq;
> + struct sockaddr_qrtr client_sq;
> + bool client_connected;
> +};
> +
> +enum mem_type {
> + MEM_EVENT_RING,
> + MEM_XFER_RING,
> + MEM_XFER_BUF,
> +};
prefixes better than 'MEM'?
> +
> +/* Supported audio formats */
> +enum usb_qmi_audio_format {
> + USB_QMI_PCM_FORMAT_S8 = 0,
> + USB_QMI_PCM_FORMAT_U8,
> + USB_QMI_PCM_FORMAT_S16_LE,
> + USB_QMI_PCM_FORMAT_S16_BE,
> + USB_QMI_PCM_FORMAT_U16_LE,
> + USB_QMI_PCM_FORMAT_U16_BE,
> + USB_QMI_PCM_FORMAT_S24_LE,
> + USB_QMI_PCM_FORMAT_S24_BE,
> + USB_QMI_PCM_FORMAT_U24_LE,
> + USB_QMI_PCM_FORMAT_U24_BE,
> + USB_QMI_PCM_FORMAT_S24_3LE,
> + USB_QMI_PCM_FORMAT_S24_3BE,
> + USB_QMI_PCM_FORMAT_U24_3LE,
> + USB_QMI_PCM_FORMAT_U24_3BE,
> + USB_QMI_PCM_FORMAT_S32_LE,
> + USB_QMI_PCM_FORMAT_S32_BE,
> + USB_QMI_PCM_FORMAT_U32_LE,
> + USB_QMI_PCM_FORMAT_U32_BE,
> +};
> +
> +static enum usb_audio_device_speed_enum_v01
> +get_speed_info(enum usb_device_speed udev_speed)
> +{
> + switch (udev_speed) {
> + case USB_SPEED_LOW:
> + return USB_AUDIO_DEVICE_SPEED_LOW_V01;
> + case USB_SPEED_FULL:
> + return USB_AUDIO_DEVICE_SPEED_FULL_V01;
> + case USB_SPEED_HIGH:
> + return USB_AUDIO_DEVICE_SPEED_HIGH_V01;
> + case USB_SPEED_SUPER:
> + return USB_AUDIO_DEVICE_SPEED_SUPER_V01;
> + case USB_SPEED_SUPER_PLUS:
> + return USB_AUDIO_DEVICE_SPEED_SUPER_PLUS_V01;
> + default:
> + return USB_AUDIO_DEVICE_SPEED_INVALID_V01;
> + }
> +}
this doesn't look qcom-specific, why is this here?
> +
> +static struct snd_usb_substream *find_substream(unsigned int card_num,
> + unsigned int pcm_idx, unsigned int direction)
> +{
> + struct snd_usb_stream *as;
> + struct snd_usb_substream *subs = NULL;
> + struct snd_usb_audio *chip;
> +
> + chip = uadev[card_num].chip;
> + if (!chip || atomic_read(&chip->shutdown))
> + goto done;
> +
> + if (pcm_idx >= chip->pcm_devs)
> + goto done;
> +
> + if (direction > SNDRV_PCM_STREAM_CAPTURE)
> + goto done;
> +
> + list_for_each_entry(as, &chip->pcm_list, list) {
> + if (as->pcm_index == pcm_idx) {
> + subs = &as->substream[direction];
> + goto done;
> + }
> + }
> +
> +done:
> + return subs;
> +}
> +
> +static int info_idx_from_ifnum(int card_num, int intf_num, bool enable)
> +{
> + int i;
> +
> + /*
> + * default index 0 is used when info is allocated upon
> + * first enable audio stream req for a pcm device
> + */
> + if (enable && !uadev[card_num].info)
> + return 0;
> +
> + for (i = 0; i < uadev[card_num].num_intf; i++) {
> + if (enable && !uadev[card_num].info[i].in_use)
> + return i;
> + else if (!enable &&
> + uadev[card_num].info[i].intf_num == intf_num)
> + return i;
> + }
> +
> + return -EINVAL;
> +}
> +
> +static int get_data_interval_from_si(struct snd_usb_substream *subs,
> + u32 service_interval)
> +{
> + unsigned int bus_intval, bus_intval_mult, binterval;
> +
> + if (subs->dev->speed >= USB_SPEED_HIGH)
> + bus_intval = BUS_INTERVAL_HIGHSPEED_AND_ABOVE;
> + else
> + bus_intval = BUS_INTERVAL_FULL_SPEED;
> +
> + if (service_interval % bus_intval)
> + return -EINVAL;
> +
> + bus_intval_mult = service_interval / bus_intval;
> + binterval = ffs(bus_intval_mult);
> + if (!binterval || binterval > MAX_BINTERVAL_ISOC_EP)
> + return -EINVAL;
> +
> + /* check if another bit is set then bail out */
> + bus_intval_mult = bus_intval_mult >> binterval;
> + if (bus_intval_mult)
> + return -EINVAL;
> +
> + return (binterval - 1);
> +}
this doesn't look qcom-specific either, is this a set of helpers that
need to be moved somewhere else?
> +/**
> + * disable_audio_stream() - disable usb snd endpoints
> + * @subs: usb substream
> + *
> + * Closes the USB SND endpoints associated with the current audio stream
> + * used. This will decrement the USB SND endpoint opened reference count.
> + *
> + */
> +static void disable_audio_stream(struct snd_usb_substream *subs)
> +{
> + struct snd_usb_audio *chip = subs->stream->chip;
> +
> + if (subs->data_endpoint || subs->sync_endpoint) {
> + close_endpoints(chip, subs);
> +
> + mutex_lock(&chip->mutex);
> + subs->cur_audiofmt = NULL;
> + mutex_unlock(&chip->mutex);
> + }
> +
> + snd_usb_autosuspend(chip);
> +}
also not qcom-specific?
> +/* kref release callback when all streams are disabled */
what does "all streams disabled" mean, and when does this happen?
> +static void uaudio_dev_release(struct kref *kref)
> +{
> + struct uaudio_dev *dev = container_of(kref, struct uaudio_dev, kref);
> +
> + uaudio_event_ring_cleanup_free(dev);
> + atomic_set(&dev->in_use, 0);
> + wake_up(&dev->disconnect_wq);
> +}
> +static int __init qc_usb_audio_offload_init(void)
> +{
> + struct uaudio_qmi_svc *svc;
> + int ret;
> +
> + ret = snd_usb_register_platform_ops(&offload_ops);
> + if (ret < 0)
> + return ret;
so what happens if snd_usb is blacklisted or takes time to probe?
This seems to assume a timing dependency when USB is initialized/probed
first?
> +
> + svc = kzalloc(sizeof(struct uaudio_qmi_svc), GFP_KERNEL);
> + if (!svc) {
> + ret = -ENOMEM;
> + goto unreg_ops;
> + }
> +
> + svc->uaudio_wq = create_singlethread_workqueue("uaudio_svc");
> + if (!svc->uaudio_wq) {
> + ret = -ENOMEM;
> + goto free_svc;
> + }
> +
> + svc->uaudio_svc_hdl = kzalloc(sizeof(struct qmi_handle), GFP_KERNEL);
> + if (!svc->uaudio_svc_hdl) {
> + ret = -ENOMEM;
> + goto free_wq;
> + }
> +
> + ret = qmi_handle_init(svc->uaudio_svc_hdl,
> + QMI_UAUDIO_STREAM_REQ_MSG_V01_MAX_MSG_LEN,
> + &uaudio_svc_ops_options,
> + &uaudio_stream_req_handlers);
> + ret = qmi_add_server(svc->uaudio_svc_hdl, UAUDIO_STREAM_SERVICE_ID_V01,
> + UAUDIO_STREAM_SERVICE_VERS_V01, 0);
> +
> + INIT_WORK(&svc->qmi_disconnect_work, qmi_disconnect_work);
> + uaudio_svc = svc;
> +
> + return 0;
> +
> +free_wq:
> + destroy_workqueue(svc->uaudio_wq);
> +free_svc:
> + kfree(svc);
> +unreg_ops:
> + snd_usb_unregister_platform_ops();
> +
> + return ret;
> +}
> +
> +static void __exit qc_usb_audio_offload_exit(void)
> +{
> + struct uaudio_qmi_svc *svc = uaudio_svc;
> +
> + qmi_handle_release(svc->uaudio_svc_hdl);
> + flush_workqueue(svc->uaudio_wq);
> + destroy_workqueue(svc->uaudio_wq);
> + kfree(svc);
> + uaudio_svc = NULL;
> + snd_usb_unregister_platform_ops();
> +}
> +
> +module_init(qc_usb_audio_offload_init);
> +module_exit(qc_usb_audio_offload_exit);
what causes this module to be loaded?
> +
> +MODULE_DESCRIPTION("QC USB Audio Offloading");
> +MODULE_LICENSE("GPL");
> diff --git a/sound/usb/qcom/usb_audio_qmi_v01.c b/sound/usb/qcom/usb_audio_qmi_v01.c
> new file mode 100644
> index 000000000000..1a0f2f579786
> --- /dev/null
> +++ b/sound/usb/qcom/usb_audio_qmi_v01.c
> @@ -0,0 +1,892 @@
> +// SPDX-License-Identifier: GPL-2.0
> +/*
> + * Copyright (c) 2022-2023 Qualcomm Innovation Center, Inc. All rights reserved.
> + */
> +
> +#include <linux/soc/qcom/qmi.h>
> +
> +#include "usb_audio_qmi_v01.h"
> +
> +static struct qmi_elem_info mem_info_v01_ei[] = {
> + {
> + .data_type = QMI_UNSIGNED_8_BYTE,
> + .elem_len = 1,
> + .elem_size = sizeof(u64),
> + .array_type = NO_ARRAY,
> + .tlv_type = 0,
> + .offset = offsetof(struct mem_info_v01, va),
> + },
maybe move these arrays to a different patch that we don't need to
scroll-through or review...
> + {
> + .data_type = QMI_UNSIGNED_8_BYTE,
> + .elem_len = 1,
> + .elem_size = sizeof(u64),
> + .array_type = NO_ARRAY,
> + .tlv_type = 0,
> + .offset = offsetof(struct mem_info_v01, pa),
> + },
> + {
> + .data_type = QMI_UNSIGNED_4_BYTE,
> + .elem_len = 1,
> + .elem_size = sizeof(u32),
> + .array_type = NO_ARRAY,
> + .tlv_type = 0,
> + .offset = offsetof(struct mem_info_v01, size),
> + },
> + {
> + .data_type = QMI_EOTI,
> + .array_type = NO_ARRAY,
> + .tlv_type = QMI_COMMON_TLV_TYPE,
> + },
> +};
Hi Srinivas,
On 3/9/2023 1:01 AM, Srinivas Kandagatla wrote:
>
>
> On 08/03/2023 23:57, Wesley Cheng wrote:
>> The Q6USB backend can carry information about the available USB SND cards
>> and PCM devices discovered on the USB bus. The dev_token field is
>> used by
>> the audio DSP to notify the USB offload driver of which card and PCM
>> index
>> to enable playback on. Separate this into a dedicated API, so the USB
>> backend can set the dev_token accordingly. The audio DSP does not
>> utilize
>> this information until the AFE port start command is sent, which is done
>> during the PCM prepare phase.
>>
>> Signed-off-by: Wesley Cheng <[email protected]>
>> ---
>> sound/soc/qcom/qdsp6/q6afe.c | 49 +++++++++++++++++++++++++-----------
>> sound/soc/qcom/qdsp6/q6afe.h | 1 +
>> 2 files changed, 36 insertions(+), 14 deletions(-)
>>
> Looks like this could be part of [06/28] ASoC: qcom: qdsp6: Introduce
> USB AFE port to q6dsp
>
> you are modifying the 06/28 patch in this patch.
>
> other than that it looks fine to me.
>
Sure I'll squash the two.
Thanks
Wesley Cheng
Hi Greg,
On 3/8/2023 10:38 PM, Greg KH wrote:
> On Wed, Mar 08, 2023 at 03:57:25PM -0800, Wesley Cheng wrote:
>> Some use cases, such as USB audio offloading, will allow for a DSP to take
>> over issuing USB transfers to the host controller. In order for the DSP to
>> submit transfers for a particular endpoint, and to handle its events, the
>> client driver will need to query for some parameters allocated by XHCI.
>>
>> - XHCI secondary interrupter event ring address
>> - XHCI transfer ring address (for a particular EP)
>> - Stop endpoint command API
>>
>> Once the resources are handed off to the DSP, the offload begins, and the
>> main processor can enter idle. When stopped, since there are no URBs
>> submitted from the main processor, the client will just issue a stop
>> endpoint command to halt any pending transfers.
>>
>> Signed-off-by: Wesley Cheng <[email protected]>
>> ---
>> drivers/usb/host/xhci.c | 130 ++++++++++++++++++++++++++++++++++
>> include/linux/usb/xhci-intr.h | 8 +++
>> 2 files changed, 138 insertions(+)
>
> Please use checkpatch.pl on your patches before sending them out :(
>
> Some other minor comments:
>
Thanks for taking the time to review these!
Hmm, I did run checkpatch, and cleaned up the warnings it did give.
However, I think something changed with regards to the tools on my host
env. Will address those and make sure it runs properly next time.
Will fix the minor changes you mentioned, and focus on the general
questions you had.
>> diff --git a/include/linux/usb/xhci-intr.h b/include/linux/usb/xhci-intr.h
>> index 738b0f0481a6..d42cc9a1e698 100644
>> --- a/include/linux/usb/xhci-intr.h
>> +++ b/include/linux/usb/xhci-intr.h
>> @@ -80,7 +80,15 @@ struct xhci_interrupter {
>> u64 s3_erst_dequeue;
>> };
>>
>> +/* Secondary interrupter */
>> struct xhci_interrupter *
>> xhci_create_secondary_interrupter(struct usb_hcd *hcd, int intr_num);
>> void xhci_remove_secondary_interrupter(struct usb_hcd *hcd, struct xhci_interrupter *ir);
>> +
>> +/* Offload */
>> +int xhci_stop_endpoint(struct usb_device *udev,
>> + struct usb_host_endpoint *ep);
>> +phys_addr_t xhci_get_xfer_resource(struct usb_device *udev,
>> + struct usb_host_endpoint *ep, dma_addr_t *dma);
>> +phys_addr_t xhci_get_ir_resource(struct usb_device *udev, struct xhci_interrupter *ir);
>
> Why are these functions unique to offload?
>
Wanted to separate the set of APIs used for creating a secondary
interrupter versus offload related ones. In general, the APIs under the
secondary interrupter portion can be used for other things other than
offloading. As Mathias pointed out, they had a use case where they
wanted to utilize the secondary interrupter to actually route and
receive interrupts on the secondary ring, not to suppress them. (which
is opposite of what the offload concept is doing)
Now for the offload section, those are specific to that feature, because
we need to pass certain memory information about what was allocated by
XHCI to the entity that we are offloading the IO operations to. Hence,
why they are APIs which fetch the transfer ring and event ring
addresses. In addition, we do have the stop EP as well, since in the
offload case, since the main processor doesn't submit TDs (transfer
descriptors) then it isn't aware there are transfers in progress. When
the endpoint is released, then the offload driver needs to be the one
that halts the EP.
As you mentioned, I will add documentation to better describe these.
Thanks
Wesley Cheng
Hi Pierre,
On 3/9/2023 9:13 AM, Pierre-Louis Bossart wrote:
>
>
> On 3/8/23 17:57, Wesley Cheng wrote:
>> Changes in v3:
>> - Changed prefix from RFC to PATCH
>> - Rebased entire series to usb-next
>> - Updated copyright years
>
> You may want to move the per-version changes after the description of
> this patchset.
>
Thanks for reading through this :).
Sure, will do that going forward.
>> XHCI:
>> - Rebased changes on top of XHCI changes merged into usb-next, and only added
>> changes that were still under discussion.
>> - Added change to read in the "num-hc-interrupters" device property.
>>
>> ASoC:
>> - qusb6 USB backend
>> - Incorporated suggestions to fetch iommu information with existing APIs
>> - Added two new sound kcontrols to fetch offload status and offload device
>> selection.
>> - offload status - will return the card and pcm device in use
>> tinymix -D 0 get 1 --> 1, 0 (offload in progress on card#1 pcm#0)
>>
>> - device selection - set the card and pcm device to enable offload on. Ex.:
>> tinymix -D 0 set 1 2 0 --> sets offload on card#2 pcm#0
>> (this should be the USB card)
>>
>> USB SND:
>> - Fixed up some locking related concerns for registering platform ops.
>> - Moved callbacks under the register_mutex, so that
>> - Modified APIs to properly pass more information about the USB SND device, so
>> that the Q6USB backend can build a device list/map, in order to monitor offload
>> status and device selection.
>>
>> Changes in v2:
>>
>> XHCI:
>> - Replaced XHCI and HCD changes with Mathias' XHCI interrupter changes
>> in his tree:
>> https://git.kernel.org/pub/scm/linux/kernel/git/mnyman/xhci.git/log/?h=feature_interrupters
>>
>> Adjustments made to Mathias' changes:
>> - Created xhci-intr.h to export/expose interrupter APIs versus exposing xhci.h.
>> Moved dependent structures to this file as well. (so clients can parse out
>> information from "struct xhci_interrupter")
>> - Added some basic locking when requesting interrupters.
>> - Fixed up some sanity checks.
>> - Removed clearing of the ERSTBA during freeing of the interrupter. (pending
>> issue where SMMU fault occurs if DMA addr returned is 64b - TODO)
>>
>> - Clean up pending events in the XHCI secondary interrupter. While testing USB
>> bus suspend, it was seen that on bus resume, the xHCI HC would run into a command
>> timeout.
>> - Added offloading APIs to xHCI to fetch transfer and event ring information.
>>
>> ASoC:
>> - Modified soc-usb to allow for multiple USB port additions. For this to work,
>> the USB offload driver has to have a reference to the USB backend by adding
>> a "usb-soc-be" DT entry to the device saved into XHCI sysdev.
>> - Created separate dt-bindings for defining USB_RX port.
>> - Increased APR timeout to accommodate the situation where the AFE port start
>> command could be delayed due to having to issue a USB bus resume while
>> handling the QMI stream start command.
>>
>> USB SND:
>> - Added a platform ops during usb_audio_suspend(). This allows for the USB
>> offload driver to halt the audio stream when system enters PM suspend. This
>> ensures the audio DSP is not issuing transfers on the USB bus.
>> - Do not override platform ops if they are already populated.
>> - Introduce a shared status variable between the USB offload and USB SND layers,
>> to ensure that only one path is active at a time. If the USB bus is occupied,
>> then userspace is notified that the path is busy.
>
>
> ---> start of the cover letter:
>
>> Several Qualcomm based chipsets can support USB audio offloading to a
>> dedicated audio DSP, which can take over issuing transfers to the USB
>> host controller. The intention is to reduce the load on the main
>> processors in the SoC, and allow them to be placed into lower power modes.
>> There are several parts to this design:
>> 1. Adding ASoC binding layer
>> 2. Create a USB backend for Q6DSP
>
> clarify what 'backend' means. I would guess you are referring to the
> ASoC DPCM concept of Back-End, which typically exposes an audio
> interface controlled by a DSP?
>
> If yes, the description should be
>
> "Create a Q6DSP ASoC DPCM BackEnd for USB audio playback/record".
>
You're correct. "backend" was referring to a Q6DSP ASoC DPCM backend.
>> 3. Introduce XHCI interrupter support
>> 4. Create vendor ops for the USB SND driver
>
> Add an introduction as to why this would be needed? which 'vendor' are
> we talking about, is this on the SOC side or the USB device side?
>
This would be referring to the SoC side. For example, QCOM can
potentially have a different implementation of offloading USB SND to the
audio DSP versus another OEM. This is to allow those other entities to
be able to define their own offload methodology.
For the most part, the common operations across all offloading
implementations have so far is being able to handle USB SND
connect/disconnect events.
>> Adding ASoC binding layer:
>> soc-usb: Intention is to treat a USB port similar to a headphone jack.
>> The port is always present on the device, but cable/pin status can be
>> enabled/disabled. Expose mechanisms for USB backend ASoC drivers to
>> communicate with USB SND.
>
> port == backend?
>
> Using different words for the same concept is a sure way to lose the
> reviewers, and not describing different concepts isn't much better.
>
Yes, port is corresponding to the
>> Create a USB backend for Q6DSP:
>> q6usb: Basic backend driver that will be responsible for maintaining the
>
> What does this mean? Is this a module that registers a set of ASoC DAIs?
>
> It's not clear to me what a 'backend driver' means either in a USB or
> ASoC context.
>
Will fix this up next time. It refers to a Q6DSP DPCM ASoC backend, as
you mentioned above.
>> resources needed to initiate a playback stream using the Q6DSP. Will
>> be the entity that checks to make sure the connected USB audio device
>> supports the requested PCM format. If it does not, the PCM open call will
>> fail, and userpsace ALSA can take action accordingly.
>
> If it's an ASoC backend, there is no PCM open call. You're probably
> referring to the hw_params, not the open/startup anyways.
>
Correct. Will fix this.
>>
>> Introduce XHCI interrupter support:
>> XHCI HCD supports multiple interrupters, which allows for events to be routed
>> to different event rings. This is determined by "Interrupter Target" field
>> specified in Section "6.4.1.1 Normal TRB" of the XHCI specification.
>>
>> Events in the offloading case will be routed to an event ring that is assigned
>> to the audio DSP.
>>
>> Create vendor ops for the USB SND driver:
>> qc_audio_offload: This particular driver has several components associated
>> with it:
>> - QMI stream request handler
>> - XHCI interrupter and resource management
>> - audio DSP memory management
>
> so how does this 'qc_audio_offload' interface with 'q6usb' described
> above? how are the roles different or complementary?
>
So in general you can think that the qc_audio_offload is a complement to
the USB SND USB class driver, while q6usb is to ASoC. Since the ASoC
framework doesn't have any communication with USB SND, the ASoC DPCM USB
backend (q6usb) will have to be the entity that maintains what is going
on in USB SND. That way, sessions initiated through the ASoC managed
sound card can evaluate what is available based on information reported
by q6usb.
qc_audio_offload and q6usb will have some interaction between each
other. The majority of communication between qc_audio_offload and q6usb
is reporting the device connection events.
>> When the audio DSP wants to enable a playback stream, the request is first
>> received by the ASoC platform sound card. Depending on the selected route,
>> ASoC will bring up the individual DAIs in the path. The Q6USB backend DAI
>> will send an AFE port start command (with enabling the USB playback path), and
>> the audio DSP will handle the request accordingly.
>>
>> Part of the AFE USB port start handling will have an exchange of control
>> messages using the QMI protocol. The qc_audio_offload driver will populate the
>> buffer information:
>> - Event ring base address
>> - EP transfer ring base address
>>
>> and pass it along to the audio DSP. All endpoint management will now be handed
>> over to the DSP, and the main processor is not involved in transfers.
>>
>> Overall, implementing this feature will still expose separate sound card and PCM
>> devices for both the platorm card and USB audio device:
>> 0 [SM8250MTPWCD938]: sm8250 - SM8250-MTP-WCD9380-WSA8810-VA-D
>> SM8250-MTP-WCD9380-WSA8810-VA-DMIC
>> 1 [Audio ]: USB-Audio - USB Audio
>> Generic USB Audio at usb-xhci-hcd.1.auto-1.4, high speed
>>
>> This is to ensure that userspace ALSA entities can decide which route to take
>> when executing the audio playback. In the above, if card#1 is selected, then
>> USB audio data will take the legacy path over the USB PCM drivers, etc...
>
> I already voiced my concerns about exposing two cards, each with their
> own set of volume controls with the same device. It would be much better
> to have an additional offloaded PCM device for card0...
>
> But if the consensus is to have two cards, it's still not clear how the
> routing would be selected. In the case where there are two USB audio
> devices attached, the offloaded path would only support one of the two.
> How would userspace know which of the two is selected?
>
With patch#24:
https://lore.kernel.org/linux-usb/[email protected]/T/#u
Now, userspace can at least choose which device it wants to offload.
Part of doing that would mean userspace knows what USB SND card devices
are available, so it is aware of which devices are shared (between the
offload and USB SND path)
> And how would userspace know the difference anyways between two physical
> devices attached to the platform with no offload, and one physical
> device with one additional offload path? The names you selected can't be
> used to identify that card1 is the optimized version of card0.
>
Is userspace currently able to differentiate between cards that are
created by USB SND versus ASoC? How complex can the userspace card
discovery be? Can it query kcontrols at this point in time? If so,
maybe we can change the names of the newly added ones to reflect that it
is an offload device?
SND kcontrol names are currently:
Q6USB offload status
Q6USB offload SND device select
> Before we review low-level kernel plumbing, it would be good to give a
> better overview of how userspace applications are supposed to interact
> with the cards and identify the offloaded path. Testing with
> tinyplay/tinymix is fine, but that's a developer-level or CI unit test.
> we've got to see the broader picture of how a sound server would use
> this USB offload capability.
Sure, I think that is fine. I was hoping that at least adding some of
the new kcontrols would help userspace make use of this path in general,
but we can add more information if required.
Thanks
Wesley Cheng
>>> Create vendor ops for the USB SND driver:
>>> qc_audio_offload: This particular driver has several components
>>> associated
>>> with it:
>>> - QMI stream request handler
>>> - XHCI interrupter and resource management
>>> - audio DSP memory management
>>
>> so how does this 'qc_audio_offload' interface with 'q6usb' described
>> above? how are the roles different or complementary?
>>
> So in general you can think that the qc_audio_offload is a complement to
> the USB SND USB class driver, while q6usb is to ASoC. Since the ASoC
Humm, that is far from clear. I don't get how a something that interacts
with the USB class driver can also be in charge of the audio DSP memory
management.
> framework doesn't have any communication with USB SND, the ASoC DPCM USB
> backend (q6usb) will have to be the entity that maintains what is going
> on in USB SND. That way, sessions initiated through the ASoC managed
> sound card can evaluate what is available based on information reported
> by q6usb.
>
> qc_audio_offload and q6usb will have some interaction between each
> other. The majority of communication between qc_audio_offload and q6usb
> is reporting the device connection events.
It's already complicated to figure out how the DSP and USB class driver
might interact and probe/timing dependencies, but with two additional
drivers in the mix it's really hard to understand.
Maybe ascii-art would help describe the concepts and types of
information exchanged. Maintaining a consistent state across multiple
drivers is not an easy task.
>
>>> When the audio DSP wants to enable a playback stream, the request is
>>> first
>>> received by the ASoC platform sound card. Depending on the selected
>>> route,
>>> ASoC will bring up the individual DAIs in the path. The Q6USB
>>> backend DAI
>>> will send an AFE port start command (with enabling the USB playback
>>> path), and
>>> the audio DSP will handle the request accordingly.
>>>
>>> Part of the AFE USB port start handling will have an exchange of control
>>> messages using the QMI protocol. The qc_audio_offload driver will
>>> populate the
>>> buffer information:
>>> - Event ring base address
>>> - EP transfer ring base address
>>>
>>> and pass it along to the audio DSP. All endpoint management will now
>>> be handed
>>> over to the DSP, and the main processor is not involved in transfers.
>>>
>>> Overall, implementing this feature will still expose separate sound
>>> card and PCM
>>> devices for both the platorm card and USB audio device:
>>> 0 [SM8250MTPWCD938]: sm8250 - SM8250-MTP-WCD9380-WSA8810-VA-D
>>> SM8250-MTP-WCD9380-WSA8810-VA-DMIC
>>> 1 [Audio ]: USB-Audio - USB Audio
>>> Generic USB Audio at usb-xhci-hcd.1.auto-1.4,
>>> high speed
>>>
>>> This is to ensure that userspace ALSA entities can decide which route
>>> to take
>>> when executing the audio playback. In the above, if card#1 is
>>> selected, then
>>> USB audio data will take the legacy path over the USB PCM drivers,
>>> etc...
>>
>> I already voiced my concerns about exposing two cards, each with their
>> own set of volume controls with the same device. It would be much better
>> to have an additional offloaded PCM device for card0...
>>
>> But if the consensus is to have two cards, it's still not clear how the
>> routing would be selected. In the case where there are two USB audio
>> devices attached, the offloaded path would only support one of the two.
>> How would userspace know which of the two is selected?
>>
>
> With patch#24:
> https://lore.kernel.org/linux-usb/[email protected]/T/#u
>
> Now, userspace can at least choose which device it wants to offload.
> Part of doing that would mean userspace knows what USB SND card devices
> are available, so it is aware of which devices are shared (between the
> offload and USB SND path)
>
>> And how would userspace know the difference anyways between two physical
>> devices attached to the platform with no offload, and one physical
>> device with one additional offload path? The names you selected can't be
>> used to identify that card1 is the optimized version of card0.
>>
>
> Is userspace currently able to differentiate between cards that are
> created by USB SND versus ASoC? How complex can the userspace card
> discovery be? Can it query kcontrols at this point in time? If so,
> maybe we can change the names of the newly added ones to reflect that it
> is an offload device?
>
> SND kcontrol names are currently:
> Q6USB offload status
> Q6USB offload SND device select
I must admit I've never seen kcontrols being used to identify what the
card is, and in this case it's a pretend-card that's just an improved
version of another. It might be easier to use something else, such as
the component strings.
>
>> Before we review low-level kernel plumbing, it would be good to give a
>> better overview of how userspace applications are supposed to interact
>> with the cards and identify the offloaded path. Testing with
>> tinyplay/tinymix is fine, but that's a developer-level or CI unit test.
>> we've got to see the broader picture of how a sound server would use
>> this USB offload capability.
>
> Sure, I think that is fine. I was hoping that at least adding some of
> the new kcontrols would help userspace make use of this path in general,
> but we can add more information if required.
Can I ask if this solution has been used with a complete userspace stack
already? I could see how this might be used with a relatively fixed
Android HAL, where the platform and routing are relatively controlled. I
don't see how a more generic audio server would deal with the discovery
and routing.
On 09/03/2023 00:57, Wesley Cheng wrote:
> Add an example on enabling of USB offload for the Q6DSP. The routing can
> be done by the mixer, which can pass the multimedia stream to the USB
> backend.
>
> Signed-off-by: Wesley Cheng <[email protected]>
Reviewed-by: Krzysztof Kozlowski <[email protected]>
You still miss binding change to APR/GPR. Where is the USB DAI going to sit?
Best regards,
Krzysztof
On 09.03.2023 01:57, Wesley Cheng wrote:
> EXTERNAL EMAIL: Do not click links or open attachments unless you know the content is safe
>
> Some use cases, such as USB audio offloading, will allow for a DSP to take
> over issuing USB transfers to the host controller. In order for the DSP to
> submit transfers for a particular endpoint, and to handle its events, the
> client driver will need to query for some parameters allocated by XHCI.
>
> - XHCI secondary interrupter event ring address
> - XHCI transfer ring address (for a particular EP)
> - Stop endpoint command API
>
> Once the resources are handed off to the DSP, the offload begins, and the
> main processor can enter idle. When stopped, since there are no URBs
> submitted from the main processor, the client will just issue a stop
> endpoint command to halt any pending transfers.
>
> Signed-off-by: Wesley Cheng <[email protected]>
> ---
> drivers/usb/host/xhci.c | 130 ++++++++++++++++++++++++++++++++++
> include/linux/usb/xhci-intr.h | 8 +++
> 2 files changed, 138 insertions(+)
>
> diff --git a/drivers/usb/host/xhci.c b/drivers/usb/host/xhci.c
> index 88435b9cd66e..5c6b3d8f834c 100644
> --- a/drivers/usb/host/xhci.c
> +++ b/drivers/usb/host/xhci.c
> @@ -1603,6 +1603,136 @@ static int xhci_check_args(struct usb_hcd *hcd, struct usb_device *udev,
> return 1;
> }
>
> +int xhci_stop_endpoint(struct usb_device *udev,
> + struct usb_host_endpoint *ep)
> +{
> + struct usb_hcd *hcd = bus_to_hcd(udev->bus);
> + struct xhci_hcd *xhci = hcd_to_xhci(hcd);
> + unsigned int ep_index;
> + struct xhci_virt_device *virt_dev;
> + struct xhci_command *cmd;
> + unsigned long flags;
> + int ret = 0;
No need to initialize it.
> +
> + ret = xhci_check_args(hcd, udev, ep, 1, true, __func__);
> + if (ret <= 0)
> + return ret;
> +
> + cmd = xhci_alloc_command(xhci, true, GFP_NOIO);
> + if (!cmd)
> + return -ENOMEM;
> +
> + spin_lock_irqsave(&xhci->lock, flags);
> + virt_dev = xhci->devs[udev->slot_id];
> + if (!virt_dev) {
> + ret = -ENODEV;
> + goto err;
> + }
> +
> + ep_index = xhci_get_endpoint_index(&ep->desc);
> + if (virt_dev->eps[ep_index].ring &&
> + virt_dev->eps[ep_index].ring->dequeue) {
> + ret = xhci_queue_stop_endpoint(xhci, cmd, udev->slot_id,
> + ep_index, 0);
> + if (ret)
> + goto err;
> +
> + xhci_ring_cmd_db(xhci);
> + spin_unlock_irqrestore(&xhci->lock, flags);
> +
> + /* Wait for stop endpoint command to finish */
> + wait_for_completion(cmd->completion);
> +
> + if (cmd->status == COMP_COMMAND_ABORTED ||
> + cmd->status == COMP_STOPPED) {
^ usually here go 2nd condition
> + xhci_warn(xhci,
> + "stop endpoint command timeout for ep%d%s\n",
> + usb_endpoint_num(&ep->desc),
> + usb_endpoint_dir_in(&ep->desc) ? "in" : "out");
> + ret = -ETIME;
> + }
} should be aligned with if
[ ... ]
Hi Pierre,
On 3/9/2023 4:37 PM, Pierre-Louis Bossart wrote:
>
>>>> Create vendor ops for the USB SND driver:
>>>> qc_audio_offload: This particular driver has several components
>>>> associated
>>>> with it:
>>>> - QMI stream request handler
>>>> - XHCI interrupter and resource management
>>>> - audio DSP memory management
>>>
>>> so how does this 'qc_audio_offload' interface with 'q6usb' described
>>> above? how are the roles different or complementary?
>>>
>> So in general you can think that the qc_audio_offload is a complement to
>> the USB SND USB class driver, while q6usb is to ASoC. Since the ASoC
>
> Humm, that is far from clear. I don't get how a something that interacts
> with the USB class driver can also be in charge of the audio DSP memory
> management.
>
This is because the USB class driver is the entity which is going to
work with the USB HCD (XHCI) in this case to fetch the required
addresses, and map that into memory accessible by the audio DSP. It
would be odd to be doing that from the q6usb end, which is part of the
ASoC layer.
>> framework doesn't have any communication with USB SND, the ASoC DPCM USB
>> backend (q6usb) will have to be the entity that maintains what is going
>> on in USB SND. That way, sessions initiated through the ASoC managed
>> sound card can evaluate what is available based on information reported
>> by q6usb.
>>
>> qc_audio_offload and q6usb will have some interaction between each
>> other. The majority of communication between qc_audio_offload and q6usb
>> is reporting the device connection events.
>
> It's already complicated to figure out how the DSP and USB class driver
> might interact and probe/timing dependencies, but with two additional
> drivers in the mix it's really hard to understand.
>
I did test some cases based on existence of both these drivers
(qc_audio_offload and q6usb). If either one doesn't exist in the
system, then the offload path would not work. I did improve some of
these potential sequences in the latest revision, such as patch#28. This
would address scenarios where the q6usb ASoC DPCM backend wasn't probed,
while the USB SND (and qc_audio_offload) were still detecting device
connections.
Once the Q6USB driver is probed, then the offload snd kcontrols would be
created, and devices would be properly identified with the rediscover api.
> Maybe ascii-art would help describe the concepts and types of
> information exchanged. Maintaining a consistent state across multiple
> drivers is not an easy task.
>
Hopefully this might help? I know its a lot to read through.
USB | ASoC
--------------------------------------------------------------------
| _________________________
| |sm8250 platform card |
| |_________________________|
| | |
| ___V____ ____V____
| |Q6USB | |Q6AFE | #5
| |"codec" | |"cpu" |
| |________| |_________|
| ^
| | #6
| ___V____
| |SOC-USB |
________ #1 ________ #7 | |
|USB SND |<--->|QC offld|<------------>|________|
|(card.c)| | |<---------- ^
|________| |________|___ #4 | | |
^ ^ | | | ___V__________________
| #2 | #2 | | | |APR/GLINK |
__ V_______________V_____ | | | |______________________|
|USB SND (endpoint.c) | | | | ^
|_________________________| | | | #8 |
^ | | | ___________V___________
| #3 | | |->|audio DSP |
___________V_____________ | | |_______________________|
|XHCI HCD |<- |
|_________________________| |
#1 - USB SND and QC offload:
Initialization:
- Register platform operations, to receive connect/disconnect events
from USB SND.
- QC offload creates a QMI handle, in order to receive QMI requests
from the audio DSP.
Runtime:
- USB SND passes along "struct snd_usb_audio" in order for QC offload
to reference USB UAC desc parsing/USB SND helper APIs.
- USB device disconnection events will result in clearing of the chip
entry.
#2 - USB SND and QC offload endpoints:
Runtime:
- In the non-offloaded path, USB snd will utilize functions exposed by
USB SND endpoint, to help with fetching USB EP references and queuing
URBs.
- In the offload path, qc offload will utilize the functions to fetch
USB EP references, so that it can use that information to query the
XHCI HCD.
- Likewise, both will clean up endpoints when audio stream is not in use.
#3 - XHCI HCD:
Initialization:
- During XHCI probe timing, when the USB HCD is added to the system, it
will also initialize the secondary event rings.
Runtime:
- During USB device plug ins/outs, allocates device slot, assigns eps,
and initializes transfer rings.
#4 - QC offload and XHCI:
Runtime:
- QC offload needs to reference the transfer ring and secondary event ring
addresses by executing XHCI offload management APIs.
- This happens when audio DSP receives a USB QMI stream request.
#5 - ASoC components:
Initialization:
- The SM8250 platform sound card driver fetches DT node entries defining
the ASoC links. This chain/link has the components involved for a
particular Q6AFE path. (not only USB offload)
- "cpu" - this is the ASoC CPU DAI that handles interaction with the
Q6 DSP's audio protocol. (AFE ports)
- "codec" - the ASoC codec (backend) DAI defined
- Registers ASoC platform sound card based on links defined in the DT node.
- Probes DAI components involved, ie Q6USB and Q6AFE
Runtime:
- Q6AFE has the bulk of the interaction w/ the audio DSP to start an audio
session, such as issuing AFE port start commands (part of the protocol
used to communicate the audio session info)
- Q6USB will be there to now check for if format requested is supported by
the device, and maintain offloading status.
#6 - Q6USB and SOC-USB:
Initialization:
- Q6USB will query QC offload for USB device connection states. (through
soc-usb)
- Creates a SOC USB entry, that carries information about resources,
such as audio DSP memory information and requested XHCI event ring
index.
Runtime:
- SOC-USB will receive connect/disconnect events and propagate to Q6USB.
- Q6USB makes devices available for offloading based on these events.
- Sets Q6AFE port configurations to select the USB SND card# and PCM#.
#7 - SOC-USB and QC offload:
Initialization:
- Rediscover USB SND devices when the SOC-USB entry is created (if needed)
- For situations where the Q6USB DAI hasn't been probed.
Runtime:
- Propagate connect/disconnect events.
#8 - audio DSP and QC offload:
Runtime:
- Handle QMI requests coming from audio DSP. These requests come AFTER
the Q6AFE port is opened by the Q6AFE DAI(#6)
- Returns memory information about resources allocated by XHCI.
- Enables audio playback when this QMI transaction is completed.
>>
>>>> When the audio DSP wants to enable a playback stream, the request is
>>>> first
>>>> received by the ASoC platform sound card. Depending on the selected
>>>> route,
>>>> ASoC will bring up the individual DAIs in the path. The Q6USB
>>>> backend DAI
>>>> will send an AFE port start command (with enabling the USB playback
>>>> path), and
>>>> the audio DSP will handle the request accordingly.
>>>>
>>>> Part of the AFE USB port start handling will have an exchange of control
>>>> messages using the QMI protocol. The qc_audio_offload driver will
>>>> populate the
>>>> buffer information:
>>>> - Event ring base address
>>>> - EP transfer ring base address
>>>>
>>>> and pass it along to the audio DSP. All endpoint management will now
>>>> be handed
>>>> over to the DSP, and the main processor is not involved in transfers.
>>>>
>>>> Overall, implementing this feature will still expose separate sound
>>>> card and PCM
>>>> devices for both the platorm card and USB audio device:
>>>> 0 [SM8250MTPWCD938]: sm8250 - SM8250-MTP-WCD9380-WSA8810-VA-D
>>>> SM8250-MTP-WCD9380-WSA8810-VA-DMIC
>>>> 1 [Audio ]: USB-Audio - USB Audio
>>>> Generic USB Audio at usb-xhci-hcd.1.auto-1.4,
>>>> high speed
>>>>
>>>> This is to ensure that userspace ALSA entities can decide which route
>>>> to take
>>>> when executing the audio playback. In the above, if card#1 is
>>>> selected, then
>>>> USB audio data will take the legacy path over the USB PCM drivers,
>>>> etc...
>>>
>>> I already voiced my concerns about exposing two cards, each with their
>>> own set of volume controls with the same device. It would be much better
>>> to have an additional offloaded PCM device for card0...
>>>
>>> But if the consensus is to have two cards, it's still not clear how the
>>> routing would be selected. In the case where there are two USB audio
>>> devices attached, the offloaded path would only support one of the two.
>>> How would userspace know which of the two is selected?
>>>
>>
>> With patch#24:
>> https://lore.kernel.org/linux-usb/[email protected]/T/#u
>>
>> Now, userspace can at least choose which device it wants to offload.
>> Part of doing that would mean userspace knows what USB SND card devices
>> are available, so it is aware of which devices are shared (between the
>> offload and USB SND path)
>>
>>> And how would userspace know the difference anyways between two physical
>>> devices attached to the platform with no offload, and one physical
>>> device with one additional offload path? The names you selected can't be
>>> used to identify that card1 is the optimized version of card0.
>>>
>>
>> Is userspace currently able to differentiate between cards that are
>> created by USB SND versus ASoC? How complex can the userspace card
>> discovery be? Can it query kcontrols at this point in time? If so,
>> maybe we can change the names of the newly added ones to reflect that it
>> is an offload device?
>>
>> SND kcontrol names are currently:
>> Q6USB offload status
>> Q6USB offload SND device select
>
> I must admit I've never seen kcontrols being used to identify what the
> card is, and in this case it's a pretend-card that's just an improved
> version of another. It might be easier to use something else, such as
> the component strings.
Its not exactly a pretend card, right? This is part of the overall
platform sound card we have in the system. At the moment, I'm only
testing by adding the USB audio routing, but there can be several ASoC
links defined in the overall platform card.
The Q6AFE CPU DAI has multiple audio AFE "ports" they can handle. USB
is only one of those.
>>
>>> Before we review low-level kernel plumbing, it would be good to give a
>>> better overview of how userspace applications are supposed to interact
>>> with the cards and identify the offloaded path. Testing with
>>> tinyplay/tinymix is fine, but that's a developer-level or CI unit test.
>>> we've got to see the broader picture of how a sound server would use
>>> this USB offload capability.
>>
>> Sure, I think that is fine. I was hoping that at least adding some of
>> the new kcontrols would help userspace make use of this path in general,
>> but we can add more information if required.
>
> Can I ask if this solution has been used with a complete userspace stack
> already? I could see how this might be used with a relatively fixed
Its been used only with the Android HAL.
> Android HAL, where the platform and routing are relatively controlled. I
> don't see how a more generic audio server would deal with the discovery
> and routing.
>
This is why your input is helpful, since it provides another use case
that wasn't considered. I think in our previous discussions the tagging
possibility was a good idea, and was hoping that it could help. Could
tag all USB SND cards to the platform sound card as well, and if the
power saving path is chosen, it would issue the playback on the platform
sound card. (if not in use)
In this case, the offload path wouldn't be the default routing, and only
enabled for power optimized path.
Thanks
Wesley Cheng
On 3/13/23 18:43, Wesley Cheng wrote:
> Hi Pierre,
>
> On 3/9/2023 4:37 PM, Pierre-Louis Bossart wrote:
>>
>>>>> Create vendor ops for the USB SND driver:
>>>>> qc_audio_offload: This particular driver has several components
>>>>> associated
>>>>> with it:
>>>>> - QMI stream request handler
>>>>> - XHCI interrupter and resource management
>>>>> - audio DSP memory management
>>>>
>>>> so how does this 'qc_audio_offload' interface with 'q6usb' described
>>>> above? how are the roles different or complementary?
>>>>
>>> So in general you can think that the qc_audio_offload is a complement to
>>> the USB SND USB class driver, while q6usb is to ASoC. Since the ASoC
>>
>> Humm, that is far from clear. I don't get how a something that interacts
>> with the USB class driver can also be in charge of the audio DSP memory
>> management.
>>
>
> This is because the USB class driver is the entity which is going to
> work with the USB HCD (XHCI) in this case to fetch the required
> addresses, and map that into memory accessible by the audio DSP. It
> would be odd to be doing that from the q6usb end, which is part of the
> ASoC layer.
>
>>> framework doesn't have any communication with USB SND, the ASoC DPCM USB
>>> backend (q6usb) will have to be the entity that maintains what is going
>>> on in USB SND. That way, sessions initiated through the ASoC managed
>>> sound card can evaluate what is available based on information reported
>>> by q6usb.
>>>
>>> qc_audio_offload and q6usb will have some interaction between each
>>> other. The majority of communication between qc_audio_offload and q6usb
>>> is reporting the device connection events.
>>
>> It's already complicated to figure out how the DSP and USB class driver
>> might interact and probe/timing dependencies, but with two additional
>> drivers in the mix it's really hard to understand.
>>
>
> I did test some cases based on existence of both these drivers
> (qc_audio_offload and q6usb). If either one doesn't exist in the
> system, then the offload path would not work. I did improve some of
> these potential sequences in the latest revision, such as patch#28. This
> would address scenarios where the q6usb ASoC DPCM backend wasn't probed,
> while the USB SND (and qc_audio_offload) were still detecting device
> connections.
>
> Once the Q6USB driver is probed, then the offload snd kcontrols would be
> created, and devices would be properly identified with the rediscover api.
>
>> Maybe ascii-art would help describe the concepts and types of
>> information exchanged. Maintaining a consistent state across multiple
>> drivers is not an easy task.
>>
>
> Hopefully this might help? I know its a lot to read through.
It's very helpful! Thanks for spending the time to illustrate the
different building blocks.
>
> USB | ASoC
> --------------------------------------------------------------------
> | _________________________
> | |sm8250 platform card |
> | |_________________________|
> | | |
> | ___V____ ____V____
> | |Q6USB | |Q6AFE | #5
> | |"codec" | |"cpu" |
> | |________| |_________|
> | ^
> | | #6
> | ___V____
> | |SOC-USB |
> ________ #1 ________ #7 | |
> |USB SND |<--->|QC offld|<------------>|________|
> |(card.c)| | |<---------- ^
> |________| |________|___ #4 | | |
> ^ ^ | | | ___V__________________
> | #2 | #2 | | | |APR/GLINK |
> __ V_______________V_____ | | | |______________________|
> |USB SND (endpoint.c) | | | | ^
> |_________________________| | | | #8 |
> ^ | | | ___________V___________
> | #3 | | |->|audio DSP |
> ___________V_____________ | | |_______________________|
> |XHCI HCD |<- |
> |_________________________| |
>
>
> #1 - USB SND and QC offload:
> Initialization:
> - Register platform operations, to receive connect/disconnect events
> from USB SND.
> - QC offload creates a QMI handle, in order to receive QMI requests
> from the audio DSP.
>
> Runtime:
> - USB SND passes along "struct snd_usb_audio" in order for QC offload
> to reference USB UAC desc parsing/USB SND helper APIs.
> - USB device disconnection events will result in clearing of the chip
> entry.
>
> #2 - USB SND and QC offload endpoints:
> Runtime:
> - In the non-offloaded path, USB snd will utilize functions exposed by
> USB SND endpoint, to help with fetching USB EP references and queuing
> URBs.
> - In the offload path, qc offload will utilize the functions to fetch
> USB EP references, so that it can use that information to query the
> XHCI HCD.
> - Likewise, both will clean up endpoints when audio stream is not in use.
>
> #3 - XHCI HCD:
> Initialization:
> - During XHCI probe timing, when the USB HCD is added to the system, it
> will also initialize the secondary event rings.
>
> Runtime:
> - During USB device plug ins/outs, allocates device slot, assigns eps,
> and initializes transfer rings.
>
> #4 - QC offload and XHCI:
> Runtime:
> - QC offload needs to reference the transfer ring and secondary event ring
> addresses by executing XHCI offload management APIs.
> - This happens when audio DSP receives a USB QMI stream request.
>
> #5 - ASoC components:
> Initialization:
> - The SM8250 platform sound card driver fetches DT node entries defining
> the ASoC links. This chain/link has the components involved for a
> particular Q6AFE path. (not only USB offload)
> - "cpu" - this is the ASoC CPU DAI that handles interaction with the
> Q6 DSP's audio protocol. (AFE ports)
> - "codec" - the ASoC codec (backend) DAI defined
> - Registers ASoC platform sound card based on links defined in the DT node.
> - Probes DAI components involved, ie Q6USB and Q6AFE
>
> Runtime:
> - Q6AFE has the bulk of the interaction w/ the audio DSP to start an audio
> session, such as issuing AFE port start commands (part of the protocol
> used to communicate the audio session info)
> - Q6USB will be there to now check for if format requested is supported by
> the device, and maintain offloading status.
>
> #6 - Q6USB and SOC-USB:
> Initialization:
> - Q6USB will query QC offload for USB device connection states. (through
> soc-usb)
> - Creates a SOC USB entry, that carries information about resources,
> such as audio DSP memory information and requested XHCI event ring
> index.
>
> Runtime:
> - SOC-USB will receive connect/disconnect events and propagate to Q6USB.
> - Q6USB makes devices available for offloading based on these events.
> - Sets Q6AFE port configurations to select the USB SND card# and PCM#.
>
> #7 - SOC-USB and QC offload:
> Initialization:
> - Rediscover USB SND devices when the SOC-USB entry is created (if needed)
> - For situations where the Q6USB DAI hasn't been probed.
>
> Runtime:
> - Propagate connect/disconnect events.
Is the SOC-USB module or building blocks intended to be generic or
Qualcomm agnostic?
It's not clear to me how it would handle "audio DSP memory information
and requested XHCI event ring index."
In addition, it seems to be the "bridge" or means of communication
between qc_audio_offload and q6usb, is this not based on custom events
or triggers?
Along the same lines, this SOC-USB entity interfaces with APR/GLINK
which doesn't speak to me so it must be a QCOM interface?
I am trying to see if this design could be used for other architectures,
and the QCOM-specific and generic parts are not obvious.
> #8 - audio DSP and QC offload:
> Runtime:
> - Handle QMI requests coming from audio DSP. These requests come AFTER
> the Q6AFE port is opened by the Q6AFE DAI(#6)
> - Returns memory information about resources allocated by XHCI.
> - Enables audio playback when this QMI transaction is completed.
>
>>>
>>>>> When the audio DSP wants to enable a playback stream, the request is
>>>>> first
>>>>> received by the ASoC platform sound card. Depending on the selected
>>>>> route,
>>>>> ASoC will bring up the individual DAIs in the path. The Q6USB
>>>>> backend DAI
>>>>> will send an AFE port start command (with enabling the USB playback
>>>>> path), and
>>>>> the audio DSP will handle the request accordingly.
>>>>>
>>>>> Part of the AFE USB port start handling will have an exchange of
>>>>> control
>>>>> messages using the QMI protocol. The qc_audio_offload driver will
>>>>> populate the
>>>>> buffer information:
>>>>> - Event ring base address
>>>>> - EP transfer ring base address
>>>>>
>>>>> and pass it along to the audio DSP. All endpoint management will now
>>>>> be handed
>>>>> over to the DSP, and the main processor is not involved in transfers.
>>>>>
>>>>> Overall, implementing this feature will still expose separate sound
>>>>> card and PCM
>>>>> devices for both the platorm card and USB audio device:
>>>>> 0 [SM8250MTPWCD938]: sm8250 - SM8250-MTP-WCD9380-WSA8810-VA-D
>>>>> SM8250-MTP-WCD9380-WSA8810-VA-DMIC
>>>>> 1 [Audio ]: USB-Audio - USB Audio
>>>>> Generic USB Audio at usb-xhci-hcd.1.auto-1.4,
>>>>> high speed
>>>>>
>>>>> This is to ensure that userspace ALSA entities can decide which route
>>>>> to take
>>>>> when executing the audio playback. In the above, if card#1 is
>>>>> selected, then
>>>>> USB audio data will take the legacy path over the USB PCM drivers,
>>>>> etc...
>>>>
>>>> I already voiced my concerns about exposing two cards, each with their
>>>> own set of volume controls with the same device. It would be much
>>>> better
>>>> to have an additional offloaded PCM device for card0...
>>>>
>>>> But if the consensus is to have two cards, it's still not clear how the
>>>> routing would be selected. In the case where there are two USB audio
>>>> devices attached, the offloaded path would only support one of the two.
>>>> How would userspace know which of the two is selected?
>>>>
>>>
>>> With patch#24:
>>> https://lore.kernel.org/linux-usb/[email protected]/T/#u
>>>
>>> Now, userspace can at least choose which device it wants to offload.
>>> Part of doing that would mean userspace knows what USB SND card devices
>>> are available, so it is aware of which devices are shared (between the
>>> offload and USB SND path)
>>>
>>>> And how would userspace know the difference anyways between two
>>>> physical
>>>> devices attached to the platform with no offload, and one physical
>>>> device with one additional offload path? The names you selected
>>>> can't be
>>>> used to identify that card1 is the optimized version of card0.
>>>>
>>>
>>> Is userspace currently able to differentiate between cards that are
>>> created by USB SND versus ASoC? How complex can the userspace card
>>> discovery be? Can it query kcontrols at this point in time? If so,
>>> maybe we can change the names of the newly added ones to reflect that it
>>> is an offload device?
>>>
>>> SND kcontrol names are currently:
>>> Q6USB offload status
>>> Q6USB offload SND device select
>>
>> I must admit I've never seen kcontrols being used to identify what the
>> card is, and in this case it's a pretend-card that's just an improved
>> version of another. It might be easier to use something else, such as
>> the component strings.
>
> Its not exactly a pretend card, right? This is part of the overall
> platform sound card we have in the system. At the moment, I'm only
> testing by adding the USB audio routing, but there can be several ASoC
> links defined in the overall platform card.
Sorry, I misunderstood the proposal. I thought there would be one card
for "generic USB Audio", and another one for "DSP-offloaded USB Audio".
I assumed, probably mistakenly, that all local audio endpoints
(speaker,mics) would be exposed as a separate card.
It looks like it's more "generic USB Audio" and "DSP Audio", with the
USB offload being exposed as a PCM device of the latter.
Did I get this right? In this case, presumably there can be some sort of
UCM file for the "DSP Audio card" that contains the configuration or
knows which kcontrols to look for. But my point about detection hold.
You could perfectly well have a 'Jack control' that tells userspace when
a device is connected. That way there's no guess work, it's similar to
HDMI for Intel: the device is exposed but only valid when the jack
control is set.
> The Q6AFE CPU DAI has multiple audio AFE "ports" they can handle. USB
> is only one of those.
>
>>>
>>>> Before we review low-level kernel plumbing, it would be good to give a
>>>> better overview of how userspace applications are supposed to interact
>>>> with the cards and identify the offloaded path. Testing with
>>>> tinyplay/tinymix is fine, but that's a developer-level or CI unit test.
>>>> we've got to see the broader picture of how a sound server would use
>>>> this USB offload capability.
>>>
>>> Sure, I think that is fine. I was hoping that at least adding some of
>>> the new kcontrols would help userspace make use of this path in general,
>>> but we can add more information if required.
>>
>> Can I ask if this solution has been used with a complete userspace stack
>> already? I could see how this might be used with a relatively fixed
>
> Its been used only with the Android HAL.
ok, that aligns with what I was thinking.
>
>> Android HAL, where the platform and routing are relatively controlled. I
>> don't see how a more generic audio server would deal with the discovery
>> and routing.
>>
>
> This is why your input is helpful, since it provides another use case
> that wasn't considered. I think in our previous discussions the tagging
> possibility was a good idea, and was hoping that it could help. Could
> tag all USB SND cards to the platform sound card as well, and if the
> power saving path is chosen, it would issue the playback on the platform
> sound card. (if not in use)
>
> In this case, the offload path wouldn't be the default routing, and only
> enabled for power optimized path.
>
> Thanks
> Wesley Cheng
Hi Pierre,
On 3/13/2023 5:42 PM, Pierre-Louis Bossart wrote:
>
>
> On 3/13/23 18:43, Wesley Cheng wrote:
>> Hi Pierre,
>>
>> On 3/9/2023 4:37 PM, Pierre-Louis Bossart wrote:
>>>
>>>>>> Create vendor ops for the USB SND driver:
>>>>>> qc_audio_offload: This particular driver has several components
>>>>>> associated
>>>>>> with it:
>>>>>> - QMI stream request handler
>>>>>> - XHCI interrupter and resource management
>>>>>> - audio DSP memory management
>>>>>
>>>>> so how does this 'qc_audio_offload' interface with 'q6usb' described
>>>>> above? how are the roles different or complementary?
>>>>>
>>>> So in general you can think that the qc_audio_offload is a complement to
>>>> the USB SND USB class driver, while q6usb is to ASoC. Since the ASoC
>>>
>>> Humm, that is far from clear. I don't get how a something that interacts
>>> with the USB class driver can also be in charge of the audio DSP memory
>>> management.
>>>
>>
>> This is because the USB class driver is the entity which is going to
>> work with the USB HCD (XHCI) in this case to fetch the required
>> addresses, and map that into memory accessible by the audio DSP. It
>> would be odd to be doing that from the q6usb end, which is part of the
>> ASoC layer.
>>
>>>> framework doesn't have any communication with USB SND, the ASoC DPCM USB
>>>> backend (q6usb) will have to be the entity that maintains what is going
>>>> on in USB SND. That way, sessions initiated through the ASoC managed
>>>> sound card can evaluate what is available based on information reported
>>>> by q6usb.
>>>>
>>>> qc_audio_offload and q6usb will have some interaction between each
>>>> other. The majority of communication between qc_audio_offload and q6usb
>>>> is reporting the device connection events.
>>>
>>> It's already complicated to figure out how the DSP and USB class driver
>>> might interact and probe/timing dependencies, but with two additional
>>> drivers in the mix it's really hard to understand.
>>>
>>
>> I did test some cases based on existence of both these drivers
>> (qc_audio_offload and q6usb). If either one doesn't exist in the
>> system, then the offload path would not work. I did improve some of
>> these potential sequences in the latest revision, such as patch#28. This
>> would address scenarios where the q6usb ASoC DPCM backend wasn't probed,
>> while the USB SND (and qc_audio_offload) were still detecting device
>> connections.
>>
>> Once the Q6USB driver is probed, then the offload snd kcontrols would be
>> created, and devices would be properly identified with the rediscover api.
>>
>>> Maybe ascii-art would help describe the concepts and types of
>>> information exchanged. Maintaining a consistent state across multiple
>>> drivers is not an easy task.
>>>
>>
>> Hopefully this might help? I know its a lot to read through.
>
> It's very helpful! Thanks for spending the time to illustrate the
> different building blocks.
>
>>
>> USB | ASoC
>> --------------------------------------------------------------------
>> | _________________________
>> | |sm8250 platform card |
>> | |_________________________|
>> | | |
>> | ___V____ ____V____
>> | |Q6USB | |Q6AFE | #5
>> | |"codec" | |"cpu" |
>> | |________| |_________|
>> | ^
>> | | #6
>> | ___V____
>> | |SOC-USB |
>> ________ #1 ________ #7 | |
>> |USB SND |<--->|QC offld|<------------>|________|
>> |(card.c)| | |<---------- ^
>> |________| |________|___ #4 | | |
>> ^ ^ | | | ___V__________________
>> | #2 | #2 | | | |APR/GLINK |
>> __ V_______________V_____ | | | |______________________|
>> |USB SND (endpoint.c) | | | | ^
>> |_________________________| | | | #8 |
>> ^ | | | ___________V___________
>> | #3 | | |->|audio DSP |
>> ___________V_____________ | | |_______________________|
>> |XHCI HCD |<- |
>> |_________________________| |
>>
>>
>> #1 - USB SND and QC offload:
>> Initialization:
>> - Register platform operations, to receive connect/disconnect events
>> from USB SND.
>> - QC offload creates a QMI handle, in order to receive QMI requests
>> from the audio DSP.
>>
>> Runtime:
>> - USB SND passes along "struct snd_usb_audio" in order for QC offload
>> to reference USB UAC desc parsing/USB SND helper APIs.
>> - USB device disconnection events will result in clearing of the chip
>> entry.
>>
>> #2 - USB SND and QC offload endpoints:
>> Runtime:
>> - In the non-offloaded path, USB snd will utilize functions exposed by
>> USB SND endpoint, to help with fetching USB EP references and queuing
>> URBs.
>> - In the offload path, qc offload will utilize the functions to fetch
>> USB EP references, so that it can use that information to query the
>> XHCI HCD.
>> - Likewise, both will clean up endpoints when audio stream is not in use.
>>
>> #3 - XHCI HCD:
>> Initialization:
>> - During XHCI probe timing, when the USB HCD is added to the system, it
>> will also initialize the secondary event rings.
>>
>> Runtime:
>> - During USB device plug ins/outs, allocates device slot, assigns eps,
>> and initializes transfer rings.
>>
>> #4 - QC offload and XHCI:
>> Runtime:
>> - QC offload needs to reference the transfer ring and secondary event ring
>> addresses by executing XHCI offload management APIs.
>> - This happens when audio DSP receives a USB QMI stream request.
>>
>> #5 - ASoC components:
>> Initialization:
>> - The SM8250 platform sound card driver fetches DT node entries defining
>> the ASoC links. This chain/link has the components involved for a
>> particular Q6AFE path. (not only USB offload)
>> - "cpu" - this is the ASoC CPU DAI that handles interaction with the
>> Q6 DSP's audio protocol. (AFE ports)
>> - "codec" - the ASoC codec (backend) DAI defined
>> - Registers ASoC platform sound card based on links defined in the DT node.
>> - Probes DAI components involved, ie Q6USB and Q6AFE
>>
>> Runtime:
>> - Q6AFE has the bulk of the interaction w/ the audio DSP to start an audio
>> session, such as issuing AFE port start commands (part of the protocol
>> used to communicate the audio session info)
>> - Q6USB will be there to now check for if format requested is supported by
>> the device, and maintain offloading status.
>>
>> #6 - Q6USB and SOC-USB:
>> Initialization:
>> - Q6USB will query QC offload for USB device connection states. (through
>> soc-usb)
>> - Creates a SOC USB entry, that carries information about resources,
>> such as audio DSP memory information and requested XHCI event ring
>> index.
>>
>> Runtime:
>> - SOC-USB will receive connect/disconnect events and propagate to Q6USB.
>> - Q6USB makes devices available for offloading based on these events.
>> - Sets Q6AFE port configurations to select the USB SND card# and PCM#.
>>
>> #7 - SOC-USB and QC offload:
>> Initialization:
>> - Rediscover USB SND devices when the SOC-USB entry is created (if needed)
>> - For situations where the Q6USB DAI hasn't been probed.
>>
>> Runtime:
>> - Propagate connect/disconnect events.
>
> Is the SOC-USB module or building blocks intended to be generic or
> Qualcomm agnostic?
>
This should be generic.
> It's not clear to me how it would handle "audio DSP memory information
> and requested XHCI event ring index."
>
Each soc-usb entry that is created by the ASoC DPCM backend DAI (q6usb)
will be able to hold "private data" that, in QC case, is defined as:
struct q6usb_offload
This is passed within the snd_soc_usb_add_port() call:
snd_soc_usb_add_port(component->dev, &data->priv, q6usb_alsa_connection_cb);
So depending on the user, the private data can contain their own struct
with the information they require.
> In addition, it seems to be the "bridge" or means of communication
> between qc_audio_offload and q6usb, is this not based on custom events
> or triggers?
>
Ideally, no, it shouldn't be based on custom events. Intention for the
connect_cb() that is defined is just to receive USB device discovery
events from USB SND. From the qc_audio_offload, we call
snd_soc_usb_connect() within our platform op that we register to USB SND.
//Platform connect_cb() - called from USB SND probe (device connected)
static void qc_usb_audio_offload_probe(struct snd_usb_audio *chip)
{
...
snd_soc_usb_connect(usb_get_usb_backend(udev), chip->card->number,
chip->index, chip->pcm_devs);
In the QC situation, we used this to build a list of active devices
connected.
> Along the same lines, this SOC-USB entity interfaces with APR/GLINK
> which doesn't speak to me so it must be a QCOM interface?
>
Sorry for not labeling those in the diagram, but yes, those are QC
specific interfaces. You can just think of it as a type of IPC transport.
> I am trying to see if this design could be used for other architectures,
> and the QCOM-specific and generic parts are not obvious.
>
>> #8 - audio DSP and QC offload:
>> Runtime:
>> - Handle QMI requests coming from audio DSP. These requests come AFTER
>> the Q6AFE port is opened by the Q6AFE DAI(#6)
>> - Returns memory information about resources allocated by XHCI.
>> - Enables audio playback when this QMI transaction is completed.
>>
>>>>
>>>>>> When the audio DSP wants to enable a playback stream, the request is
>>>>>> first
>>>>>> received by the ASoC platform sound card. Depending on the selected
>>>>>> route,
>>>>>> ASoC will bring up the individual DAIs in the path. The Q6USB
>>>>>> backend DAI
>>>>>> will send an AFE port start command (with enabling the USB playback
>>>>>> path), and
>>>>>> the audio DSP will handle the request accordingly.
>>>>>>
>>>>>> Part of the AFE USB port start handling will have an exchange of
>>>>>> control
>>>>>> messages using the QMI protocol. The qc_audio_offload driver will
>>>>>> populate the
>>>>>> buffer information:
>>>>>> - Event ring base address
>>>>>> - EP transfer ring base address
>>>>>>
>>>>>> and pass it along to the audio DSP. All endpoint management will now
>>>>>> be handed
>>>>>> over to the DSP, and the main processor is not involved in transfers.
>>>>>>
>>>>>> Overall, implementing this feature will still expose separate sound
>>>>>> card and PCM
>>>>>> devices for both the platorm card and USB audio device:
>>>>>> 0 [SM8250MTPWCD938]: sm8250 - SM8250-MTP-WCD9380-WSA8810-VA-D
>>>>>> SM8250-MTP-WCD9380-WSA8810-VA-DMIC
>>>>>> 1 [Audio ]: USB-Audio - USB Audio
>>>>>> Generic USB Audio at usb-xhci-hcd.1.auto-1.4,
>>>>>> high speed
>>>>>>
>>>>>> This is to ensure that userspace ALSA entities can decide which route
>>>>>> to take
>>>>>> when executing the audio playback. In the above, if card#1 is
>>>>>> selected, then
>>>>>> USB audio data will take the legacy path over the USB PCM drivers,
>>>>>> etc...
>>>>>
>>>>> I already voiced my concerns about exposing two cards, each with their
>>>>> own set of volume controls with the same device. It would be much
>>>>> better
>>>>> to have an additional offloaded PCM device for card0...
>>>>>
>>>>> But if the consensus is to have two cards, it's still not clear how the
>>>>> routing would be selected. In the case where there are two USB audio
>>>>> devices attached, the offloaded path would only support one of the two.
>>>>> How would userspace know which of the two is selected?
>>>>>
>>>>
>>>> With patch#24:
>>>> https://lore.kernel.org/linux-usb/[email protected]/T/#u
>>>>
>>>> Now, userspace can at least choose which device it wants to offload.
>>>> Part of doing that would mean userspace knows what USB SND card devices
>>>> are available, so it is aware of which devices are shared (between the
>>>> offload and USB SND path)
>>>>
>>>>> And how would userspace know the difference anyways between two
>>>>> physical
>>>>> devices attached to the platform with no offload, and one physical
>>>>> device with one additional offload path? The names you selected
>>>>> can't be
>>>>> used to identify that card1 is the optimized version of card0.
>>>>>
>>>>
>>>> Is userspace currently able to differentiate between cards that are
>>>> created by USB SND versus ASoC? How complex can the userspace card
>>>> discovery be? Can it query kcontrols at this point in time? If so,
>>>> maybe we can change the names of the newly added ones to reflect that it
>>>> is an offload device?
>>>>
>>>> SND kcontrol names are currently:
>>>> Q6USB offload status
>>>> Q6USB offload SND device select
>>>
>>> I must admit I've never seen kcontrols being used to identify what the
>>> card is, and in this case it's a pretend-card that's just an improved
>>> version of another. It might be easier to use something else, such as
>>> the component strings.
>>
>> Its not exactly a pretend card, right? This is part of the overall
>> platform sound card we have in the system. At the moment, I'm only
>> testing by adding the USB audio routing, but there can be several ASoC
>> links defined in the overall platform card.
>
> Sorry, I misunderstood the proposal. I thought there would be one card
> for "generic USB Audio", and another one for "DSP-offloaded USB Audio".
> I assumed, probably mistakenly, that all local audio endpoints
> (speaker,mics) would be exposed as a separate card.
>
Ah got it. No, that isn't the case here.
> It looks like it's more "generic USB Audio" and "DSP Audio", with the
> USB offload being exposed as a PCM device of the latter.
>
> Did I get this right? In this case, presumably there can be some sort of
Yep that's correct!
> UCM file for the "DSP Audio card" that contains the configuration or
> knows which kcontrols to look for. But my point about detection hold.
> You could perfectly well have a 'Jack control' that tells userspace when
> a device is connected. That way there's no guess work, it's similar to
> HDMI for Intel: the device is exposed but only valid when the jack
> control is set.
>
Hmm, ok. Let me see if I can switch up some things. Maybe replace the
current snd_soc_dapm_enable_pin() calls in the q6usb connection_cb and
replace that with a snd jack report. (the snd jack implementation
already takes care of updating the pin if needed)
Thanks
Wesley Cheng
>> The Q6AFE CPU DAI has multiple audio AFE "ports" they can handle. USB
>> is only one of those.
>>
>>>>
>>>>> Before we review low-level kernel plumbing, it would be good to give a
>>>>> better overview of how userspace applications are supposed to interact
>>>>> with the cards and identify the offloaded path. Testing with
>>>>> tinyplay/tinymix is fine, but that's a developer-level or CI unit test.
>>>>> we've got to see the broader picture of how a sound server would use
>>>>> this USB offload capability.
>>>>
>>>> Sure, I think that is fine. I was hoping that at least adding some of
>>>> the new kcontrols would help userspace make use of this path in general,
>>>> but we can add more information if required.
>>>
>>> Can I ask if this solution has been used with a complete userspace stack
>>> already? I could see how this might be used with a relatively fixed
>>
>> Its been used only with the Android HAL.
>
> ok, that aligns with what I was thinking.
>
>>
>>> Android HAL, where the platform and routing are relatively controlled. I
>>> don't see how a more generic audio server would deal with the discovery
>>> and routing.
>>>
>>
>> This is why your input is helpful, since it provides another use case
>> that wasn't considered. I think in our previous discussions the tagging
>> possibility was a good idea, and was hoping that it could help. Could
>> tag all USB SND cards to the platform sound card as well, and if the
>> power saving path is chosen, it would issue the playback on the platform
>> sound card. (if not in use)
>>
>> In this case, the offload path wouldn't be the default routing, and only
>> enabled for power optimized path.
>>
>> Thanks
>> Wesley Cheng
<snip>
>>
>>>
>>> USB | ASoC
>>> --------------------------------------------------------------------
>>> | _________________________
>>> | |sm8250 platform card |
>>> | |_________________________|
>>> | | |
>>> | ___V____ ____V____
>>> | |Q6USB | |Q6AFE | #5
>>> | |"codec" | |"cpu" |
>>> | |________| |_________|
>>> | ^
>>> | | #6
>>> | ___V____
>>> | |SOC-USB |
>>> ________ #1 ________ #7 | |
>>> |USB SND |<--->|QC offld|<------------>|________|
>>> |(card.c)| | |<---------- ^
>>> |________| |________|___ #4 | | |
>>> ^ ^ | | | ___V__________________
>>> | #2 | #2 | | | |APR/GLINK |
>>> __ V_______________V_____ | | | |______________________|
>>> |USB SND (endpoint.c) | | | | ^
>>> |_________________________| | | | #8 |
>>> ^ | | | ___________V___________
>>> | #3 | | |->|audio DSP |
>>> ___________V_____________ | | |_______________________|
>>> |XHCI HCD |<- |
>>> |_________________________| |
>>>
>>>
>>> #1 - USB SND and QC offload:
>>> Initialization:
>>> - Register platform operations, to receive connect/disconnect events
>>> from USB SND.
>>> - QC offload creates a QMI handle, in order to receive QMI requests
>>> from the audio DSP.
>>>
>>> Runtime:
>>> - USB SND passes along "struct snd_usb_audio" in order for QC offload
>>> to reference USB UAC desc parsing/USB SND helper APIs.
>>> - USB device disconnection events will result in clearing of the chip
>>> entry.
>>>
>>> #2 - USB SND and QC offload endpoints:
>>> Runtime:
>>> - In the non-offloaded path, USB snd will utilize functions exposed by
>>> USB SND endpoint, to help with fetching USB EP references and queuing
>>> URBs.
>>> - In the offload path, qc offload will utilize the functions to fetch
>>> USB EP references, so that it can use that information to query the
>>> XHCI HCD.
>>> - Likewise, both will clean up endpoints when audio stream is not in
>>> use.
>>>
>>> #3 - XHCI HCD:
>>> Initialization:
>>> - During XHCI probe timing, when the USB HCD is added to the system, it
>>> will also initialize the secondary event rings.
>>>
>>> Runtime:
>>> - During USB device plug ins/outs, allocates device slot, assigns eps,
>>> and initializes transfer rings.
>>>
>>> #4 - QC offload and XHCI:
>>> Runtime:
>>> - QC offload needs to reference the transfer ring and secondary event
>>> ring
>>> addresses by executing XHCI offload management APIs.
>>> - This happens when audio DSP receives a USB QMI stream request.
>>>
>>> #5 - ASoC components:
>>> Initialization:
>>> - The SM8250 platform sound card driver fetches DT node entries defining
>>> the ASoC links. This chain/link has the components involved for a
>>> particular Q6AFE path. (not only USB offload)
>>> - "cpu" - this is the ASoC CPU DAI that handles interaction with
>>> the
>>> Q6 DSP's audio protocol. (AFE ports)
>>> - "codec" - the ASoC codec (backend) DAI defined
>>> - Registers ASoC platform sound card based on links defined in the DT
>>> node.
>>> - Probes DAI components involved, ie Q6USB and Q6AFE
>>>
>>> Runtime:
>>> - Q6AFE has the bulk of the interaction w/ the audio DSP to start an
>>> audio
>>> session, such as issuing AFE port start commands (part of the
>>> protocol
>>> used to communicate the audio session info)
>>> - Q6USB will be there to now check for if format requested is
>>> supported by
>>> the device, and maintain offloading status.
>>>
>>> #6 - Q6USB and SOC-USB:
>>> Initialization:
>>> - Q6USB will query QC offload for USB device connection states. (through
>>> soc-usb)
>>> - Creates a SOC USB entry, that carries information about resources,
>>> such as audio DSP memory information and requested XHCI event ring
>>> index.
>>>
>>> Runtime:
>>> - SOC-USB will receive connect/disconnect events and propagate to Q6USB.
>>> - Q6USB makes devices available for offloading based on these events.
>>> - Sets Q6AFE port configurations to select the USB SND card# and PCM#.
>>>
>>> #7 - SOC-USB and QC offload:
>>> Initialization:
>>> - Rediscover USB SND devices when the SOC-USB entry is created (if
>>> needed)
>>> - For situations where the Q6USB DAI hasn't been probed.
>>>
>>> Runtime:
>>> - Propagate connect/disconnect events.
>>
>> Is the SOC-USB module or building blocks intended to be generic or
>> Qualcomm agnostic?
>>
>
> This should be generic.
ok, but then how would it communicate with APR/GLINK described below [1]
>
>> It's not clear to me how it would handle "audio DSP memory information
>> and requested XHCI event ring index."
>>
>
> Each soc-usb entry that is created by the ASoC DPCM backend DAI (q6usb)
> will be able to hold "private data" that, in QC case, is defined as:
> struct q6usb_offload
>
> This is passed within the snd_soc_usb_add_port() call:
> snd_soc_usb_add_port(component->dev, &data->priv,
> q6usb_alsa_connection_cb);
>
> So depending on the user, the private data can contain their own struct
> with the information they require.
ok, so "handle private data such as audio DSP memory information
>> and requested XHCI event ring index" is what you meant. That'd fine.
>> In addition, it seems to be the "bridge" or means of communication
>> between qc_audio_offload and q6usb, is this not based on custom events
>> or triggers?
>>
>
> Ideally, no, it shouldn't be based on custom events. Intention for the
> connect_cb() that is defined is just to receive USB device discovery
> events from USB SND. From the qc_audio_offload, we call
> snd_soc_usb_connect() within our platform op that we register to USB SND.
>
> //Platform connect_cb() - called from USB SND probe (device connected)
> static void qc_usb_audio_offload_probe(struct snd_usb_audio *chip)
> {
> ...
> snd_soc_usb_connect(usb_get_usb_backend(udev), chip->card->number,
> chip->index, chip->pcm_devs);
>
> In the QC situation, we used this to build a list of active devices
> connected.
>
>> Along the same lines, this SOC-USB entity interfaces with APR/GLINK
>> which doesn't speak to me so it must be a QCOM interface?>>
>
> Sorry for not labeling those in the diagram, but yes, those are QC
> specific interfaces. You can just think of it as a type of IPC transport.
[1] ... something's not clear on how a generic 'soc-usb' component can
directly talk to a vendor-specific IPC.
Is there a missing layer?
>> I am trying to see if this design could be used for other architectures,
>> and the QCOM-specific and generic parts are not obvious.
>>
>>> #8 - audio DSP and QC offload:
>>> Runtime:
>>> - Handle QMI requests coming from audio DSP. These requests come AFTER
>>> the Q6AFE port is opened by the Q6AFE DAI(#6)
>>> - Returns memory information about resources allocated by XHCI.
>>> - Enables audio playback when this QMI transaction is completed.
>>>
>>>>>
>>>>>>> When the audio DSP wants to enable a playback stream, the request is
>>>>>>> first
>>>>>>> received by the ASoC platform sound card. Depending on the selected
>>>>>>> route,
>>>>>>> ASoC will bring up the individual DAIs in the path. The Q6USB
>>>>>>> backend DAI
>>>>>>> will send an AFE port start command (with enabling the USB playback
>>>>>>> path), and
>>>>>>> the audio DSP will handle the request accordingly.
>>>>>>>
>>>>>>> Part of the AFE USB port start handling will have an exchange of
>>>>>>> control
>>>>>>> messages using the QMI protocol. The qc_audio_offload driver will
>>>>>>> populate the
>>>>>>> buffer information:
>>>>>>> - Event ring base address
>>>>>>> - EP transfer ring base address
>>>>>>>
>>>>>>> and pass it along to the audio DSP. All endpoint management will
>>>>>>> now
>>>>>>> be handed
>>>>>>> over to the DSP, and the main processor is not involved in
>>>>>>> transfers.
>>>>>>>
>>>>>>> Overall, implementing this feature will still expose separate sound
>>>>>>> card and PCM
>>>>>>> devices for both the platorm card and USB audio device:
>>>>>>> 0 [SM8250MTPWCD938]: sm8250 - SM8250-MTP-WCD9380-WSA8810-VA-D
>>>>>>> SM8250-MTP-WCD9380-WSA8810-VA-DMIC
>>>>>>> 1 [Audio ]: USB-Audio - USB Audio
>>>>>>> Generic USB Audio at
>>>>>>> usb-xhci-hcd.1.auto-1.4,
>>>>>>> high speed
>>>>>>>
>>>>>>> This is to ensure that userspace ALSA entities can decide which
>>>>>>> route
>>>>>>> to take
>>>>>>> when executing the audio playback. In the above, if card#1 is
>>>>>>> selected, then
>>>>>>> USB audio data will take the legacy path over the USB PCM drivers,
>>>>>>> etc...
>>>>>>
>>>>>> I already voiced my concerns about exposing two cards, each with
>>>>>> their
>>>>>> own set of volume controls with the same device. It would be much
>>>>>> better
>>>>>> to have an additional offloaded PCM device for card0...
>>>>>>
>>>>>> But if the consensus is to have two cards, it's still not clear
>>>>>> how the
>>>>>> routing would be selected. In the case where there are two USB audio
>>>>>> devices attached, the offloaded path would only support one of the
>>>>>> two.
>>>>>> How would userspace know which of the two is selected?
>>>>>>
>>>>>
>>>>> With patch#24:
>>>>> https://lore.kernel.org/linux-usb/[email protected]/T/#u
>>>>>
>>>>> Now, userspace can at least choose which device it wants to offload.
>>>>> Part of doing that would mean userspace knows what USB SND card
>>>>> devices
>>>>> are available, so it is aware of which devices are shared (between the
>>>>> offload and USB SND path)
>>>>>
>>>>>> And how would userspace know the difference anyways between two
>>>>>> physical
>>>>>> devices attached to the platform with no offload, and one physical
>>>>>> device with one additional offload path? The names you selected
>>>>>> can't be
>>>>>> used to identify that card1 is the optimized version of card0.
>>>>>>
>>>>>
>>>>> Is userspace currently able to differentiate between cards that are
>>>>> created by USB SND versus ASoC? How complex can the userspace card
>>>>> discovery be? Can it query kcontrols at this point in time? If so,
>>>>> maybe we can change the names of the newly added ones to reflect
>>>>> that it
>>>>> is an offload device?
>>>>>
>>>>> SND kcontrol names are currently:
>>>>> Q6USB offload status
>>>>> Q6USB offload SND device select
>>>>
>>>> I must admit I've never seen kcontrols being used to identify what the
>>>> card is, and in this case it's a pretend-card that's just an improved
>>>> version of another. It might be easier to use something else, such as
>>>> the component strings.
>>>
>>> Its not exactly a pretend card, right? This is part of the overall
>>> platform sound card we have in the system. At the moment, I'm only
>>> testing by adding the USB audio routing, but there can be several ASoC
>>> links defined in the overall platform card.
>>
>> Sorry, I misunderstood the proposal. I thought there would be one card
>> for "generic USB Audio", and another one for "DSP-offloaded USB Audio".
>> I assumed, probably mistakenly, that all local audio endpoints
>> (speaker,mics) would be exposed as a separate card.
>>
>
> Ah got it. No, that isn't the case here.
>
>> It looks like it's more "generic USB Audio" and "DSP Audio", with the
>> USB offload being exposed as a PCM device of the latter.
>>
>> Did I get this right? In this case, presumably there can be some sort of
>
> Yep that's correct!
ok, that's good.
My initial thought was to add a 'DSP offload' PCM to the USB card, you
added a "USB offload" PCM to the DSP card. Nice logical swap!
Your proposal might be easier in practice since there's typically a
vendor-specific configuration file (UCM or custom) file for the DSP,
where USB information can be added.
It's more problematic to change a generic USB card as we know it today
and bolt vendor-specific DSP information on top.
The only open I have with your option is that there are still two
control paths to e.g. set the volume. It would be so much easier for
userspace if there was a single volume control no matter what path is
used for data, or make sure the kcontrols are 'mirrored' somehow. If we
found a way to address this issue that would be ideal.
>> UCM file for the "DSP Audio card" that contains the configuration or
>> knows which kcontrols to look for. But my point about detection hold.
>> You could perfectly well have a 'Jack control' that tells userspace when
>> a device is connected. That way there's no guess work, it's similar to
>> HDMI for Intel: the device is exposed but only valid when the jack
>> control is set.
>>
>
> Hmm, ok. Let me see if I can switch up some things. Maybe replace the
> current snd_soc_dapm_enable_pin() calls in the q6usb connection_cb and
> replace that with a snd jack report. (the snd jack implementation
> already takes care of updating the pin if needed)
The jack is useful to let userspace know if a PCM device, i.e. a
Front-End, can be used. But if you expose a PCM device, nothing prevents
an application from trying to open and use it, we recently had such an
issue due to a change in PipeWire that tried to open a non-functional
HDMI device. So you do need something to bail if the PCM device is
mistakenly used.
DAPM pin management seems different, it will turn-on/off parts of the
graph connected to an endpoint. Userpace will typically not know
anything about pin management, it's an in-kernel concept.
Not sure if you have to choose, those are two different layers, no?
Hi Pierre,
On 3/13/2023 7:22 PM, Pierre-Louis Bossart wrote:
>
> <snip>
>
>>>
>>>>
>>>> USB | ASoC
>>>> --------------------------------------------------------------------
>>>> | _________________________
>>>> | |sm8250 platform card |
>>>> | |_________________________|
>>>> | | |
>>>> | ___V____ ____V____
>>>> | |Q6USB | |Q6AFE | #5
>>>> | |"codec" | |"cpu" |
>>>> | |________| |_________|
>>>> | ^
>>>> | | #6
>>>> | ___V____
>>>> | |SOC-USB |
>>>> ________ #1 ________ #7 | |
>>>> |USB SND |<--->|QC offld|<------------>|________|
>>>> |(card.c)| | |<---------- ^
>>>> |________| |________|___ #4 | | |
>>>> ^ ^ | | | ___V__________________
>>>> | #2 | #2 | | | |APR/GLINK |
>>>> __ V_______________V_____ | | | |______________________|
>>>> |USB SND (endpoint.c) | | | | ^
>>>> |_________________________| | | | #8 |
>>>> ^ | | | ___________V___________
>>>> | #3 | | |->|audio DSP |
>>>> ___________V_____________ | | |_______________________|
>>>> |XHCI HCD |<- |
>>>> |_________________________| |
>>>>
>>>>
>>>> #1 - USB SND and QC offload:
>>>> Initialization:
>>>> - Register platform operations, to receive connect/disconnect events
>>>> from USB SND.
>>>> - QC offload creates a QMI handle, in order to receive QMI requests
>>>> from the audio DSP.
>>>>
>>>> Runtime:
>>>> - USB SND passes along "struct snd_usb_audio" in order for QC offload
>>>> to reference USB UAC desc parsing/USB SND helper APIs.
>>>> - USB device disconnection events will result in clearing of the chip
>>>> entry.
>>>>
>>>> #2 - USB SND and QC offload endpoints:
>>>> Runtime:
>>>> - In the non-offloaded path, USB snd will utilize functions exposed by
>>>> USB SND endpoint, to help with fetching USB EP references and queuing
>>>> URBs.
>>>> - In the offload path, qc offload will utilize the functions to fetch
>>>> USB EP references, so that it can use that information to query the
>>>> XHCI HCD.
>>>> - Likewise, both will clean up endpoints when audio stream is not in
>>>> use.
>>>>
>>>> #3 - XHCI HCD:
>>>> Initialization:
>>>> - During XHCI probe timing, when the USB HCD is added to the system, it
>>>> will also initialize the secondary event rings.
>>>>
>>>> Runtime:
>>>> - During USB device plug ins/outs, allocates device slot, assigns eps,
>>>> and initializes transfer rings.
>>>>
>>>> #4 - QC offload and XHCI:
>>>> Runtime:
>>>> - QC offload needs to reference the transfer ring and secondary event
>>>> ring
>>>> addresses by executing XHCI offload management APIs.
>>>> - This happens when audio DSP receives a USB QMI stream request.
>>>>
>>>> #5 - ASoC components:
>>>> Initialization:
>>>> - The SM8250 platform sound card driver fetches DT node entries defining
>>>> the ASoC links. This chain/link has the components involved for a
>>>> particular Q6AFE path. (not only USB offload)
>>>> - "cpu" - this is the ASoC CPU DAI that handles interaction with
>>>> the
>>>> Q6 DSP's audio protocol. (AFE ports)
>>>> - "codec" - the ASoC codec (backend) DAI defined
>>>> - Registers ASoC platform sound card based on links defined in the DT
>>>> node.
>>>> - Probes DAI components involved, ie Q6USB and Q6AFE
>>>>
>>>> Runtime:
>>>> - Q6AFE has the bulk of the interaction w/ the audio DSP to start an
>>>> audio
>>>> session, such as issuing AFE port start commands (part of the
>>>> protocol
>>>> used to communicate the audio session info)
>>>> - Q6USB will be there to now check for if format requested is
>>>> supported by
>>>> the device, and maintain offloading status.
>>>>
>>>> #6 - Q6USB and SOC-USB:
>>>> Initialization:
>>>> - Q6USB will query QC offload for USB device connection states. (through
>>>> soc-usb)
>>>> - Creates a SOC USB entry, that carries information about resources,
>>>> such as audio DSP memory information and requested XHCI event ring
>>>> index.
>>>>
>>>> Runtime:
>>>> - SOC-USB will receive connect/disconnect events and propagate to Q6USB.
>>>> - Q6USB makes devices available for offloading based on these events.
>>>> - Sets Q6AFE port configurations to select the USB SND card# and PCM#.
>>>>
>>>> #7 - SOC-USB and QC offload:
>>>> Initialization:
>>>> - Rediscover USB SND devices when the SOC-USB entry is created (if
>>>> needed)
>>>> - For situations where the Q6USB DAI hasn't been probed.
>>>>
>>>> Runtime:
>>>> - Propagate connect/disconnect events.
>>>
>>> Is the SOC-USB module or building blocks intended to be generic or
>>> Qualcomm agnostic?
>>>
>>
>> This should be generic.
>
> ok, but then how would it communicate with APR/GLINK described below [1]
To make the diagram a bit more compact, I left out our Q6ASM DAI, which
is the path that handles the PCM data/buffers. (not really involved in
initializing any part of the offload path)
Sorry made a mistake on the diagram. There is no connection from
SOC-USB to the APR/GLINK. The Q6USB driver will be the one that is
going to configure some of the Q6AFE ports along withe the Q6AFE DAI driver.
| ASoC
----------------------------------
| _________________________
| |sm8250 platform card |
| |_________________________|
| | |
| ___V____ ____V____
| |Q6USB | |Q6AFE | #5
| |"codec" | |"cpu" |
| |________| |_________|
| ^ ^ ^
| #6 | |________|
| ___V____ |
| |SOC-USB | |
#7 | | |
----->|________| |
--- |
| | |
| | _____________V________
| | |APR/GLINK |
| | |______________________|
| | ^
| | #8 |
| | ___________V___________
| |->|audio DSP |
| |_______________________|
|
|
>>
>>> It's not clear to me how it would handle "audio DSP memory information
>>> and requested XHCI event ring index."
>>>
>>
>> Each soc-usb entry that is created by the ASoC DPCM backend DAI (q6usb)
>> will be able to hold "private data" that, in QC case, is defined as:
>> struct q6usb_offload
>>
>> This is passed within the snd_soc_usb_add_port() call:
>> snd_soc_usb_add_port(component->dev, &data->priv,
>> q6usb_alsa_connection_cb);
>>
>> So depending on the user, the private data can contain their own struct
>> with the information they require.
>
> ok, so "handle private data such as audio DSP memory information
>>> and requested XHCI event ring index" is what you meant. That'd fine.
>
>>> In addition, it seems to be the "bridge" or means of communication
>>> between qc_audio_offload and q6usb, is this not based on custom events
>>> or triggers?
>>>
>>
>> Ideally, no, it shouldn't be based on custom events. Intention for the
>> connect_cb() that is defined is just to receive USB device discovery
>> events from USB SND. From the qc_audio_offload, we call
>> snd_soc_usb_connect() within our platform op that we register to USB SND.
>>
>> //Platform connect_cb() - called from USB SND probe (device connected)
>> static void qc_usb_audio_offload_probe(struct snd_usb_audio *chip)
>> {
>> ...
>> snd_soc_usb_connect(usb_get_usb_backend(udev), chip->card->number,
>> chip->index, chip->pcm_devs);
>>
>> In the QC situation, we used this to build a list of active devices
>> connected.
>>
>>> Along the same lines, this SOC-USB entity interfaces with APR/GLINK
>>> which doesn't speak to me so it must be a QCOM interface?>>
>>
>> Sorry for not labeling those in the diagram, but yes, those are QC
>> specific interfaces. You can just think of it as a type of IPC transport.
>
> [1] ... something's not clear on how a generic 'soc-usb' component can
> directly talk to a vendor-specific IPC.
>
> Is there a missing layer?
>
:) hopefully the updated diagram clarifies this.
>>> I am trying to see if this design could be used for other architectures,
>>> and the QCOM-specific and generic parts are not obvious.
>>>
>>>> #8 - audio DSP and QC offload:
>>>> Runtime:
>>>> - Handle QMI requests coming from audio DSP. These requests come AFTER
>>>> the Q6AFE port is opened by the Q6AFE DAI(#6)
>>>> - Returns memory information about resources allocated by XHCI.
>>>> - Enables audio playback when this QMI transaction is completed.
>>>>
>>>>>>
>>>>>>>> When the audio DSP wants to enable a playback stream, the request is
>>>>>>>> first
>>>>>>>> received by the ASoC platform sound card. Depending on the selected
>>>>>>>> route,
>>>>>>>> ASoC will bring up the individual DAIs in the path. The Q6USB
>>>>>>>> backend DAI
>>>>>>>> will send an AFE port start command (with enabling the USB playback
>>>>>>>> path), and
>>>>>>>> the audio DSP will handle the request accordingly.
>>>>>>>>
>>>>>>>> Part of the AFE USB port start handling will have an exchange of
>>>>>>>> control
>>>>>>>> messages using the QMI protocol. The qc_audio_offload driver will
>>>>>>>> populate the
>>>>>>>> buffer information:
>>>>>>>> - Event ring base address
>>>>>>>> - EP transfer ring base address
>>>>>>>>
>>>>>>>> and pass it along to the audio DSP. All endpoint management will
>>>>>>>> now
>>>>>>>> be handed
>>>>>>>> over to the DSP, and the main processor is not involved in
>>>>>>>> transfers.
>>>>>>>>
>>>>>>>> Overall, implementing this feature will still expose separate sound
>>>>>>>> card and PCM
>>>>>>>> devices for both the platorm card and USB audio device:
>>>>>>>> 0 [SM8250MTPWCD938]: sm8250 - SM8250-MTP-WCD9380-WSA8810-VA-D
>>>>>>>> SM8250-MTP-WCD9380-WSA8810-VA-DMIC
>>>>>>>> 1 [Audio ]: USB-Audio - USB Audio
>>>>>>>> Generic USB Audio at
>>>>>>>> usb-xhci-hcd.1.auto-1.4,
>>>>>>>> high speed
>>>>>>>>
>>>>>>>> This is to ensure that userspace ALSA entities can decide which
>>>>>>>> route
>>>>>>>> to take
>>>>>>>> when executing the audio playback. In the above, if card#1 is
>>>>>>>> selected, then
>>>>>>>> USB audio data will take the legacy path over the USB PCM drivers,
>>>>>>>> etc...
>>>>>>>
>>>>>>> I already voiced my concerns about exposing two cards, each with
>>>>>>> their
>>>>>>> own set of volume controls with the same device. It would be much
>>>>>>> better
>>>>>>> to have an additional offloaded PCM device for card0...
>>>>>>>
>>>>>>> But if the consensus is to have two cards, it's still not clear
>>>>>>> how the
>>>>>>> routing would be selected. In the case where there are two USB audio
>>>>>>> devices attached, the offloaded path would only support one of the
>>>>>>> two.
>>>>>>> How would userspace know which of the two is selected?
>>>>>>>
>>>>>>
>>>>>> With patch#24:
>>>>>> https://lore.kernel.org/linux-usb/[email protected]/T/#u
>>>>>>
>>>>>> Now, userspace can at least choose which device it wants to offload.
>>>>>> Part of doing that would mean userspace knows what USB SND card
>>>>>> devices
>>>>>> are available, so it is aware of which devices are shared (between the
>>>>>> offload and USB SND path)
>>>>>>
>>>>>>> And how would userspace know the difference anyways between two
>>>>>>> physical
>>>>>>> devices attached to the platform with no offload, and one physical
>>>>>>> device with one additional offload path? The names you selected
>>>>>>> can't be
>>>>>>> used to identify that card1 is the optimized version of card0.
>>>>>>>
>>>>>>
>>>>>> Is userspace currently able to differentiate between cards that are
>>>>>> created by USB SND versus ASoC? How complex can the userspace card
>>>>>> discovery be? Can it query kcontrols at this point in time? If so,
>>>>>> maybe we can change the names of the newly added ones to reflect
>>>>>> that it
>>>>>> is an offload device?
>>>>>>
>>>>>> SND kcontrol names are currently:
>>>>>> Q6USB offload status
>>>>>> Q6USB offload SND device select
>>>>>
>>>>> I must admit I've never seen kcontrols being used to identify what the
>>>>> card is, and in this case it's a pretend-card that's just an improved
>>>>> version of another. It might be easier to use something else, such as
>>>>> the component strings.
>>>>
>>>> Its not exactly a pretend card, right? This is part of the overall
>>>> platform sound card we have in the system. At the moment, I'm only
>>>> testing by adding the USB audio routing, but there can be several ASoC
>>>> links defined in the overall platform card.
>>>
>>> Sorry, I misunderstood the proposal. I thought there would be one card
>>> for "generic USB Audio", and another one for "DSP-offloaded USB Audio".
>>> I assumed, probably mistakenly, that all local audio endpoints
>>> (speaker,mics) would be exposed as a separate card.
>>>
>>
>> Ah got it. No, that isn't the case here.
>>
>>> It looks like it's more "generic USB Audio" and "DSP Audio", with the
>>> USB offload being exposed as a PCM device of the latter.
>>>
>>> Did I get this right? In this case, presumably there can be some sort of
>>
>> Yep that's correct!
>
> ok, that's good.
>
> My initial thought was to add a 'DSP offload' PCM to the USB card, you
> added a "USB offload" PCM to the DSP card. Nice logical swap!
>
> Your proposal might be easier in practice since there's typically a
> vendor-specific configuration file (UCM or custom) file for the DSP,
> where USB information can be added.
>
> It's more problematic to change a generic USB card as we know it today
> and bolt vendor-specific DSP information on top.
>
> The only open I have with your option is that there are still two
> control paths to e.g. set the volume. It would be so much easier for
> userspace if there was a single volume control no matter what path is
> used for data, or make sure the kcontrols are 'mirrored' somehow. If we
> found a way to address this issue that would be ideal.
>
Got it. Let me look to see if that is something we can address/add. I
think the current implementation is that USB SND will expose some mixer
controls based on the UAC descriptor parsing. Then when they want to
change the volume (for example) it will result in a USB SETUP transaction.
So USB SND will eventually be the entity controlling these changes.
>>> UCM file for the "DSP Audio card" that contains the configuration or
>>> knows which kcontrols to look for. But my point about detection hold.
>>> You could perfectly well have a 'Jack control' that tells userspace when
>>> a device is connected. That way there's no guess work, it's similar to
>>> HDMI for Intel: the device is exposed but only valid when the jack
>>> control is set.
>>>
>>
>> Hmm, ok. Let me see if I can switch up some things. Maybe replace the
>> current snd_soc_dapm_enable_pin() calls in the q6usb connection_cb and
>> replace that with a snd jack report. (the snd jack implementation
>> already takes care of updating the pin if needed)
>
> The jack is useful to let userspace know if a PCM device, i.e. a
> Front-End, can be used. But if you expose a PCM device, nothing prevents
> an application from trying to open and use it, we recently had such an
> issue due to a change in PipeWire that tried to open a non-functional
> HDMI device. So you do need something to bail if the PCM device is
> mistakenly used.
>
> DAPM pin management seems different, it will turn-on/off parts of the
> graph connected to an endpoint. Userpace will typically not know
> anything about pin management, it's an in-kernel concept.
>
> Not sure if you have to choose, those are two different layers, no?
Will review this more and fix it in the next rev. Thanks for the inputs!
Thanks
Wesley Cheng
Hi Wesley,
> Sorry made a mistake on the diagram. There is no connection from
> SOC-USB to the APR/GLINK. The Q6USB driver will be the one that is
> going to configure some of the Q6AFE ports along withe the Q6AFE DAI
> driver.
>
> | ASoC
> ----------------------------------
> | _________________________
> | |sm8250 platform card |
> | |_________________________|
> | | |
> | ___V____ ____V____
> | |Q6USB | |Q6AFE | #5
> | |"codec" | |"cpu" |
> | |________| |_________|
> | ^ ^ ^
> | #6 | |________|
> | ___V____ |
> | |SOC-USB | |
> #7 | | |
> ----->|________| |
> --- |
> | | |
> | | _____________V________
> | | |APR/GLINK |
> | | |______________________|
> | | ^
> | | #8 |
> | | ___________V___________
> | |->|audio DSP |
> | |_______________________|
> |
> |
>
>>>
Makes sense now, thank you for the clarification.
I'll have to dig more in this 'soc-usb' block, it's clearly a key
component that will have to maintain a consistent state across two
different parts of the stack and deal with probe/remove/shutdown.
>> My initial thought was to add a 'DSP offload' PCM to the USB card, you
>> added a "USB offload" PCM to the DSP card. Nice logical swap!
>>
>> Your proposal might be easier in practice since there's typically a
>> vendor-specific configuration file (UCM or custom) file for the DSP,
>> where USB information can be added.
>>
>> It's more problematic to change a generic USB card as we know it today
>> and bolt vendor-specific DSP information on top.
>>
>> The only open I have with your option is that there are still two
>> control paths to e.g. set the volume. It would be so much easier for
>> userspace if there was a single volume control no matter what path is
>> used for data, or make sure the kcontrols are 'mirrored' somehow. If we
>> found a way to address this issue that would be ideal.
>>
>
> Got it. Let me look to see if that is something we can address/add. I
> think the current implementation is that USB SND will expose some mixer
> controls based on the UAC descriptor parsing. Then when they want to
> change the volume (for example) it will result in a USB SETUP transaction.
>
> So USB SND will eventually be the entity controlling these changes.
That's probably ok then, am I getting this right that the the DSP card
would not expose any USB-related kcontrols then, i.e. the ONLY path to
change volumes, etc., would through the regular USB card kcontrols?
That would limit the changes in the platform sound card to the addition
of a PCM USB device.
On Wed, Mar 15, 2023 at 09:30:58AM -0500, Pierre-Louis Bossart wrote:
> That's probably ok then, am I getting this right that the the DSP card
> would not expose any USB-related kcontrols then, i.e. the ONLY path to
> change volumes, etc., would through the regular USB card kcontrols?
> That would limit the changes in the platform sound card to the addition
> of a PCM USB device.
I'd guess that there might be some volume control in the DSP as part of
the generic routing to the port (eg, if all ports have some output
control) but I'm not sure that's an issue, could even be useful for
normalising the output of DSP algorithms compared to direct PCM
playback.
Hi Pierre,
On 3/15/2023 7:30 AM, Pierre-Louis Bossart wrote:
> Hi Wesley,
>
>> Sorry made a mistake on the diagram. There is no connection from
>> SOC-USB to the APR/GLINK. The Q6USB driver will be the one that is
>> going to configure some of the Q6AFE ports along withe the Q6AFE DAI
>> driver.
>>
>> | ASoC
>> ----------------------------------
>> | _________________________
>> | |sm8250 platform card |
>> | |_________________________|
>> | | |
>> | ___V____ ____V____
>> | |Q6USB | |Q6AFE | #5
>> | |"codec" | |"cpu" |
>> | |________| |_________|
>> | ^ ^ ^
>> | #6 | |________|
>> | ___V____ |
>> | |SOC-USB | |
>> #7 | | |
>> ----->|________| |
>> --- |
>> | | |
>> | | _____________V________
>> | | |APR/GLINK |
>> | | |______________________|
>> | | ^
>> | | #8 |
>> | | ___________V___________
>> | |->|audio DSP |
>> | |_______________________|
>> |
>> |
>>
>>>>
>
> Makes sense now, thank you for the clarification.
>
> I'll have to dig more in this 'soc-usb' block, it's clearly a key
> component that will have to maintain a consistent state across two
> different parts of the stack and deal with probe/remove/shutdown.
>
>>> My initial thought was to add a 'DSP offload' PCM to the USB card, you
>>> added a "USB offload" PCM to the DSP card. Nice logical swap!
>>>
>>> Your proposal might be easier in practice since there's typically a
>>> vendor-specific configuration file (UCM or custom) file for the DSP,
>>> where USB information can be added.
>>>
>>> It's more problematic to change a generic USB card as we know it today
>>> and bolt vendor-specific DSP information on top.
>>>
>>> The only open I have with your option is that there are still two
>>> control paths to e.g. set the volume. It would be so much easier for
>>> userspace if there was a single volume control no matter what path is
>>> used for data, or make sure the kcontrols are 'mirrored' somehow. If we
>>> found a way to address this issue that would be ideal.
>>>
>>
>> Got it. Let me look to see if that is something we can address/add. I
>> think the current implementation is that USB SND will expose some mixer
>> controls based on the UAC descriptor parsing. Then when they want to
>> change the volume (for example) it will result in a USB SETUP transaction.
>>
>> So USB SND will eventually be the entity controlling these changes.
>
> That's probably ok then, am I getting this right that the the DSP card
> would not expose any USB-related kcontrols then, i.e. the ONLY path to
> change volumes, etc., would through the regular USB card kcontrols?
>
> That would limit the changes in the platform sound card to the addition
> of a PCM USB device.
Yes, that's correct. There won't be any exposed USB volume controls
from the DSP card.
Thanks
Wesley Cheng
Hi Krzysztof,
On 3/10/2023 12:56 AM, Krzysztof Kozlowski wrote:
> On 09/03/2023 00:57, Wesley Cheng wrote:
>> Add an example on enabling of USB offload for the Q6DSP. The routing can
>> be done by the mixer, which can pass the multimedia stream to the USB
>> backend.
>>
>> Signed-off-by: Wesley Cheng <[email protected]>
>
>
> Reviewed-by: Krzysztof Kozlowski <[email protected]>
>
> You still miss binding change to APR/GPR. Where is the USB DAI going to sit?
>
My initial idea is to have it as part of the q6afe APR node (as a
child). It would need to issues some transactions over APR to the Q6AFE
port on the audio DSP, which was the main reason for this.
Something like:
q6afe: apr-service@4 {
compatible = "qcom,q6afe";
reg = <APR_SVC_AFE>;
q6afedai: dais {
compatible = "qcom,q6afe-dais";
#address-cells = <1>;
#size-cells = <0>;
#sound-dai-cells = <1>;
};
...
usbdai: usbd {
compatible = "qcom,q6usb";
#sound-dai-cells = <1>;
iommus = <&apps_smmu 0x180f 0x0>;
qcom,usb-audio-stream-id = <0xf>;
qcom,usb-audio-intr-num = <2>;
};
};
I think the only modification I would probably make is to have an
example of how to add the q6usb node to enable the audio offloading.
Thanks,
Wesley Cheng
>
>
> Best regards,
> Krzysztof
>