midi2.c

   1// SPDX-License-Identifier: GPL-2.0-or-later
   2/*
   3 * MIDI 2.0 support
   4 */
   5
   6#include <linux/bitops.h>
   7#include <linux/string.h>
   8#include <linux/init.h>
   9#include <linux/slab.h>
  10#include <linux/usb.h>
  11#include <linux/wait.h>
  12#include <linux/module.h>
  13#include <linux/moduleparam.h>
  14#include <linux/usb/audio.h>
  15#include <linux/usb/midi.h>
  16#include <linux/usb/midi-v2.h>
  17
  18#include <sound/core.h>
  19#include <sound/control.h>
  20#include <sound/ump.h>
  21#include "usbaudio.h"
  22#include "midi.h"
  23#include "midi2.h"
  24#include "helper.h"
  25
  26static bool midi2_enable = true;
  27module_param(midi2_enable, bool, 0444);
  28MODULE_PARM_DESC(midi2_enable, "Enable MIDI 2.0 support.");
  29
  30static bool midi2_ump_probe = true;
  31module_param(midi2_ump_probe, bool, 0444);
  32MODULE_PARM_DESC(midi2_ump_probe, "Probe UMP v1.1 support at first.");
  33
  34/* stream direction; just shorter names */
  35enum {
  36	STR_OUT = SNDRV_RAWMIDI_STREAM_OUTPUT,
  37	STR_IN = SNDRV_RAWMIDI_STREAM_INPUT
  38};
  39
  40#define NUM_URBS	8
  41
  42struct snd_usb_midi2_urb;
  43struct snd_usb_midi2_endpoint;
  44struct snd_usb_midi2_ump;
  45struct snd_usb_midi2_interface;
  46
  47/* URB context */
  48struct snd_usb_midi2_urb {
  49	struct urb *urb;
  50	struct snd_usb_midi2_endpoint *ep;
  51	unsigned int index;		/* array index */
  52};
  53
  54/* A USB MIDI input/output endpoint */
  55struct snd_usb_midi2_endpoint {
  56	struct usb_device *dev;
  57	const struct usb_ms20_endpoint_descriptor *ms_ep; /* reference to EP descriptor */
  58	struct snd_usb_midi2_endpoint *pair;	/* bidirectional pair EP */
  59	struct snd_usb_midi2_ump *rmidi;	/* assigned UMP EP pair */
  60	struct snd_ump_endpoint *ump;		/* assigned UMP EP */
  61	int direction;			/* direction (STR_IN/OUT) */
  62	unsigned int endpoint;		/* EP number */
  63	unsigned int pipe;		/* URB pipe */
  64	unsigned int packets;		/* packet buffer size in bytes */
  65	unsigned int interval;		/* interval for INT EP */
  66	wait_queue_head_t wait;		/* URB waiter */
  67	spinlock_t lock;		/* URB locking */
  68	struct snd_rawmidi_substream *substream; /* NULL when closed */
  69	unsigned int num_urbs;		/* number of allocated URBs */
  70	unsigned long urb_free;		/* bitmap for free URBs */
  71	unsigned long urb_free_mask;	/* bitmask for free URBs */
  72	atomic_t running;		/* running status */
  73	atomic_t suspended;		/* saved running status for suspend */
  74	bool disconnected;		/* shadow of umidi->disconnected */
  75	struct list_head list;		/* list to umidi->ep_list */
  76	struct snd_usb_midi2_urb urbs[NUM_URBS];
  77};
  78
  79/* A UMP endpoint - one or two USB MIDI endpoints are assigned */
  80struct snd_usb_midi2_ump {
  81	struct usb_device *dev;
  82	struct snd_usb_midi2_interface *umidi;	/* reference to MIDI iface */
  83	struct snd_ump_endpoint *ump;		/* assigned UMP EP object */
  84	struct snd_usb_midi2_endpoint *eps[2];	/* USB MIDI endpoints */
  85	int index;				/* rawmidi device index */
  86	unsigned char usb_block_id;		/* USB GTB id used for finding a pair */
  87	bool ump_parsed;			/* Parsed UMP 1.1 EP/FB info*/
  88	struct list_head list;		/* list to umidi->rawmidi_list */
  89};
  90
  91/* top-level instance per USB MIDI interface */
  92struct snd_usb_midi2_interface {
  93	struct snd_usb_audio *chip;	/* assigned USB-audio card */
  94	struct usb_interface *iface;	/* assigned USB interface */
  95	struct usb_host_interface *hostif;
  96	const char *blk_descs;		/* group terminal block descriptors */
  97	unsigned int blk_desc_size;	/* size of GTB descriptors */
  98	bool disconnected;
  99	struct list_head ep_list;	/* list of endpoints */
 100	struct list_head rawmidi_list;	/* list of UMP rawmidis */
 101	struct list_head list;		/* list to chip->midi_v2_list */
 102};
 103
 104/* submit URBs as much as possible; used for both input and output */
 105static void do_submit_urbs_locked(struct snd_usb_midi2_endpoint *ep,
 106				  int (*prepare)(struct snd_usb_midi2_endpoint *,
 107						 struct urb *))
 108{
 109	struct snd_usb_midi2_urb *ctx;
 110	int index, err = 0;
 111
 112	if (ep->disconnected)
 113		return;
 114
 115	while (ep->urb_free) {
 116		index = find_first_bit(&ep->urb_free, ep->num_urbs);
 117		if (index >= ep->num_urbs)
 118			return;
 119		ctx = &ep->urbs[index];
 120		err = prepare(ep, ctx->urb);
 121		if (err < 0)
 122			return;
 123		if (!ctx->urb->transfer_buffer_length)
 124			return;
 125		ctx->urb->dev = ep->dev;
 126		err = usb_submit_urb(ctx->urb, GFP_ATOMIC);
 127		if (err < 0) {
 128			dev_dbg(&ep->dev->dev,
 129				"usb_submit_urb error %d\n", err);
 130			return;
 131		}
 132		clear_bit(index, &ep->urb_free);
 133	}
 134}
 135
 136/* prepare for output submission: copy from rawmidi buffer to urb packet */
 137static int prepare_output_urb(struct snd_usb_midi2_endpoint *ep,
 138			      struct urb *urb)
 139{
 140	int count;
 141
 142	count = snd_ump_transmit(ep->ump, urb->transfer_buffer,
 143				 ep->packets);
 144	if (count < 0) {
 145		dev_dbg(&ep->dev->dev, "rawmidi transmit error %d\n", count);
 146		return count;
 147	}
 148	cpu_to_le32_array((u32 *)urb->transfer_buffer, count >> 2);
 149	urb->transfer_buffer_length = count;
 150	return 0;
 151}
 152
 153static void submit_output_urbs_locked(struct snd_usb_midi2_endpoint *ep)
 154{
 155	do_submit_urbs_locked(ep, prepare_output_urb);
 156}
 157
 158/* URB completion for output; re-filling and re-submit */
 159static void output_urb_complete(struct urb *urb)
 160{
 161	struct snd_usb_midi2_urb *ctx = urb->context;
 162	struct snd_usb_midi2_endpoint *ep = ctx->ep;
 163
 164	guard(spinlock_irqsave)(&ep->lock);
 165	set_bit(ctx->index, &ep->urb_free);
 166	if (urb->status >= 0 && atomic_read(&ep->running))
 167		submit_output_urbs_locked(ep);
 168	if (ep->urb_free == ep->urb_free_mask)
 169		wake_up(&ep->wait);
 170}
 171
 172/* prepare for input submission: just set the buffer length */
 173static int prepare_input_urb(struct snd_usb_midi2_endpoint *ep,
 174			     struct urb *urb)
 175{
 176	urb->transfer_buffer_length = ep->packets;
 177	return 0;
 178}
 179
 180static void submit_input_urbs_locked(struct snd_usb_midi2_endpoint *ep)
 181{
 182	do_submit_urbs_locked(ep, prepare_input_urb);
 183}
 184
 185/* URB completion for input; copy into rawmidi buffer and resubmit */
 186static void input_urb_complete(struct urb *urb)
 187{
 188	struct snd_usb_midi2_urb *ctx = urb->context;
 189	struct snd_usb_midi2_endpoint *ep = ctx->ep;
 190	int len;
 191
 192	guard(spinlock_irqsave)(&ep->lock);
 193	if (ep->disconnected || urb->status < 0)
 194		goto dequeue;
 195	len = urb->actual_length;
 196	len &= ~3; /* align UMP */
 197	if (len > ep->packets)
 198		len = ep->packets;
 199	if (len > 0) {
 200		le32_to_cpu_array((u32 *)urb->transfer_buffer, len >> 2);
 201		snd_ump_receive(ep->ump, (u32 *)urb->transfer_buffer, len);
 202	}
 203 dequeue:
 204	set_bit(ctx->index, &ep->urb_free);
 205	submit_input_urbs_locked(ep);
 206	if (ep->urb_free == ep->urb_free_mask)
 207		wake_up(&ep->wait);
 208}
 209
 210/* URB submission helper; for both direction */
 211static void submit_io_urbs(struct snd_usb_midi2_endpoint *ep)
 212{
 213	if (!ep)
 214		return;
 215	guard(spinlock_irqsave)(&ep->lock);
 216	if (ep->direction == STR_IN)
 217		submit_input_urbs_locked(ep);
 218	else
 219		submit_output_urbs_locked(ep);
 220}
 221
 222/* kill URBs for close, suspend and disconnect */
 223static void kill_midi_urbs(struct snd_usb_midi2_endpoint *ep, bool suspending)
 224{
 225	int i;
 226
 227	if (!ep)
 228		return;
 229	if (suspending)
 230		ep->suspended = ep->running;
 231	atomic_set(&ep->running, 0);
 232	for (i = 0; i < ep->num_urbs; i++) {
 233		if (!ep->urbs[i].urb)
 234			break;
 235		usb_kill_urb(ep->urbs[i].urb);
 236	}
 237}
 238
 239/* wait until all URBs get freed */
 240static void drain_urb_queue(struct snd_usb_midi2_endpoint *ep)
 241{
 242	if (!ep)
 243		return;
 244	guard(spinlock_irq)(&ep->lock);
 245	atomic_set(&ep->running, 0);
 246	wait_event_lock_irq_timeout(ep->wait,
 247				    ep->disconnected ||
 248				    ep->urb_free == ep->urb_free_mask,
 249				    ep->lock, msecs_to_jiffies(500));
 250}
 251
 252/* release URBs for an EP */
 253static void free_midi_urbs(struct snd_usb_midi2_endpoint *ep)
 254{
 255	struct snd_usb_midi2_urb *ctx;
 256	int i;
 257
 258	if (!ep)
 259		return;
 260	for (i = 0; i < NUM_URBS; ++i) {
 261		ctx = &ep->urbs[i];
 262		if (!ctx->urb)
 263			break;
 264		usb_free_coherent(ep->dev, ep->packets,
 265				  ctx->urb->transfer_buffer,
 266				  ctx->urb->transfer_dma);
 267		usb_free_urb(ctx->urb);
 268		ctx->urb = NULL;
 269	}
 270	ep->num_urbs = 0;
 271}
 272
 273/* allocate URBs for an EP */
 274/* the callers should handle allocation errors via free_midi_urbs() */
 275static int alloc_midi_urbs(struct snd_usb_midi2_endpoint *ep)
 276{
 277	struct snd_usb_midi2_urb *ctx;
 278	void (*comp)(struct urb *urb);
 279	void *buffer;
 280	int i, err;
 281	int endpoint, len;
 282
 283	endpoint = ep->endpoint;
 284	len = ep->packets;
 285	if (ep->direction == STR_IN)
 286		comp = input_urb_complete;
 287	else
 288		comp = output_urb_complete;
 289
 290	ep->num_urbs = 0;
 291	ep->urb_free = ep->urb_free_mask = 0;
 292	for (i = 0; i < NUM_URBS; i++) {
 293		ctx = &ep->urbs[i];
 294		ctx->index = i;
 295		ctx->urb = usb_alloc_urb(0, GFP_KERNEL);
 296		if (!ctx->urb) {
 297			dev_err(&ep->dev->dev, "URB alloc failed\n");
 298			return -ENOMEM;
 299		}
 300		ctx->ep = ep;
 301		buffer = usb_alloc_coherent(ep->dev, len, GFP_KERNEL,
 302					    &ctx->urb->transfer_dma);
 303		if (!buffer) {
 304			dev_err(&ep->dev->dev,
 305				"URB buffer alloc failed (size %d)\n", len);
 306			return -ENOMEM;
 307		}
 308		if (ep->interval)
 309			usb_fill_int_urb(ctx->urb, ep->dev, ep->pipe,
 310					 buffer, len, comp, ctx, ep->interval);
 311		else
 312			usb_fill_bulk_urb(ctx->urb, ep->dev, ep->pipe,
 313					  buffer, len, comp, ctx);
 314		err = usb_urb_ep_type_check(ctx->urb);
 315		if (err < 0) {
 316			dev_err(&ep->dev->dev, "invalid MIDI EP %x\n",
 317				endpoint);
 318			return err;
 319		}
 320		ctx->urb->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
 321		ep->num_urbs++;
 322	}
 323	ep->urb_free = ep->urb_free_mask = GENMASK(ep->num_urbs - 1, 0);
 324	return 0;
 325}
 326
 327static struct snd_usb_midi2_endpoint *
 328ump_to_endpoint(struct snd_ump_endpoint *ump, int dir)
 329{
 330	struct snd_usb_midi2_ump *rmidi = ump->private_data;
 331
 332	return rmidi->eps[dir];
 333}
 334
 335/* ump open callback */
 336static int snd_usb_midi_v2_open(struct snd_ump_endpoint *ump, int dir)
 337{
 338	struct snd_usb_midi2_endpoint *ep = ump_to_endpoint(ump, dir);
 339	int err = 0;
 340
 341	if (!ep || !ep->endpoint)
 342		return -ENODEV;
 343	if (ep->disconnected)
 344		return -EIO;
 345	if (ep->direction == STR_OUT) {
 346		err = alloc_midi_urbs(ep);
 347		if (err) {
 348			free_midi_urbs(ep);
 349			return err;
 350		}
 351	}
 352	return 0;
 353}
 354
 355/* ump close callback */
 356static void snd_usb_midi_v2_close(struct snd_ump_endpoint *ump, int dir)
 357{
 358	struct snd_usb_midi2_endpoint *ep = ump_to_endpoint(ump, dir);
 359
 360	if (ep->direction == STR_OUT) {
 361		kill_midi_urbs(ep, false);
 362		drain_urb_queue(ep);
 363		free_midi_urbs(ep);
 364	}
 365}
 366
 367/* ump trigger callback */
 368static void snd_usb_midi_v2_trigger(struct snd_ump_endpoint *ump, int dir,
 369				    int up)
 370{
 371	struct snd_usb_midi2_endpoint *ep = ump_to_endpoint(ump, dir);
 372
 373	atomic_set(&ep->running, up);
 374	if (up && ep->direction == STR_OUT && !ep->disconnected)
 375		submit_io_urbs(ep);
 376}
 377
 378/* ump drain callback */
 379static void snd_usb_midi_v2_drain(struct snd_ump_endpoint *ump, int dir)
 380{
 381	struct snd_usb_midi2_endpoint *ep = ump_to_endpoint(ump, dir);
 382
 383	drain_urb_queue(ep);
 384}
 385
 386/* allocate and start all input streams */
 387static int start_input_streams(struct snd_usb_midi2_interface *umidi)
 388{
 389	struct snd_usb_midi2_endpoint *ep;
 390	int err;
 391
 392	list_for_each_entry(ep, &umidi->ep_list, list) {
 393		if (ep->direction == STR_IN) {
 394			err = alloc_midi_urbs(ep);
 395			if (err < 0)
 396				goto error;
 397		}
 398	}
 399
 400	list_for_each_entry(ep, &umidi->ep_list, list) {
 401		if (ep->direction == STR_IN)
 402			submit_io_urbs(ep);
 403	}
 404
 405	return 0;
 406
 407 error:
 408	list_for_each_entry(ep, &umidi->ep_list, list) {
 409		if (ep->direction == STR_IN)
 410			free_midi_urbs(ep);
 411	}
 412
 413	return err;
 414}
 415
 416static const struct snd_ump_ops snd_usb_midi_v2_ump_ops = {
 417	.open = snd_usb_midi_v2_open,
 418	.close = snd_usb_midi_v2_close,
 419	.trigger = snd_usb_midi_v2_trigger,
 420	.drain = snd_usb_midi_v2_drain,
 421};
 422
 423/* create a USB MIDI 2.0 endpoint object */
 424static int create_midi2_endpoint(struct snd_usb_midi2_interface *umidi,
 425				 struct usb_host_endpoint *hostep,
 426				 const struct usb_ms20_endpoint_descriptor *ms_ep)
 427{
 428	struct snd_usb_midi2_endpoint *ep;
 429	int endpoint, dir;
 430
 431	usb_audio_dbg(umidi->chip, "Creating an EP 0x%02x, #GTB=%d\n",
 432		      hostep->desc.bEndpointAddress,
 433		      ms_ep->bNumGrpTrmBlock);
 434
 435	ep = kzalloc(sizeof(*ep), GFP_KERNEL);
 436	if (!ep)
 437		return -ENOMEM;
 438
 439	spin_lock_init(&ep->lock);
 440	init_waitqueue_head(&ep->wait);
 441	ep->dev = umidi->chip->dev;
 442	endpoint = hostep->desc.bEndpointAddress;
 443	dir = (endpoint & USB_DIR_IN) ? STR_IN : STR_OUT;
 444
 445	ep->endpoint = endpoint;
 446	ep->direction = dir;
 447	ep->ms_ep = ms_ep;
 448	if (usb_endpoint_xfer_int(&hostep->desc))
 449		ep->interval = hostep->desc.bInterval;
 450	else
 451		ep->interval = 0;
 452	if (dir == STR_IN) {
 453		if (ep->interval)
 454			ep->pipe = usb_rcvintpipe(ep->dev, endpoint);
 455		else
 456			ep->pipe = usb_rcvbulkpipe(ep->dev, endpoint);
 457	} else {
 458		if (ep->interval)
 459			ep->pipe = usb_sndintpipe(ep->dev, endpoint);
 460		else
 461			ep->pipe = usb_sndbulkpipe(ep->dev, endpoint);
 462	}
 463	ep->packets = usb_maxpacket(ep->dev, ep->pipe);
 464	list_add_tail(&ep->list, &umidi->ep_list);
 465
 466	return 0;
 467}
 468
 469/* destructor for endpoint; from snd_usb_midi_v2_free() */
 470static void free_midi2_endpoint(struct snd_usb_midi2_endpoint *ep)
 471{
 472	list_del(&ep->list);
 473	free_midi_urbs(ep);
 474	kfree(ep);
 475}
 476
 477/* call all endpoint destructors */
 478static void free_all_midi2_endpoints(struct snd_usb_midi2_interface *umidi)
 479{
 480	struct snd_usb_midi2_endpoint *ep;
 481
 482	while (!list_empty(&umidi->ep_list)) {
 483		ep = list_first_entry(&umidi->ep_list,
 484				      struct snd_usb_midi2_endpoint, list);
 485		free_midi2_endpoint(ep);
 486	}
 487}
 488
 489/* find a MIDI STREAMING descriptor with a given subtype */
 490static void *find_usb_ms_endpoint_descriptor(struct usb_host_endpoint *hostep,
 491					     unsigned char subtype)
 492{
 493	unsigned char *extra = hostep->extra;
 494	int extralen = hostep->extralen;
 495
 496	while (extralen > 3) {
 497		struct usb_ms_endpoint_descriptor *ms_ep =
 498			(struct usb_ms_endpoint_descriptor *)extra;
 499
 500		if (ms_ep->bLength > 3 &&
 501		    ms_ep->bDescriptorType == USB_DT_CS_ENDPOINT &&
 502		    ms_ep->bDescriptorSubtype == subtype)
 503			return ms_ep;
 504		if (!extra[0])
 505			break;
 506		extralen -= extra[0];
 507		extra += extra[0];
 508	}
 509	return NULL;
 510}
 511
 512/* get the full group terminal block descriptors and return the size */
 513static int get_group_terminal_block_descs(struct snd_usb_midi2_interface *umidi)
 514{
 515	struct usb_host_interface *hostif = umidi->hostif;
 516	struct usb_device *dev = umidi->chip->dev;
 517	struct usb_ms20_gr_trm_block_header_descriptor header = { 0 };
 518	unsigned char *data;
 519	int err, size;
 520
 521	err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0),
 522			      USB_REQ_GET_DESCRIPTOR,
 523			      USB_RECIP_INTERFACE | USB_TYPE_STANDARD | USB_DIR_IN,
 524			      USB_DT_CS_GR_TRM_BLOCK << 8 | hostif->desc.bAlternateSetting,
 525			      hostif->desc.bInterfaceNumber,
 526			      &header, sizeof(header));
 527	if (err < 0)
 528		return err;
 529	size = __le16_to_cpu(header.wTotalLength);
 530	if (!size) {
 531		dev_err(&dev->dev, "Failed to get GTB descriptors for %d:%d\n",
 532			hostif->desc.bInterfaceNumber, hostif->desc.bAlternateSetting);
 533		return -EINVAL;
 534	}
 535
 536	data = kzalloc(size, GFP_KERNEL);
 537	if (!data)
 538		return -ENOMEM;
 539
 540	err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0),
 541			      USB_REQ_GET_DESCRIPTOR,
 542			      USB_RECIP_INTERFACE | USB_TYPE_STANDARD | USB_DIR_IN,
 543			      USB_DT_CS_GR_TRM_BLOCK << 8 | hostif->desc.bAlternateSetting,
 544			      hostif->desc.bInterfaceNumber, data, size);
 545	if (err < 0) {
 546		kfree(data);
 547		return err;
 548	}
 549
 550	umidi->blk_descs = data;
 551	umidi->blk_desc_size = size;
 552	return 0;
 553}
 554
 555/* find the corresponding group terminal block descriptor */
 556static const struct usb_ms20_gr_trm_block_descriptor *
 557find_group_terminal_block(struct snd_usb_midi2_interface *umidi, int id)
 558{
 559	const unsigned char *data = umidi->blk_descs;
 560	int size = umidi->blk_desc_size;
 561	const struct usb_ms20_gr_trm_block_descriptor *desc;
 562
 563	size -= sizeof(struct usb_ms20_gr_trm_block_header_descriptor);
 564	data += sizeof(struct usb_ms20_gr_trm_block_header_descriptor);
 565	while (size > 0 && *data && *data <= size) {
 566		desc = (const struct usb_ms20_gr_trm_block_descriptor *)data;
 567		if (desc->bLength >= sizeof(*desc) &&
 568		    desc->bDescriptorType == USB_DT_CS_GR_TRM_BLOCK &&
 569		    desc->bDescriptorSubtype == USB_MS_GR_TRM_BLOCK &&
 570		    desc->bGrpTrmBlkID == id)
 571			return desc;
 572		size -= *data;
 573		data += *data;
 574	}
 575
 576	return NULL;
 577}
 578
 579/* fill up the information from GTB */
 580static int parse_group_terminal_block(struct snd_usb_midi2_ump *rmidi,
 581				      const struct usb_ms20_gr_trm_block_descriptor *desc)
 582{
 583	struct snd_ump_endpoint *ump = rmidi->ump;
 584	unsigned int protocol, protocol_caps;
 585
 586	/* set default protocol */
 587	switch (desc->bMIDIProtocol) {
 588	case USB_MS_MIDI_PROTO_1_0_64:
 589	case USB_MS_MIDI_PROTO_1_0_64_JRTS:
 590	case USB_MS_MIDI_PROTO_1_0_128:
 591	case USB_MS_MIDI_PROTO_1_0_128_JRTS:
 592		protocol = SNDRV_UMP_EP_INFO_PROTO_MIDI1;
 593		break;
 594	case USB_MS_MIDI_PROTO_2_0:
 595	case USB_MS_MIDI_PROTO_2_0_JRTS:
 596		protocol = SNDRV_UMP_EP_INFO_PROTO_MIDI2;
 597		break;
 598	default:
 599		return 0;
 600	}
 601
 602	if (!ump->info.protocol)
 603		ump->info.protocol = protocol;
 604
 605	protocol_caps = protocol;
 606	switch (desc->bMIDIProtocol) {
 607	case USB_MS_MIDI_PROTO_1_0_64_JRTS:
 608	case USB_MS_MIDI_PROTO_1_0_128_JRTS:
 609	case USB_MS_MIDI_PROTO_2_0_JRTS:
 610		protocol_caps |= SNDRV_UMP_EP_INFO_PROTO_JRTS_TX |
 611			SNDRV_UMP_EP_INFO_PROTO_JRTS_RX;
 612		break;
 613	}
 614
 615	ump->info.protocol_caps |= protocol_caps;
 616	return 0;
 617}
 618
 619/* allocate and parse for each assigned group terminal block */
 620static int parse_group_terminal_blocks(struct snd_usb_midi2_interface *umidi)
 621{
 622	struct snd_usb_midi2_ump *rmidi;
 623	const struct usb_ms20_gr_trm_block_descriptor *desc;
 624	int err;
 625
 626	err = get_group_terminal_block_descs(umidi);
 627	if (err < 0)
 628		return err;
 629	if (!umidi->blk_descs)
 630		return 0;
 631
 632	list_for_each_entry(rmidi, &umidi->rawmidi_list, list) {
 633		desc = find_group_terminal_block(umidi, rmidi->usb_block_id);
 634		if (!desc)
 635			continue;
 636		err = parse_group_terminal_block(rmidi, desc);
 637		if (err < 0)
 638			return err;
 639	}
 640
 641	return 0;
 642}
 643
 644/* parse endpoints included in the given interface and create objects */
 645static int parse_midi_2_0_endpoints(struct snd_usb_midi2_interface *umidi)
 646{
 647	struct usb_host_interface *hostif = umidi->hostif;
 648	struct usb_host_endpoint *hostep;
 649	struct usb_ms20_endpoint_descriptor *ms_ep;
 650	int i, err;
 651
 652	for (i = 0; i < hostif->desc.bNumEndpoints; i++) {
 653		hostep = &hostif->endpoint[i];
 654		if (!usb_endpoint_xfer_bulk(&hostep->desc) &&
 655		    !usb_endpoint_xfer_int(&hostep->desc))
 656			continue;
 657		ms_ep = find_usb_ms_endpoint_descriptor(hostep, USB_MS_GENERAL_2_0);
 658		if (!ms_ep)
 659			continue;
 660		if (ms_ep->bLength <= sizeof(*ms_ep))
 661			continue;
 662		if (!ms_ep->bNumGrpTrmBlock)
 663			continue;
 664		if (ms_ep->bLength < sizeof(*ms_ep) + ms_ep->bNumGrpTrmBlock)
 665			continue;
 666		err = create_midi2_endpoint(umidi, hostep, ms_ep);
 667		if (err < 0)
 668			return err;
 669	}
 670	return 0;
 671}
 672
 673static void free_all_midi2_umps(struct snd_usb_midi2_interface *umidi)
 674{
 675	struct snd_usb_midi2_ump *rmidi;
 676
 677	while (!list_empty(&umidi->rawmidi_list)) {
 678		rmidi = list_first_entry(&umidi->rawmidi_list,
 679					 struct snd_usb_midi2_ump, list);
 680		list_del(&rmidi->list);
 681		kfree(rmidi);
 682	}
 683}
 684
 685static int create_midi2_ump(struct snd_usb_midi2_interface *umidi,
 686			    struct snd_usb_midi2_endpoint *ep_in,
 687			    struct snd_usb_midi2_endpoint *ep_out,
 688			    int blk_id)
 689{
 690	struct snd_usb_midi2_ump *rmidi;
 691	struct snd_ump_endpoint *ump;
 692	int input, output;
 693	char idstr[16];
 694	int err;
 695
 696	rmidi = kzalloc(sizeof(*rmidi), GFP_KERNEL);
 697	if (!rmidi)
 698		return -ENOMEM;
 699	INIT_LIST_HEAD(&rmidi->list);
 700	rmidi->dev = umidi->chip->dev;
 701	rmidi->umidi = umidi;
 702	rmidi->usb_block_id = blk_id;
 703
 704	rmidi->index = umidi->chip->num_rawmidis;
 705	snprintf(idstr, sizeof(idstr), "UMP %d", rmidi->index);
 706	input = ep_in ? 1 : 0;
 707	output = ep_out ? 1 : 0;
 708	err = snd_ump_endpoint_new(umidi->chip->card, idstr, rmidi->index,
 709				   output, input, &ump);
 710	if (err < 0) {
 711		usb_audio_dbg(umidi->chip, "Failed to create a UMP object\n");
 712		kfree(rmidi);
 713		return err;
 714	}
 715
 716	rmidi->ump = ump;
 717	umidi->chip->num_rawmidis++;
 718
 719	ump->private_data = rmidi;
 720	ump->ops = &snd_usb_midi_v2_ump_ops;
 721
 722	rmidi->eps[STR_IN] = ep_in;
 723	rmidi->eps[STR_OUT] = ep_out;
 724	if (ep_in) {
 725		ep_in->pair = ep_out;
 726		ep_in->rmidi = rmidi;
 727		ep_in->ump = ump;
 728	}
 729	if (ep_out) {
 730		ep_out->pair = ep_in;
 731		ep_out->rmidi = rmidi;
 732		ep_out->ump = ump;
 733	}
 734
 735	list_add_tail(&rmidi->list, &umidi->rawmidi_list);
 736	return 0;
 737}
 738
 739/* find the UMP EP with the given USB block id */
 740static struct snd_usb_midi2_ump *
 741find_midi2_ump(struct snd_usb_midi2_interface *umidi, int blk_id)
 742{
 743	struct snd_usb_midi2_ump *rmidi;
 744
 745	list_for_each_entry(rmidi, &umidi->rawmidi_list, list) {
 746		if (rmidi->usb_block_id == blk_id)
 747			return rmidi;
 748	}
 749	return NULL;
 750}
 751
 752/* look for the matching output endpoint and create UMP object if found */
 753static int find_matching_ep_partner(struct snd_usb_midi2_interface *umidi,
 754				    struct snd_usb_midi2_endpoint *ep,
 755				    int blk_id)
 756{
 757	struct snd_usb_midi2_endpoint *pair_ep;
 758	int blk;
 759
 760	usb_audio_dbg(umidi->chip, "Looking for a pair for EP-in 0x%02x\n",
 761		      ep->endpoint);
 762	list_for_each_entry(pair_ep, &umidi->ep_list, list) {
 763		if (pair_ep->direction != STR_OUT)
 764			continue;
 765		if (pair_ep->pair)
 766			continue; /* already paired */
 767		for (blk = 0; blk < pair_ep->ms_ep->bNumGrpTrmBlock; blk++) {
 768			if (pair_ep->ms_ep->baAssoGrpTrmBlkID[blk] == blk_id) {
 769				usb_audio_dbg(umidi->chip,
 770					      "Found a match with EP-out 0x%02x blk %d\n",
 771					      pair_ep->endpoint, blk);
 772				return create_midi2_ump(umidi, ep, pair_ep, blk_id);
 773			}
 774		}
 775	}
 776	return 0;
 777}
 778
 779/* Call UMP helper to parse UMP endpoints;
 780 * this needs to be called after starting the input streams for bi-directional
 781 * communications
 782 */
 783static int parse_ump_endpoints(struct snd_usb_midi2_interface *umidi)
 784{
 785	struct snd_usb_midi2_ump *rmidi;
 786	int err;
 787
 788	list_for_each_entry(rmidi, &umidi->rawmidi_list, list) {
 789		if (!rmidi->ump ||
 790		    !(rmidi->ump->core.info_flags & SNDRV_RAWMIDI_INFO_DUPLEX))
 791			continue;
 792		err = snd_ump_parse_endpoint(rmidi->ump);
 793		if (!err) {
 794			rmidi->ump_parsed = true;
 795		} else {
 796			if (err == -ENOMEM)
 797				return err;
 798			/* fall back to GTB later */
 799		}
 800	}
 801	return 0;
 802}
 803
 804/* create a UMP block from a GTB entry */
 805static int create_gtb_block(struct snd_usb_midi2_ump *rmidi, int dir, int blk)
 806{
 807	struct snd_usb_midi2_interface *umidi = rmidi->umidi;
 808	const struct usb_ms20_gr_trm_block_descriptor *desc;
 809	struct snd_ump_block *fb;
 810	int type, err;
 811
 812	desc = find_group_terminal_block(umidi, blk);
 813	if (!desc)
 814		return 0;
 815
 816	usb_audio_dbg(umidi->chip,
 817		      "GTB %d: type=%d, group=%d/%d, protocol=%d, in bw=%d, out bw=%d\n",
 818		      blk, desc->bGrpTrmBlkType, desc->nGroupTrm,
 819		      desc->nNumGroupTrm, desc->bMIDIProtocol,
 820		      __le16_to_cpu(desc->wMaxInputBandwidth),
 821		      __le16_to_cpu(desc->wMaxOutputBandwidth));
 822
 823	/* assign the direction */
 824	switch (desc->bGrpTrmBlkType) {
 825	case USB_MS_GR_TRM_BLOCK_TYPE_BIDIRECTIONAL:
 826		type = SNDRV_UMP_DIR_BIDIRECTION;
 827		break;
 828	case USB_MS_GR_TRM_BLOCK_TYPE_INPUT_ONLY:
 829		type = SNDRV_UMP_DIR_INPUT;
 830		break;
 831	case USB_MS_GR_TRM_BLOCK_TYPE_OUTPUT_ONLY:
 832		type = SNDRV_UMP_DIR_OUTPUT;
 833		break;
 834	default:
 835		usb_audio_dbg(umidi->chip, "Unsupported GTB type %d\n",
 836			      desc->bGrpTrmBlkType);
 837		return 0; /* unsupported */
 838	}
 839
 840	/* guess work: set blk-1 as the (0-based) block ID */
 841	err = snd_ump_block_new(rmidi->ump, blk - 1, type,
 842				desc->nGroupTrm, desc->nNumGroupTrm,
 843				&fb);
 844	if (err == -EBUSY)
 845		return 0; /* already present */
 846	else if (err)
 847		return err;
 848
 849	if (desc->iBlockItem)
 850		usb_string(rmidi->dev, desc->iBlockItem,
 851			   fb->info.name, sizeof(fb->info.name));
 852
 853	if (__le16_to_cpu(desc->wMaxInputBandwidth) == 1 ||
 854	    __le16_to_cpu(desc->wMaxOutputBandwidth) == 1)
 855		fb->info.flags |= SNDRV_UMP_BLOCK_IS_MIDI1 |
 856			SNDRV_UMP_BLOCK_IS_LOWSPEED;
 857
 858	/* if MIDI 2.0 protocol is supported and yet the GTB shows MIDI 1.0,
 859	 * treat it as a MIDI 1.0-specific block
 860	 */
 861	if (rmidi->ump->info.protocol_caps & SNDRV_UMP_EP_INFO_PROTO_MIDI2) {
 862		switch (desc->bMIDIProtocol) {
 863		case USB_MS_MIDI_PROTO_1_0_64:
 864		case USB_MS_MIDI_PROTO_1_0_64_JRTS:
 865		case USB_MS_MIDI_PROTO_1_0_128:
 866		case USB_MS_MIDI_PROTO_1_0_128_JRTS:
 867			fb->info.flags |= SNDRV_UMP_BLOCK_IS_MIDI1;
 868			break;
 869		}
 870	}
 871
 872	snd_ump_update_group_attrs(rmidi->ump);
 873
 874	usb_audio_dbg(umidi->chip,
 875		      "Created a UMP block %d from GTB, name=%s, flags=0x%x\n",
 876		      blk, fb->info.name, fb->info.flags);
 877	return 0;
 878}
 879
 880/* Create UMP blocks for each UMP EP */
 881static int create_blocks_from_gtb(struct snd_usb_midi2_interface *umidi)
 882{
 883	struct snd_usb_midi2_ump *rmidi;
 884	int i, blk, err, dir;
 885
 886	list_for_each_entry(rmidi, &umidi->rawmidi_list, list) {
 887		if (!rmidi->ump)
 888			continue;
 889		/* Blocks have been already created? */
 890		if (rmidi->ump_parsed || rmidi->ump->info.num_blocks)
 891			continue;
 892		/* GTB is static-only */
 893		rmidi->ump->info.flags |= SNDRV_UMP_EP_INFO_STATIC_BLOCKS;
 894		/* loop over GTBs */
 895		for (dir = 0; dir < 2; dir++) {
 896			if (!rmidi->eps[dir])
 897				continue;
 898			for (i = 0; i < rmidi->eps[dir]->ms_ep->bNumGrpTrmBlock; i++) {
 899				blk = rmidi->eps[dir]->ms_ep->baAssoGrpTrmBlkID[i];
 900				err = create_gtb_block(rmidi, dir, blk);
 901				if (err < 0)
 902					return err;
 903			}
 904		}
 905	}
 906
 907	return 0;
 908}
 909
 910/* attach legacy rawmidis */
 911static int attach_legacy_rawmidi(struct snd_usb_midi2_interface *umidi)
 912{
 913#if IS_ENABLED(CONFIG_SND_UMP_LEGACY_RAWMIDI)
 914	struct snd_usb_midi2_ump *rmidi;
 915	int err;
 916
 917	list_for_each_entry(rmidi, &umidi->rawmidi_list, list) {
 918		err = snd_ump_attach_legacy_rawmidi(rmidi->ump,
 919						    "Legacy MIDI",
 920						    umidi->chip->num_rawmidis);
 921		if (err < 0)
 922			return err;
 923		umidi->chip->num_rawmidis++;
 924	}
 925#endif
 926	return 0;
 927}
 928
 929static void snd_usb_midi_v2_free(struct snd_usb_midi2_interface *umidi)
 930{
 931	free_all_midi2_endpoints(umidi);
 932	free_all_midi2_umps(umidi);
 933	list_del(&umidi->list);
 934	kfree(umidi->blk_descs);
 935	kfree(umidi);
 936}
 937
 938/* parse the interface for MIDI 2.0 */
 939static int parse_midi_2_0(struct snd_usb_midi2_interface *umidi)
 940{
 941	struct snd_usb_midi2_endpoint *ep;
 942	int blk, id, err;
 943
 944	/* First, create an object for each USB MIDI Endpoint */
 945	err = parse_midi_2_0_endpoints(umidi);
 946	if (err < 0)
 947		return err;
 948	if (list_empty(&umidi->ep_list)) {
 949		usb_audio_warn(umidi->chip, "No MIDI endpoints found\n");
 950		return -ENODEV;
 951	}
 952
 953	/*
 954	 * Next, look for EP I/O pairs that are found in group terminal blocks
 955	 * A UMP object is created for each EP I/O pair as bidirecitonal
 956	 * UMP EP
 957	 */
 958	list_for_each_entry(ep, &umidi->ep_list, list) {
 959		/* only input in this loop; output is matched in find_midi_ump() */
 960		if (ep->direction != STR_IN)
 961			continue;
 962		for (blk = 0; blk < ep->ms_ep->bNumGrpTrmBlock; blk++) {
 963			id = ep->ms_ep->baAssoGrpTrmBlkID[blk];
 964			err = find_matching_ep_partner(umidi, ep, id);
 965			if (err < 0)
 966				return err;
 967		}
 968	}
 969
 970	/*
 971	 * For the remaining EPs, treat as singles, create a UMP object with
 972	 * unidirectional EP
 973	 */
 974	list_for_each_entry(ep, &umidi->ep_list, list) {
 975		if (ep->rmidi)
 976			continue; /* already paired */
 977		for (blk = 0; blk < ep->ms_ep->bNumGrpTrmBlock; blk++) {
 978			id = ep->ms_ep->baAssoGrpTrmBlkID[blk];
 979			if (find_midi2_ump(umidi, id))
 980				continue;
 981			usb_audio_dbg(umidi->chip,
 982				      "Creating a unidirection UMP for EP=0x%02x, blk=%d\n",
 983				      ep->endpoint, id);
 984			if (ep->direction == STR_IN)
 985				err = create_midi2_ump(umidi, ep, NULL, id);
 986			else
 987				err = create_midi2_ump(umidi, NULL, ep, id);
 988			if (err < 0)
 989				return err;
 990			break;
 991		}
 992	}
 993
 994	return 0;
 995}
 996
 997/* is the given interface for MIDI 2.0? */
 998static bool is_midi2_altset(struct usb_host_interface *hostif)
 999{
1000	struct usb_ms_header_descriptor *ms_header =
1001		(struct usb_ms_header_descriptor *)hostif->extra;
1002
1003	if (hostif->extralen < 7 ||
1004	    ms_header->bLength < 7 ||
1005	    ms_header->bDescriptorType != USB_DT_CS_INTERFACE ||
1006	    ms_header->bDescriptorSubtype != UAC_HEADER)
1007		return false;
1008
1009	return le16_to_cpu(ms_header->bcdMSC) == USB_MS_REV_MIDI_2_0;
1010}
1011
1012/* change the altsetting */
1013static int set_altset(struct snd_usb_midi2_interface *umidi)
1014{
1015	usb_audio_dbg(umidi->chip, "Setting host iface %d:%d\n",
1016		      umidi->hostif->desc.bInterfaceNumber,
1017		      umidi->hostif->desc.bAlternateSetting);
1018	return usb_set_interface(umidi->chip->dev,
1019				 umidi->hostif->desc.bInterfaceNumber,
1020				 umidi->hostif->desc.bAlternateSetting);
1021}
1022
1023/* fill UMP Endpoint name string from USB descriptor */
1024static void fill_ump_ep_name(struct snd_ump_endpoint *ump,
1025			     struct usb_device *dev, int id)
1026{
1027	int len;
1028
1029	usb_string(dev, id, ump->info.name, sizeof(ump->info.name));
1030
1031	/* trim superfluous "MIDI" suffix */
1032	len = strlen(ump->info.name);
1033	if (len > 5 && !strcmp(ump->info.name + len - 5, " MIDI"))
1034		ump->info.name[len - 5] = 0;
1035}
1036
1037/* fill the fallback name string for each rawmidi instance */
1038static void set_fallback_rawmidi_names(struct snd_usb_midi2_interface *umidi)
1039{
1040	struct usb_device *dev = umidi->chip->dev;
1041	struct snd_usb_midi2_ump *rmidi;
1042	struct snd_ump_endpoint *ump;
1043
1044	list_for_each_entry(rmidi, &umidi->rawmidi_list, list) {
1045		ump = rmidi->ump;
1046		/* fill UMP EP name from USB descriptors */
1047		if (!*ump->info.name && umidi->hostif->desc.iInterface)
1048			fill_ump_ep_name(ump, dev, umidi->hostif->desc.iInterface);
1049		else if (!*ump->info.name && dev->descriptor.iProduct)
1050			fill_ump_ep_name(ump, dev, dev->descriptor.iProduct);
1051		/* fill fallback name */
1052		if (!*ump->info.name)
1053			scnprintf(ump->info.name, sizeof(ump->info.name),
1054				  "USB MIDI %d", rmidi->index);
1055		/* copy as rawmidi name if not set */
1056		if (!*ump->core.name)
1057			strscpy(ump->core.name, ump->info.name,
1058				sizeof(ump->core.name));
1059		/* use serial number string as unique UMP product id */
1060		if (!*ump->info.product_id && dev->descriptor.iSerialNumber)
1061			usb_string(dev, dev->descriptor.iSerialNumber,
1062				   ump->info.product_id,
1063				   sizeof(ump->info.product_id));
1064	}
1065}
1066
1067/* create MIDI interface; fallback to MIDI 1.0 if needed */
1068int snd_usb_midi_v2_create(struct snd_usb_audio *chip,
1069			   struct usb_interface *iface,
1070			   const struct snd_usb_audio_quirk *quirk,
1071			   unsigned int usb_id)
1072{
1073	struct snd_usb_midi2_interface *umidi;
1074	struct usb_host_interface *hostif;
1075	int err;
1076
1077	usb_audio_dbg(chip, "Parsing interface %d...\n",
1078		      iface->altsetting[0].desc.bInterfaceNumber);
1079
1080	/* fallback to MIDI 1.0? */
1081	if (!midi2_enable) {
1082		usb_audio_info(chip, "Falling back to MIDI 1.0 by module option\n");
1083		goto fallback_to_midi1;
1084	}
1085	if ((quirk && quirk->type != QUIRK_MIDI_STANDARD_INTERFACE) ||
1086	    iface->num_altsetting < 2) {
1087		usb_audio_info(chip, "Quirk or no altset; falling back to MIDI 1.0\n");
1088		goto fallback_to_midi1;
1089	}
1090	hostif = &iface->altsetting[1];
1091	if (!is_midi2_altset(hostif)) {
1092		usb_audio_info(chip, "No MIDI 2.0 at altset 1, falling back to MIDI 1.0\n");
1093		goto fallback_to_midi1;
1094	}
1095	if (!hostif->desc.bNumEndpoints) {
1096		usb_audio_info(chip, "No endpoint at altset 1, falling back to MIDI 1.0\n");
1097		goto fallback_to_midi1;
1098	}
1099
1100	usb_audio_dbg(chip, "Creating a MIDI 2.0 instance for %d:%d\n",
1101		      hostif->desc.bInterfaceNumber,
1102		      hostif->desc.bAlternateSetting);
1103
1104	umidi = kzalloc(sizeof(*umidi), GFP_KERNEL);
1105	if (!umidi)
1106		return -ENOMEM;
1107	umidi->chip = chip;
1108	umidi->iface = iface;
1109	umidi->hostif = hostif;
1110	INIT_LIST_HEAD(&umidi->rawmidi_list);
1111	INIT_LIST_HEAD(&umidi->ep_list);
1112
1113	list_add_tail(&umidi->list, &chip->midi_v2_list);
1114
1115	err = set_altset(umidi);
1116	if (err < 0) {
1117		usb_audio_err(chip, "Failed to set altset\n");
1118		goto error;
1119	}
1120
1121	/* assume only altset 1 corresponding to MIDI 2.0 interface */
1122	err = parse_midi_2_0(umidi);
1123	if (err < 0) {
1124		usb_audio_err(chip, "Failed to parse MIDI 2.0 interface\n");
1125		goto error;
1126	}
1127
1128	/* parse USB group terminal blocks */
1129	err = parse_group_terminal_blocks(umidi);
1130	if (err < 0) {
1131		usb_audio_err(chip, "Failed to parse GTB\n");
1132		goto error;
1133	}
1134
1135	err = start_input_streams(umidi);
1136	if (err < 0) {
1137		usb_audio_err(chip, "Failed to start input streams\n");
1138		goto error;
1139	}
1140
1141	if (midi2_ump_probe) {
1142		err = parse_ump_endpoints(umidi);
1143		if (err < 0) {
1144			usb_audio_err(chip, "Failed to parse UMP endpoint\n");
1145			goto error;
1146		}
1147	}
1148
1149	err = create_blocks_from_gtb(umidi);
1150	if (err < 0) {
1151		usb_audio_err(chip, "Failed to create GTB blocks\n");
1152		goto error;
1153	}
1154
1155	set_fallback_rawmidi_names(umidi);
1156
1157	err = attach_legacy_rawmidi(umidi);
1158	if (err < 0) {
1159		usb_audio_err(chip, "Failed to create legacy rawmidi\n");
1160		goto error;
1161	}
1162
1163	return 0;
1164
1165 error:
1166	snd_usb_midi_v2_free(umidi);
1167	return err;
1168
1169 fallback_to_midi1:
1170	return __snd_usbmidi_create(chip->card, iface, &chip->midi_list,
1171				    quirk, usb_id, &chip->num_rawmidis);
1172}
1173
1174static void suspend_midi2_endpoint(struct snd_usb_midi2_endpoint *ep)
1175{
1176	kill_midi_urbs(ep, true);
1177	drain_urb_queue(ep);
1178}
1179
1180void snd_usb_midi_v2_suspend_all(struct snd_usb_audio *chip)
1181{
1182	struct snd_usb_midi2_interface *umidi;
1183	struct snd_usb_midi2_endpoint *ep;
1184
1185	list_for_each_entry(umidi, &chip->midi_v2_list, list) {
1186		list_for_each_entry(ep, &umidi->ep_list, list)
1187			suspend_midi2_endpoint(ep);
1188	}
1189}
1190
1191static void resume_midi2_endpoint(struct snd_usb_midi2_endpoint *ep)
1192{
1193	ep->running = ep->suspended;
1194	if (ep->direction == STR_IN)
1195		submit_io_urbs(ep);
1196	/* FIXME: does it all? */
1197}
1198
1199void snd_usb_midi_v2_resume_all(struct snd_usb_audio *chip)
1200{
1201	struct snd_usb_midi2_interface *umidi;
1202	struct snd_usb_midi2_endpoint *ep;
1203
1204	list_for_each_entry(umidi, &chip->midi_v2_list, list) {
1205		set_altset(umidi);
1206		list_for_each_entry(ep, &umidi->ep_list, list)
1207			resume_midi2_endpoint(ep);
1208	}
1209}
1210
1211void snd_usb_midi_v2_disconnect_all(struct snd_usb_audio *chip)
1212{
1213	struct snd_usb_midi2_interface *umidi;
1214	struct snd_usb_midi2_endpoint *ep;
1215
1216	list_for_each_entry(umidi, &chip->midi_v2_list, list) {
1217		umidi->disconnected = 1;
1218		list_for_each_entry(ep, &umidi->ep_list, list) {
1219			ep->disconnected = 1;
1220			kill_midi_urbs(ep, false);
1221			drain_urb_queue(ep);
1222		}
1223	}
1224}
1225
1226/* release the MIDI instance */
1227void snd_usb_midi_v2_free_all(struct snd_usb_audio *chip)
1228{
1229	struct snd_usb_midi2_interface *umidi, *next;
1230
1231	list_for_each_entry_safe(umidi, next, &chip->midi_v2_list, list)
1232		snd_usb_midi_v2_free(umidi);
1233}