// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
*/
#include <linux/auxiliary_bus.h>
#include <linux/ctype.h>
#include <linux/dma-mapping.h>
#include <linux/dma-map-ops.h>
#include <linux/init.h>
#include <linux/iommu.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/soc/qcom/qmi.h>
#include <linux/usb.h>
#include <linux/usb/audio.h>
#include <linux/usb/audio-v2.h>
#include <linux/usb/audio-v3.h>
#include <linux/usb/hcd.h>
#include <linux/usb/quirks.h>
#include <linux/usb/xhci-sideband.h>
#include <sound/control.h>
#include <sound/core.h>
#include <sound/info.h>
#include <sound/initval.h>
#include <sound/pcm.h>
#include <sound/pcm_params.h>
#include <sound/q6usboffload.h>
#include <sound/soc.h>
#include <sound/soc-usb.h>
#include "../usbaudio.h"
#include "../card.h"
#include "../endpoint.h"
#include "../format.h"
#include "../helper.h"
#include "../pcm.h"
#include "../power.h"
#include "mixer_usb_offload.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 QMI_STREAM_REQ_CARD_NUM_MASK 0xffff0000
#define QMI_STREAM_REQ_DEV_NUM_MASK 0xff00
#define QMI_STREAM_REQ_DIRECTION 0xff
/* iommu resource parameters and management */
#define PREPEND_SID_TO_IOVA(iova, sid) ((u64)(((u64)(iova)) | \
(((u64)sid) << 32)))
#define IOVA_MASK(iova) (((u64)(iova)) & 0xFFFFFFFF)
#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 {
/* IOMMU ring/buffer mapping information */
unsigned long data_xfer_ring_va;
size_t data_xfer_ring_size;
unsigned long sync_xfer_ring_va;
size_t sync_xfer_ring_size;
dma_addr_t xfer_buf_iova;
size_t xfer_buf_size;
dma_addr_t xfer_buf_dma;
u8 *xfer_buf_cpu;
/* USB endpoint information */
unsigned int data_ep_pipe;
unsigned int sync_ep_pipe;
unsigned int data_ep_idx;
unsigned int sync_ep_idx;
u8 intf_num;
u8 pcm_card_num;
u8 pcm_dev_num;
u8 direction;
bool in_use;
};
struct uaudio_qmi_dev {
struct device *dev;
struct q6usb_offload *data;
struct auxiliary_device *auxdev;
/* 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;
};
struct uaudio_dev {
struct usb_device *udev;
/* audio control interface */
struct usb_host_interface *ctrl_intf;
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;
/* xhci sideband */
struct xhci_sideband *sb;
/* SoC USB device */
struct snd_soc_usb_device *sdev;
};
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 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 int usb_qmi_get_pcm_num(struct snd_usb_audio *chip, int direction)
{
struct snd_usb_substream *subs = NULL;
struct snd_usb_stream *as;
int count = 0;
list_for_each_entry(as, &chip->pcm_list, list) {
subs = &as->substream[direction];
if (subs->ep_num)
count++;
}
return count;
}
static enum usb_qmi_audio_device_speed_enum_v01
get_speed_info(enum usb_device_speed udev_speed)
{
switch (udev_speed) {
case USB_SPEED_LOW:
return USB_QMI_DEVICE_SPEED_LOW_V01;
case USB_SPEED_FULL:
return USB_QMI_DEVICE_SPEED_FULL_V01;
case USB_SPEED_HIGH:
return USB_QMI_DEVICE_SPEED_HIGH_V01;
case USB_SPEED_SUPER:
return USB_QMI_DEVICE_SPEED_SUPER_V01;
case USB_SPEED_SUPER_PLUS:
return USB_QMI_DEVICE_SPEED_SUPER_PLUS_V01;
default:
return USB_QMI_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_substream *subs = NULL;
struct snd_usb_audio *chip;
struct snd_usb_stream *as;
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_mult;
unsigned int bus_intval;
unsigned int 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;
}
}
/*
* Sends QMI disconnect indication message, assumes chip->mutex and qdev_mutex
* lock held by caller.
*/
static int uaudio_send_disconnect_ind(struct snd_usb_audio *chip)
{
struct qmi_uaudio_stream_ind_msg_v01 disconnect_ind = {0};
struct uaudio_qmi_svc *svc = uaudio_svc;
struct uaudio_dev *dev;
int ret = 0;
dev = &uadev[chip->card->number];
if (atomic_read(&dev->in_use)) {
mutex_unlock(&chip->mutex);
mutex_unlock(&qdev_mutex);
dev_dbg(uaudio_qdev->data->dev, "sending qmi indication suspend\n");
disconnect_ind.dev_event = USB_QMI_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->data->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->data->dev,
"timeout while waiting for dev_release\n");
atomic_set(&dev->in_use, 0);
} else if (ret < 0) {
dev_err(uaudio_qdev->data->dev,
"failed with ret %d\n", ret);
atomic_set(&dev->in_use, 0);
}
mutex_lock(&qdev_mutex);
mutex_lock(&chip->mutex);
}
return ret;
}
/* 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;
size_t tmp_size = size;
unsigned long iova = 0;
if (size % PAGE_SIZE)
goto done;
if (size > *curr_iova_size)
goto done;
if (*curr_iova_size == 0)
goto done;
list_for_each_entry(info, head, list) {
/* exact size iova_info */
if (!info->in_use && info->size == size) {
info->in_use = true;
iova = info->start_iova;
*curr_iova_size -= size;
goto done;
} else if (!info->in_use && tmp_size >= info->size) {
if (!new_info)
new_info = info;
tmp_size -= info->size;
if (tmp_size)
continue;
iova = 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;
goto done;
} else {
/* iova region in use */
new_info = NULL;
tmp_size = size;
}
}
info = kzalloc_obj(*info);
if (!info) {
iova = 0;
goto done;
}
iova = *curr_iova;
info->start_iova = *curr_iova;
info->size = size;
info->in_use = true;
*curr_iova += size;
*curr_iova_size -= size;
list_add_tail(&info->list, head);
done:
return iova;
}
static void uaudio_put_iova(unsigned long iova, 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 == iova) {
if (!info->in_use)
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)
return;
done:
*curr_iova_size += size;
}
/**
* uaudio_iommu_unmap() - unmaps iommu memory for adsp
* @mtype: ring type
* @iova: 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 iova,
size_t iova_size, size_t mapped_iova_size)
{
size_t umap_size;
bool unmap = true;
if (!iova || !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(iova, iova_size, &uaudio_qdev->xfer_ring_list,
&uaudio_qdev->xfer_ring_iova_size);
break;
case MEM_XFER_BUF:
uaudio_put_iova(iova, iova_size, &uaudio_qdev->xfer_buf_list,
&uaudio_qdev->xfer_buf_iova_size);
break;
default:
unmap = false;
}
if (!unmap || !mapped_iova_size)
return;
umap_size = iommu_unmap(uaudio_qdev->data->domain, iova, mapped_iova_size);
if (umap_size != mapped_iova_size)
dev_err(uaudio_qdev->data->dev,
"unmapped size %zu for iova 0x%08lx of mapped size %zu\n",
umap_size, iova, mapped_iova_size);
}
static int uaudio_iommu_map_prot(bool dma_coherent)
{
int prot = IOMMU_READ | IOMMU_WRITE;
if (dma_coherent)
prot |= IOMMU_CACHE;
return prot;
}
/**
* uaudio_iommu_map_pa() - maps iommu memory for adsp
* @mtype: ring type
* @dma_coherent: dma coherent
* @pa: physical address for ring/buffer
* @size: size of 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_pa(enum mem_type mtype, bool dma_coherent,
phys_addr_t pa, size_t size)
{
unsigned long iova = 0;
bool map = true;
int prot = uaudio_iommu_map_prot(dma_coherent);
int ret;
switch (mtype) {
case MEM_EVENT_RING:
iova = IOVA_BASE;
/* er already mapped */
if (uaudio_qdev->er_mapped)
map = false;
break;
case MEM_XFER_RING:
iova = uaudio_get_iova(&uaudio_qdev->curr_xfer_ring_iova,
&uaudio_qdev->xfer_ring_iova_size,
&uaudio_qdev->xfer_ring_list, size);
break;
default:
dev_err(uaudio_qdev->data->dev, "unknown mem type %d\n", mtype);
}
if (!iova)
return 0;
if (!map)
return iova;
ret = iommu_map(uaudio_qdev->data->domain, iova, pa, size, prot,
GFP_KERNEL);
if (ret) {
dev_err(uaudio_qdev->data->dev,
"failed to map %zu bytes at iova 0x%08lx: %d\n",
size, iova, ret);
if (mtype == MEM_XFER_RING)
uaudio_put_iova(iova, size,
&uaudio_qdev->xfer_ring_list,
&uaudio_qdev->xfer_ring_iova_size);
return 0;
}
return iova;
}
static unsigned long uaudio_iommu_map_xfer_buf(bool dma_coherent, size_t size,
struct sg_table *sgt)
{
struct scatterlist *sg;
unsigned long iova = 0;
size_t total_len = 0;
unsigned long iova_sg;
phys_addr_t pa_sg;
size_t sg_len;
int prot = uaudio_iommu_map_prot(dma_coherent);
int ret;
int i;
prot = IOMMU_READ | IOMMU_WRITE;
if (dma_coherent)
prot |= IOMMU_CACHE;
iova = uaudio_get_iova(&uaudio_qdev->curr_xfer_buf_iova,
&uaudio_qdev->xfer_buf_iova_size,
&uaudio_qdev->xfer_buf_list, size);
if (!iova)
goto done;
iova_sg = iova;
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->data->domain, iova_sg, pa_sg, sg_len,
prot, GFP_KERNEL);
if (ret) {
uaudio_iommu_unmap(MEM_XFER_BUF, iova, size, total_len);
iova = 0;
goto done;
}
iova_sg += sg_len;
total_len += sg_len;
}
if (size != total_len) {
uaudio_iommu_unmap(MEM_XFER_BUF, iova, size, total_len);
iova = 0;
}
done:
return iova;
}
/* 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_iova, info->xfer_buf_size,
info->xfer_buf_size);
info->xfer_buf_iova = 0;
usb_free_coherent(udev, info->xfer_buf_size, info->xfer_buf_cpu,
info->xfer_buf_dma);
info->xfer_buf_size = 0;
info->xfer_buf_cpu = NULL;
info->xfer_buf_dma = 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)
{
clear_bit(dev->chip->card->number, &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_sideband_remove_interrupter(uadev[dev->chip->card->number].sb);
usb_offload_put(dev->udev);
}
}
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->data->dev,
"release resources: intf# %d card# %d\n",
dev->info[if_idx].intf_num, dev->chip->card->number);
}
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;
snd_usb_hw_free(subs);
snd_usb_autosuspend(chip);
}
/* QMI service disconnect handlers */
static void qmi_stop_session(void)
{
struct snd_usb_substream *subs;
struct usb_host_endpoint *ep;
struct snd_usb_audio *chip;
struct intf_info *info;
int pcm_card_num;
int if_idx;
int idx;
guard(mutex)(&qdev_mutex);
/* 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];
pcm_card_num = info->pcm_card_num;
subs = find_substream(pcm_card_num, info->pcm_dev_num,
info->direction);
if (!subs || !chip || atomic_read(&chip->shutdown)) {
dev_err(&uadev[idx].udev->dev,
"no sub for c#%u dev#%u dir%u\n",
info->pcm_card_num,
info->pcm_dev_num,
info->direction);
continue;
}
/* Release XHCI endpoints */
if (info->data_ep_pipe) {
ep = usb_pipe_endpoint(uadev[pcm_card_num].udev,
info->data_ep_pipe);
if (ep)
xhci_sideband_remove_endpoint(uadev[pcm_card_num].sb,
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_sideband_remove_endpoint(uadev[pcm_card_num].sb,
ep);
info->sync_ep_pipe = 0;
}
disable_audio_stream(subs);
}
atomic_set(&uadev[idx].in_use, 0);
guard(mutex)(&chip->mutex);
uaudio_dev_cleanup(&uadev[idx]);
}
}
/**
* uaudio_sideband_notifier() - xHCI sideband event handler
* @intf: USB interface handle
* @evt: xHCI sideband event type
*
* This callback is executed when the xHCI sideband encounters a sequence
* that requires the sideband clients to take action. An example, is when
* xHCI frees the transfer ring, so the client has to ensure that the
* offload path is halted.
*
*/
static int uaudio_sideband_notifier(struct usb_interface *intf,
struct xhci_sideband_event *evt)
{
struct snd_usb_audio *chip;
struct uaudio_dev *dev;
int if_idx;
if (!intf || !evt)
return 0;
chip = usb_get_intfdata(intf);
guard(mutex)(&qdev_mutex);
guard(mutex)(&chip->mutex);
dev = &uadev[chip->card->number];
if (evt->type == XHCI_SIDEBAND_XFER_RING_FREE) {
unsigned int *ep = (unsigned int *) evt->evt_data;
for (if_idx = 0; if_idx < dev->num_intf; if_idx++) {
if (dev->info[if_idx].data_ep_idx == *ep ||
dev->info[if_idx].sync_ep_idx == *ep)
uaudio_send_disconnect_ind(chip);
}
}
return 0;
}
/**
* 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) {
qmi_stop_session();
/* clear QMI client parameters to block further QMI messages */
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)
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) {
qmi_stop_session();
/* clear QMI client parameters to block further QMI messages */
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_pcm_hw_params params;
struct snd_usb_audio *chip;
struct snd_interval *i;
struct snd_mask *m;
int ret;
chip = subs->stream->chip;
_snd_pcm_hw_params_any(¶ms);
m = hw_param_mask(¶ms, SNDRV_PCM_HW_PARAM_FORMAT);
snd_mask_leave(m, (__force unsigned int)pcm_format);
i = hw_param_interval(¶ms, SNDRV_PCM_HW_PARAM_CHANNELS);
snd_interval_setinteger(i);
i->min = channels;
i->max = channels;
i = hw_param_interval(¶ms, SNDRV_PCM_HW_PARAM_RATE);
snd_interval_setinteger(i);
i->min = cur_rate;
i->max = cur_rate;
pm_runtime_barrier(&chip->intf[0]->dev);
snd_usb_autoresume(chip);
ret = snd_usb_hw_params(subs, ¶ms);
if (ret < 0)
goto put_suspend;
if (!atomic_read(&chip->shutdown)) {
CLASS(snd_usb_lock, pm)(chip);
if (pm.err < 0) {
ret = pm.err;
goto detach_ep;
}
if (subs->sync_endpoint) {
ret = snd_usb_endpoint_prepare(chip, subs->sync_endpoint);
if (ret < 0)
goto detach_ep;
}
ret = snd_usb_endpoint_prepare(chip, subs->data_endpoint);
if (ret < 0)
goto detach_ep;
dev_dbg(uaudio_qdev->data->dev,
"selected %s iface:%d altsetting:%d datainterval:%dus\n",
subs->direction ? "capture" : "playback",
subs->cur_audiofmt->iface, subs->cur_audiofmt->altsetting,
(1 << subs->cur_audiofmt->datainterval) *
(subs->dev->speed >= USB_SPEED_HIGH ?
BUS_INTERVAL_HIGHSPEED_AND_ABOVE :
BUS_INTERVAL_FULL_SPEED));
}
return 0;
detach_ep:
snd_usb_hw_free(subs);
put_suspend:
snd_usb_autosuspend(chip);
return ret;
}
/**
* uaudio_transfer_buffer_setup() - fetch and populate xfer buffer params
* @subs: usb substream
* @xfer_buf_cpu: xfer buf to be allocated
* @xfer_buf_len: size of allocation
* @mem_info: QMI response info
*
* Allocates and maps the transfer buffers that will be utilized by the
* audio DSP. Will populate the information in the QMI response that is
* sent back to the stream enable request.
*
*/
static int uaudio_transfer_buffer_setup(struct snd_usb_substream *subs,
void **xfer_buf_cpu, u32 xfer_buf_len,
struct mem_info_v01 *mem_info)
{
struct sg_table xfer_buf_sgt;
dma_addr_t xfer_buf_dma;
void *xfer_buf;
u32 len = xfer_buf_len;
bool dma_coherent;
dma_addr_t xfer_buf_dma_sysdev;
int ret;
dma_coherent = dev_is_dma_coherent(subs->dev->bus->sysdev);
/* xfer buffer, multiple of 4K only */
if (!len)
len = PAGE_SIZE;
len = PAGE_ALIGN(len);
if (len > MAX_XFER_BUFF_LEN) {
dev_err(uaudio_qdev->data->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;
}
/* get buffer mapped into subs->dev */
xfer_buf = usb_alloc_coherent(subs->dev, len, GFP_KERNEL, &xfer_buf_dma);
if (!xfer_buf)
return -ENOMEM;
ret = dma_get_sgtable(subs->dev->bus->sysdev, &xfer_buf_sgt, xfer_buf,
xfer_buf_dma, len);
if (ret)
goto free_xfer_buf;
/* map the physical buffer into sysdev as well */
xfer_buf_dma_sysdev = uaudio_iommu_map_xfer_buf(dma_coherent,
len, &xfer_buf_sgt);
if (!xfer_buf_dma_sysdev) {
ret = -ENOMEM;
goto free_sgt;
}
mem_info->dma = xfer_buf_dma;
mem_info->size = len;
mem_info->iova = PREPEND_SID_TO_IOVA(xfer_buf_dma_sysdev, uaudio_qdev->data->sid);
*xfer_buf_cpu = xfer_buf;
sg_free_table(&xfer_buf_sgt);
return 0;
free_sgt:
sg_free_table(&xfer_buf_sgt);
free_xfer_buf:
usb_free_coherent(subs->dev, len, xfer_buf, xfer_buf_dma);
return ret;
}
/**
* uaudio_endpoint_setup() - fetch and populate endpoint params
* @subs: usb substream
* @endpoint: usb endpoint to add
* @card_num: uadev index
* @mem_info: QMI response info
* @ep_desc: QMI ep desc response field
*
* Initialize the USB endpoint being used for a particular USB
* stream. Will request XHCI sec intr to reserve the EP for
* offloading as well as populating the QMI response with the
* transfer ring parameters.
*
*/
static phys_addr_t
uaudio_endpoint_setup(struct snd_usb_substream *subs,
struct snd_usb_endpoint *endpoint, int card_num,
struct mem_info_v01 *mem_info,
struct usb_endpoint_descriptor_v01 *ep_desc)
{
struct usb_host_endpoint *ep;
phys_addr_t tr_pa = 0;
struct sg_table *sgt;
bool dma_coherent;
unsigned long iova;
struct page *pg;
int ret = -ENODEV;
dma_coherent = dev_is_dma_coherent(subs->dev->bus->sysdev);
ep = usb_pipe_endpoint(subs->dev, endpoint->pipe);
if (!ep) {
dev_err(uaudio_qdev->data->dev, "data ep # %d context is null\n",
subs->data_endpoint->ep_num);
goto exit;
}
memcpy(ep_desc, &ep->desc, sizeof(ep->desc));
ret = xhci_sideband_add_endpoint(uadev[card_num].sb, ep);
if (ret < 0) {
dev_err(&subs->dev->dev,
"failed to add data ep to sec intr: %d\n", ret);
ret = -ENODEV;
goto exit;
}
sgt = xhci_sideband_get_endpoint_buffer(uadev[card_num].sb, ep);
if (!sgt) {
dev_err(&subs->dev->dev,
"failed to get data ep ring address: %d\n", ret);
ret = -ENODEV;
goto remove_ep;
}
pg = sg_page(sgt->sgl);
tr_pa = page_to_phys(pg);
mem_info->dma = sg_dma_address(sgt->sgl);
sg_free_table(sgt);
kfree(sgt);
/* data transfer ring */
iova = uaudio_iommu_map_pa(MEM_XFER_RING, dma_coherent, tr_pa,
PAGE_SIZE);
if (!iova) {
ret = -ENOMEM;
goto clear_pa;
}
mem_info->iova = PREPEND_SID_TO_IOVA(iova, uaudio_qdev->data->sid);
mem_info->size = PAGE_SIZE;
return 0;
clear_pa:
mem_info->dma = 0;
remove_ep:
xhci_sideband_remove_endpoint(uadev[card_num].sb, ep);
exit:
return ret;
}
/**
* uaudio_event_ring_setup() - fetch and populate event ring params
* @subs: usb substream
* @card_num: uadev index
* @mem_info: QMI response info
*
* Register secondary interrupter to XHCI and fetch the event buffer info
* and populate the information into the QMI response.
*
*/
static int uaudio_event_ring_setup(struct snd_usb_substream *subs,
int card_num, struct mem_info_v01 *mem_info)
{
struct sg_table *sgt;
phys_addr_t er_pa;
bool dma_coherent;
unsigned long iova;
struct page *pg;
int ret;
dma_coherent = dev_is_dma_coherent(subs->dev->bus->sysdev);
er_pa = 0;
ret = usb_offload_get(subs->dev);
if (ret < 0)
goto exit;
/* event ring */
ret = xhci_sideband_create_interrupter(uadev[card_num].sb, 1, false,
0, uaudio_qdev->data->intr_num);
if (ret < 0) {
dev_err(&subs->dev->dev, "failed to fetch interrupter\n");
goto put_offload;
}
sgt = xhci_sideband_get_event_buffer(uadev[card_num].sb);
if (!sgt) {
dev_err(&subs->dev->dev,
"failed to get event ring address\n");
ret = -ENODEV;
goto remove_interrupter;
}
pg = sg_page(sgt->sgl);
er_pa = page_to_phys(pg);
mem_info->dma = sg_dma_address(sgt->sgl);
sg_free_table(sgt);
kfree(sgt);
iova = uaudio_iommu_map_pa(MEM_EVENT_RING, dma_coherent, er_pa,
PAGE_SIZE);
if (!iova) {
ret = -ENOMEM;
goto clear_pa;
}
mem_info->iova = PREPEND_SID_TO_IOVA(iova, uaudio_qdev->data->sid);
mem_info->size = PAGE_SIZE;
return 0;
clear_pa:
mem_info->dma = 0;
remove_interrupter:
xhci_sideband_remove_interrupter(uadev[card_num].sb);
put_offload:
usb_offload_put(subs->dev);
exit:
return ret;
}
/**
* uaudio_populate_uac_desc() - parse UAC parameters and populate QMI resp
* @subs: usb substream
* @resp: QMI response buffer
*
* Parses information specified within UAC descriptors which explain the
* sample parameters that the device expects. This information is populated
* to the QMI response sent back to the audio DSP.
*
*/
static int uaudio_populate_uac_desc(struct snd_usb_substream *subs,
struct qmi_uaudio_stream_resp_msg_v01 *resp)
{
struct usb_interface_descriptor *altsd;
struct usb_host_interface *alts;
struct usb_interface *iface;
int protocol;
iface = usb_ifnum_to_if(subs->dev, subs->cur_audiofmt->iface);
if (!iface) {
dev_err(&subs->dev->dev, "interface # %d does not exist\n",
subs->cur_audiofmt->iface);
return -ENODEV;
}
alts = &iface->altsetting[subs->cur_audiofmt->altset_idx];
altsd = get_iface_desc(alts);
protocol = altsd->bInterfaceProtocol;
if (protocol == UAC_VERSION_1) {
struct uac1_as_header_descriptor *as;
as = snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL,
UAC_AS_GENERAL);
if (!as) {
dev_err(&subs->dev->dev,
"%u:%d : no UAC_AS_GENERAL desc\n",
subs->cur_audiofmt->iface,
subs->cur_audiofmt->altset_idx);
return -ENODEV;
}
resp->data_path_delay = as->bDelay;
resp->data_path_delay_valid = 1;
resp->usb_audio_subslot_size = subs->cur_audiofmt->fmt_sz;
resp->usb_audio_subslot_size_valid = 1;
resp->usb_audio_spec_revision = le16_to_cpu((__force __le16)0x0100);
resp->usb_audio_spec_revision_valid = 1;
} else if (protocol == UAC_VERSION_2) {
resp->usb_audio_subslot_size = subs->cur_audiofmt->fmt_sz;
resp->usb_audio_subslot_size_valid = 1;
resp->usb_audio_spec_revision = le16_to_cpu((__force __le16)0x0200);
resp->usb_audio_spec_revision_valid = 1;
} else if (protocol == UAC_VERSION_3) {
if (iface->intf_assoc->bFunctionSubClass ==
UAC3_FUNCTION_SUBCLASS_FULL_ADC_3_0) {
dev_err(&subs->dev->dev,
"full adc is not supported\n");
return -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(&subs->dev->dev,
"%d: %u: Invalid wMaxPacketSize\n",
subs->cur_audiofmt->iface,
subs->cur_audiofmt->altset_idx);
return -EINVAL;
}
resp->usb_audio_subslot_size_valid = 1;
} else {
dev_err(&subs->dev->dev, "unknown protocol version %x\n",
protocol);
return -ENODEV;
}
memcpy(&resp->std_as_opr_intf_desc, &alts->desc, sizeof(alts->desc));
return 0;
}
/**
* 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 q6usb_offload *data;
int pcm_dev_num;
int card_num;
void *xfer_buf_cpu;
int ret;
pcm_dev_num = (req_msg->usb_token & QMI_STREAM_REQ_DEV_NUM_MASK) >> 8;
card_num = (req_msg->usb_token & QMI_STREAM_REQ_CARD_NUM_MASK) >> 16;
if (!uadev[card_num].ctrl_intf) {
dev_err(&subs->dev->dev, "audio ctrl intf info not cached\n");
return -ENODEV;
}
ret = uaudio_populate_uac_desc(subs, resp);
if (ret < 0)
return ret;
resp->slot_id = subs->dev->slot_id;
resp->slot_id_valid = 1;
data = snd_soc_usb_find_priv_data(uaudio_qdev->auxdev->dev.parent);
if (!data) {
dev_err(&subs->dev->dev, "No private data found\n");
return -ENODEV;
}
uaudio_qdev->data = data;
resp->std_as_opr_intf_desc_valid = 1;
ret = uaudio_endpoint_setup(subs, subs->data_endpoint, card_num,
&resp->xhci_mem_info.tr_data,
&resp->std_as_data_ep_desc);
if (ret < 0)
return ret;
resp->std_as_data_ep_desc_valid = 1;
if (subs->sync_endpoint) {
ret = uaudio_endpoint_setup(subs, subs->sync_endpoint, card_num,
&resp->xhci_mem_info.tr_sync,
&resp->std_as_sync_ep_desc);
if (ret < 0)
goto drop_data_ep;
resp->std_as_sync_ep_desc_valid = 1;
}
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;
}
/* event ring */
ret = uaudio_event_ring_setup(subs, card_num,
&resp->xhci_mem_info.evt_ring);
if (ret < 0)
goto drop_sync_ep;
uaudio_qdev->er_mapped = true;
resp->interrupter_num = xhci_sideband_interrupter_id(uadev[card_num].sb);
resp->speed_info = get_speed_info(subs->dev->speed);
if (resp->speed_info == USB_QMI_DEVICE_SPEED_INVALID_V01) {
ret = -ENODEV;
goto free_sec_ring;
}
resp->speed_info_valid = 1;
ret = uaudio_transfer_buffer_setup(subs, &xfer_buf_cpu, req_msg->xfer_buff_size,
&resp->xhci_mem_info.xfer_buff);
if (ret < 0) {
ret = -ENOMEM;
goto free_sec_ring;
}
resp->xhci_mem_info_valid = 1;
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 = kzalloc_objs(struct intf_info,
uadev[card_num].num_intf);
if (!uadev[card_num].info) {
ret = -ENOMEM;
goto unmap_er;
}
uadev[card_num].udev = subs->dev;
atomic_set(&uadev[card_num].in_use, 1);
} else {
kref_get(&uadev[card_num].kref);
}
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 =
IOVA_MASK(resp->xhci_mem_info.tr_data.iova);
uadev[card_num].info[info_idx].data_xfer_ring_size = PAGE_SIZE;
uadev[card_num].info[info_idx].sync_xfer_ring_va =
IOVA_MASK(resp->xhci_mem_info.tr_sync.iova);
uadev[card_num].info[info_idx].sync_xfer_ring_size = PAGE_SIZE;
uadev[card_num].info[info_idx].xfer_buf_iova =
IOVA_MASK(resp->xhci_mem_info.xfer_buff.iova);
uadev[card_num].info[info_idx].xfer_buf_dma =
resp->xhci_mem_info.xfer_buff.dma;
uadev[card_num].info[info_idx].xfer_buf_size =
resp->xhci_mem_info.xfer_buff.size;
uadev[card_num].info[info_idx].data_ep_pipe = subs->data_endpoint ?
subs->data_endpoint->pipe : 0;
uadev[card_num].info[info_idx].sync_ep_pipe = subs->sync_endpoint ?
subs->sync_endpoint->pipe : 0;
uadev[card_num].info[info_idx].data_ep_idx = subs->data_endpoint ?
subs->data_endpoint->ep_num : 0;
uadev[card_num].info[info_idx].sync_ep_idx = subs->sync_endpoint ?
subs->sync_endpoint->ep_num : 0;
uadev[card_num].info[info_idx].xfer_buf_cpu = xfer_buf_cpu;
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_er:
uaudio_iommu_unmap(MEM_EVENT_RING, IOVA_BASE, PAGE_SIZE, PAGE_SIZE);
free_sec_ring:
xhci_sideband_remove_interrupter(uadev[card_num].sb);
usb_offload_put(subs->dev);
drop_sync_ep:
if (subs->sync_endpoint) {
uaudio_iommu_unmap(MEM_XFER_RING,
IOVA_MASK(resp->xhci_mem_info.tr_sync.iova),
PAGE_SIZE, PAGE_SIZE);
xhci_sideband_remove_endpoint(uadev[card_num].sb,
usb_pipe_endpoint(subs->dev, subs->sync_endpoint->pipe));
}
drop_data_ep:
uaudio_iommu_unmap(MEM_XFER_RING, IOVA_MASK(resp->xhci_mem_info.tr_data.iova),
PAGE_SIZE, PAGE_SIZE);
xhci_sideband_remove_endpoint(uadev[card_num].sb,
usb_pipe_endpoint(subs->dev, subs->data_endpoint->pipe));
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 uaudio_qmi_svc *svc = uaudio_svc;
struct snd_usb_audio *chip = NULL;
struct snd_usb_substream *subs;
struct usb_host_endpoint *ep;
int datainterval = -EINVAL;
int info_idx = -EINVAL;
struct intf_info *info;
u8 pcm_card_num;
u8 pcm_dev_num;
u8 direction;
int 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 & QMI_STREAM_REQ_DIRECTION);
pcm_dev_num = (req_msg->usb_token & QMI_STREAM_REQ_DEV_NUM_MASK) >> 8;
pcm_card_num = (req_msg->usb_token & QMI_STREAM_REQ_CARD_NUM_MASK) >> 16;
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;
}
scoped_guard(mutex, &chip->mutex) {
if (req_msg->enable) {
if (info_idx < 0 || chip->system_suspend || subs->opened) {
ret = -EBUSY;
goto response;
}
subs->opened = 1;
}
}
if (req_msg->service_interval_valid) {
ret = get_data_interval_from_si(subs,
req_msg->service_interval);
if (ret == -EINVAL) {
if (req_msg->enable) {
guard(mutex)(&chip->mutex);
subs->opened = 0;
}
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);
if (ret < 0) {
guard(mutex)(&chip->mutex);
subs->opened = 0;
}
} else {
if (info_idx < 0) {
ret = -EINVAL;
goto response;
}
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_sideband_stop_endpoint(uadev[pcm_card_num].sb,
ep);
xhci_sideband_remove_endpoint(uadev[pcm_card_num].sb,
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_sideband_stop_endpoint(uadev[pcm_card_num].sb,
ep);
xhci_sideband_remove_endpoint(uadev[pcm_card_num].sb,
ep);
}
info->sync_ep_pipe = 0;
}
disable_audio_stream(subs);
guard(mutex)(&chip->mutex);
subs->opened = 0;
}
response:
if (!req_msg->enable && ret != -EINVAL && ret != -ENODEV) {
guard(mutex)(&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(&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_QMI_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(void)
{
uaudio_qdev = kzalloc_obj(*uaudio_qdev);
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;
}
/* Populates ppcm_idx array with supported PCM indexes */
static int qc_usb_audio_offload_fill_avail_pcms(struct snd_usb_audio *chip,
struct snd_soc_usb_device *sdev)
{
struct snd_usb_stream *as;
struct snd_usb_substream *subs;
int idx = 0;
list_for_each_entry(as, &chip->pcm_list, list) {
subs = &as->substream[SNDRV_PCM_STREAM_PLAYBACK];
if (subs->ep_num) {
sdev->ppcm_idx[idx] = as->pcm->device;
idx++;
}
/*
* Break if the current index exceeds the number of possible
* playback streams counted from the UAC descriptors.
*/
if (idx >= sdev->num_playback)
break;
}
return idx;
}
/**
* 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_interface *intf = chip->intf[chip->num_interfaces - 1];
struct usb_interface_descriptor *altsd;
struct usb_host_interface *alts;
struct snd_soc_usb_device *sdev;
struct xhci_sideband *sb;
/*
* If there is no priv_data, or no playback paths, the connected
* device doesn't support offloading. Avoid populating entries for
* this device.
*/
if (!snd_soc_usb_find_priv_data(uaudio_qdev->auxdev->dev.parent) ||
!usb_qmi_get_pcm_num(chip, 0))
return;
guard(mutex)(&qdev_mutex);
guard(mutex)(&chip->mutex);
if (!uadev[chip->card->number].chip) {
sdev = kzalloc_obj(*sdev);
if (!sdev)
return;
sb = xhci_sideband_register(intf, XHCI_SIDEBAND_VENDOR,
uaudio_sideband_notifier);
if (!sb)
goto free_sdev;
} else {
sb = uadev[chip->card->number].sb;
sdev = uadev[chip->card->number].sdev;
}
uadev[chip->card->number].sb = sb;
uadev[chip->card->number].chip = chip;
uadev[chip->card->number].sdev = sdev;
alts = &intf->altsetting[0];
altsd = get_iface_desc(alts);
/* Wait until all PCM devices are populated before notifying soc-usb */
if (altsd->bInterfaceNumber == chip->last_iface) {
sdev->num_playback = usb_qmi_get_pcm_num(chip, 0);
/*
* Allocate playback pcm index array based on number of possible
* playback paths within the UAC descriptors.
*/
sdev->ppcm_idx = kcalloc(sdev->num_playback, sizeof(unsigned int),
GFP_KERNEL);
if (!sdev->ppcm_idx)
goto unreg_xhci;
qc_usb_audio_offload_fill_avail_pcms(chip, sdev);
sdev->card_idx = chip->card->number;
sdev->chip_idx = chip->index;
snd_usb_offload_create_ctl(chip, uaudio_qdev->auxdev->dev.parent);
snd_soc_usb_connect(uaudio_qdev->auxdev->dev.parent, sdev);
}
return;
unreg_xhci:
xhci_sideband_unregister(sb);
uadev[chip->card->number].sb = NULL;
free_sdev:
kfree(sdev);
uadev[chip->card->number].sdev = NULL;
uadev[chip->card->number].chip = NULL;
}
/**
* 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 uaudio_dev *dev;
int card_num;
if (!chip)
return;
card_num = chip->card->number;
if (card_num >= SNDRV_CARDS)
return;
guard(mutex)(&qdev_mutex);
guard(mutex)(&chip->mutex);
dev = &uadev[card_num];
/* Device has already been cleaned up, or never populated */
if (!dev->chip)
return;
/* cleaned up already */
if (!dev->udev)
goto done;
uaudio_send_disconnect_ind(chip);
uaudio_dev_cleanup(dev);
done:
/*
* If num_interfaces == 1, the last USB SND interface is being removed.
* This is to accommodate for devices w/ multiple UAC functions.
*/
if (chip->num_interfaces == 1) {
snd_soc_usb_disconnect(uaudio_qdev->auxdev->dev.parent, dev->sdev);
xhci_sideband_unregister(dev->sb);
dev->chip = NULL;
kfree(dev->sdev->ppcm_idx);
kfree(dev->sdev);
dev->sdev = NULL;
}
}
/**
* 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);
int card_num;
if (!chip)
return;
card_num = chip->card->number;
if (card_num >= SNDRV_CARDS)
return;
guard(mutex)(&qdev_mutex);
guard(mutex)(&chip->mutex);
uaudio_send_disconnect_ind(chip);
}
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 qc_usb_audio_probe(struct auxiliary_device *auxdev,
const struct auxiliary_device_id *id)
{
struct uaudio_qmi_svc *svc;
int ret;
svc = kzalloc_obj(*svc);
if (!svc)
return -ENOMEM;
svc->uaudio_svc_hdl = kzalloc_obj(*svc->uaudio_svc_hdl);
if (!svc->uaudio_svc_hdl) {
ret = -ENOMEM;
goto free_svc;
}
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);
uaudio_svc = svc;
qc_usb_audio_offload_init_qmi_dev();
uaudio_qdev->auxdev = auxdev;
ret = snd_usb_register_platform_ops(&offload_ops);
if (ret < 0)
goto release_qmi;
snd_usb_rediscover_devices();
return 0;
release_qmi:
qc_usb_audio_cleanup_qmi_dev();
qmi_handle_release(svc->uaudio_svc_hdl);
kfree(svc->uaudio_svc_hdl);
free_svc:
kfree(svc);
return ret;
}
static void qc_usb_audio_remove(struct auxiliary_device *auxdev)
{
struct uaudio_qmi_svc *svc = uaudio_svc;
int idx;
/*
* Remove all connected devices after unregistering ops, to ensure
* that no further connect events will occur. The disconnect routine
* will issue the QMI disconnect indication, which results in the
* external DSP to stop issuing transfers.
*/
snd_usb_unregister_platform_ops();
for (idx = 0; idx < SNDRV_CARDS; idx++)
qc_usb_audio_offload_disconnect(uadev[idx].chip);
qc_usb_audio_cleanup_qmi_dev();
qmi_handle_release(svc->uaudio_svc_hdl);
kfree(svc->uaudio_svc_hdl);
kfree(svc);
uaudio_svc = NULL;
}
static const struct auxiliary_device_id qc_usb_audio_table[] = {
{ .name = "q6usb.qc-usb-audio-offload" },
{},
};
MODULE_DEVICE_TABLE(auxiliary, qc_usb_audio_table);
static struct auxiliary_driver qc_usb_audio_offload_drv = {
.name = "qc-usb-audio-offload",
.id_table = qc_usb_audio_table,
.probe = qc_usb_audio_probe,
.remove = qc_usb_audio_remove,
};
module_auxiliary_driver(qc_usb_audio_offload_drv);
MODULE_DESCRIPTION("QC USB Audio Offloading");
MODULE_LICENSE("GPL");
