1/* 2 * f_midi.c -- USB MIDI class function driver 3 * 4 * Copyright (C) 2006 Thumtronics Pty Ltd. 5 * Developed for Thumtronics by Grey Innovation 6 * Ben Williamson <ben.williamson@greyinnovation.com> 7 * 8 * Rewritten for the composite framework 9 * Copyright (C) 2011 Daniel Mack <zonque@gmail.com> 10 * 11 * Based on drivers/usb/gadget/f_audio.c, 12 * Copyright (C) 2008 Bryan Wu <cooloney@kernel.org> 13 * Copyright (C) 2008 Analog Devices, Inc 14 * 15 * and drivers/usb/gadget/midi.c, 16 * Copyright (C) 2006 Thumtronics Pty Ltd. 17 * Ben Williamson <ben.williamson@greyinnovation.com> 18 * 19 * Licensed under the GPL-2 or later. 20 */ 21 22#include <linux/kernel.h> 23#include <linux/slab.h> 24#include <linux/utsname.h> 25#include <linux/device.h> 26 27#include <sound/core.h> 28#include <sound/initval.h> 29#include <sound/rawmidi.h> 30 31#include <linux/usb/ch9.h> 32#include <linux/usb/gadget.h> 33#include <linux/usb/audio.h> 34#include <linux/usb/midi.h> 35 36MODULE_AUTHOR("Ben Williamson"); 37MODULE_LICENSE("GPL v2"); 38 39static const char f_midi_shortname[] = "f_midi"; 40static const char f_midi_longname[] = "MIDI Gadget"; 41 42/* 43 * We can only handle 16 cables on one single endpoint, as cable numbers are 44 * stored in 4-bit fields. And as the interface currently only holds one 45 * single endpoint, this is the maximum number of ports we can allow. 46 */ 47#define MAX_PORTS 16 48 49/* 50 * This is a gadget, and the IN/OUT naming is from the host's perspective. 51 * USB -> OUT endpoint -> rawmidi 52 * USB <- IN endpoint <- rawmidi 53 */ 54struct gmidi_in_port { 55 struct f_midi *midi; 56 int active; 57 uint8_t cable; 58 uint8_t state; 59#define STATE_UNKNOWN 0 60#define STATE_1PARAM 1 61#define STATE_2PARAM_1 2 62#define STATE_2PARAM_2 3 63#define STATE_SYSEX_0 4 64#define STATE_SYSEX_1 5 65#define STATE_SYSEX_2 6 66 uint8_t data[2]; 67}; 68 69struct f_midi { 70 struct usb_function func; 71 struct usb_gadget *gadget; 72 struct usb_ep *in_ep, *out_ep; 73 struct snd_card *card; 74 struct snd_rawmidi *rmidi; 75 76 struct snd_rawmidi_substream *in_substream[MAX_PORTS]; 77 struct snd_rawmidi_substream *out_substream[MAX_PORTS]; 78 struct gmidi_in_port *in_port[MAX_PORTS]; 79 80 unsigned long out_triggered; 81 struct tasklet_struct tasklet; 82 unsigned int in_ports; 83 unsigned int out_ports; 84 int index; 85 char *id; 86 unsigned int buflen, qlen; 87}; 88 89static inline struct f_midi *func_to_midi(struct usb_function *f) 90{ 91 return container_of(f, struct f_midi, func); 92} 93 94static void f_midi_transmit(struct f_midi *midi, struct usb_request *req); 95 96DECLARE_UAC_AC_HEADER_DESCRIPTOR(1); 97DECLARE_USB_MIDI_OUT_JACK_DESCRIPTOR(1); 98DECLARE_USB_MS_ENDPOINT_DESCRIPTOR(16); 99 100/* B.3.1 Standard AC Interface Descriptor */ 101static struct usb_interface_descriptor ac_interface_desc __initdata = { 102 .bLength = USB_DT_INTERFACE_SIZE, 103 .bDescriptorType = USB_DT_INTERFACE, 104 /* .bInterfaceNumber = DYNAMIC */ 105 /* .bNumEndpoints = DYNAMIC */ 106 .bInterfaceClass = USB_CLASS_AUDIO, 107 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL, 108 /* .iInterface = DYNAMIC */ 109}; 110 111/* B.3.2 Class-Specific AC Interface Descriptor */ 112static struct uac1_ac_header_descriptor_1 ac_header_desc __initdata = { 113 .bLength = UAC_DT_AC_HEADER_SIZE(1), 114 .bDescriptorType = USB_DT_CS_INTERFACE, 115 .bDescriptorSubtype = USB_MS_HEADER, 116 .bcdADC = cpu_to_le16(0x0100), 117 .wTotalLength = cpu_to_le16(UAC_DT_AC_HEADER_SIZE(1)), 118 .bInCollection = 1, 119 /* .baInterfaceNr = DYNAMIC */ 120}; 121 122/* B.4.1 Standard MS Interface Descriptor */ 123static struct usb_interface_descriptor ms_interface_desc __initdata = { 124 .bLength = USB_DT_INTERFACE_SIZE, 125 .bDescriptorType = USB_DT_INTERFACE, 126 /* .bInterfaceNumber = DYNAMIC */ 127 .bNumEndpoints = 2, 128 .bInterfaceClass = USB_CLASS_AUDIO, 129 .bInterfaceSubClass = USB_SUBCLASS_MIDISTREAMING, 130 /* .iInterface = DYNAMIC */ 131}; 132 133/* B.4.2 Class-Specific MS Interface Descriptor */ 134static struct usb_ms_header_descriptor ms_header_desc __initdata = { 135 .bLength = USB_DT_MS_HEADER_SIZE, 136 .bDescriptorType = USB_DT_CS_INTERFACE, 137 .bDescriptorSubtype = USB_MS_HEADER, 138 .bcdMSC = cpu_to_le16(0x0100), 139 /* .wTotalLength = DYNAMIC */ 140}; 141 142/* B.5.1 Standard Bulk OUT Endpoint Descriptor */ 143static struct usb_endpoint_descriptor bulk_out_desc = { 144 .bLength = USB_DT_ENDPOINT_AUDIO_SIZE, 145 .bDescriptorType = USB_DT_ENDPOINT, 146 .bEndpointAddress = USB_DIR_OUT, 147 .bmAttributes = USB_ENDPOINT_XFER_BULK, 148}; 149 150/* B.5.2 Class-specific MS Bulk OUT Endpoint Descriptor */ 151static struct usb_ms_endpoint_descriptor_16 ms_out_desc = { 152 /* .bLength = DYNAMIC */ 153 .bDescriptorType = USB_DT_CS_ENDPOINT, 154 .bDescriptorSubtype = USB_MS_GENERAL, 155 /* .bNumEmbMIDIJack = DYNAMIC */ 156 /* .baAssocJackID = DYNAMIC */ 157}; 158 159/* B.6.1 Standard Bulk IN Endpoint Descriptor */ 160static struct usb_endpoint_descriptor bulk_in_desc = { 161 .bLength = USB_DT_ENDPOINT_AUDIO_SIZE, 162 .bDescriptorType = USB_DT_ENDPOINT, 163 .bEndpointAddress = USB_DIR_IN, 164 .bmAttributes = USB_ENDPOINT_XFER_BULK, 165}; 166 167/* B.6.2 Class-specific MS Bulk IN Endpoint Descriptor */ 168static struct usb_ms_endpoint_descriptor_16 ms_in_desc = { 169 /* .bLength = DYNAMIC */ 170 .bDescriptorType = USB_DT_CS_ENDPOINT, 171 .bDescriptorSubtype = USB_MS_GENERAL, 172 /* .bNumEmbMIDIJack = DYNAMIC */ 173 /* .baAssocJackID = DYNAMIC */ 174}; 175 176/* string IDs are assigned dynamically */ 177 178#define STRING_FUNC_IDX 0 179 180static struct usb_string midi_string_defs[] = { 181 [STRING_FUNC_IDX].s = "MIDI function", 182 { } /* end of list */ 183}; 184 185static struct usb_gadget_strings midi_stringtab = { 186 .language = 0x0409, /* en-us */ 187 .strings = midi_string_defs, 188}; 189 190static struct usb_gadget_strings *midi_strings[] = { 191 &midi_stringtab, 192 NULL, 193}; 194 195static struct usb_request *alloc_ep_req(struct usb_ep *ep, unsigned length) 196{ 197 struct usb_request *req; 198 199 req = usb_ep_alloc_request(ep, GFP_ATOMIC); 200 if (req) { 201 req->length = length; 202 req->buf = kmalloc(length, GFP_ATOMIC); 203 if (!req->buf) { 204 usb_ep_free_request(ep, req); 205 req = NULL; 206 } 207 } 208 return req; 209} 210 211static void free_ep_req(struct usb_ep *ep, struct usb_request *req) 212{ 213 kfree(req->buf); 214 usb_ep_free_request(ep, req); 215} 216 217static const uint8_t f_midi_cin_length[] = { 218 0, 0, 2, 3, 3, 1, 2, 3, 3, 3, 3, 3, 2, 2, 3, 1 219}; 220 221/* 222 * Receives a chunk of MIDI data. 223 */ 224static void f_midi_read_data(struct usb_ep *ep, int cable, 225 uint8_t *data, int length) 226{ 227 struct f_midi *midi = ep->driver_data; 228 struct snd_rawmidi_substream *substream = midi->out_substream[cable]; 229 230 if (!substream) 231 /* Nobody is listening - throw it on the floor. */ 232 return; 233 234 if (!test_bit(cable, &midi->out_triggered)) 235 return; 236 237 snd_rawmidi_receive(substream, data, length); 238} 239 240static void f_midi_handle_out_data(struct usb_ep *ep, struct usb_request *req) 241{ 242 unsigned int i; 243 u8 *buf = req->buf; 244 245 for (i = 0; i + 3 < req->actual; i += 4) 246 if (buf[i] != 0) { 247 int cable = buf[i] >> 4; 248 int length = f_midi_cin_length[buf[i] & 0x0f]; 249 f_midi_read_data(ep, cable, &buf[i + 1], length); 250 } 251} 252 253static void 254f_midi_complete(struct usb_ep *ep, struct usb_request *req) 255{ 256 struct f_midi *midi = ep->driver_data; 257 struct usb_composite_dev *cdev = midi->func.config->cdev; 258 int status = req->status; 259 260 switch (status) { 261 case 0: /* normal completion */ 262 if (ep == midi->out_ep) { 263 /* We received stuff. req is queued again, below */ 264 f_midi_handle_out_data(ep, req); 265 } else if (ep == midi->in_ep) { 266 /* Our transmit completed. See if there's more to go. 267 * f_midi_transmit eats req, don't queue it again. */ 268 f_midi_transmit(midi, req); 269 return; 270 } 271 break; 272 273 /* this endpoint is normally active while we're configured */ 274 case -ECONNABORTED: /* hardware forced ep reset */ 275 case -ECONNRESET: /* request dequeued */ 276 case -ESHUTDOWN: /* disconnect from host */ 277 VDBG(cdev, "%s gone (%d), %d/%d\n", ep->name, status, 278 req->actual, req->length); 279 if (ep == midi->out_ep) 280 f_midi_handle_out_data(ep, req); 281 282 free_ep_req(ep, req); 283 return; 284 285 case -EOVERFLOW: /* buffer overrun on read means that 286 * we didn't provide a big enough buffer. 287 */ 288 default: 289 DBG(cdev, "%s complete --> %d, %d/%d\n", ep->name, 290 status, req->actual, req->length); 291 break; 292 case -EREMOTEIO: /* short read */ 293 break; 294 } 295 296 status = usb_ep_queue(ep, req, GFP_ATOMIC); 297 if (status) { 298 ERROR(cdev, "kill %s: resubmit %d bytes --> %d\n", 299 ep->name, req->length, status); 300 usb_ep_set_halt(ep); 301 /* FIXME recover later ... somehow */ 302 } 303} 304 305static int f_midi_start_ep(struct f_midi *midi, 306 struct usb_function *f, 307 struct usb_ep *ep) 308{ 309 int err; 310 struct usb_composite_dev *cdev = f->config->cdev; 311 312 if (ep->driver_data) 313 usb_ep_disable(ep); 314 315 err = config_ep_by_speed(midi->gadget, f, ep); 316 if (err) { 317 ERROR(cdev, "can't configure %s: %d\n", ep->name, err); 318 return err; 319 } 320 321 err = usb_ep_enable(ep); 322 if (err) { 323 ERROR(cdev, "can't start %s: %d\n", ep->name, err); 324 return err; 325 } 326 327 ep->driver_data = midi; 328 329 return 0; 330} 331 332static int f_midi_set_alt(struct usb_function *f, unsigned intf, unsigned alt) 333{ 334 struct f_midi *midi = func_to_midi(f); 335 struct usb_composite_dev *cdev = f->config->cdev; 336 unsigned i; 337 int err; 338 339 err = f_midi_start_ep(midi, f, midi->in_ep); 340 if (err) 341 return err; 342 343 err = f_midi_start_ep(midi, f, midi->out_ep); 344 if (err) 345 return err; 346 347 if (midi->out_ep->driver_data) 348 usb_ep_disable(midi->out_ep); 349 350 err = config_ep_by_speed(midi->gadget, f, midi->out_ep); 351 if (err) { 352 ERROR(cdev, "can't configure %s: %d\n", 353 midi->out_ep->name, err); 354 return err; 355 } 356 357 err = usb_ep_enable(midi->out_ep); 358 if (err) { 359 ERROR(cdev, "can't start %s: %d\n", 360 midi->out_ep->name, err); 361 return err; 362 } 363 364 midi->out_ep->driver_data = midi; 365 366 /* allocate a bunch of read buffers and queue them all at once. */ 367 for (i = 0; i < midi->qlen && err == 0; i++) { 368 struct usb_request *req = 369 alloc_ep_req(midi->out_ep, midi->buflen); 370 if (req == NULL) 371 return -ENOMEM; 372 373 req->complete = f_midi_complete; 374 err = usb_ep_queue(midi->out_ep, req, GFP_ATOMIC); 375 if (err) { 376 ERROR(midi, "%s queue req: %d\n", 377 midi->out_ep->name, err); 378 } 379 } 380 381 return 0; 382} 383 384static void f_midi_disable(struct usb_function *f) 385{ 386 struct f_midi *midi = func_to_midi(f); 387 struct usb_composite_dev *cdev = f->config->cdev; 388 389 DBG(cdev, "disable\n"); 390 391 /* 392 * just disable endpoints, forcing completion of pending i/o. 393 * all our completion handlers free their requests in this case. 394 */ 395 usb_ep_disable(midi->in_ep); 396 usb_ep_disable(midi->out_ep); 397} 398 399static void f_midi_unbind(struct usb_configuration *c, struct usb_function *f) 400{ 401 struct usb_composite_dev *cdev = f->config->cdev; 402 struct f_midi *midi = func_to_midi(f); 403 struct snd_card *card; 404 405 DBG(cdev, "unbind\n"); 406 407 /* just to be sure */ 408 f_midi_disable(f); 409 410 card = midi->card; 411 midi->card = NULL; 412 if (card) 413 snd_card_free(card); 414 415 kfree(midi->id); 416 midi->id = NULL; 417 418 usb_free_descriptors(f->descriptors); 419 kfree(midi); 420} 421 422static int f_midi_snd_free(struct snd_device *device) 423{ 424 return 0; 425} 426 427static void f_midi_transmit_packet(struct usb_request *req, uint8_t p0, 428 uint8_t p1, uint8_t p2, uint8_t p3) 429{ 430 unsigned length = req->length; 431 u8 *buf = (u8 *)req->buf + length; 432 433 buf[0] = p0; 434 buf[1] = p1; 435 buf[2] = p2; 436 buf[3] = p3; 437 req->length = length + 4; 438} 439 440/* 441 * Converts MIDI commands to USB MIDI packets. 442 */ 443static void f_midi_transmit_byte(struct usb_request *req, 444 struct gmidi_in_port *port, uint8_t b) 445{ 446 uint8_t p0 = port->cable << 4; 447 448 if (b >= 0xf8) { 449 f_midi_transmit_packet(req, p0 | 0x0f, b, 0, 0); 450 } else if (b >= 0xf0) { 451 switch (b) { 452 case 0xf0: 453 port->data[0] = b; 454 port->state = STATE_SYSEX_1; 455 break; 456 case 0xf1: 457 case 0xf3: 458 port->data[0] = b; 459 port->state = STATE_1PARAM; 460 break; 461 case 0xf2: 462 port->data[0] = b; 463 port->state = STATE_2PARAM_1; 464 break; 465 case 0xf4: 466 case 0xf5: 467 port->state = STATE_UNKNOWN; 468 break; 469 case 0xf6: 470 f_midi_transmit_packet(req, p0 | 0x05, 0xf6, 0, 0); 471 port->state = STATE_UNKNOWN; 472 break; 473 case 0xf7: 474 switch (port->state) { 475 case STATE_SYSEX_0: 476 f_midi_transmit_packet(req, 477 p0 | 0x05, 0xf7, 0, 0); 478 break; 479 case STATE_SYSEX_1: 480 f_midi_transmit_packet(req, 481 p0 | 0x06, port->data[0], 0xf7, 0); 482 break; 483 case STATE_SYSEX_2: 484 f_midi_transmit_packet(req, 485 p0 | 0x07, port->data[0], 486 port->data[1], 0xf7); 487 break; 488 } 489 port->state = STATE_UNKNOWN; 490 break; 491 } 492 } else if (b >= 0x80) { 493 port->data[0] = b; 494 if (b >= 0xc0 && b <= 0xdf) 495 port->state = STATE_1PARAM; 496 else 497 port->state = STATE_2PARAM_1; 498 } else { /* b < 0x80 */ 499 switch (port->state) { 500 case STATE_1PARAM: 501 if (port->data[0] < 0xf0) { 502 p0 |= port->data[0] >> 4; 503 } else { 504 p0 |= 0x02; 505 port->state = STATE_UNKNOWN; 506 } 507 f_midi_transmit_packet(req, p0, port->data[0], b, 0); 508 break; 509 case STATE_2PARAM_1: 510 port->data[1] = b; 511 port->state = STATE_2PARAM_2; 512 break; 513 case STATE_2PARAM_2: 514 if (port->data[0] < 0xf0) { 515 p0 |= port->data[0] >> 4; 516 port->state = STATE_2PARAM_1; 517 } else { 518 p0 |= 0x03; 519 port->state = STATE_UNKNOWN; 520 } 521 f_midi_transmit_packet(req, 522 p0, port->data[0], port->data[1], b); 523 break; 524 case STATE_SYSEX_0: 525 port->data[0] = b; 526 port->state = STATE_SYSEX_1; 527 break; 528 case STATE_SYSEX_1: 529 port->data[1] = b; 530 port->state = STATE_SYSEX_2; 531 break; 532 case STATE_SYSEX_2: 533 f_midi_transmit_packet(req, 534 p0 | 0x04, port->data[0], port->data[1], b); 535 port->state = STATE_SYSEX_0; 536 break; 537 } 538 } 539} 540 541static void f_midi_transmit(struct f_midi *midi, struct usb_request *req) 542{ 543 struct usb_ep *ep = midi->in_ep; 544 int i; 545 546 if (!ep) 547 return; 548 549 if (!req) 550 req = alloc_ep_req(ep, midi->buflen); 551 552 if (!req) { 553 ERROR(midi, "gmidi_transmit: alloc_ep_request failed\n"); 554 return; 555 } 556 req->length = 0; 557 req->complete = f_midi_complete; 558 559 for (i = 0; i < MAX_PORTS; i++) { 560 struct gmidi_in_port *port = midi->in_port[i]; 561 struct snd_rawmidi_substream *substream = midi->in_substream[i]; 562 563 if (!port || !port->active || !substream) 564 continue; 565 566 while (req->length + 3 < midi->buflen) { 567 uint8_t b; 568 if (snd_rawmidi_transmit(substream, &b, 1) != 1) { 569 port->active = 0; 570 break; 571 } 572 f_midi_transmit_byte(req, port, b); 573 } 574 } 575 576 if (req->length > 0) 577 usb_ep_queue(ep, req, GFP_ATOMIC); 578 else 579 free_ep_req(ep, req); 580} 581 582static void f_midi_in_tasklet(unsigned long data) 583{ 584 struct f_midi *midi = (struct f_midi *) data; 585 f_midi_transmit(midi, NULL); 586} 587 588static int f_midi_in_open(struct snd_rawmidi_substream *substream) 589{ 590 struct f_midi *midi = substream->rmidi->private_data; 591 592 if (!midi->in_port[substream->number]) 593 return -EINVAL; 594 595 VDBG(midi, "%s()\n", __func__); 596 midi->in_substream[substream->number] = substream; 597 midi->in_port[substream->number]->state = STATE_UNKNOWN; 598 return 0; 599} 600 601static int f_midi_in_close(struct snd_rawmidi_substream *substream) 602{ 603 struct f_midi *midi = substream->rmidi->private_data; 604 605 VDBG(midi, "%s()\n", __func__); 606 return 0; 607} 608 609static void f_midi_in_trigger(struct snd_rawmidi_substream *substream, int up) 610{ 611 struct f_midi *midi = substream->rmidi->private_data; 612 613 if (!midi->in_port[substream->number]) 614 return; 615 616 VDBG(midi, "%s() %d\n", __func__, up); 617 midi->in_port[substream->number]->active = up; 618 if (up) 619 tasklet_hi_schedule(&midi->tasklet); 620} 621 622static int f_midi_out_open(struct snd_rawmidi_substream *substream) 623{ 624 struct f_midi *midi = substream->rmidi->private_data; 625 626 if (substream->number >= MAX_PORTS) 627 return -EINVAL; 628 629 VDBG(midi, "%s()\n", __func__); 630 midi->out_substream[substream->number] = substream; 631 return 0; 632} 633 634static int f_midi_out_close(struct snd_rawmidi_substream *substream) 635{ 636 struct f_midi *midi = substream->rmidi->private_data; 637 638 VDBG(midi, "%s()\n", __func__); 639 return 0; 640} 641 642static void f_midi_out_trigger(struct snd_rawmidi_substream *substream, int up) 643{ 644 struct f_midi *midi = substream->rmidi->private_data; 645 646 VDBG(midi, "%s()\n", __func__); 647 648 if (up) 649 set_bit(substream->number, &midi->out_triggered); 650 else 651 clear_bit(substream->number, &midi->out_triggered); 652} 653 654static struct snd_rawmidi_ops gmidi_in_ops = { 655 .open = f_midi_in_open, 656 .close = f_midi_in_close, 657 .trigger = f_midi_in_trigger, 658}; 659 660static struct snd_rawmidi_ops gmidi_out_ops = { 661 .open = f_midi_out_open, 662 .close = f_midi_out_close, 663 .trigger = f_midi_out_trigger 664}; 665 666/* register as a sound "card" */ 667static int f_midi_register_card(struct f_midi *midi) 668{ 669 struct snd_card *card; 670 struct snd_rawmidi *rmidi; 671 int err; 672 static struct snd_device_ops ops = { 673 .dev_free = f_midi_snd_free, 674 }; 675 676 err = snd_card_create(midi->index, midi->id, THIS_MODULE, 0, &card); 677 if (err < 0) { 678 ERROR(midi, "snd_card_create() failed\n"); 679 goto fail; 680 } 681 midi->card = card; 682 683 err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, midi, &ops); 684 if (err < 0) { 685 ERROR(midi, "snd_device_new() failed: error %d\n", err); 686 goto fail; 687 } 688 689 strcpy(card->driver, f_midi_longname); 690 strcpy(card->longname, f_midi_longname); 691 strcpy(card->shortname, f_midi_shortname); 692 693 /* Set up rawmidi */ 694 snd_component_add(card, "MIDI"); 695 err = snd_rawmidi_new(card, card->longname, 0, 696 midi->out_ports, midi->in_ports, &rmidi); 697 if (err < 0) { 698 ERROR(midi, "snd_rawmidi_new() failed: error %d\n", err); 699 goto fail; 700 } 701 midi->rmidi = rmidi; 702 strcpy(rmidi->name, card->shortname); 703 rmidi->info_flags = SNDRV_RAWMIDI_INFO_OUTPUT | 704 SNDRV_RAWMIDI_INFO_INPUT | 705 SNDRV_RAWMIDI_INFO_DUPLEX; 706 rmidi->private_data = midi; 707 708 /* 709 * Yes, rawmidi OUTPUT = USB IN, and rawmidi INPUT = USB OUT. 710 * It's an upside-down world being a gadget. 711 */ 712 snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT, &gmidi_in_ops); 713 snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT, &gmidi_out_ops); 714 715 snd_card_set_dev(card, &midi->gadget->dev); 716 717 /* register it - we're ready to go */ 718 err = snd_card_register(card); 719 if (err < 0) { 720 ERROR(midi, "snd_card_register() failed\n"); 721 goto fail; 722 } 723 724 VDBG(midi, "%s() finished ok\n", __func__); 725 return 0; 726 727fail: 728 if (midi->card) { 729 snd_card_free(midi->card); 730 midi->card = NULL; 731 } 732 return err; 733} 734 735/* MIDI function driver setup/binding */ 736 737static int __init 738f_midi_bind(struct usb_configuration *c, struct usb_function *f) 739{ 740 struct usb_descriptor_header **midi_function; 741 struct usb_midi_in_jack_descriptor jack_in_ext_desc[MAX_PORTS]; 742 struct usb_midi_in_jack_descriptor jack_in_emb_desc[MAX_PORTS]; 743 struct usb_midi_out_jack_descriptor_1 jack_out_ext_desc[MAX_PORTS]; 744 struct usb_midi_out_jack_descriptor_1 jack_out_emb_desc[MAX_PORTS]; 745 struct usb_composite_dev *cdev = c->cdev; 746 struct f_midi *midi = func_to_midi(f); 747 int status, n, jack = 1, i = 0; 748 749 /* maybe allocate device-global string ID */ 750 if (midi_string_defs[0].id == 0) { 751 status = usb_string_id(c->cdev); 752 if (status < 0) 753 goto fail; 754 midi_string_defs[0].id = status; 755 } 756 757 /* We have two interfaces, AudioControl and MIDIStreaming */ 758 status = usb_interface_id(c, f); 759 if (status < 0) 760 goto fail; 761 ac_interface_desc.bInterfaceNumber = status; 762 763 status = usb_interface_id(c, f); 764 if (status < 0) 765 goto fail; 766 ms_interface_desc.bInterfaceNumber = status; 767 ac_header_desc.baInterfaceNr[0] = status; 768 769 status = -ENODEV; 770 771 /* allocate instance-specific endpoints */ 772 midi->in_ep = usb_ep_autoconfig(cdev->gadget, &bulk_in_desc); 773 if (!midi->in_ep) 774 goto fail; 775 midi->in_ep->driver_data = cdev; /* claim */ 776 777 midi->out_ep = usb_ep_autoconfig(cdev->gadget, &bulk_out_desc); 778 if (!midi->out_ep) 779 goto fail; 780 midi->out_ep->driver_data = cdev; /* claim */ 781 782 /* allocate temporary function list */ 783 midi_function = kcalloc((MAX_PORTS * 4) + 9, sizeof(*midi_function), 784 GFP_KERNEL); 785 if (!midi_function) { 786 status = -ENOMEM; 787 goto fail; 788 } 789 790 /* 791 * construct the function's descriptor set. As the number of 792 * input and output MIDI ports is configurable, we have to do 793 * it that way. 794 */ 795 796 /* add the headers - these are always the same */ 797 midi_function[i++] = (struct usb_descriptor_header *) &ac_interface_desc; 798 midi_function[i++] = (struct usb_descriptor_header *) &ac_header_desc; 799 midi_function[i++] = (struct usb_descriptor_header *) &ms_interface_desc; 800 801 /* calculate the header's wTotalLength */ 802 n = USB_DT_MS_HEADER_SIZE 803 + (midi->in_ports + midi->out_ports) * 804 (USB_DT_MIDI_IN_SIZE + USB_DT_MIDI_OUT_SIZE(1)); 805 ms_header_desc.wTotalLength = cpu_to_le16(n); 806 807 midi_function[i++] = (struct usb_descriptor_header *) &ms_header_desc; 808 809 /* configure the external IN jacks, each linked to an embedded OUT jack */ 810 for (n = 0; n < midi->in_ports; n++) { 811 struct usb_midi_in_jack_descriptor *in_ext = &jack_in_ext_desc[n]; 812 struct usb_midi_out_jack_descriptor_1 *out_emb = &jack_out_emb_desc[n]; 813 814 in_ext->bLength = USB_DT_MIDI_IN_SIZE; 815 in_ext->bDescriptorType = USB_DT_CS_INTERFACE; 816 in_ext->bDescriptorSubtype = USB_MS_MIDI_IN_JACK; 817 in_ext->bJackType = USB_MS_EXTERNAL; 818 in_ext->bJackID = jack++; 819 in_ext->iJack = 0; 820 midi_function[i++] = (struct usb_descriptor_header *) in_ext; 821 822 out_emb->bLength = USB_DT_MIDI_OUT_SIZE(1); 823 out_emb->bDescriptorType = USB_DT_CS_INTERFACE; 824 out_emb->bDescriptorSubtype = USB_MS_MIDI_OUT_JACK; 825 out_emb->bJackType = USB_MS_EMBEDDED; 826 out_emb->bJackID = jack++; 827 out_emb->bNrInputPins = 1; 828 out_emb->pins[0].baSourcePin = 1; 829 out_emb->pins[0].baSourceID = in_ext->bJackID; 830 out_emb->iJack = 0; 831 midi_function[i++] = (struct usb_descriptor_header *) out_emb; 832 833 /* link it to the endpoint */ 834 ms_in_desc.baAssocJackID[n] = out_emb->bJackID; 835 } 836 837 /* configure the external OUT jacks, each linked to an embedded IN jack */ 838 for (n = 0; n < midi->out_ports; n++) { 839 struct usb_midi_in_jack_descriptor *in_emb = &jack_in_emb_desc[n]; 840 struct usb_midi_out_jack_descriptor_1 *out_ext = &jack_out_ext_desc[n]; 841 842 in_emb->bLength = USB_DT_MIDI_IN_SIZE; 843 in_emb->bDescriptorType = USB_DT_CS_INTERFACE; 844 in_emb->bDescriptorSubtype = USB_MS_MIDI_IN_JACK; 845 in_emb->bJackType = USB_MS_EMBEDDED; 846 in_emb->bJackID = jack++; 847 in_emb->iJack = 0; 848 midi_function[i++] = (struct usb_descriptor_header *) in_emb; 849 850 out_ext->bLength = USB_DT_MIDI_OUT_SIZE(1); 851 out_ext->bDescriptorType = USB_DT_CS_INTERFACE; 852 out_ext->bDescriptorSubtype = USB_MS_MIDI_OUT_JACK; 853 out_ext->bJackType = USB_MS_EXTERNAL; 854 out_ext->bJackID = jack++; 855 out_ext->bNrInputPins = 1; 856 out_ext->iJack = 0; 857 out_ext->pins[0].baSourceID = in_emb->bJackID; 858 out_ext->pins[0].baSourcePin = 1; 859 midi_function[i++] = (struct usb_descriptor_header *) out_ext; 860 861 /* link it to the endpoint */ 862 ms_out_desc.baAssocJackID[n] = in_emb->bJackID; 863 } 864 865 /* configure the endpoint descriptors ... */ 866 ms_out_desc.bLength = USB_DT_MS_ENDPOINT_SIZE(midi->in_ports); 867 ms_out_desc.bNumEmbMIDIJack = midi->in_ports; 868 869 ms_in_desc.bLength = USB_DT_MS_ENDPOINT_SIZE(midi->out_ports); 870 ms_in_desc.bNumEmbMIDIJack = midi->out_ports; 871 872 /* ... and add them to the list */ 873 midi_function[i++] = (struct usb_descriptor_header *) &bulk_out_desc; 874 midi_function[i++] = (struct usb_descriptor_header *) &ms_out_desc; 875 midi_function[i++] = (struct usb_descriptor_header *) &bulk_in_desc; 876 midi_function[i++] = (struct usb_descriptor_header *) &ms_in_desc; 877 midi_function[i++] = NULL; 878 879 /* 880 * support all relevant hardware speeds... we expect that when 881 * hardware is dual speed, all bulk-capable endpoints work at 882 * both speeds 883 */ 884 /* copy descriptors, and track endpoint copies */ 885 if (gadget_is_dualspeed(c->cdev->gadget)) { 886 c->highspeed = true; 887 bulk_in_desc.wMaxPacketSize = cpu_to_le16(512); 888 bulk_out_desc.wMaxPacketSize = cpu_to_le16(512); 889 f->hs_descriptors = usb_copy_descriptors(midi_function); 890 } else { 891 f->descriptors = usb_copy_descriptors(midi_function); 892 } 893 894 kfree(midi_function); 895 896 return 0; 897 898fail: 899 /* we might as well release our claims on endpoints */ 900 if (midi->out_ep) 901 midi->out_ep->driver_data = NULL; 902 if (midi->in_ep) 903 midi->in_ep->driver_data = NULL; 904 905 ERROR(cdev, "%s: can't bind, err %d\n", f->name, status); 906 907 return status; 908} 909 910/** 911 * f_midi_bind_config - add USB MIDI function to a configuration 912 * @c: the configuration to supcard the USB audio function 913 * @index: the soundcard index to use for the ALSA device creation 914 * @id: the soundcard id to use for the ALSA device creation 915 * @buflen: the buffer length to use 916 * @qlen the number of read requests to pre-allocate 917 * Context: single threaded during gadget setup 918 * 919 * Returns zero on success, else negative errno. 920 */ 921int __init f_midi_bind_config(struct usb_configuration *c, 922 int index, char *id, 923 unsigned int in_ports, 924 unsigned int out_ports, 925 unsigned int buflen, 926 unsigned int qlen) 927{ 928 struct f_midi *midi; 929 int status, i; 930 931 /* sanity check */ 932 if (in_ports > MAX_PORTS || out_ports > MAX_PORTS) 933 return -EINVAL; 934 935 /* allocate and initialize one new instance */ 936 midi = kzalloc(sizeof *midi, GFP_KERNEL); 937 if (!midi) { 938 status = -ENOMEM; 939 goto fail; 940 } 941 942 for (i = 0; i < in_ports; i++) { 943 struct gmidi_in_port *port = kzalloc(sizeof(*port), GFP_KERNEL); 944 if (!port) { 945 status = -ENOMEM; 946 goto setup_fail; 947 } 948 949 port->midi = midi; 950 port->active = 0; 951 port->cable = i; 952 midi->in_port[i] = port; 953 } 954 955 midi->gadget = c->cdev->gadget; 956 tasklet_init(&midi->tasklet, f_midi_in_tasklet, (unsigned long) midi); 957 958 /* set up ALSA midi devices */ 959 midi->in_ports = in_ports; 960 midi->out_ports = out_ports; 961 status = f_midi_register_card(midi); 962 if (status < 0) 963 goto setup_fail; 964 965 midi->func.name = "gmidi function"; 966 midi->func.strings = midi_strings; 967 midi->func.bind = f_midi_bind; 968 midi->func.unbind = f_midi_unbind; 969 midi->func.set_alt = f_midi_set_alt; 970 midi->func.disable = f_midi_disable; 971 972 midi->id = kstrdup(id, GFP_KERNEL); 973 midi->index = index; 974 midi->buflen = buflen; 975 midi->qlen = qlen; 976 977 status = usb_add_function(c, &midi->func); 978 if (status) 979 goto setup_fail; 980 981 return 0; 982 983setup_fail: 984 for (--i; i >= 0; i--) 985 kfree(midi->in_port[i]); 986 kfree(midi); 987fail: 988 return status; 989} 990 991