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 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 */ 173 static 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 180 static 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 */ 186 static 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 */ 211 static 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 */ 223 static 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 atomic_set(&ep->suspended, atomic_read(&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 */ 240 static 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 */ 253 static 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() */ 275 static 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 327 static struct snd_usb_midi2_endpoint * 328 ump_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 */ 336 static 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 */ 356 static 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 */ 368 static 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 */ 379 static 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 */ 387 static 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 416 static 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 */ 424 static 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_obj(*ep); 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() */ 470 static void free_midi2_endpoint(struct snd_usb_midi2_endpoint *ep) 471 { 472 list_del(&ep->list); 473 if (!ep->disconnected) { 474 ep->disconnected = 1; 475 kill_midi_urbs(ep, false); 476 drain_urb_queue(ep); 477 } 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 int length = ms_ep->bLength; 505 506 if (!length || length > extralen) 507 break; 508 509 if (length > 3 && 510 ms_ep->bDescriptorType == USB_DT_CS_ENDPOINT && 511 ms_ep->bDescriptorSubtype == subtype) 512 return ms_ep; 513 extralen -= length; 514 extra += length; 515 } 516 return NULL; 517 } 518 519 /* get the full group terminal block descriptors and return the size */ 520 static int get_group_terminal_block_descs(struct snd_usb_midi2_interface *umidi) 521 { 522 struct usb_host_interface *hostif = umidi->hostif; 523 struct usb_device *dev = umidi->chip->dev; 524 struct usb_ms20_gr_trm_block_header_descriptor header = { 0 }; 525 unsigned char *data; 526 int err, size; 527 528 err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), 529 USB_REQ_GET_DESCRIPTOR, 530 USB_RECIP_INTERFACE | USB_TYPE_STANDARD | USB_DIR_IN, 531 USB_DT_CS_GR_TRM_BLOCK << 8 | hostif->desc.bAlternateSetting, 532 hostif->desc.bInterfaceNumber, 533 &header, sizeof(header)); 534 if (err < 0) 535 return err; 536 size = __le16_to_cpu(header.wTotalLength); 537 if (!size) { 538 dev_err(&dev->dev, "Failed to get GTB descriptors for %d:%d\n", 539 hostif->desc.bInterfaceNumber, hostif->desc.bAlternateSetting); 540 return -EINVAL; 541 } 542 543 data = kzalloc(size, GFP_KERNEL); 544 if (!data) 545 return -ENOMEM; 546 547 err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), 548 USB_REQ_GET_DESCRIPTOR, 549 USB_RECIP_INTERFACE | USB_TYPE_STANDARD | USB_DIR_IN, 550 USB_DT_CS_GR_TRM_BLOCK << 8 | hostif->desc.bAlternateSetting, 551 hostif->desc.bInterfaceNumber, data, size); 552 if (err < 0) { 553 kfree(data); 554 return err; 555 } 556 557 umidi->blk_descs = data; 558 umidi->blk_desc_size = size; 559 return 0; 560 } 561 562 /* find the corresponding group terminal block descriptor */ 563 static const struct usb_ms20_gr_trm_block_descriptor * 564 find_group_terminal_block(struct snd_usb_midi2_interface *umidi, int id) 565 { 566 const unsigned char *data = umidi->blk_descs; 567 int size = umidi->blk_desc_size; 568 const struct usb_ms20_gr_trm_block_descriptor *desc; 569 570 size -= sizeof(struct usb_ms20_gr_trm_block_header_descriptor); 571 data += sizeof(struct usb_ms20_gr_trm_block_header_descriptor); 572 while (size > 0 && *data && *data <= size) { 573 desc = (const struct usb_ms20_gr_trm_block_descriptor *)data; 574 if (desc->bLength >= sizeof(*desc) && 575 desc->bDescriptorType == USB_DT_CS_GR_TRM_BLOCK && 576 desc->bDescriptorSubtype == USB_MS_GR_TRM_BLOCK && 577 desc->bGrpTrmBlkID == id) 578 return desc; 579 size -= *data; 580 data += *data; 581 } 582 583 return NULL; 584 } 585 586 /* fill up the information from GTB */ 587 static int parse_group_terminal_block(struct snd_usb_midi2_ump *rmidi, 588 const struct usb_ms20_gr_trm_block_descriptor *desc) 589 { 590 struct snd_ump_endpoint *ump = rmidi->ump; 591 unsigned int protocol, protocol_caps; 592 593 /* set default protocol */ 594 switch (desc->bMIDIProtocol) { 595 case USB_MS_MIDI_PROTO_1_0_64: 596 case USB_MS_MIDI_PROTO_1_0_64_JRTS: 597 case USB_MS_MIDI_PROTO_1_0_128: 598 case USB_MS_MIDI_PROTO_1_0_128_JRTS: 599 protocol = SNDRV_UMP_EP_INFO_PROTO_MIDI1; 600 break; 601 case USB_MS_MIDI_PROTO_2_0: 602 case USB_MS_MIDI_PROTO_2_0_JRTS: 603 protocol = SNDRV_UMP_EP_INFO_PROTO_MIDI2; 604 break; 605 default: 606 return 0; 607 } 608 609 if (!ump->info.protocol) 610 ump->info.protocol = protocol; 611 612 protocol_caps = protocol; 613 switch (desc->bMIDIProtocol) { 614 case USB_MS_MIDI_PROTO_1_0_64_JRTS: 615 case USB_MS_MIDI_PROTO_1_0_128_JRTS: 616 case USB_MS_MIDI_PROTO_2_0_JRTS: 617 protocol_caps |= SNDRV_UMP_EP_INFO_PROTO_JRTS_TX | 618 SNDRV_UMP_EP_INFO_PROTO_JRTS_RX; 619 break; 620 } 621 622 ump->info.protocol_caps |= protocol_caps; 623 return 0; 624 } 625 626 /* allocate and parse for each assigned group terminal block */ 627 static int parse_group_terminal_blocks(struct snd_usb_midi2_interface *umidi) 628 { 629 struct snd_usb_midi2_ump *rmidi; 630 const struct usb_ms20_gr_trm_block_descriptor *desc; 631 int err; 632 633 err = get_group_terminal_block_descs(umidi); 634 if (err < 0) 635 return err; 636 if (!umidi->blk_descs) 637 return 0; 638 639 list_for_each_entry(rmidi, &umidi->rawmidi_list, list) { 640 desc = find_group_terminal_block(umidi, rmidi->usb_block_id); 641 if (!desc) 642 continue; 643 err = parse_group_terminal_block(rmidi, desc); 644 if (err < 0) 645 return err; 646 } 647 648 return 0; 649 } 650 651 /* parse endpoints included in the given interface and create objects */ 652 static int parse_midi_2_0_endpoints(struct snd_usb_midi2_interface *umidi) 653 { 654 struct usb_host_interface *hostif = umidi->hostif; 655 struct usb_host_endpoint *hostep; 656 struct usb_ms20_endpoint_descriptor *ms_ep; 657 int i, err; 658 659 for (i = 0; i < hostif->desc.bNumEndpoints; i++) { 660 hostep = &hostif->endpoint[i]; 661 if (!usb_endpoint_xfer_bulk(&hostep->desc) && 662 !usb_endpoint_xfer_int(&hostep->desc)) 663 continue; 664 ms_ep = find_usb_ms_endpoint_descriptor(hostep, USB_MS_GENERAL_2_0); 665 if (!ms_ep) 666 continue; 667 if (ms_ep->bLength <= sizeof(*ms_ep)) 668 continue; 669 if (!ms_ep->bNumGrpTrmBlock) 670 continue; 671 if (ms_ep->bLength < sizeof(*ms_ep) + ms_ep->bNumGrpTrmBlock) 672 continue; 673 err = create_midi2_endpoint(umidi, hostep, ms_ep); 674 if (err < 0) 675 return err; 676 } 677 return 0; 678 } 679 680 static void free_all_midi2_umps(struct snd_usb_midi2_interface *umidi) 681 { 682 struct snd_usb_midi2_ump *rmidi; 683 684 while (!list_empty(&umidi->rawmidi_list)) { 685 rmidi = list_first_entry(&umidi->rawmidi_list, 686 struct snd_usb_midi2_ump, list); 687 list_del(&rmidi->list); 688 kfree(rmidi); 689 } 690 } 691 692 static int create_midi2_ump(struct snd_usb_midi2_interface *umidi, 693 struct snd_usb_midi2_endpoint *ep_in, 694 struct snd_usb_midi2_endpoint *ep_out, 695 int blk_id) 696 { 697 struct snd_usb_midi2_ump *rmidi; 698 struct snd_ump_endpoint *ump; 699 int input, output; 700 char idstr[16]; 701 int err; 702 703 rmidi = kzalloc_obj(*rmidi); 704 if (!rmidi) 705 return -ENOMEM; 706 INIT_LIST_HEAD(&rmidi->list); 707 rmidi->dev = umidi->chip->dev; 708 rmidi->umidi = umidi; 709 rmidi->usb_block_id = blk_id; 710 711 rmidi->index = umidi->chip->num_rawmidis; 712 snprintf(idstr, sizeof(idstr), "UMP %d", rmidi->index); 713 input = ep_in ? 1 : 0; 714 output = ep_out ? 1 : 0; 715 err = snd_ump_endpoint_new(umidi->chip->card, idstr, rmidi->index, 716 output, input, &ump); 717 if (err < 0) { 718 usb_audio_dbg(umidi->chip, "Failed to create a UMP object\n"); 719 kfree(rmidi); 720 return err; 721 } 722 723 rmidi->ump = ump; 724 umidi->chip->num_rawmidis++; 725 726 ump->private_data = rmidi; 727 ump->ops = &snd_usb_midi_v2_ump_ops; 728 729 rmidi->eps[STR_IN] = ep_in; 730 rmidi->eps[STR_OUT] = ep_out; 731 if (ep_in) { 732 ep_in->pair = ep_out; 733 ep_in->rmidi = rmidi; 734 ep_in->ump = ump; 735 } 736 if (ep_out) { 737 ep_out->pair = ep_in; 738 ep_out->rmidi = rmidi; 739 ep_out->ump = ump; 740 } 741 742 list_add_tail(&rmidi->list, &umidi->rawmidi_list); 743 return 0; 744 } 745 746 /* find the UMP EP with the given USB block id */ 747 static struct snd_usb_midi2_ump * 748 find_midi2_ump(struct snd_usb_midi2_interface *umidi, int blk_id) 749 { 750 struct snd_usb_midi2_ump *rmidi; 751 752 list_for_each_entry(rmidi, &umidi->rawmidi_list, list) { 753 if (rmidi->usb_block_id == blk_id) 754 return rmidi; 755 } 756 return NULL; 757 } 758 759 /* look for the matching output endpoint and create UMP object if found */ 760 static int find_matching_ep_partner(struct snd_usb_midi2_interface *umidi, 761 struct snd_usb_midi2_endpoint *ep, 762 int blk_id) 763 { 764 struct snd_usb_midi2_endpoint *pair_ep; 765 int blk; 766 767 usb_audio_dbg(umidi->chip, "Looking for a pair for EP-in 0x%02x\n", 768 ep->endpoint); 769 list_for_each_entry(pair_ep, &umidi->ep_list, list) { 770 if (pair_ep->direction != STR_OUT) 771 continue; 772 if (pair_ep->pair) 773 continue; /* already paired */ 774 for (blk = 0; blk < pair_ep->ms_ep->bNumGrpTrmBlock; blk++) { 775 if (pair_ep->ms_ep->baAssoGrpTrmBlkID[blk] == blk_id) { 776 usb_audio_dbg(umidi->chip, 777 "Found a match with EP-out 0x%02x blk %d\n", 778 pair_ep->endpoint, blk); 779 return create_midi2_ump(umidi, ep, pair_ep, blk_id); 780 } 781 } 782 } 783 return 0; 784 } 785 786 /* Call UMP helper to parse UMP endpoints; 787 * this needs to be called after starting the input streams for bi-directional 788 * communications 789 */ 790 static int parse_ump_endpoints(struct snd_usb_midi2_interface *umidi) 791 { 792 struct snd_usb_midi2_ump *rmidi; 793 int err; 794 795 list_for_each_entry(rmidi, &umidi->rawmidi_list, list) { 796 if (!rmidi->ump || 797 !(rmidi->ump->core.info_flags & SNDRV_RAWMIDI_INFO_DUPLEX)) 798 continue; 799 err = snd_ump_parse_endpoint(rmidi->ump); 800 if (!err) { 801 rmidi->ump_parsed = true; 802 } else { 803 if (err == -ENOMEM) 804 return err; 805 /* fall back to GTB later */ 806 } 807 } 808 return 0; 809 } 810 811 /* create a UMP block from a GTB entry */ 812 static int create_gtb_block(struct snd_usb_midi2_ump *rmidi, int dir, int blk) 813 { 814 struct snd_usb_midi2_interface *umidi = rmidi->umidi; 815 const struct usb_ms20_gr_trm_block_descriptor *desc; 816 struct snd_ump_block *fb; 817 int type, err; 818 819 desc = find_group_terminal_block(umidi, blk); 820 if (!desc) 821 return 0; 822 823 usb_audio_dbg(umidi->chip, 824 "GTB %d: type=%d, group=%d/%d, protocol=%d, in bw=%d, out bw=%d\n", 825 blk, desc->bGrpTrmBlkType, desc->nGroupTrm, 826 desc->nNumGroupTrm, desc->bMIDIProtocol, 827 __le16_to_cpu(desc->wMaxInputBandwidth), 828 __le16_to_cpu(desc->wMaxOutputBandwidth)); 829 830 /* assign the direction */ 831 switch (desc->bGrpTrmBlkType) { 832 case USB_MS_GR_TRM_BLOCK_TYPE_BIDIRECTIONAL: 833 type = SNDRV_UMP_DIR_BIDIRECTION; 834 break; 835 case USB_MS_GR_TRM_BLOCK_TYPE_INPUT_ONLY: 836 type = SNDRV_UMP_DIR_INPUT; 837 break; 838 case USB_MS_GR_TRM_BLOCK_TYPE_OUTPUT_ONLY: 839 type = SNDRV_UMP_DIR_OUTPUT; 840 break; 841 default: 842 usb_audio_dbg(umidi->chip, "Unsupported GTB type %d\n", 843 desc->bGrpTrmBlkType); 844 return 0; /* unsupported */ 845 } 846 847 /* guess work: set blk-1 as the (0-based) block ID */ 848 err = snd_ump_block_new(rmidi->ump, blk - 1, type, 849 desc->nGroupTrm, desc->nNumGroupTrm, 850 &fb); 851 if (err == -EBUSY) 852 return 0; /* already present */ 853 else if (err) 854 return err; 855 856 if (desc->iBlockItem) 857 usb_string(rmidi->dev, desc->iBlockItem, 858 fb->info.name, sizeof(fb->info.name)); 859 860 if (__le16_to_cpu(desc->wMaxInputBandwidth) == 1 || 861 __le16_to_cpu(desc->wMaxOutputBandwidth) == 1) 862 fb->info.flags |= SNDRV_UMP_BLOCK_IS_MIDI1 | 863 SNDRV_UMP_BLOCK_IS_LOWSPEED; 864 865 /* if MIDI 2.0 protocol is supported and yet the GTB shows MIDI 1.0, 866 * treat it as a MIDI 1.0-specific block 867 */ 868 if (rmidi->ump->info.protocol_caps & SNDRV_UMP_EP_INFO_PROTO_MIDI2) { 869 switch (desc->bMIDIProtocol) { 870 case USB_MS_MIDI_PROTO_1_0_64: 871 case USB_MS_MIDI_PROTO_1_0_64_JRTS: 872 case USB_MS_MIDI_PROTO_1_0_128: 873 case USB_MS_MIDI_PROTO_1_0_128_JRTS: 874 fb->info.flags |= SNDRV_UMP_BLOCK_IS_MIDI1; 875 break; 876 } 877 } 878 879 snd_ump_update_group_attrs(rmidi->ump); 880 881 usb_audio_dbg(umidi->chip, 882 "Created a UMP block %d from GTB, name=%s, flags=0x%x\n", 883 blk, fb->info.name, fb->info.flags); 884 return 0; 885 } 886 887 /* Create UMP blocks for each UMP EP */ 888 static int create_blocks_from_gtb(struct snd_usb_midi2_interface *umidi) 889 { 890 struct snd_usb_midi2_ump *rmidi; 891 int i, blk, err, dir; 892 893 list_for_each_entry(rmidi, &umidi->rawmidi_list, list) { 894 if (!rmidi->ump) 895 continue; 896 /* Blocks have been already created? */ 897 if (rmidi->ump_parsed || rmidi->ump->info.num_blocks) 898 continue; 899 /* GTB is static-only */ 900 rmidi->ump->info.flags |= SNDRV_UMP_EP_INFO_STATIC_BLOCKS; 901 /* loop over GTBs */ 902 for (dir = 0; dir < 2; dir++) { 903 if (!rmidi->eps[dir]) 904 continue; 905 for (i = 0; i < rmidi->eps[dir]->ms_ep->bNumGrpTrmBlock; i++) { 906 blk = rmidi->eps[dir]->ms_ep->baAssoGrpTrmBlkID[i]; 907 err = create_gtb_block(rmidi, dir, blk); 908 if (err < 0) 909 return err; 910 } 911 } 912 } 913 914 return 0; 915 } 916 917 /* attach legacy rawmidis */ 918 static int attach_legacy_rawmidi(struct snd_usb_midi2_interface *umidi) 919 { 920 #if IS_ENABLED(CONFIG_SND_UMP_LEGACY_RAWMIDI) 921 struct snd_usb_midi2_ump *rmidi; 922 int err; 923 924 list_for_each_entry(rmidi, &umidi->rawmidi_list, list) { 925 err = snd_ump_attach_legacy_rawmidi(rmidi->ump, 926 "Legacy MIDI", 927 umidi->chip->num_rawmidis); 928 if (err < 0) 929 return err; 930 umidi->chip->num_rawmidis++; 931 } 932 #endif 933 return 0; 934 } 935 936 static void snd_usb_midi_v2_free(struct snd_usb_midi2_interface *umidi) 937 { 938 free_all_midi2_endpoints(umidi); 939 free_all_midi2_umps(umidi); 940 list_del(&umidi->list); 941 kfree(umidi->blk_descs); 942 kfree(umidi); 943 } 944 945 /* parse the interface for MIDI 2.0 */ 946 static int parse_midi_2_0(struct snd_usb_midi2_interface *umidi) 947 { 948 struct snd_usb_midi2_endpoint *ep; 949 int blk, id, err; 950 951 /* First, create an object for each USB MIDI Endpoint */ 952 err = parse_midi_2_0_endpoints(umidi); 953 if (err < 0) 954 return err; 955 if (list_empty(&umidi->ep_list)) { 956 usb_audio_warn(umidi->chip, "No MIDI endpoints found\n"); 957 return -ENODEV; 958 } 959 960 /* 961 * Next, look for EP I/O pairs that are found in group terminal blocks 962 * A UMP object is created for each EP I/O pair as bidirecitonal 963 * UMP EP 964 */ 965 list_for_each_entry(ep, &umidi->ep_list, list) { 966 /* only input in this loop; output is matched in find_midi_ump() */ 967 if (ep->direction != STR_IN) 968 continue; 969 for (blk = 0; blk < ep->ms_ep->bNumGrpTrmBlock; blk++) { 970 id = ep->ms_ep->baAssoGrpTrmBlkID[blk]; 971 err = find_matching_ep_partner(umidi, ep, id); 972 if (err < 0) 973 return err; 974 } 975 } 976 977 /* 978 * For the remaining EPs, treat as singles, create a UMP object with 979 * unidirectional EP 980 */ 981 list_for_each_entry(ep, &umidi->ep_list, list) { 982 if (ep->rmidi) 983 continue; /* already paired */ 984 for (blk = 0; blk < ep->ms_ep->bNumGrpTrmBlock; blk++) { 985 id = ep->ms_ep->baAssoGrpTrmBlkID[blk]; 986 if (find_midi2_ump(umidi, id)) 987 continue; 988 usb_audio_dbg(umidi->chip, 989 "Creating a unidirection UMP for EP=0x%02x, blk=%d\n", 990 ep->endpoint, id); 991 if (ep->direction == STR_IN) 992 err = create_midi2_ump(umidi, ep, NULL, id); 993 else 994 err = create_midi2_ump(umidi, NULL, ep, id); 995 if (err < 0) 996 return err; 997 break; 998 } 999 } 1000 1001 return 0; 1002 } 1003 1004 /* is the given interface for MIDI 2.0? */ 1005 static bool is_midi2_altset(struct usb_host_interface *hostif) 1006 { 1007 struct usb_ms_header_descriptor *ms_header = 1008 (struct usb_ms_header_descriptor *)hostif->extra; 1009 1010 if (hostif->extralen < 7 || 1011 ms_header->bLength < 7 || 1012 ms_header->bDescriptorType != USB_DT_CS_INTERFACE || 1013 ms_header->bDescriptorSubtype != UAC_HEADER) 1014 return false; 1015 1016 return le16_to_cpu(ms_header->bcdMSC) == USB_MS_REV_MIDI_2_0; 1017 } 1018 1019 /* change the altsetting */ 1020 static int set_altset(struct snd_usb_midi2_interface *umidi) 1021 { 1022 usb_audio_dbg(umidi->chip, "Setting host iface %d:%d\n", 1023 umidi->hostif->desc.bInterfaceNumber, 1024 umidi->hostif->desc.bAlternateSetting); 1025 return usb_set_interface(umidi->chip->dev, 1026 umidi->hostif->desc.bInterfaceNumber, 1027 umidi->hostif->desc.bAlternateSetting); 1028 } 1029 1030 /* fill UMP Endpoint name string from USB descriptor */ 1031 static void fill_ump_ep_name(struct snd_ump_endpoint *ump, 1032 struct usb_device *dev, int id) 1033 { 1034 int len; 1035 1036 usb_string(dev, id, ump->info.name, sizeof(ump->info.name)); 1037 1038 /* trim superfluous "MIDI" suffix */ 1039 len = strlen(ump->info.name); 1040 if (len > 5 && !strcmp(ump->info.name + len - 5, " MIDI")) 1041 ump->info.name[len - 5] = 0; 1042 } 1043 1044 /* fill the fallback name string for each rawmidi instance */ 1045 static void set_fallback_rawmidi_names(struct snd_usb_midi2_interface *umidi) 1046 { 1047 struct usb_device *dev = umidi->chip->dev; 1048 struct snd_usb_midi2_ump *rmidi; 1049 struct snd_ump_endpoint *ump; 1050 1051 list_for_each_entry(rmidi, &umidi->rawmidi_list, list) { 1052 ump = rmidi->ump; 1053 /* fill UMP EP name from USB descriptors */ 1054 if (!*ump->info.name && umidi->hostif->desc.iInterface) 1055 fill_ump_ep_name(ump, dev, umidi->hostif->desc.iInterface); 1056 else if (!*ump->info.name && dev->descriptor.iProduct) 1057 fill_ump_ep_name(ump, dev, dev->descriptor.iProduct); 1058 /* fill fallback name */ 1059 if (!*ump->info.name) 1060 scnprintf(ump->info.name, sizeof(ump->info.name), 1061 "USB MIDI %d", rmidi->index); 1062 /* copy as rawmidi name if not set */ 1063 if (!*ump->core.name) 1064 strscpy(ump->core.name, ump->info.name, 1065 sizeof(ump->core.name)); 1066 /* use serial number string as unique UMP product id */ 1067 if (!*ump->info.product_id && dev->serial && *dev->serial) 1068 strscpy(ump->info.product_id, dev->serial); 1069 } 1070 } 1071 1072 /* create MIDI interface; fallback to MIDI 1.0 if needed */ 1073 int snd_usb_midi_v2_create(struct snd_usb_audio *chip, 1074 struct usb_interface *iface, 1075 const struct snd_usb_audio_quirk *quirk, 1076 unsigned int usb_id) 1077 { 1078 struct snd_usb_midi2_interface *umidi; 1079 struct usb_host_interface *hostif; 1080 int err; 1081 1082 usb_audio_dbg(chip, "Parsing interface %d...\n", 1083 iface->altsetting[0].desc.bInterfaceNumber); 1084 1085 /* fallback to MIDI 1.0? */ 1086 if (!midi2_enable) { 1087 usb_audio_info(chip, "Falling back to MIDI 1.0 by module option\n"); 1088 goto fallback_to_midi1; 1089 } 1090 if ((quirk && quirk->type != QUIRK_MIDI_STANDARD_INTERFACE) || 1091 iface->num_altsetting < 2) { 1092 usb_audio_info(chip, "Quirk or no altset; falling back to MIDI 1.0\n"); 1093 goto fallback_to_midi1; 1094 } 1095 hostif = &iface->altsetting[1]; 1096 if (!is_midi2_altset(hostif)) { 1097 usb_audio_info(chip, "No MIDI 2.0 at altset 1, falling back to MIDI 1.0\n"); 1098 goto fallback_to_midi1; 1099 } 1100 if (!hostif->desc.bNumEndpoints) { 1101 usb_audio_info(chip, "No endpoint at altset 1, falling back to MIDI 1.0\n"); 1102 goto fallback_to_midi1; 1103 } 1104 1105 usb_audio_dbg(chip, "Creating a MIDI 2.0 instance for %d:%d\n", 1106 hostif->desc.bInterfaceNumber, 1107 hostif->desc.bAlternateSetting); 1108 1109 umidi = kzalloc_obj(*umidi); 1110 if (!umidi) 1111 return -ENOMEM; 1112 umidi->chip = chip; 1113 umidi->iface = iface; 1114 umidi->hostif = hostif; 1115 INIT_LIST_HEAD(&umidi->rawmidi_list); 1116 INIT_LIST_HEAD(&umidi->ep_list); 1117 1118 list_add_tail(&umidi->list, &chip->midi_v2_list); 1119 1120 err = set_altset(umidi); 1121 if (err < 0) { 1122 usb_audio_err(chip, "Failed to set altset\n"); 1123 goto error; 1124 } 1125 1126 /* assume only altset 1 corresponding to MIDI 2.0 interface */ 1127 err = parse_midi_2_0(umidi); 1128 if (err < 0) { 1129 usb_audio_err(chip, "Failed to parse MIDI 2.0 interface\n"); 1130 goto error; 1131 } 1132 1133 /* parse USB group terminal blocks */ 1134 err = parse_group_terminal_blocks(umidi); 1135 if (err < 0) { 1136 usb_audio_err(chip, "Failed to parse GTB\n"); 1137 goto error; 1138 } 1139 1140 err = start_input_streams(umidi); 1141 if (err < 0) { 1142 usb_audio_err(chip, "Failed to start input streams\n"); 1143 goto error; 1144 } 1145 1146 if (midi2_ump_probe) { 1147 err = parse_ump_endpoints(umidi); 1148 if (err < 0) { 1149 usb_audio_err(chip, "Failed to parse UMP endpoint\n"); 1150 goto error; 1151 } 1152 } 1153 1154 err = create_blocks_from_gtb(umidi); 1155 if (err < 0) { 1156 usb_audio_err(chip, "Failed to create GTB blocks\n"); 1157 goto error; 1158 } 1159 1160 set_fallback_rawmidi_names(umidi); 1161 1162 err = attach_legacy_rawmidi(umidi); 1163 if (err < 0) { 1164 usb_audio_err(chip, "Failed to create legacy rawmidi\n"); 1165 goto error; 1166 } 1167 1168 return 0; 1169 1170 error: 1171 snd_usb_midi_v2_free(umidi); 1172 return err; 1173 1174 fallback_to_midi1: 1175 return __snd_usbmidi_create(chip->card, iface, &chip->midi_list, 1176 quirk, usb_id, &chip->num_rawmidis); 1177 } 1178 1179 static void suspend_midi2_endpoint(struct snd_usb_midi2_endpoint *ep) 1180 { 1181 kill_midi_urbs(ep, true); 1182 drain_urb_queue(ep); 1183 } 1184 1185 void snd_usb_midi_v2_suspend_all(struct snd_usb_audio *chip) 1186 { 1187 struct snd_usb_midi2_interface *umidi; 1188 struct snd_usb_midi2_endpoint *ep; 1189 1190 list_for_each_entry(umidi, &chip->midi_v2_list, list) { 1191 list_for_each_entry(ep, &umidi->ep_list, list) 1192 suspend_midi2_endpoint(ep); 1193 } 1194 } 1195 1196 static void resume_midi2_endpoint(struct snd_usb_midi2_endpoint *ep) 1197 { 1198 atomic_set(&ep->running, atomic_read(&ep->suspended)); 1199 atomic_set(&ep->suspended, 0); 1200 1201 if (ep->direction == STR_IN || atomic_read(&ep->running)) 1202 submit_io_urbs(ep); 1203 } 1204 1205 void snd_usb_midi_v2_resume_all(struct snd_usb_audio *chip) 1206 { 1207 struct snd_usb_midi2_interface *umidi; 1208 struct snd_usb_midi2_endpoint *ep; 1209 1210 list_for_each_entry(umidi, &chip->midi_v2_list, list) { 1211 set_altset(umidi); 1212 list_for_each_entry(ep, &umidi->ep_list, list) 1213 resume_midi2_endpoint(ep); 1214 } 1215 } 1216 1217 void snd_usb_midi_v2_disconnect_all(struct snd_usb_audio *chip) 1218 { 1219 struct snd_usb_midi2_interface *umidi; 1220 struct snd_usb_midi2_endpoint *ep; 1221 1222 list_for_each_entry(umidi, &chip->midi_v2_list, list) { 1223 umidi->disconnected = 1; 1224 list_for_each_entry(ep, &umidi->ep_list, list) { 1225 ep->disconnected = 1; 1226 kill_midi_urbs(ep, false); 1227 drain_urb_queue(ep); 1228 } 1229 } 1230 } 1231 1232 /* release the MIDI instance */ 1233 void snd_usb_midi_v2_free_all(struct snd_usb_audio *chip) 1234 { 1235 struct snd_usb_midi2_interface *umidi, *next; 1236 1237 list_for_each_entry_safe(umidi, next, &chip->midi_v2_list, list) 1238 snd_usb_midi_v2_free(umidi); 1239 } 1240