Expose helpers in the SoC USB layer so components can update and keep track
of the offloading sessions. This exposes a kcontrol to userspace, so that
applications can be aware of what the current USB offloading status is.
An example output using tinymix is:
USB offloading idle:
tinymix -D 0 get 'USB Offload Playback Route Status'
-->-1, -1 (range -1->32)
USB offloading active(USB card#1 pcm#0):
tinymix -D 0 get 'USB Offload Playback Route Status'
-->1, 0 (range -1->32)
Signed-off-by: Wesley Cheng <quic_wcheng@xxxxxxxxxxx>
---
include/sound/soc-usb.h | 46 +++++++++++
sound/soc/soc-usb.c | 176 ++++++++++++++++++++++++++++++++++++++++
2 files changed, 222 insertions(+)
diff --git a/include/sound/soc-usb.h b/include/sound/soc-usb.h
index 18cdc59df9aa..5e6076f65a41 100644
--- a/include/sound/soc-usb.h
+++ b/include/sound/soc-usb.h
@@ -9,9 +9,29 @@
enum snd_soc_usb_kctl {
SND_SOC_USB_KCTL_CARD_ROUTE,
SND_SOC_USB_KCTL_PCM_ROUTE,
+ SND_SOC_USB_KCTL_CARD_STATUS,
+ SND_SOC_USB_KCTL_PCM_STATUS,
SND_SOC_USB_KCTL_MAX,
};
+enum snd_soc_usb_dai_state {
+ SND_SOC_USB_IDLE,
+ SND_SOC_USB_PREPARED,
+ SND_SOC_USB_RUNNING,
+};
+
+/**
+ * struct snd_soc_usb_session
+ * @active_card_idx - active offloaded sound card
+ * @active_pcm_idx - active offloaded PCM device
+ * @state - USB BE DAI link PCM state
+ */
+struct snd_soc_usb_session {
+ int active_card_idx;
+ int active_pcm_idx;
+ enum snd_soc_usb_dai_state state;
+};
+
/**
* struct snd_soc_usb_device
* @card_idx - sound card index associated with USB device
@@ -31,6 +51,7 @@ struct snd_soc_usb_device {
* @list - list head for SND SOC struct list
* @component - reference to ASoC component
* @kctl - list of kcontrols created
+ * @active_list - active sessions
* @num_supported_streams - number of supported concurrent sessions
* @connection_status_cb - callback to notify connection events
* @put_offload_dev - callback to select USB sound card/PCM device
@@ -41,6 +62,7 @@ struct snd_soc_usb {
struct list_head list;
struct snd_soc_component *component;
struct snd_kcontrol *kctl[SND_SOC_USB_KCTL_MAX];
+ struct snd_soc_usb_session *active_list;
unsigned int num_supported_streams;
int (*connection_status_cb)(struct snd_soc_usb *usb,
struct snd_soc_usb_device *sdev, bool connected);
@@ -62,6 +84,11 @@ int snd_soc_usb_connect(struct device *usbdev, struct snd_soc_usb_device *sdev);
int snd_soc_usb_disconnect(struct device *usbdev, struct snd_soc_usb_device *sdev);
void *snd_soc_usb_find_priv_data(struct device *dev);
+int snd_soc_usb_prepare_session(struct snd_soc_usb *usb, int card_idx, int pcm_idx);
+int snd_soc_usb_shutdown_session(struct snd_soc_usb *usb, int session_id);
+int snd_soc_usb_set_session_state(struct snd_soc_usb *usb, int session_id,
+ enum snd_soc_usb_dai_state state);
+
struct snd_soc_usb *snd_soc_usb_allocate_port(struct snd_soc_component *component,
int num_streams, void *data);
void snd_soc_usb_free_port(struct snd_soc_usb *usb);
@@ -97,6 +124,25 @@ static inline void *snd_soc_usb_find_priv_data(struct device *dev)
return NULL;
}
+static inline int snd_soc_usb_prepare_session(struct snd_soc_usb *usb, int card_idx,
+ int pcm_idx)
+{
+ return -EINVAL;
+}
+
+static inline int snd_soc_usb_shutdown_session(struct snd_soc_usb *usb,
+ int session_id)
+{
+ return -EINVAL;
+}
+
+static inline int snd_soc_usb_set_session_state(struct snd_soc_usb *usb,
+ int session_id,
+ enum snd_soc_usb_dai_state state)
+{
+ return -EINVAL;
+}
+
static inline struct snd_soc_usb *snd_soc_usb_allocate_port(
struct snd_soc_component *component,
int num_streams, void *data)
diff --git a/sound/soc/soc-usb.c b/sound/soc/soc-usb.c
index ade09b416d45..e291f146a79d 100644
--- a/sound/soc/soc-usb.c
+++ b/sound/soc/soc-usb.c
@@ -42,6 +42,79 @@ static struct snd_soc_usb *snd_soc_find_usb_ctx(struct device_node *node)
}
/* SOC USB sound kcontrols */
+static int snd_soc_usb_get_offload_card_status(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
+{
+ struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
+ struct snd_soc_usb *ctx = snd_soc_find_usb_ctx(component->dev->of_node);
+ int control_idx = 0;
+ int card_idx;
+ int i;
+
+ for (i = 0; i < ctx->num_supported_streams; i++) {
+ card_idx = -1;
+
+ if (ctx->active_list[i].state == SND_SOC_USB_RUNNING)
+ card_idx = ctx->active_list[i].active_card_idx;
+
+ ucontrol->value.integer.value[control_idx] = card_idx;
+ control_idx++;
+ }
+
+ return 0;
+}
+
+static int snd_soc_usb_offload_card_status_info(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_info *uinfo)
+{
+ struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
+ struct snd_soc_usb *ctx = snd_soc_find_usb_ctx(component->dev->of_node);
+
+ uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
+ uinfo->count = ctx->num_supported_streams;
+ uinfo->value.integer.min = -1;
+ uinfo->value.integer.max = SNDRV_CARDS;
+
+ return 0;
+}
+
+static int snd_soc_usb_get_offload_pcm_status(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
+{
+ struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
+ struct snd_soc_usb *ctx = snd_soc_find_usb_ctx(component->dev->of_node);
+ int control_idx = 0;
+ int pcm_idx;
+ int i;
+
+ for (i = 0; i < ctx->num_supported_streams; i++) {
+ pcm_idx = -1;
+
+ if (ctx->active_list[i].state == SND_SOC_USB_RUNNING)
+ pcm_idx = ctx->active_list[i].active_pcm_idx;
+
+ ucontrol->value.integer.value[control_idx] = pcm_idx;
+ control_idx++;
+ }
+
+ return 0;
+}
+
+static int snd_soc_usb_offload_pcm_status_info(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_info *uinfo)
+{
+ struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
+ struct snd_soc_usb *ctx = snd_soc_find_usb_ctx(component->dev->of_node);
+
+ uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
+ uinfo->count = ctx->num_supported_streams;
+ uinfo->value.integer.min = -1;
+ /* Arbitrary max value, as there is no 'limit' on number of PCM devices */
+ uinfo->value.integer.max = 0xff;
+
+ return 0;
+}
+
static int soc_usb_put_offload_pcm_dev(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{
@@ -152,6 +225,22 @@ static const struct snd_kcontrol_new soc_usb_kcontrols[] = {
.get = soc_usb_get_offload_pcm_dev,
.put = soc_usb_put_offload_pcm_dev,
},
+ [SND_SOC_USB_KCTL_CARD_STATUS] = {
+ .iface = SNDRV_CTL_ELEM_IFACE_CARD,
+ .access = SNDRV_CTL_ELEM_ACCESS_READ,
+ .name = "USB Offload Playback Route Card Status",
+ .info = snd_soc_usb_offload_card_status_info,
+ .get = snd_soc_usb_get_offload_card_status,
+ .put = NULL,
+ },
+ [SND_SOC_USB_KCTL_PCM_STATUS] = {
+ .iface = SNDRV_CTL_ELEM_IFACE_CARD,
+ .access = SNDRV_CTL_ELEM_ACCESS_READ,
+ .name = "USB Offload Playback Route PCM Status",
+ .info = snd_soc_usb_offload_pcm_status_info,
+ .get = snd_soc_usb_get_offload_pcm_status,
+ .put = NULL,
+ },
};
static int snd_soc_usb_control_remove(struct snd_soc_usb *usb)
@@ -187,6 +276,85 @@ static int snd_soc_usb_control_init(struct snd_soc_usb *usb)
return ret;
}
+/**
+ * snd_soc_usb_set_session_state() - Set the session state for a session
+ * @usb: SOC USB device
+ * @session_id: index to active_list
+ * @state: USB PCM device index
+ *
+ * Set the session state for an entry in active_list. This should be only
+ * called after snd_soc_usb_prepare_session.
+ *
+ * Returns 0 on success, negative on error.
+ *
+ */
+int snd_soc_usb_set_session_state(struct snd_soc_usb *usb, int session_id,
+ enum snd_soc_usb_dai_state state)
+{
+ if (session_id < 0 || session_id >= usb->num_supported_streams)
+ return -EINVAL;
+
+ mutex_lock(&ctx_mutex);
+ if (usb->active_list[session_id].state == state) {
+ mutex_unlock(&ctx_mutex);
+ return 0;
+ }
+
+ usb->active_list[session_id].state = state;
+ mutex_unlock(&ctx_mutex);
+
+ return 0;
+}
+EXPORT_SYMBOL_GPL(snd_soc_usb_set_session_state);
+
+/**
+ * snd_soc_usb_prepare_session() - Find and prepare a session
+ * @usb: SOC USB device
+ * @card_idx: USB card index
+ * @pcm_idx: USB PCM device index
+ *
+ * Find an open active session slot on the SOC USB device. If all slots
+ * are busy, return an error. If not, claim the slot and place it into
+ * the SND_SOC_USB_PREPARED state. This should be called first before
+ * calling snd_soc_usb_set_session_state or snd_soc_usb_shutdown_session.
+ *
+ * Returns the session id (index) to active_list, negative on error.
+ *
+ */
+int snd_soc_usb_prepare_session(struct snd_soc_usb *usb, int card_idx, int pcm_idx)
+{
+ int i;
+
+ mutex_lock(&ctx_mutex);
+ for (i = 0; i < usb->num_supported_streams; i++) {
+ if (usb->active_list[i].state == SND_SOC_USB_IDLE) {
+ usb->active_list[i].active_card_idx = card_idx;
+ usb->active_list[i].active_pcm_idx = pcm_idx;
+ usb->active_list[i].state = SND_SOC_USB_PREPARED;
+ mutex_unlock(&ctx_mutex);
+ return i;
+ }
+ }
+ mutex_unlock(&ctx_mutex);
+
+ return -EBUSY;
+}
+EXPORT_SYMBOL_GPL(snd_soc_usb_prepare_session);
+
+/**
+ * snd_soc_usb_shutdown_session() - Set USB SOC to idle state
+ * @usb: SOC USB device
+ * @session_id: index to active_list
+ *
+ * Place the session specified by session_id into the idle/shutdown state.
+ *
+ */
+int snd_soc_usb_shutdown_session(struct snd_soc_usb *usb, int session_id)
+{
+ return snd_soc_usb_set_session_state(usb, session_id, SND_SOC_USB_IDLE);
+}
+EXPORT_SYMBOL_GPL(snd_soc_usb_shutdown_session);
+
/**
* snd_soc_usb_get_components_tag() - Retrieve SOC USB component tag
* @playback: direction of audio stream
@@ -273,6 +441,13 @@ struct snd_soc_usb *snd_soc_usb_allocate_port(struct snd_soc_component *componen
if (!usb)
return ERR_PTR(-ENOMEM);
+ usb->active_list = kcalloc(num_streams, sizeof(struct snd_soc_usb_session),
+ GFP_KERNEL);
+ if (!usb->active_list) {
+ kfree(usb);
+ return ERR_PTR(-ENOMEM);
+ }
+
usb->component = component;
usb->priv_data = data;
usb->num_supported_streams = num_streams;
@@ -291,6 +466,7 @@ EXPORT_SYMBOL_GPL(snd_soc_usb_allocate_port);
void snd_soc_usb_free_port(struct snd_soc_usb *usb)
{
snd_soc_usb_remove_port(usb);
+ kfree(usb->active_list);
kfree(usb);
}
EXPORT_SYMBOL_GPL(snd_soc_usb_free_port);
[Index of Archives]
[Pulseaudio]
[Linux Audio Users]
[ALSA Devel]
[Fedora Desktop]
[Fedora SELinux]
[Big List of Linux Books]
[Yosemite News]
[KDE Users]
