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