lkml.org 
[lkml]   [2023]   [Oct]   [17]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    /
    Date
    From
    SubjectRe: [PATCH v9 19/34] ALSA: usb-audio: qcom: Introduce QC USB SND offloading support

    > +config SND_USB_AUDIO_QMI
    > + tristate "Qualcomm Audio Offload driver"
    > + depends on QCOM_QMI_HELPERS && SND_USB_AUDIO && USB_XHCI_SIDEBAND
    > + select SND_PCM

    This select is not needed:

    config SND_USB_AUDIO
    tristate "USB Audio/MIDI driver"
    select SND_HWDEP
    select SND_RAWMIDI
    select SND_PCM


    > +#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-sideband.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 "../endpoint.h"
    > +#include "../helper.h"
    > +#include "../pcm.h"
    > +#include "../format.h"
    > +#include "../power.h"
    > +#include "usb_audio_qmi_v01.h"
    > +
    > +/* Stream disable request timeout during USB device disconnect */
    > +#define DEV_RELEASE_WAIT_TIMEOUT 10000 /* in ms */

    DEV_RELEASE_WAIT_TIMEOUT_MS?

    why 10s btw?

    > +
    > +/* 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_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_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 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;
    > +};

    these structures feel like a set of kitchen sinks... Or a possible
    copy-paste, I don't know how one would add all these pointers on their own?

    Do you really need all this? Is there not a way to use existing
    substructures?


    > +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 also feels like a generic helper. I don't see what's Qualcomm
    specific here?


    > +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;

    reverse x-mas tree style?

    > +
    > + 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;

    so it's an error but the function returns 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)
    > +{
    > + 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);
    > + }
    > +}
    > +
    > +static void uaudio_dev_cleanup(struct uaudio_dev *dev)

    there should be a comment that this assumes a mutex is locked in the caller.

    > +{
    > + 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->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_disconnect_work(struct work_struct *w)
    > +{
    > + struct intf_info *info;
    > + int idx, if_idx;
    > + struct snd_usb_substream *subs;
    > + struct snd_usb_audio *chip;
    > +
    > + mutex_lock(&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];
    > + 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);
    > + }
    > + mutex_unlock(&qdev_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;

    this feels racy, shouldn't all these reset values be set in the work
    function?

    > + }
    > +}
    > +
    > +/* 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;
    > + struct snd_mask *m;
    > + struct snd_interval *i;
    > + int ret;
    > +
    > + _snd_pcm_hw_params_any(&params);
    > +
    > + m = hw_param_mask(&params, SNDRV_PCM_HW_PARAM_FORMAT);
    > + snd_mask_leave(m, pcm_format);
    > +
    > + i = hw_param_interval(&params, SNDRV_PCM_HW_PARAM_CHANNELS);
    > + snd_interval_setinteger(i);
    > + i->min = i->max = channels;
    > +
    > + i = hw_param_interval(&params, SNDRV_PCM_HW_PARAM_RATE);
    > + snd_interval_setinteger(i);
    > + i->min = i->max = cur_rate;
    > +
    > + pm_runtime_barrier(&chip->intf[0]->dev);
    > + snd_usb_autoresume(chip);
    > +
    > + ret = snd_usb_hw_params(subs, &params);
    > + if (ret < 0)
    > + goto put_suspend;
    > +
    > + if (!atomic_read(&chip->shutdown)) {
    > + ret = snd_usb_lock_shutdown(chip);
    > + if (ret < 0)
    > + goto detach_ep;
    > +
    > + if (subs->sync_endpoint) {
    > + ret = snd_usb_endpoint_prepare(chip, subs->sync_endpoint);
    > + if (ret < 0)
    > + goto unlock;
    > + }
    > +
    > + ret = snd_usb_endpoint_prepare(chip, subs->data_endpoint);
    > + if (ret < 0)
    > + goto unlock;
    > +
    > + snd_usb_unlock_shutdown(chip);
    > +
    > + dev_dbg(uaudio_qdev->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;
    > +
    > +unlock:
    > + snd_usb_unlock_shutdown(chip);
    > +
    > +detach_ep:
    > + snd_usb_hw_free(subs);
    > +
    > +put_suspend:
    > + snd_usb_autosuspend(chip);
    > +
    > + return ret;
    > +}
    > +
    > +/* 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 q6usb_offload *data;
    > + 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;
    > + struct sg_table *sgt;
    > + struct sg_table xfer_buf_sgt;
    > + struct page *pg;
    > + bool dma_coherent;

    consider simplifying or splitting in different functions? you have 20
    lines and probably 30-odd variables. This is a bit beyond what reviewers
    can handle...
    > +
    > + 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 & QMI_STREAM_REQ_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;
    > + }

    these 100-odd lines look like duplicated code. Why would we redo the
    parsing of UAC3 stuff in a QCOM-specific driver?

    > +
    > + 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;
    > +
    > + ret = xhci_sideband_add_endpoint(uadev[card_num].sb, ep);
    > + if (ret < 0) {
    > + dev_err(uaudio_qdev->dev, "failed to add data ep to sideband\n");
    > + ret = -ENODEV;
    > + goto err;
    > + }
    > +
    > + sgt = xhci_sideband_get_endpoint_buffer(uadev[card_num].sb, ep);
    > + if (!sgt) {
    > + dev_err(uaudio_qdev->dev, "failed to get data ep ring address\n");
    > + ret = -ENODEV;
    > + goto drop_data_ep;
    > + }
    > +
    > + pg = sg_page(sgt->sgl);
    > + tr_data_pa = page_to_phys(pg);
    > + resp->xhci_mem_info.tr_data.pa = sg_dma_address(sgt->sgl);
    > + sg_free_table(sgt);
    > +
    > + 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;
    > +
    > + ret = xhci_sideband_add_endpoint(uadev[card_num].sb, ep);
    > + if (ret < 0) {
    > + dev_err(uaudio_qdev->dev,
    > + "failed to add sync ep to sideband\n");
    > + ret = -ENODEV;
    > + goto drop_data_ep;
    > + }
    > +
    > + sgt = xhci_sideband_get_endpoint_buffer(uadev[card_num].sb, ep);
    > + if (!sgt) {
    > + dev_err(uaudio_qdev->dev, "failed to get sync ep ring address\n");
    > + ret = -ENODEV;
    > + goto drop_sync_ep;
    > + }
    > +
    > + pg = sg_page(sgt->sgl);
    > + tr_sync_pa = page_to_phys(pg);
    > + resp->xhci_mem_info.tr_sync.pa = sg_dma_address(sgt->sgl);
    > + sg_free_table(sgt);
    > + }
    > +
    > +skip_sync_ep:
    > + data = snd_soc_usb_find_priv_data(usb_get_usb_backend(subs->dev));
    > + if (!data)
    > + goto drop_sync_ep;
    > +
    > + uaudio_qdev->domain = data->domain;
    > + uaudio_qdev->sid = data->sid;
    > + uaudio_qdev->intr_num = data->intr_num;
    > + uaudio_qdev->dev = data->dev;
    > +
    > + 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 */
    > + ret = xhci_sideband_create_interrupter(uadev[card_num].sb, uaudio_qdev->intr_num);
    > + if (ret < 0) {
    > + dev_err(uaudio_qdev->dev, "failed to fetch interrupter\n");
    > + ret = -ENODEV;
    > + goto drop_sync_ep;
    > + }
    > +
    > + sgt = xhci_sideband_get_event_buffer(uadev[card_num].sb);
    > + if (!sgt) {
    > + dev_err(uaudio_qdev->dev, "failed to get event ring address\n");
    > + ret = -ENODEV;
    > + goto free_sec_ring;
    > + }
    > +
    > + xhci_pa = page_to_phys(sg_page(sgt->sgl));
    > + resp->xhci_mem_info.evt_ring.pa = sg_dma_address(sgt->sgl);
    > + sg_free_table(sgt);
    > + if (!xhci_pa) {
    > + dev_err(uaudio_qdev->dev,
    > + "failed to get sec event ring address\n");
    > + ret = -ENODEV;
    > + goto free_sec_ring;
    > + }
    > +
    > + resp->interrupter_num = xhci_sideband_interrupter_id(uadev[card_num].sb);
    > +
    > + 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.size = PAGE_SIZE;
    > + uaudio_qdev->er_mapped = true;
    > +
    > + resp->speed_info = get_speed_info(subs->dev->speed);
    > + if (resp->speed_info == USB_QMI_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, &xfer_buf_sgt, xfer_buf, xfer_buf_pa,
    > + len);
    > + va = uaudio_iommu_map(MEM_XFER_BUF, dma_coherent, xfer_buf_pa, len,
    > + &xfer_buf_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(&xfer_buf_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].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_sideband_remove_interrupter(uadev[card_num].sb);
    > +drop_sync_ep:
    > + if (subs->sync_endpoint)
    > + xhci_sideband_remove_endpoint(uadev[card_num].sb,
    > + usb_pipe_endpoint(subs->dev, subs->sync_endpoint->pipe));
    > +drop_data_ep:
    > + xhci_sideband_remove_endpoint(uadev[card_num].sb,
    > + usb_pipe_endpoint(subs->dev, subs->data_endpoint->pipe));
    > +
    > +err:
    > + return ret;
    > +}

    this is really the largest function I've seen in a while... Can this use
    helpers or be more modular?

    > +
    > +/**
    > + * 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;

    this looks like copy pasted code, this function return void so all uses
    of 'ret' are not so useful, are they?

    > + 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->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_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);
    > + }
    > +
    > +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_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);

    ret is not used?

    > +}


    I stopped here...

    \
     
     \ /
      Last update: 2023-10-18 01:25    [W:7.915 / U:0.048 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site