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