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