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