qc_audio_offload.c

   1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * Copyright (c) 2022-2025 Qualcomm Innovation Center, Inc. All rights reserved.
   4 */
   5
   6#include <linux/auxiliary_bus.h>
   7#include <linux/ctype.h>
   8#include <linux/dma-mapping.h>
   9#include <linux/dma-map-ops.h>
  10#include <linux/init.h>
  11#include <linux/iommu.h>
  12#include <linux/module.h>
  13#include <linux/moduleparam.h>
  14#include <linux/soc/qcom/qmi.h>
  15#include <linux/usb.h>
  16#include <linux/usb/audio.h>
  17#include <linux/usb/audio-v2.h>
  18#include <linux/usb/audio-v3.h>
  19#include <linux/usb/hcd.h>
  20#include <linux/usb/quirks.h>
  21#include <linux/usb/xhci-sideband.h>
  22
  23#include <sound/control.h>
  24#include <sound/core.h>
  25#include <sound/info.h>
  26#include <sound/initval.h>
  27#include <sound/pcm.h>
  28#include <sound/pcm_params.h>
  29#include <sound/q6usboffload.h>
  30#include <sound/soc.h>
  31#include <sound/soc-usb.h>
  32
  33#include "../usbaudio.h"
  34#include "../card.h"
  35#include "../endpoint.h"
  36#include "../format.h"
  37#include "../helper.h"
  38#include "../pcm.h"
  39#include "../power.h"
  40
  41#include "mixer_usb_offload.h"
  42#include "usb_audio_qmi_v01.h"
  43
  44/* Stream disable request timeout during USB device disconnect */
  45#define DEV_RELEASE_WAIT_TIMEOUT 10000 /* in ms */
  46
  47/* Data interval calculation parameters */
  48#define BUS_INTERVAL_FULL_SPEED 1000 /* in us */
  49#define BUS_INTERVAL_HIGHSPEED_AND_ABOVE 125 /* in us */
  50#define MAX_BINTERVAL_ISOC_EP 16
  51
  52#define QMI_STREAM_REQ_CARD_NUM_MASK 0xffff0000
  53#define QMI_STREAM_REQ_DEV_NUM_MASK 0xff00
  54#define QMI_STREAM_REQ_DIRECTION 0xff
  55
  56/* iommu resource parameters and management */
  57#define PREPEND_SID_TO_IOVA(iova, sid) ((u64)(((u64)(iova)) | \
  58					(((u64)sid) << 32)))
  59#define IOVA_MASK(iova) (((u64)(iova)) & 0xFFFFFFFF)
  60#define IOVA_BASE 0x1000
  61#define IOVA_XFER_RING_BASE (IOVA_BASE + PAGE_SIZE * (SNDRV_CARDS + 1))
  62#define IOVA_XFER_BUF_BASE (IOVA_XFER_RING_BASE + PAGE_SIZE * SNDRV_CARDS * 32)
  63#define IOVA_XFER_RING_MAX (IOVA_XFER_BUF_BASE - PAGE_SIZE)
  64#define IOVA_XFER_BUF_MAX (0xfffff000 - PAGE_SIZE)
  65
  66#define MAX_XFER_BUFF_LEN (24 * PAGE_SIZE)
  67
  68struct iova_info {
  69	struct list_head list;
  70	unsigned long start_iova;
  71	size_t size;
  72	bool in_use;
  73};
  74
  75struct intf_info {
  76	/* IOMMU ring/buffer mapping information */
  77	unsigned long data_xfer_ring_va;
  78	size_t data_xfer_ring_size;
  79	unsigned long sync_xfer_ring_va;
  80	size_t sync_xfer_ring_size;
  81	dma_addr_t xfer_buf_iova;
  82	size_t xfer_buf_size;
  83	dma_addr_t xfer_buf_dma;
  84	u8 *xfer_buf_cpu;
  85
  86	/* USB endpoint information */
  87	unsigned int data_ep_pipe;
  88	unsigned int sync_ep_pipe;
  89	unsigned int data_ep_idx;
  90	unsigned int sync_ep_idx;
  91
  92	u8 intf_num;
  93	u8 pcm_card_num;
  94	u8 pcm_dev_num;
  95	u8 direction;
  96	bool in_use;
  97};
  98
  99struct uaudio_qmi_dev {
 100	struct device *dev;
 101	struct q6usb_offload *data;
 102	struct auxiliary_device *auxdev;
 103
 104	/* list to keep track of available iova */
 105	struct list_head xfer_ring_list;
 106	size_t xfer_ring_iova_size;
 107	unsigned long curr_xfer_ring_iova;
 108	struct list_head xfer_buf_list;
 109	size_t xfer_buf_iova_size;
 110	unsigned long curr_xfer_buf_iova;
 111
 112	/* bit fields representing pcm card enabled */
 113	unsigned long card_slot;
 114	/* indicate event ring mapped or not */
 115	bool er_mapped;
 116};
 117
 118struct uaudio_dev {
 119	struct usb_device *udev;
 120	/* audio control interface */
 121	struct usb_host_interface *ctrl_intf;
 122	unsigned int usb_core_id;
 123	atomic_t in_use;
 124	struct kref kref;
 125	wait_queue_head_t disconnect_wq;
 126
 127	/* interface specific */
 128	int num_intf;
 129	struct intf_info *info;
 130	struct snd_usb_audio *chip;
 131
 132	/* xhci sideband */
 133	struct xhci_sideband *sb;
 134
 135	/* SoC USB device */
 136	struct snd_soc_usb_device *sdev;
 137};
 138
 139static struct uaudio_dev uadev[SNDRV_CARDS];
 140static struct uaudio_qmi_dev *uaudio_qdev;
 141static struct uaudio_qmi_svc *uaudio_svc;
 142static DEFINE_MUTEX(qdev_mutex);
 143
 144struct uaudio_qmi_svc {
 145	struct qmi_handle *uaudio_svc_hdl;
 146	struct sockaddr_qrtr client_sq;
 147	bool client_connected;
 148};
 149
 150enum mem_type {
 151	MEM_EVENT_RING,
 152	MEM_XFER_RING,
 153	MEM_XFER_BUF,
 154};
 155
 156/* Supported audio formats */
 157enum usb_qmi_audio_format {
 158	USB_QMI_PCM_FORMAT_S8 = 0,
 159	USB_QMI_PCM_FORMAT_U8,
 160	USB_QMI_PCM_FORMAT_S16_LE,
 161	USB_QMI_PCM_FORMAT_S16_BE,
 162	USB_QMI_PCM_FORMAT_U16_LE,
 163	USB_QMI_PCM_FORMAT_U16_BE,
 164	USB_QMI_PCM_FORMAT_S24_LE,
 165	USB_QMI_PCM_FORMAT_S24_BE,
 166	USB_QMI_PCM_FORMAT_U24_LE,
 167	USB_QMI_PCM_FORMAT_U24_BE,
 168	USB_QMI_PCM_FORMAT_S24_3LE,
 169	USB_QMI_PCM_FORMAT_S24_3BE,
 170	USB_QMI_PCM_FORMAT_U24_3LE,
 171	USB_QMI_PCM_FORMAT_U24_3BE,
 172	USB_QMI_PCM_FORMAT_S32_LE,
 173	USB_QMI_PCM_FORMAT_S32_BE,
 174	USB_QMI_PCM_FORMAT_U32_LE,
 175	USB_QMI_PCM_FORMAT_U32_BE,
 176};
 177
 178static int usb_qmi_get_pcm_num(struct snd_usb_audio *chip, int direction)
 179{
 180	struct snd_usb_substream *subs = NULL;
 181	struct snd_usb_stream *as;
 182	int count = 0;
 183
 184	list_for_each_entry(as, &chip->pcm_list, list) {
 185		subs = &as->substream[direction];
 186		if (subs->ep_num)
 187			count++;
 188	}
 189
 190	return count;
 191}
 192
 193static enum usb_qmi_audio_device_speed_enum_v01
 194get_speed_info(enum usb_device_speed udev_speed)
 195{
 196	switch (udev_speed) {
 197	case USB_SPEED_LOW:
 198		return USB_QMI_DEVICE_SPEED_LOW_V01;
 199	case USB_SPEED_FULL:
 200		return USB_QMI_DEVICE_SPEED_FULL_V01;
 201	case USB_SPEED_HIGH:
 202		return USB_QMI_DEVICE_SPEED_HIGH_V01;
 203	case USB_SPEED_SUPER:
 204		return USB_QMI_DEVICE_SPEED_SUPER_V01;
 205	case USB_SPEED_SUPER_PLUS:
 206		return USB_QMI_DEVICE_SPEED_SUPER_PLUS_V01;
 207	default:
 208		return USB_QMI_DEVICE_SPEED_INVALID_V01;
 209	}
 210}
 211
 212static struct snd_usb_substream *find_substream(unsigned int card_num,
 213						unsigned int pcm_idx,
 214						unsigned int direction)
 215{
 216	struct snd_usb_substream *subs = NULL;
 217	struct snd_usb_audio *chip;
 218	struct snd_usb_stream *as;
 219
 220	chip = uadev[card_num].chip;
 221	if (!chip || atomic_read(&chip->shutdown))
 222		goto done;
 223
 224	if (pcm_idx >= chip->pcm_devs)
 225		goto done;
 226
 227	if (direction > SNDRV_PCM_STREAM_CAPTURE)
 228		goto done;
 229
 230	list_for_each_entry(as, &chip->pcm_list, list) {
 231		if (as->pcm_index == pcm_idx) {
 232			subs = &as->substream[direction];
 233			goto done;
 234		}
 235	}
 236
 237done:
 238	return subs;
 239}
 240
 241static int info_idx_from_ifnum(int card_num, int intf_num, bool enable)
 242{
 243	int i;
 244
 245	/*
 246	 * default index 0 is used when info is allocated upon
 247	 * first enable audio stream req for a pcm device
 248	 */
 249	if (enable && !uadev[card_num].info)
 250		return 0;
 251
 252	for (i = 0; i < uadev[card_num].num_intf; i++) {
 253		if (enable && !uadev[card_num].info[i].in_use)
 254			return i;
 255		else if (!enable &&
 256			 uadev[card_num].info[i].intf_num == intf_num)
 257			return i;
 258	}
 259
 260	return -EINVAL;
 261}
 262
 263static int get_data_interval_from_si(struct snd_usb_substream *subs,
 264				     u32 service_interval)
 265{
 266	unsigned int bus_intval_mult;
 267	unsigned int bus_intval;
 268	unsigned int binterval;
 269
 270	if (subs->dev->speed >= USB_SPEED_HIGH)
 271		bus_intval = BUS_INTERVAL_HIGHSPEED_AND_ABOVE;
 272	else
 273		bus_intval = BUS_INTERVAL_FULL_SPEED;
 274
 275	if (service_interval % bus_intval)
 276		return -EINVAL;
 277
 278	bus_intval_mult = service_interval / bus_intval;
 279	binterval = ffs(bus_intval_mult);
 280	if (!binterval || binterval > MAX_BINTERVAL_ISOC_EP)
 281		return -EINVAL;
 282
 283	/* check if another bit is set then bail out */
 284	bus_intval_mult = bus_intval_mult >> binterval;
 285	if (bus_intval_mult)
 286		return -EINVAL;
 287
 288	return (binterval - 1);
 289}
 290
 291/* maps audio format received over QMI to asound.h based pcm format */
 292static snd_pcm_format_t map_pcm_format(enum usb_qmi_audio_format fmt_received)
 293{
 294	switch (fmt_received) {
 295	case USB_QMI_PCM_FORMAT_S8:
 296		return SNDRV_PCM_FORMAT_S8;
 297	case USB_QMI_PCM_FORMAT_U8:
 298		return SNDRV_PCM_FORMAT_U8;
 299	case USB_QMI_PCM_FORMAT_S16_LE:
 300		return SNDRV_PCM_FORMAT_S16_LE;
 301	case USB_QMI_PCM_FORMAT_S16_BE:
 302		return SNDRV_PCM_FORMAT_S16_BE;
 303	case USB_QMI_PCM_FORMAT_U16_LE:
 304		return SNDRV_PCM_FORMAT_U16_LE;
 305	case USB_QMI_PCM_FORMAT_U16_BE:
 306		return SNDRV_PCM_FORMAT_U16_BE;
 307	case USB_QMI_PCM_FORMAT_S24_LE:
 308		return SNDRV_PCM_FORMAT_S24_LE;
 309	case USB_QMI_PCM_FORMAT_S24_BE:
 310		return SNDRV_PCM_FORMAT_S24_BE;
 311	case USB_QMI_PCM_FORMAT_U24_LE:
 312		return SNDRV_PCM_FORMAT_U24_LE;
 313	case USB_QMI_PCM_FORMAT_U24_BE:
 314		return SNDRV_PCM_FORMAT_U24_BE;
 315	case USB_QMI_PCM_FORMAT_S24_3LE:
 316		return SNDRV_PCM_FORMAT_S24_3LE;
 317	case USB_QMI_PCM_FORMAT_S24_3BE:
 318		return SNDRV_PCM_FORMAT_S24_3BE;
 319	case USB_QMI_PCM_FORMAT_U24_3LE:
 320		return SNDRV_PCM_FORMAT_U24_3LE;
 321	case USB_QMI_PCM_FORMAT_U24_3BE:
 322		return SNDRV_PCM_FORMAT_U24_3BE;
 323	case USB_QMI_PCM_FORMAT_S32_LE:
 324		return SNDRV_PCM_FORMAT_S32_LE;
 325	case USB_QMI_PCM_FORMAT_S32_BE:
 326		return SNDRV_PCM_FORMAT_S32_BE;
 327	case USB_QMI_PCM_FORMAT_U32_LE:
 328		return SNDRV_PCM_FORMAT_U32_LE;
 329	case USB_QMI_PCM_FORMAT_U32_BE:
 330		return SNDRV_PCM_FORMAT_U32_BE;
 331	default:
 332		/*
 333		 * We expect the caller to do input validation so we should
 334		 * never hit this. But we do have to return a proper
 335		 * snd_pcm_format_t value due to the __bitwise attribute; so
 336		 * just return the equivalent of 0 in case of bad input.
 337		 */
 338		return SNDRV_PCM_FORMAT_S8;
 339	}
 340}
 341
 342/*
 343 * Sends QMI disconnect indication message, assumes chip->mutex and qdev_mutex
 344 * lock held by caller.
 345 */
 346static int uaudio_send_disconnect_ind(struct snd_usb_audio *chip)
 347{
 348	struct qmi_uaudio_stream_ind_msg_v01 disconnect_ind = {0};
 349	struct uaudio_qmi_svc *svc = uaudio_svc;
 350	struct uaudio_dev *dev;
 351	int ret = 0;
 352
 353	dev = &uadev[chip->card->number];
 354
 355	if (atomic_read(&dev->in_use)) {
 356		mutex_unlock(&chip->mutex);
 357		mutex_unlock(&qdev_mutex);
 358		dev_dbg(uaudio_qdev->data->dev, "sending qmi indication suspend\n");
 359		disconnect_ind.dev_event = USB_QMI_DEV_DISCONNECT_V01;
 360		disconnect_ind.slot_id = dev->udev->slot_id;
 361		disconnect_ind.controller_num = dev->usb_core_id;
 362		disconnect_ind.controller_num_valid = 1;
 363		ret = qmi_send_indication(svc->uaudio_svc_hdl, &svc->client_sq,
 364					  QMI_UAUDIO_STREAM_IND_V01,
 365					  QMI_UAUDIO_STREAM_IND_MSG_V01_MAX_MSG_LEN,
 366					  qmi_uaudio_stream_ind_msg_v01_ei,
 367					  &disconnect_ind);
 368		if (ret < 0)
 369			dev_err(uaudio_qdev->data->dev,
 370				"qmi send failed with err: %d\n", ret);
 371
 372		ret = wait_event_interruptible_timeout(dev->disconnect_wq,
 373				!atomic_read(&dev->in_use),
 374				msecs_to_jiffies(DEV_RELEASE_WAIT_TIMEOUT));
 375		if (!ret) {
 376			dev_err(uaudio_qdev->data->dev,
 377				"timeout while waiting for dev_release\n");
 378			atomic_set(&dev->in_use, 0);
 379		} else if (ret < 0) {
 380			dev_err(uaudio_qdev->data->dev,
 381				"failed with ret %d\n", ret);
 382			atomic_set(&dev->in_use, 0);
 383		}
 384		mutex_lock(&qdev_mutex);
 385		mutex_lock(&chip->mutex);
 386	}
 387
 388	return ret;
 389}
 390
 391/* Offloading IOMMU management */
 392static unsigned long uaudio_get_iova(unsigned long *curr_iova,
 393				     size_t *curr_iova_size,
 394				     struct list_head *head, size_t size)
 395{
 396	struct iova_info *info, *new_info = NULL;
 397	struct list_head *curr_head;
 398	size_t tmp_size = size;
 399	unsigned long iova = 0;
 400
 401	if (size % PAGE_SIZE)
 402		goto done;
 403
 404	if (size > *curr_iova_size)
 405		goto done;
 406
 407	if (*curr_iova_size == 0)
 408		goto done;
 409
 410	list_for_each_entry(info, head, list) {
 411		/* exact size iova_info */
 412		if (!info->in_use && info->size == size) {
 413			info->in_use = true;
 414			iova = info->start_iova;
 415			*curr_iova_size -= size;
 416			goto done;
 417		} else if (!info->in_use && tmp_size >= info->size) {
 418			if (!new_info)
 419				new_info = info;
 420			tmp_size -= info->size;
 421			if (tmp_size)
 422				continue;
 423
 424			iova = new_info->start_iova;
 425			for (curr_head = &new_info->list; curr_head !=
 426			&info->list; curr_head = curr_head->next) {
 427				new_info = list_entry(curr_head, struct
 428						iova_info, list);
 429				new_info->in_use = true;
 430			}
 431			info->in_use = true;
 432			*curr_iova_size -= size;
 433			goto done;
 434		} else {
 435			/* iova region in use */
 436			new_info = NULL;
 437			tmp_size = size;
 438		}
 439	}
 440
 441	info = kzalloc(sizeof(*info), GFP_KERNEL);
 442	if (!info) {
 443		iova = 0;
 444		goto done;
 445	}
 446
 447	iova = *curr_iova;
 448	info->start_iova = *curr_iova;
 449	info->size = size;
 450	info->in_use = true;
 451	*curr_iova += size;
 452	*curr_iova_size -= size;
 453	list_add_tail(&info->list, head);
 454
 455done:
 456	return iova;
 457}
 458
 459static void uaudio_put_iova(unsigned long iova, size_t size, struct list_head
 460	*head, size_t *curr_iova_size)
 461{
 462	struct iova_info *info;
 463	size_t tmp_size = size;
 464	bool found = false;
 465
 466	list_for_each_entry(info, head, list) {
 467		if (info->start_iova == iova) {
 468			if (!info->in_use)
 469				return;
 470
 471			found = true;
 472			info->in_use = false;
 473			if (info->size == size)
 474				goto done;
 475		}
 476
 477		if (found && tmp_size >= info->size) {
 478			info->in_use = false;
 479			tmp_size -= info->size;
 480			if (!tmp_size)
 481				goto done;
 482		}
 483	}
 484
 485	if (!found)
 486		return;
 487
 488done:
 489	*curr_iova_size += size;
 490}
 491
 492/**
 493 * uaudio_iommu_unmap() - unmaps iommu memory for adsp
 494 * @mtype: ring type
 495 * @iova: virtual address to unmap
 496 * @iova_size: region size
 497 * @mapped_iova_size: mapped region size
 498 *
 499 * Unmaps the memory region that was previously assigned to the adsp.
 500 *
 501 */
 502static void uaudio_iommu_unmap(enum mem_type mtype, unsigned long iova,
 503			       size_t iova_size, size_t mapped_iova_size)
 504{
 505	size_t umap_size;
 506	bool unmap = true;
 507
 508	if (!iova || !iova_size)
 509		return;
 510
 511	switch (mtype) {
 512	case MEM_EVENT_RING:
 513		if (uaudio_qdev->er_mapped)
 514			uaudio_qdev->er_mapped = false;
 515		else
 516			unmap = false;
 517		break;
 518
 519	case MEM_XFER_RING:
 520		uaudio_put_iova(iova, iova_size, &uaudio_qdev->xfer_ring_list,
 521				&uaudio_qdev->xfer_ring_iova_size);
 522		break;
 523	case MEM_XFER_BUF:
 524		uaudio_put_iova(iova, iova_size, &uaudio_qdev->xfer_buf_list,
 525				&uaudio_qdev->xfer_buf_iova_size);
 526		break;
 527	default:
 528		unmap = false;
 529	}
 530
 531	if (!unmap || !mapped_iova_size)
 532		return;
 533
 534	umap_size = iommu_unmap(uaudio_qdev->data->domain, iova, mapped_iova_size);
 535	if (umap_size != mapped_iova_size)
 536		dev_err(uaudio_qdev->data->dev,
 537			"unmapped size %zu for iova 0x%08lx of mapped size %zu\n",
 538			umap_size, iova, mapped_iova_size);
 539}
 540
 541static int uaudio_iommu_map_prot(bool dma_coherent)
 542{
 543	int prot = IOMMU_READ | IOMMU_WRITE;
 544
 545	if (dma_coherent)
 546		prot |= IOMMU_CACHE;
 547	return prot;
 548}
 549
 550/**
 551 * uaudio_iommu_map_pa() - maps iommu memory for adsp
 552 * @mtype: ring type
 553 * @dma_coherent: dma coherent
 554 * @pa: physical address for ring/buffer
 555 * @size: size of memory region
 556 *
 557 * Maps the XHCI related resources to a memory region that is assigned to be
 558 * used by the adsp.  This will be mapped to the domain, which is created by
 559 * the ASoC USB backend driver.
 560 *
 561 */
 562static unsigned long uaudio_iommu_map_pa(enum mem_type mtype, bool dma_coherent,
 563					 phys_addr_t pa, size_t size)
 564{
 565	unsigned long iova = 0;
 566	bool map = true;
 567	int prot = uaudio_iommu_map_prot(dma_coherent);
 568
 569	switch (mtype) {
 570	case MEM_EVENT_RING:
 571		iova = IOVA_BASE;
 572		/* er already mapped */
 573		if (uaudio_qdev->er_mapped)
 574			map = false;
 575		break;
 576	case MEM_XFER_RING:
 577		iova = uaudio_get_iova(&uaudio_qdev->curr_xfer_ring_iova,
 578				     &uaudio_qdev->xfer_ring_iova_size,
 579				     &uaudio_qdev->xfer_ring_list, size);
 580		break;
 581	default:
 582		dev_err(uaudio_qdev->data->dev, "unknown mem type %d\n", mtype);
 583	}
 584
 585	if (!iova || !map)
 586		return 0;
 587
 588	iommu_map(uaudio_qdev->data->domain, iova, pa, size, prot, GFP_KERNEL);
 589
 590	return iova;
 591}
 592
 593static unsigned long uaudio_iommu_map_xfer_buf(bool dma_coherent, size_t size,
 594					       struct sg_table *sgt)
 595{
 596	struct scatterlist *sg;
 597	unsigned long iova = 0;
 598	size_t total_len = 0;
 599	unsigned long iova_sg;
 600	phys_addr_t pa_sg;
 601	size_t sg_len;
 602	int prot = uaudio_iommu_map_prot(dma_coherent);
 603	int ret;
 604	int i;
 605
 606	prot = IOMMU_READ | IOMMU_WRITE;
 607
 608	if (dma_coherent)
 609		prot |= IOMMU_CACHE;
 610
 611	iova = uaudio_get_iova(&uaudio_qdev->curr_xfer_buf_iova,
 612			       &uaudio_qdev->xfer_buf_iova_size,
 613			       &uaudio_qdev->xfer_buf_list, size);
 614	if (!iova)
 615		goto done;
 616
 617	iova_sg = iova;
 618	for_each_sg(sgt->sgl, sg, sgt->nents, i) {
 619		sg_len = PAGE_ALIGN(sg->offset + sg->length);
 620		pa_sg = page_to_phys(sg_page(sg));
 621		ret = iommu_map(uaudio_qdev->data->domain, iova_sg, pa_sg, sg_len,
 622				prot, GFP_KERNEL);
 623		if (ret) {
 624			uaudio_iommu_unmap(MEM_XFER_BUF, iova, size, total_len);
 625			iova = 0;
 626			goto done;
 627		}
 628
 629		iova_sg += sg_len;
 630		total_len += sg_len;
 631	}
 632
 633	if (size != total_len) {
 634		uaudio_iommu_unmap(MEM_XFER_BUF, iova, size, total_len);
 635		iova = 0;
 636	}
 637done:
 638	return iova;
 639}
 640
 641/* looks up alias, if any, for controller DT node and returns the index */
 642static int usb_get_controller_id(struct usb_device *udev)
 643{
 644	if (udev->bus->sysdev && udev->bus->sysdev->of_node)
 645		return of_alias_get_id(udev->bus->sysdev->of_node, "usb");
 646
 647	return -ENODEV;
 648}
 649
 650/**
 651 * uaudio_dev_intf_cleanup() - cleanup transfer resources
 652 * @udev: usb device
 653 * @info: usb offloading interface
 654 *
 655 * Cleans up the transfer ring related resources which are assigned per
 656 * endpoint from XHCI.  This is invoked when the USB endpoints are no
 657 * longer in use by the adsp.
 658 *
 659 */
 660static void uaudio_dev_intf_cleanup(struct usb_device *udev, struct intf_info *info)
 661{
 662	uaudio_iommu_unmap(MEM_XFER_RING, info->data_xfer_ring_va,
 663			   info->data_xfer_ring_size, info->data_xfer_ring_size);
 664	info->data_xfer_ring_va = 0;
 665	info->data_xfer_ring_size = 0;
 666
 667	uaudio_iommu_unmap(MEM_XFER_RING, info->sync_xfer_ring_va,
 668			   info->sync_xfer_ring_size, info->sync_xfer_ring_size);
 669	info->sync_xfer_ring_va = 0;
 670	info->sync_xfer_ring_size = 0;
 671
 672	uaudio_iommu_unmap(MEM_XFER_BUF, info->xfer_buf_iova, info->xfer_buf_size,
 673			   info->xfer_buf_size);
 674	info->xfer_buf_iova = 0;
 675
 676	usb_free_coherent(udev, info->xfer_buf_size, info->xfer_buf_cpu,
 677			  info->xfer_buf_dma);
 678	info->xfer_buf_size = 0;
 679	info->xfer_buf_cpu = NULL;
 680	info->xfer_buf_dma = 0;
 681
 682	info->in_use = false;
 683}
 684
 685/**
 686 * uaudio_event_ring_cleanup_free() - cleanup secondary event ring
 687 * @dev: usb offload device
 688 *
 689 * Cleans up the secondary event ring that was requested.  This will
 690 * occur when the adsp is no longer transferring data on the USB bus
 691 * across all endpoints.
 692 *
 693 */
 694static void uaudio_event_ring_cleanup_free(struct uaudio_dev *dev)
 695{
 696	clear_bit(dev->chip->card->number, &uaudio_qdev->card_slot);
 697	/* all audio devices are disconnected */
 698	if (!uaudio_qdev->card_slot) {
 699		uaudio_iommu_unmap(MEM_EVENT_RING, IOVA_BASE, PAGE_SIZE,
 700				   PAGE_SIZE);
 701		xhci_sideband_remove_interrupter(uadev[dev->chip->card->number].sb);
 702		usb_offload_put(dev->udev);
 703	}
 704}
 705
 706static void uaudio_dev_cleanup(struct uaudio_dev *dev)
 707{
 708	int if_idx;
 709
 710	if (!dev->udev)
 711		return;
 712
 713	/* free xfer buffer and unmap xfer ring and buf per interface */
 714	for (if_idx = 0; if_idx < dev->num_intf; if_idx++) {
 715		if (!dev->info[if_idx].in_use)
 716			continue;
 717		uaudio_dev_intf_cleanup(dev->udev, &dev->info[if_idx]);
 718		dev_dbg(uaudio_qdev->data->dev,
 719			"release resources: intf# %d card# %d\n",
 720			dev->info[if_idx].intf_num, dev->chip->card->number);
 721	}
 722
 723	dev->num_intf = 0;
 724
 725	/* free interface info */
 726	kfree(dev->info);
 727	dev->info = NULL;
 728	uaudio_event_ring_cleanup_free(dev);
 729	dev->udev = NULL;
 730}
 731
 732/**
 733 * disable_audio_stream() - disable usb snd endpoints
 734 * @subs: usb substream
 735 *
 736 * Closes the USB SND endpoints associated with the current audio stream
 737 * used.  This will decrement the USB SND endpoint opened reference count.
 738 *
 739 */
 740static void disable_audio_stream(struct snd_usb_substream *subs)
 741{
 742	struct snd_usb_audio *chip = subs->stream->chip;
 743
 744	snd_usb_hw_free(subs);
 745	snd_usb_autosuspend(chip);
 746}
 747
 748/* QMI service disconnect handlers */
 749static void qmi_stop_session(void)
 750{
 751	struct snd_usb_substream *subs;
 752	struct usb_host_endpoint *ep;
 753	struct snd_usb_audio *chip;
 754	struct intf_info *info;
 755	int pcm_card_num;
 756	int if_idx;
 757	int idx;
 758
 759	guard(mutex)(&qdev_mutex);
 760	/* find all active intf for set alt 0 and cleanup usb audio dev */
 761	for (idx = 0; idx < SNDRV_CARDS; idx++) {
 762		if (!atomic_read(&uadev[idx].in_use))
 763			continue;
 764
 765		chip = uadev[idx].chip;
 766		for (if_idx = 0; if_idx < uadev[idx].num_intf; if_idx++) {
 767			if (!uadev[idx].info || !uadev[idx].info[if_idx].in_use)
 768				continue;
 769			info = &uadev[idx].info[if_idx];
 770			pcm_card_num = info->pcm_card_num;
 771			subs = find_substream(pcm_card_num, info->pcm_dev_num,
 772					      info->direction);
 773			if (!subs || !chip || atomic_read(&chip->shutdown)) {
 774				dev_err(&uadev[idx].udev->dev,
 775					"no sub for c#%u dev#%u dir%u\n",
 776					info->pcm_card_num,
 777					info->pcm_dev_num,
 778					info->direction);
 779				continue;
 780			}
 781			/* Release XHCI endpoints */
 782			if (info->data_ep_pipe)
 783				ep = usb_pipe_endpoint(uadev[pcm_card_num].udev,
 784						       info->data_ep_pipe);
 785			xhci_sideband_remove_endpoint(uadev[pcm_card_num].sb, ep);
 786
 787			if (info->sync_ep_pipe)
 788				ep = usb_pipe_endpoint(uadev[pcm_card_num].udev,
 789						       info->sync_ep_pipe);
 790			xhci_sideband_remove_endpoint(uadev[pcm_card_num].sb, ep);
 791
 792			disable_audio_stream(subs);
 793		}
 794		atomic_set(&uadev[idx].in_use, 0);
 795		guard(mutex)(&chip->mutex);
 796		uaudio_dev_cleanup(&uadev[idx]);
 797	}
 798}
 799
 800/**
 801 * uaudio_sideband_notifier() - xHCI sideband event handler
 802 * @intf: USB interface handle
 803 * @evt: xHCI sideband event type
 804 *
 805 * This callback is executed when the xHCI sideband encounters a sequence
 806 * that requires the sideband clients to take action.  An example, is when
 807 * xHCI frees the transfer ring, so the client has to ensure that the
 808 * offload path is halted.
 809 *
 810 */
 811static int uaudio_sideband_notifier(struct usb_interface *intf,
 812				    struct xhci_sideband_event *evt)
 813{
 814	struct snd_usb_audio *chip;
 815	struct uaudio_dev *dev;
 816	int if_idx;
 817
 818	if (!intf || !evt)
 819		return 0;
 820
 821	chip = usb_get_intfdata(intf);
 822
 823	guard(mutex)(&qdev_mutex);
 824	guard(mutex)(&chip->mutex);
 825
 826	dev = &uadev[chip->card->number];
 827
 828	if (evt->type == XHCI_SIDEBAND_XFER_RING_FREE) {
 829		unsigned int *ep = (unsigned int *) evt->evt_data;
 830
 831		for (if_idx = 0; if_idx < dev->num_intf; if_idx++) {
 832			if (dev->info[if_idx].data_ep_idx == *ep ||
 833			    dev->info[if_idx].sync_ep_idx == *ep)
 834				uaudio_send_disconnect_ind(chip);
 835		}
 836	}
 837
 838	return 0;
 839}
 840
 841/**
 842 * qmi_bye_cb() - qmi bye message callback
 843 * @handle: QMI handle
 844 * @node: id of the dying node
 845 *
 846 * This callback is invoked when the QMI bye control message is received
 847 * from the QMI client.  Handle the message accordingly by ensuring that
 848 * the USB offload path is disabled and cleaned up.  At this point, ADSP
 849 * is not utilizing the USB bus.
 850 *
 851 */
 852static void qmi_bye_cb(struct qmi_handle *handle, unsigned int node)
 853{
 854	struct uaudio_qmi_svc *svc = uaudio_svc;
 855
 856	if (svc->uaudio_svc_hdl != handle)
 857		return;
 858
 859	if (svc->client_connected && svc->client_sq.sq_node == node) {
 860		qmi_stop_session();
 861
 862		/* clear QMI client parameters to block further QMI messages */
 863		svc->client_sq.sq_node = 0;
 864		svc->client_sq.sq_port = 0;
 865		svc->client_sq.sq_family = 0;
 866		svc->client_connected = false;
 867	}
 868}
 869
 870/**
 871 * qmi_svc_disconnect_cb() - qmi client disconnected
 872 * @handle: QMI handle
 873 * @node: id of the dying node
 874 * @port: port of the dying client
 875 *
 876 * Invoked when the remote QMI client is disconnected.  Handle this event
 877 * the same way as when the QMI bye message is received.  This will ensure
 878 * the USB offloading path is disabled and cleaned up.
 879 *
 880 */
 881static void qmi_svc_disconnect_cb(struct qmi_handle *handle,
 882				  unsigned int node, unsigned int port)
 883{
 884	struct uaudio_qmi_svc *svc;
 885
 886	if (!uaudio_svc)
 887		return;
 888
 889	svc = uaudio_svc;
 890	if (svc->uaudio_svc_hdl != handle)
 891		return;
 892
 893	if (svc->client_connected && svc->client_sq.sq_node == node &&
 894	    svc->client_sq.sq_port == port) {
 895		qmi_stop_session();
 896
 897		/* clear QMI client parameters to block further QMI messages */
 898		svc->client_sq.sq_node = 0;
 899		svc->client_sq.sq_port = 0;
 900		svc->client_sq.sq_family = 0;
 901		svc->client_connected = false;
 902	}
 903}
 904
 905/* QMI client callback handlers from QMI interface */
 906static struct qmi_ops uaudio_svc_ops_options = {
 907	.bye = qmi_bye_cb,
 908	.del_client = qmi_svc_disconnect_cb,
 909};
 910
 911/* kref release callback when all streams are disabled */
 912static void uaudio_dev_release(struct kref *kref)
 913{
 914	struct uaudio_dev *dev = container_of(kref, struct uaudio_dev, kref);
 915
 916	uaudio_event_ring_cleanup_free(dev);
 917	atomic_set(&dev->in_use, 0);
 918	wake_up(&dev->disconnect_wq);
 919}
 920
 921/**
 922 * enable_audio_stream() - enable usb snd endpoints
 923 * @subs: usb substream
 924 * @pcm_format: pcm format requested
 925 * @channels: number of channels
 926 * @cur_rate: sample rate
 927 * @datainterval: interval
 928 *
 929 * Opens all USB SND endpoints used for the data interface.  This will increment
 930 * the USB SND endpoint's opened count.  Requests to keep the interface resumed
 931 * until the audio stream is stopped.  Will issue the USB set interface control
 932 * message to enable the data interface.
 933 *
 934 */
 935static int enable_audio_stream(struct snd_usb_substream *subs,
 936			       snd_pcm_format_t pcm_format,
 937			       unsigned int channels, unsigned int cur_rate,
 938			       int datainterval)
 939{
 940	struct snd_pcm_hw_params params;
 941	struct snd_usb_audio *chip;
 942	struct snd_interval *i;
 943	struct snd_mask *m;
 944	int ret;
 945
 946	chip = subs->stream->chip;
 947
 948	_snd_pcm_hw_params_any(&params);
 949
 950	m = hw_param_mask(&params, SNDRV_PCM_HW_PARAM_FORMAT);
 951	snd_mask_leave(m, pcm_format);
 952
 953	i = hw_param_interval(&params, SNDRV_PCM_HW_PARAM_CHANNELS);
 954	snd_interval_setinteger(i);
 955	i->min = channels;
 956	i->max = channels;
 957
 958	i = hw_param_interval(&params, SNDRV_PCM_HW_PARAM_RATE);
 959	snd_interval_setinteger(i);
 960	i->min = cur_rate;
 961	i->max = cur_rate;
 962
 963	pm_runtime_barrier(&chip->intf[0]->dev);
 964	snd_usb_autoresume(chip);
 965
 966	ret = snd_usb_hw_params(subs, &params);
 967	if (ret < 0)
 968		goto put_suspend;
 969
 970	if (!atomic_read(&chip->shutdown)) {
 971		CLASS(snd_usb_lock, pm)(chip);
 972		if (pm.err < 0) {
 973			ret = pm.err;
 974			goto detach_ep;
 975		}
 976
 977		if (subs->sync_endpoint) {
 978			ret = snd_usb_endpoint_prepare(chip, subs->sync_endpoint);
 979			if (ret < 0)
 980				goto detach_ep;
 981		}
 982
 983		ret = snd_usb_endpoint_prepare(chip, subs->data_endpoint);
 984		if (ret < 0)
 985			goto detach_ep;
 986
 987		dev_dbg(uaudio_qdev->data->dev,
 988			"selected %s iface:%d altsetting:%d datainterval:%dus\n",
 989			subs->direction ? "capture" : "playback",
 990			subs->cur_audiofmt->iface, subs->cur_audiofmt->altsetting,
 991			(1 << subs->cur_audiofmt->datainterval) *
 992			(subs->dev->speed >= USB_SPEED_HIGH ?
 993			BUS_INTERVAL_HIGHSPEED_AND_ABOVE :
 994			BUS_INTERVAL_FULL_SPEED));
 995	}
 996
 997	return 0;
 998
 999detach_ep:
1000	snd_usb_hw_free(subs);
1001
1002put_suspend:
1003	snd_usb_autosuspend(chip);
1004
1005	return ret;
1006}
1007
1008/**
1009 * uaudio_transfer_buffer_setup() - fetch and populate xfer buffer params
1010 * @subs: usb substream
1011 * @xfer_buf_cpu: xfer buf to be allocated
1012 * @xfer_buf_len: size of allocation
1013 * @mem_info: QMI response info
1014 *
1015 * Allocates and maps the transfer buffers that will be utilized by the
1016 * audio DSP.  Will populate the information in the QMI response that is
1017 * sent back to the stream enable request.
1018 *
1019 */
1020static int uaudio_transfer_buffer_setup(struct snd_usb_substream *subs,
1021					void **xfer_buf_cpu, u32 xfer_buf_len,
1022					struct mem_info_v01 *mem_info)
1023{
1024	struct sg_table xfer_buf_sgt;
1025	dma_addr_t xfer_buf_dma;
1026	void *xfer_buf;
1027	u32 len = xfer_buf_len;
1028	bool dma_coherent;
1029	dma_addr_t xfer_buf_dma_sysdev;
1030	u32 remainder;
1031	u32 mult;
1032	int ret;
1033
1034	dma_coherent = dev_is_dma_coherent(subs->dev->bus->sysdev);
1035
1036	/* xfer buffer, multiple of 4K only */
1037	if (!len)
1038		len = PAGE_SIZE;
1039
1040	mult = len / PAGE_SIZE;
1041	remainder = len % PAGE_SIZE;
1042	len = mult * PAGE_SIZE;
1043	len += remainder ? PAGE_SIZE : 0;
1044
1045	if (len > MAX_XFER_BUFF_LEN) {
1046		dev_err(uaudio_qdev->data->dev,
1047			"req buf len %d > max buf len %lu, setting %lu\n",
1048			len, MAX_XFER_BUFF_LEN, MAX_XFER_BUFF_LEN);
1049		len = MAX_XFER_BUFF_LEN;
1050	}
1051
1052	/* get buffer mapped into subs->dev */
1053	xfer_buf = usb_alloc_coherent(subs->dev, len, GFP_KERNEL, &xfer_buf_dma);
1054	if (!xfer_buf)
1055		return -ENOMEM;
1056
1057	dma_get_sgtable(subs->dev->bus->sysdev, &xfer_buf_sgt, xfer_buf,
1058			xfer_buf_dma, len);
1059
1060	/* map the physical buffer into sysdev as well */
1061	xfer_buf_dma_sysdev = uaudio_iommu_map_xfer_buf(dma_coherent,
1062							len, &xfer_buf_sgt);
1063	if (!xfer_buf_dma_sysdev) {
1064		ret = -ENOMEM;
1065		goto unmap_sync;
1066	}
1067
1068	mem_info->dma = xfer_buf_dma;
1069	mem_info->size = len;
1070	mem_info->iova = PREPEND_SID_TO_IOVA(xfer_buf_dma_sysdev, uaudio_qdev->data->sid);
1071	*xfer_buf_cpu = xfer_buf;
1072	sg_free_table(&xfer_buf_sgt);
1073
1074	return 0;
1075
1076unmap_sync:
1077	usb_free_coherent(subs->dev, len, xfer_buf, xfer_buf_dma);
1078
1079	return ret;
1080}
1081
1082/**
1083 * uaudio_endpoint_setup() - fetch and populate endpoint params
1084 * @subs: usb substream
1085 * @endpoint: usb endpoint to add
1086 * @card_num: uadev index
1087 * @mem_info: QMI response info
1088 * @ep_desc: QMI ep desc response field
1089 *
1090 * Initialize the USB endpoint being used for a particular USB
1091 * stream.  Will request XHCI sec intr to reserve the EP for
1092 * offloading as well as populating the QMI response with the
1093 * transfer ring parameters.
1094 *
1095 */
1096static phys_addr_t
1097uaudio_endpoint_setup(struct snd_usb_substream *subs,
1098		      struct snd_usb_endpoint *endpoint, int card_num,
1099		      struct mem_info_v01 *mem_info,
1100		      struct usb_endpoint_descriptor_v01 *ep_desc)
1101{
1102	struct usb_host_endpoint *ep;
1103	phys_addr_t tr_pa = 0;
1104	struct sg_table *sgt;
1105	bool dma_coherent;
1106	unsigned long iova;
1107	struct page *pg;
1108	int ret = -ENODEV;
1109
1110	dma_coherent = dev_is_dma_coherent(subs->dev->bus->sysdev);
1111
1112	ep = usb_pipe_endpoint(subs->dev, endpoint->pipe);
1113	if (!ep) {
1114		dev_err(uaudio_qdev->data->dev, "data ep # %d context is null\n",
1115			subs->data_endpoint->ep_num);
1116		goto exit;
1117	}
1118
1119	memcpy(ep_desc, &ep->desc, sizeof(ep->desc));
1120
1121	ret = xhci_sideband_add_endpoint(uadev[card_num].sb, ep);
1122	if (ret < 0) {
1123		dev_err(&subs->dev->dev,
1124			"failed to add data ep to sec intr\n");
1125		ret = -ENODEV;
1126		goto exit;
1127	}
1128
1129	sgt = xhci_sideband_get_endpoint_buffer(uadev[card_num].sb, ep);
1130	if (!sgt) {
1131		dev_err(&subs->dev->dev,
1132			"failed to get data ep ring address\n");
1133		ret = -ENODEV;
1134		goto remove_ep;
1135	}
1136
1137	pg = sg_page(sgt->sgl);
1138	tr_pa = page_to_phys(pg);
1139	mem_info->dma = sg_dma_address(sgt->sgl);
1140	sg_free_table(sgt);
1141
1142	/* data transfer ring */
1143	iova = uaudio_iommu_map_pa(MEM_XFER_RING, dma_coherent, tr_pa,
1144				   PAGE_SIZE);
1145	if (!iova) {
1146		ret = -ENOMEM;
1147		goto clear_pa;
1148	}
1149
1150	mem_info->iova = PREPEND_SID_TO_IOVA(iova, uaudio_qdev->data->sid);
1151	mem_info->size = PAGE_SIZE;
1152
1153	return 0;
1154
1155clear_pa:
1156	mem_info->dma = 0;
1157remove_ep:
1158	xhci_sideband_remove_endpoint(uadev[card_num].sb, ep);
1159exit:
1160	return ret;
1161}
1162
1163/**
1164 * uaudio_event_ring_setup() - fetch and populate event ring params
1165 * @subs: usb substream
1166 * @card_num: uadev index
1167 * @mem_info: QMI response info
1168 *
1169 * Register secondary interrupter to XHCI and fetch the event buffer info
1170 * and populate the information into the QMI response.
1171 *
1172 */
1173static int uaudio_event_ring_setup(struct snd_usb_substream *subs,
1174				   int card_num, struct mem_info_v01 *mem_info)
1175{
1176	struct sg_table *sgt;
1177	phys_addr_t er_pa;
1178	bool dma_coherent;
1179	unsigned long iova;
1180	struct page *pg;
1181	int ret;
1182
1183	dma_coherent = dev_is_dma_coherent(subs->dev->bus->sysdev);
1184	er_pa = 0;
1185
1186	ret = usb_offload_get(subs->dev);
1187	if (ret < 0)
1188		goto exit;
1189
1190	/* event ring */
1191	ret = xhci_sideband_create_interrupter(uadev[card_num].sb, 1, false,
1192					       0, uaudio_qdev->data->intr_num);
1193	if (ret < 0) {
1194		dev_err(&subs->dev->dev, "failed to fetch interrupter\n");
1195		goto put_offload;
1196	}
1197
1198	sgt = xhci_sideband_get_event_buffer(uadev[card_num].sb);
1199	if (!sgt) {
1200		dev_err(&subs->dev->dev,
1201			"failed to get event ring address\n");
1202		ret = -ENODEV;
1203		goto remove_interrupter;
1204	}
1205
1206	pg = sg_page(sgt->sgl);
1207	er_pa = page_to_phys(pg);
1208	mem_info->dma = sg_dma_address(sgt->sgl);
1209	sg_free_table(sgt);
1210
1211	iova = uaudio_iommu_map_pa(MEM_EVENT_RING, dma_coherent, er_pa,
1212				   PAGE_SIZE);
1213	if (!iova) {
1214		ret = -ENOMEM;
1215		goto clear_pa;
1216	}
1217
1218	mem_info->iova = PREPEND_SID_TO_IOVA(iova, uaudio_qdev->data->sid);
1219	mem_info->size = PAGE_SIZE;
1220
1221	return 0;
1222
1223clear_pa:
1224	mem_info->dma = 0;
1225remove_interrupter:
1226	xhci_sideband_remove_interrupter(uadev[card_num].sb);
1227put_offload:
1228	usb_offload_put(subs->dev);
1229exit:
1230	return ret;
1231}
1232
1233/**
1234 * uaudio_populate_uac_desc() - parse UAC parameters and populate QMI resp
1235 * @subs: usb substream
1236 * @resp: QMI response buffer
1237 *
1238 * Parses information specified within UAC descriptors which explain the
1239 * sample parameters that the device expects.  This information is populated
1240 * to the QMI response sent back to the audio DSP.
1241 *
1242 */
1243static int uaudio_populate_uac_desc(struct snd_usb_substream *subs,
1244				    struct qmi_uaudio_stream_resp_msg_v01 *resp)
1245{
1246	struct usb_interface_descriptor *altsd;
1247	struct usb_host_interface *alts;
1248	struct usb_interface *iface;
1249	int protocol;
1250
1251	iface = usb_ifnum_to_if(subs->dev, subs->cur_audiofmt->iface);
1252	if (!iface) {
1253		dev_err(&subs->dev->dev, "interface # %d does not exist\n",
1254			subs->cur_audiofmt->iface);
1255		return -ENODEV;
1256	}
1257
1258	alts = &iface->altsetting[subs->cur_audiofmt->altset_idx];
1259	altsd = get_iface_desc(alts);
1260	protocol = altsd->bInterfaceProtocol;
1261
1262	if (protocol == UAC_VERSION_1) {
1263		struct uac1_as_header_descriptor *as;
1264
1265		as = snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL,
1266					     UAC_AS_GENERAL);
1267		if (!as) {
1268			dev_err(&subs->dev->dev,
1269				"%u:%d : no UAC_AS_GENERAL desc\n",
1270				subs->cur_audiofmt->iface,
1271				subs->cur_audiofmt->altset_idx);
1272			return -ENODEV;
1273		}
1274
1275		resp->data_path_delay = as->bDelay;
1276		resp->data_path_delay_valid = 1;
1277
1278		resp->usb_audio_subslot_size = subs->cur_audiofmt->fmt_sz;
1279		resp->usb_audio_subslot_size_valid = 1;
1280
1281		resp->usb_audio_spec_revision = le16_to_cpu((__force __le16)0x0100);
1282		resp->usb_audio_spec_revision_valid = 1;
1283	} else if (protocol == UAC_VERSION_2) {
1284		resp->usb_audio_subslot_size = subs->cur_audiofmt->fmt_sz;
1285		resp->usb_audio_subslot_size_valid = 1;
1286
1287		resp->usb_audio_spec_revision = le16_to_cpu((__force __le16)0x0200);
1288		resp->usb_audio_spec_revision_valid = 1;
1289	} else if (protocol == UAC_VERSION_3) {
1290		if (iface->intf_assoc->bFunctionSubClass ==
1291					UAC3_FUNCTION_SUBCLASS_FULL_ADC_3_0) {
1292			dev_err(&subs->dev->dev,
1293				"full adc is not supported\n");
1294			return -EINVAL;
1295		}
1296
1297		switch (le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize)) {
1298		case UAC3_BADD_EP_MAXPSIZE_SYNC_MONO_16:
1299		case UAC3_BADD_EP_MAXPSIZE_SYNC_STEREO_16:
1300		case UAC3_BADD_EP_MAXPSIZE_ASYNC_MONO_16:
1301		case UAC3_BADD_EP_MAXPSIZE_ASYNC_STEREO_16: {
1302			resp->usb_audio_subslot_size = 0x2;
1303			break;
1304		}
1305
1306		case UAC3_BADD_EP_MAXPSIZE_SYNC_MONO_24:
1307		case UAC3_BADD_EP_MAXPSIZE_SYNC_STEREO_24:
1308		case UAC3_BADD_EP_MAXPSIZE_ASYNC_MONO_24:
1309		case UAC3_BADD_EP_MAXPSIZE_ASYNC_STEREO_24: {
1310			resp->usb_audio_subslot_size = 0x3;
1311			break;
1312		}
1313
1314		default:
1315			dev_err(&subs->dev->dev,
1316				"%d: %u: Invalid wMaxPacketSize\n",
1317				subs->cur_audiofmt->iface,
1318				subs->cur_audiofmt->altset_idx);
1319			return -EINVAL;
1320		}
1321		resp->usb_audio_subslot_size_valid = 1;
1322	} else {
1323		dev_err(&subs->dev->dev, "unknown protocol version %x\n",
1324			protocol);
1325		return -ENODEV;
1326	}
1327
1328	memcpy(&resp->std_as_opr_intf_desc, &alts->desc, sizeof(alts->desc));
1329
1330	return 0;
1331}
1332
1333/**
1334 * prepare_qmi_response() - prepare stream enable response
1335 * @subs: usb substream
1336 * @req_msg: QMI request message
1337 * @resp: QMI response buffer
1338 * @info_idx: usb interface array index
1339 *
1340 * Prepares the QMI response for a USB QMI stream enable request.  Will parse
1341 * out the parameters within the stream enable request, in order to match
1342 * requested audio profile to the ones exposed by the USB device connected.
1343 *
1344 * In addition, will fetch the XHCI transfer resources needed for the handoff to
1345 * happen.  This includes, transfer ring and buffer addresses and secondary event
1346 * ring address.  These parameters will be communicated as part of the USB QMI
1347 * stream enable response.
1348 *
1349 */
1350static int prepare_qmi_response(struct snd_usb_substream *subs,
1351				struct qmi_uaudio_stream_req_msg_v01 *req_msg,
1352				struct qmi_uaudio_stream_resp_msg_v01 *resp,
1353				int info_idx)
1354{
1355	struct q6usb_offload *data;
1356	int pcm_dev_num;
1357	int card_num;
1358	void *xfer_buf_cpu;
1359	int ret;
1360
1361	pcm_dev_num = (req_msg->usb_token & QMI_STREAM_REQ_DEV_NUM_MASK) >> 8;
1362	card_num = (req_msg->usb_token & QMI_STREAM_REQ_CARD_NUM_MASK) >> 16;
1363
1364	if (!uadev[card_num].ctrl_intf) {
1365		dev_err(&subs->dev->dev, "audio ctrl intf info not cached\n");
1366		return -ENODEV;
1367	}
1368
1369	ret = uaudio_populate_uac_desc(subs, resp);
1370	if (ret < 0)
1371		return ret;
1372
1373	resp->slot_id = subs->dev->slot_id;
1374	resp->slot_id_valid = 1;
1375
1376	data = snd_soc_usb_find_priv_data(uaudio_qdev->auxdev->dev.parent);
1377	if (!data) {
1378		dev_err(&subs->dev->dev, "No private data found\n");
1379		return -ENODEV;
1380	}
1381
1382	uaudio_qdev->data = data;
1383
1384	resp->std_as_opr_intf_desc_valid = 1;
1385	ret = uaudio_endpoint_setup(subs, subs->data_endpoint, card_num,
1386				    &resp->xhci_mem_info.tr_data,
1387				    &resp->std_as_data_ep_desc);
1388	if (ret < 0)
1389		return ret;
1390
1391	resp->std_as_data_ep_desc_valid = 1;
1392
1393	if (subs->sync_endpoint) {
1394		ret = uaudio_endpoint_setup(subs, subs->sync_endpoint, card_num,
1395					    &resp->xhci_mem_info.tr_sync,
1396					    &resp->std_as_sync_ep_desc);
1397		if (ret < 0)
1398			goto drop_data_ep;
1399
1400		resp->std_as_sync_ep_desc_valid = 1;
1401	}
1402
1403	resp->interrupter_num_valid = 1;
1404	resp->controller_num_valid = 0;
1405	ret = usb_get_controller_id(subs->dev);
1406	if (ret >= 0) {
1407		resp->controller_num = ret;
1408		resp->controller_num_valid = 1;
1409	}
1410
1411	/* event ring */
1412	ret = uaudio_event_ring_setup(subs, card_num,
1413				      &resp->xhci_mem_info.evt_ring);
1414	if (ret < 0)
1415		goto drop_sync_ep;
1416
1417	uaudio_qdev->er_mapped = true;
1418	resp->interrupter_num = xhci_sideband_interrupter_id(uadev[card_num].sb);
1419
1420	resp->speed_info = get_speed_info(subs->dev->speed);
1421	if (resp->speed_info == USB_QMI_DEVICE_SPEED_INVALID_V01) {
1422		ret = -ENODEV;
1423		goto free_sec_ring;
1424	}
1425
1426	resp->speed_info_valid = 1;
1427
1428	ret = uaudio_transfer_buffer_setup(subs, &xfer_buf_cpu, req_msg->xfer_buff_size,
1429					   &resp->xhci_mem_info.xfer_buff);
1430	if (ret < 0) {
1431		ret = -ENOMEM;
1432		goto free_sec_ring;
1433	}
1434
1435	resp->xhci_mem_info_valid = 1;
1436
1437	if (!atomic_read(&uadev[card_num].in_use)) {
1438		kref_init(&uadev[card_num].kref);
1439		init_waitqueue_head(&uadev[card_num].disconnect_wq);
1440		uadev[card_num].num_intf =
1441			subs->dev->config->desc.bNumInterfaces;
1442		uadev[card_num].info = kcalloc(uadev[card_num].num_intf,
1443					       sizeof(struct intf_info),
1444					       GFP_KERNEL);
1445		if (!uadev[card_num].info) {
1446			ret = -ENOMEM;
1447			goto unmap_er;
1448		}
1449		uadev[card_num].udev = subs->dev;
1450		atomic_set(&uadev[card_num].in_use, 1);
1451	} else {
1452		kref_get(&uadev[card_num].kref);
1453	}
1454
1455	uadev[card_num].usb_core_id = resp->controller_num;
1456
1457	/* cache intf specific info to use it for unmap and free xfer buf */
1458	uadev[card_num].info[info_idx].data_xfer_ring_va =
1459					IOVA_MASK(resp->xhci_mem_info.tr_data.iova);
1460	uadev[card_num].info[info_idx].data_xfer_ring_size = PAGE_SIZE;
1461	uadev[card_num].info[info_idx].sync_xfer_ring_va =
1462					IOVA_MASK(resp->xhci_mem_info.tr_sync.iova);
1463	uadev[card_num].info[info_idx].sync_xfer_ring_size = PAGE_SIZE;
1464	uadev[card_num].info[info_idx].xfer_buf_iova =
1465					IOVA_MASK(resp->xhci_mem_info.xfer_buff.iova);
1466	uadev[card_num].info[info_idx].xfer_buf_dma =
1467					resp->xhci_mem_info.xfer_buff.dma;
1468	uadev[card_num].info[info_idx].xfer_buf_size =
1469					resp->xhci_mem_info.xfer_buff.size;
1470	uadev[card_num].info[info_idx].data_ep_pipe = subs->data_endpoint ?
1471						subs->data_endpoint->pipe : 0;
1472	uadev[card_num].info[info_idx].sync_ep_pipe = subs->sync_endpoint ?
1473						subs->sync_endpoint->pipe : 0;
1474	uadev[card_num].info[info_idx].data_ep_idx = subs->data_endpoint ?
1475						subs->data_endpoint->ep_num : 0;
1476	uadev[card_num].info[info_idx].sync_ep_idx = subs->sync_endpoint ?
1477						subs->sync_endpoint->ep_num : 0;
1478	uadev[card_num].info[info_idx].xfer_buf_cpu = xfer_buf_cpu;
1479	uadev[card_num].info[info_idx].pcm_card_num = card_num;
1480	uadev[card_num].info[info_idx].pcm_dev_num = pcm_dev_num;
1481	uadev[card_num].info[info_idx].direction = subs->direction;
1482	uadev[card_num].info[info_idx].intf_num = subs->cur_audiofmt->iface;
1483	uadev[card_num].info[info_idx].in_use = true;
1484
1485	set_bit(card_num, &uaudio_qdev->card_slot);
1486
1487	return 0;
1488
1489unmap_er:
1490	uaudio_iommu_unmap(MEM_EVENT_RING, IOVA_BASE, PAGE_SIZE, PAGE_SIZE);
1491free_sec_ring:
1492	xhci_sideband_remove_interrupter(uadev[card_num].sb);
1493	usb_offload_put(subs->dev);
1494drop_sync_ep:
1495	if (subs->sync_endpoint) {
1496		uaudio_iommu_unmap(MEM_XFER_RING,
1497				   IOVA_MASK(resp->xhci_mem_info.tr_sync.iova),
1498				   PAGE_SIZE, PAGE_SIZE);
1499		xhci_sideband_remove_endpoint(uadev[card_num].sb,
1500			usb_pipe_endpoint(subs->dev, subs->sync_endpoint->pipe));
1501	}
1502drop_data_ep:
1503	uaudio_iommu_unmap(MEM_XFER_RING, IOVA_MASK(resp->xhci_mem_info.tr_data.iova),
1504			   PAGE_SIZE, PAGE_SIZE);
1505	xhci_sideband_remove_endpoint(uadev[card_num].sb,
1506			usb_pipe_endpoint(subs->dev, subs->data_endpoint->pipe));
1507
1508	return ret;
1509}
1510
1511/**
1512 * handle_uaudio_stream_req() - handle stream enable/disable request
1513 * @handle: QMI client handle
1514 * @sq: qrtr socket
1515 * @txn: QMI transaction context
1516 * @decoded_msg: decoded QMI message
1517 *
1518 * Main handler for the QMI stream enable/disable requests.  This executes the
1519 * corresponding enable/disable stream apis, respectively.
1520 *
1521 */
1522static void handle_uaudio_stream_req(struct qmi_handle *handle,
1523				     struct sockaddr_qrtr *sq,
1524				     struct qmi_txn *txn,
1525				     const void *decoded_msg)
1526{
1527	struct qmi_uaudio_stream_req_msg_v01 *req_msg;
1528	struct qmi_uaudio_stream_resp_msg_v01 resp = {{0}, 0};
1529	struct uaudio_qmi_svc *svc = uaudio_svc;
1530	struct snd_usb_audio *chip = NULL;
1531	struct snd_usb_substream *subs;
1532	struct usb_host_endpoint *ep;
1533	int datainterval = -EINVAL;
1534	int info_idx = -EINVAL;
1535	struct intf_info *info;
1536	u8 pcm_card_num;
1537	u8 pcm_dev_num;
1538	u8 direction;
1539	int ret = 0;
1540
1541	if (!svc->client_connected) {
1542		svc->client_sq = *sq;
1543		svc->client_connected = true;
1544	}
1545
1546	mutex_lock(&qdev_mutex);
1547	req_msg = (struct qmi_uaudio_stream_req_msg_v01 *)decoded_msg;
1548	if (!req_msg->audio_format_valid || !req_msg->bit_rate_valid ||
1549	    !req_msg->number_of_ch_valid || !req_msg->xfer_buff_size_valid) {
1550		ret = -EINVAL;
1551		goto response;
1552	}
1553
1554	if (!uaudio_qdev) {
1555		ret = -EINVAL;
1556		goto response;
1557	}
1558
1559	direction = (req_msg->usb_token & QMI_STREAM_REQ_DIRECTION);
1560	pcm_dev_num = (req_msg->usb_token & QMI_STREAM_REQ_DEV_NUM_MASK) >> 8;
1561	pcm_card_num = (req_msg->usb_token & QMI_STREAM_REQ_CARD_NUM_MASK) >> 16;
1562	if (pcm_card_num >= SNDRV_CARDS) {
1563		ret = -EINVAL;
1564		goto response;
1565	}
1566
1567	if (req_msg->audio_format > USB_QMI_PCM_FORMAT_U32_BE) {
1568		ret = -EINVAL;
1569		goto response;
1570	}
1571
1572	subs = find_substream(pcm_card_num, pcm_dev_num, direction);
1573	chip = uadev[pcm_card_num].chip;
1574	if (!subs || !chip || atomic_read(&chip->shutdown)) {
1575		ret = -ENODEV;
1576		goto response;
1577	}
1578
1579	info_idx = info_idx_from_ifnum(pcm_card_num, subs->cur_audiofmt ?
1580			subs->cur_audiofmt->iface : -1, req_msg->enable);
1581	if (atomic_read(&chip->shutdown) || !subs->stream || !subs->stream->pcm ||
1582	    !subs->stream->chip) {
1583		ret = -ENODEV;
1584		goto response;
1585	}
1586
1587	scoped_guard(mutex, &chip->mutex) {
1588		if (req_msg->enable) {
1589			if (info_idx < 0 || chip->system_suspend || subs->opened) {
1590				ret = -EBUSY;
1591				goto response;
1592			}
1593			subs->opened = 1;
1594		}
1595	}
1596
1597	if (req_msg->service_interval_valid) {
1598		ret = get_data_interval_from_si(subs,
1599						req_msg->service_interval);
1600		if (ret == -EINVAL)
1601			goto response;
1602
1603		datainterval = ret;
1604	}
1605
1606	uadev[pcm_card_num].ctrl_intf = chip->ctrl_intf;
1607
1608	if (req_msg->enable) {
1609		ret = enable_audio_stream(subs,
1610					  map_pcm_format(req_msg->audio_format),
1611					  req_msg->number_of_ch, req_msg->bit_rate,
1612					  datainterval);
1613
1614		if (!ret)
1615			ret = prepare_qmi_response(subs, req_msg, &resp,
1616						   info_idx);
1617		if (ret < 0) {
1618			guard(mutex)(&chip->mutex);
1619			subs->opened = 0;
1620		}
1621	} else {
1622		info = &uadev[pcm_card_num].info[info_idx];
1623		if (info->data_ep_pipe) {
1624			ep = usb_pipe_endpoint(uadev[pcm_card_num].udev,
1625					       info->data_ep_pipe);
1626			if (ep) {
1627				xhci_sideband_stop_endpoint(uadev[pcm_card_num].sb,
1628							    ep);
1629				xhci_sideband_remove_endpoint(uadev[pcm_card_num].sb,
1630							      ep);
1631			}
1632
1633			info->data_ep_pipe = 0;
1634		}
1635
1636		if (info->sync_ep_pipe) {
1637			ep = usb_pipe_endpoint(uadev[pcm_card_num].udev,
1638					       info->sync_ep_pipe);
1639			if (ep) {
1640				xhci_sideband_stop_endpoint(uadev[pcm_card_num].sb,
1641							    ep);
1642				xhci_sideband_remove_endpoint(uadev[pcm_card_num].sb,
1643							      ep);
1644			}
1645
1646			info->sync_ep_pipe = 0;
1647		}
1648
1649		disable_audio_stream(subs);
1650		guard(mutex)(&chip->mutex);
1651		subs->opened = 0;
1652	}
1653
1654response:
1655	if (!req_msg->enable && ret != -EINVAL && ret != -ENODEV) {
1656		guard(mutex)(&chip->mutex);
1657		if (info_idx >= 0) {
1658			info = &uadev[pcm_card_num].info[info_idx];
1659			uaudio_dev_intf_cleanup(uadev[pcm_card_num].udev,
1660						info);
1661		}
1662		if (atomic_read(&uadev[pcm_card_num].in_use))
1663			kref_put(&uadev[pcm_card_num].kref,
1664				 uaudio_dev_release);
1665	}
1666	mutex_unlock(&qdev_mutex);
1667
1668	resp.usb_token = req_msg->usb_token;
1669	resp.usb_token_valid = 1;
1670	resp.internal_status = ret;
1671	resp.internal_status_valid = 1;
1672	resp.status = ret ? USB_QMI_STREAM_REQ_FAILURE_V01 : ret;
1673	resp.status_valid = 1;
1674	ret = qmi_send_response(svc->uaudio_svc_hdl, sq, txn,
1675				QMI_UAUDIO_STREAM_RESP_V01,
1676				QMI_UAUDIO_STREAM_RESP_MSG_V01_MAX_MSG_LEN,
1677				qmi_uaudio_stream_resp_msg_v01_ei, &resp);
1678}
1679
1680static struct qmi_msg_handler uaudio_stream_req_handlers = {
1681	.type = QMI_REQUEST,
1682	.msg_id = QMI_UAUDIO_STREAM_REQ_V01,
1683	.ei = qmi_uaudio_stream_req_msg_v01_ei,
1684	.decoded_size = QMI_UAUDIO_STREAM_REQ_MSG_V01_MAX_MSG_LEN,
1685	.fn = handle_uaudio_stream_req,
1686};
1687
1688/**
1689 * qc_usb_audio_offload_init_qmi_dev() - initializes qmi dev
1690 *
1691 * Initializes the USB qdev, which is used to carry information pertaining to
1692 * the offloading resources.  This device is freed only when there are no longer
1693 * any offloading candidates. (i.e, when all audio devices are disconnected)
1694 *
1695 */
1696static int qc_usb_audio_offload_init_qmi_dev(void)
1697{
1698	uaudio_qdev = kzalloc(sizeof(*uaudio_qdev), GFP_KERNEL);
1699	if (!uaudio_qdev)
1700		return -ENOMEM;
1701
1702	/* initialize xfer ring and xfer buf iova list */
1703	INIT_LIST_HEAD(&uaudio_qdev->xfer_ring_list);
1704	uaudio_qdev->curr_xfer_ring_iova = IOVA_XFER_RING_BASE;
1705	uaudio_qdev->xfer_ring_iova_size =
1706			IOVA_XFER_RING_MAX - IOVA_XFER_RING_BASE;
1707
1708	INIT_LIST_HEAD(&uaudio_qdev->xfer_buf_list);
1709	uaudio_qdev->curr_xfer_buf_iova = IOVA_XFER_BUF_BASE;
1710	uaudio_qdev->xfer_buf_iova_size =
1711		IOVA_XFER_BUF_MAX - IOVA_XFER_BUF_BASE;
1712
1713	return 0;
1714}
1715
1716/* Populates ppcm_idx array with supported PCM indexes */
1717static int qc_usb_audio_offload_fill_avail_pcms(struct snd_usb_audio *chip,
1718						struct snd_soc_usb_device *sdev)
1719{
1720	struct snd_usb_stream *as;
1721	struct snd_usb_substream *subs;
1722	int idx = 0;
1723
1724	list_for_each_entry(as, &chip->pcm_list, list) {
1725		subs = &as->substream[SNDRV_PCM_STREAM_PLAYBACK];
1726		if (subs->ep_num) {
1727			sdev->ppcm_idx[idx] = as->pcm->device;
1728			idx++;
1729		}
1730		/*
1731		 * Break if the current index exceeds the number of possible
1732		 * playback streams counted from the UAC descriptors.
1733		 */
1734		if (idx >= sdev->num_playback)
1735			break;
1736	}
1737
1738	return -1;
1739}
1740
1741/**
1742 * qc_usb_audio_offload_probe() - platform op connect handler
1743 * @chip: USB SND device
1744 *
1745 * Platform connect handler when a USB SND device is detected. Will
1746 * notify SOC USB about the connection to enable the USB ASoC backend
1747 * and populate internal USB chip array.
1748 *
1749 */
1750static void qc_usb_audio_offload_probe(struct snd_usb_audio *chip)
1751{
1752	struct usb_interface *intf = chip->intf[chip->num_interfaces - 1];
1753	struct usb_interface_descriptor *altsd;
1754	struct usb_host_interface *alts;
1755	struct snd_soc_usb_device *sdev;
1756	struct xhci_sideband *sb;
1757
1758	/*
1759	 * If there is no priv_data, or no playback paths, the connected
1760	 * device doesn't support offloading.  Avoid populating entries for
1761	 * this device.
1762	 */
1763	if (!snd_soc_usb_find_priv_data(uaudio_qdev->auxdev->dev.parent) ||
1764	    !usb_qmi_get_pcm_num(chip, 0))
1765		return;
1766
1767	guard(mutex)(&qdev_mutex);
1768	guard(mutex)(&chip->mutex);
1769	if (!uadev[chip->card->number].chip) {
1770		sdev = kzalloc(sizeof(*sdev), GFP_KERNEL);
1771		if (!sdev)
1772			return;
1773
1774		sb = xhci_sideband_register(intf, XHCI_SIDEBAND_VENDOR,
1775					    uaudio_sideband_notifier);
1776		if (!sb)
1777			goto free_sdev;
1778	} else {
1779		sb = uadev[chip->card->number].sb;
1780		sdev = uadev[chip->card->number].sdev;
1781	}
1782
1783	uadev[chip->card->number].sb = sb;
1784	uadev[chip->card->number].chip = chip;
1785	uadev[chip->card->number].sdev = sdev;
1786
1787	alts = &intf->altsetting[0];
1788	altsd = get_iface_desc(alts);
1789
1790	/* Wait until all PCM devices are populated before notifying soc-usb */
1791	if (altsd->bInterfaceNumber == chip->last_iface) {
1792		sdev->num_playback = usb_qmi_get_pcm_num(chip, 0);
1793
1794		/*
1795		 * Allocate playback pcm index array based on number of possible
1796		 * playback paths within the UAC descriptors.
1797		 */
1798		sdev->ppcm_idx = kcalloc(sdev->num_playback, sizeof(unsigned int),
1799					 GFP_KERNEL);
1800		if (!sdev->ppcm_idx)
1801			goto unreg_xhci;
1802
1803		qc_usb_audio_offload_fill_avail_pcms(chip, sdev);
1804		sdev->card_idx = chip->card->number;
1805		sdev->chip_idx = chip->index;
1806
1807		snd_usb_offload_create_ctl(chip, uaudio_qdev->auxdev->dev.parent);
1808		snd_soc_usb_connect(uaudio_qdev->auxdev->dev.parent, sdev);
1809	}
1810
1811	return;
1812
1813unreg_xhci:
1814	xhci_sideband_unregister(sb);
1815	uadev[chip->card->number].sb = NULL;
1816free_sdev:
1817	kfree(sdev);
1818	uadev[chip->card->number].sdev = NULL;
1819	uadev[chip->card->number].chip = NULL;
1820}
1821
1822/**
1823 * qc_usb_audio_cleanup_qmi_dev() - release qmi device
1824 *
1825 * Frees the USB qdev.  Only occurs when there are no longer any potential
1826 * devices that can utilize USB audio offloading.
1827 *
1828 */
1829static void qc_usb_audio_cleanup_qmi_dev(void)
1830{
1831	kfree(uaudio_qdev);
1832	uaudio_qdev = NULL;
1833}
1834
1835/**
1836 * qc_usb_audio_offload_disconnect() - platform op disconnect handler
1837 * @chip: USB SND device
1838 *
1839 * Platform disconnect handler.  Will ensure that any pending stream is
1840 * halted by issuing a QMI disconnect indication packet to the adsp.
1841 *
1842 */
1843static void qc_usb_audio_offload_disconnect(struct snd_usb_audio *chip)
1844{
1845	struct uaudio_dev *dev;
1846	int card_num;
1847
1848	if (!chip)
1849		return;
1850
1851	card_num = chip->card->number;
1852	if (card_num >= SNDRV_CARDS)
1853		return;
1854
1855	guard(mutex)(&qdev_mutex);
1856	guard(mutex)(&chip->mutex);
1857	dev = &uadev[card_num];
1858
1859	/* Device has already been cleaned up, or never populated */
1860	if (!dev->chip)
1861		return;
1862
1863	/* cleaned up already */
1864	if (!dev->udev)
1865		goto done;
1866
1867	uaudio_send_disconnect_ind(chip);
1868	uaudio_dev_cleanup(dev);
1869done:
1870	/*
1871	 * If num_interfaces == 1, the last USB SND interface is being removed.
1872	 * This is to accommodate for devices w/ multiple UAC functions.
1873	 */
1874	if (chip->num_interfaces == 1) {
1875		snd_soc_usb_disconnect(uaudio_qdev->auxdev->dev.parent, dev->sdev);
1876		xhci_sideband_unregister(dev->sb);
1877		dev->chip = NULL;
1878		kfree(dev->sdev->ppcm_idx);
1879		kfree(dev->sdev);
1880		dev->sdev = NULL;
1881	}
1882}
1883
1884/**
1885 * qc_usb_audio_offload_suspend() - USB offload PM suspend handler
1886 * @intf: USB interface
1887 * @message: suspend type
1888 *
1889 * PM suspend handler to ensure that the USB offloading driver is able to stop
1890 * any pending traffic, so that the bus can be suspended.
1891 *
1892 */
1893static void qc_usb_audio_offload_suspend(struct usb_interface *intf,
1894					 pm_message_t message)
1895{
1896	struct snd_usb_audio *chip = usb_get_intfdata(intf);
1897	int card_num;
1898
1899	if (!chip)
1900		return;
1901
1902	card_num = chip->card->number;
1903	if (card_num >= SNDRV_CARDS)
1904		return;
1905
1906	guard(mutex)(&qdev_mutex);
1907	guard(mutex)(&chip->mutex);
1908
1909	uaudio_send_disconnect_ind(chip);
1910}
1911
1912static struct snd_usb_platform_ops offload_ops = {
1913	.connect_cb = qc_usb_audio_offload_probe,
1914	.disconnect_cb = qc_usb_audio_offload_disconnect,
1915	.suspend_cb = qc_usb_audio_offload_suspend,
1916};
1917
1918static int qc_usb_audio_probe(struct auxiliary_device *auxdev,
1919			  const struct auxiliary_device_id *id)
1920
1921{
1922	struct uaudio_qmi_svc *svc;
1923	int ret;
1924
1925	svc = kzalloc(sizeof(*svc), GFP_KERNEL);
1926	if (!svc)
1927		return -ENOMEM;
1928
1929	svc->uaudio_svc_hdl = kzalloc(sizeof(*svc->uaudio_svc_hdl), GFP_KERNEL);
1930	if (!svc->uaudio_svc_hdl) {
1931		ret = -ENOMEM;
1932		goto free_svc;
1933	}
1934
1935	ret = qmi_handle_init(svc->uaudio_svc_hdl,
1936			      QMI_UAUDIO_STREAM_REQ_MSG_V01_MAX_MSG_LEN,
1937			      &uaudio_svc_ops_options,
1938			      &uaudio_stream_req_handlers);
1939	ret = qmi_add_server(svc->uaudio_svc_hdl, UAUDIO_STREAM_SERVICE_ID_V01,
1940			     UAUDIO_STREAM_SERVICE_VERS_V01, 0);
1941
1942	uaudio_svc = svc;
1943
1944	qc_usb_audio_offload_init_qmi_dev();
1945	uaudio_qdev->auxdev = auxdev;
1946
1947	ret = snd_usb_register_platform_ops(&offload_ops);
1948	if (ret < 0)
1949		goto release_qmi;
1950
1951	snd_usb_rediscover_devices();
1952
1953	return 0;
1954
1955release_qmi:
1956	qc_usb_audio_cleanup_qmi_dev();
1957	qmi_handle_release(svc->uaudio_svc_hdl);
1958free_svc:
1959	kfree(svc);
1960
1961	return ret;
1962}
1963
1964static void qc_usb_audio_remove(struct auxiliary_device *auxdev)
1965{
1966	struct uaudio_qmi_svc *svc = uaudio_svc;
1967	int idx;
1968
1969	/*
1970	 * Remove all connected devices after unregistering ops, to ensure
1971	 * that no further connect events will occur.  The disconnect routine
1972	 * will issue the QMI disconnect indication, which results in the
1973	 * external DSP to stop issuing transfers.
1974	 */
1975	snd_usb_unregister_platform_ops();
1976	for (idx = 0; idx < SNDRV_CARDS; idx++)
1977		qc_usb_audio_offload_disconnect(uadev[idx].chip);
1978
1979	qc_usb_audio_cleanup_qmi_dev();
1980
1981	qmi_handle_release(svc->uaudio_svc_hdl);
1982	kfree(svc);
1983	uaudio_svc = NULL;
1984}
1985
1986static const struct auxiliary_device_id qc_usb_audio_table[] = {
1987	{ .name = "q6usb.qc-usb-audio-offload" },
1988	{},
1989};
1990MODULE_DEVICE_TABLE(auxiliary, qc_usb_audio_table);
1991
1992static struct auxiliary_driver qc_usb_audio_offload_drv = {
1993	.name = "qc-usb-audio-offload",
1994	.id_table = qc_usb_audio_table,
1995	.probe = qc_usb_audio_probe,
1996	.remove = qc_usb_audio_remove,
1997};
1998module_auxiliary_driver(qc_usb_audio_offload_drv);
1999
2000MODULE_DESCRIPTION("QC USB Audio Offloading");
2001MODULE_LICENSE("GPL");