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/module.h> 24 #include <linux/slab.h> 25 #include <linux/device.h> 26 #include <linux/kfifo.h> 27 #include <linux/spinlock.h> 28 29 #include <sound/core.h> 30 #include <sound/initval.h> 31 #include <sound/rawmidi.h> 32 33 #include <linux/usb/ch9.h> 34 #include <linux/usb/gadget.h> 35 #include <linux/usb/audio.h> 36 #include <linux/usb/midi.h> 37 38 #include "u_f.h" 39 #include "u_midi.h" 40 41 MODULE_AUTHOR("Ben Williamson"); 42 MODULE_LICENSE("GPL v2"); 43 44 static const char f_midi_shortname[] = "f_midi"; 45 static const char f_midi_longname[] = "MIDI Gadget"; 46 47 /* 48 * We can only handle 16 cables on one single endpoint, as cable numbers are 49 * stored in 4-bit fields. And as the interface currently only holds one 50 * single endpoint, this is the maximum number of ports we can allow. 51 */ 52 #define MAX_PORTS 16 53 54 /* 55 * This is a gadget, and the IN/OUT naming is from the host's perspective. 56 * USB -> OUT endpoint -> rawmidi 57 * USB <- IN endpoint <- rawmidi 58 */ 59 struct gmidi_in_port { 60 struct snd_rawmidi_substream *substream; 61 int active; 62 uint8_t cable; 63 uint8_t state; 64 #define STATE_UNKNOWN 0 65 #define STATE_1PARAM 1 66 #define STATE_2PARAM_1 2 67 #define STATE_2PARAM_2 3 68 #define STATE_SYSEX_0 4 69 #define STATE_SYSEX_1 5 70 #define STATE_SYSEX_2 6 71 uint8_t data[2]; 72 }; 73 74 struct f_midi { 75 struct usb_function func; 76 struct usb_gadget *gadget; 77 struct usb_ep *in_ep, *out_ep; 78 struct snd_card *card; 79 struct snd_rawmidi *rmidi; 80 u8 ms_id; 81 82 struct snd_rawmidi_substream *out_substream[MAX_PORTS]; 83 84 unsigned long out_triggered; 85 struct tasklet_struct tasklet; 86 unsigned int in_ports; 87 unsigned int out_ports; 88 int index; 89 char *id; 90 unsigned int buflen, qlen; 91 /* This fifo is used as a buffer ring for pre-allocated IN usb_requests */ 92 DECLARE_KFIFO_PTR(in_req_fifo, struct usb_request *); 93 spinlock_t transmit_lock; 94 unsigned int in_last_port; 95 96 struct gmidi_in_port in_ports_array[/* in_ports */]; 97 }; 98 99 static inline struct f_midi *func_to_midi(struct usb_function *f) 100 { 101 return container_of(f, struct f_midi, func); 102 } 103 104 static void f_midi_transmit(struct f_midi *midi); 105 106 DECLARE_UAC_AC_HEADER_DESCRIPTOR(1); 107 DECLARE_USB_MIDI_OUT_JACK_DESCRIPTOR(1); 108 DECLARE_USB_MS_ENDPOINT_DESCRIPTOR(16); 109 110 /* B.3.1 Standard AC Interface Descriptor */ 111 static struct usb_interface_descriptor ac_interface_desc = { 112 .bLength = USB_DT_INTERFACE_SIZE, 113 .bDescriptorType = USB_DT_INTERFACE, 114 /* .bInterfaceNumber = DYNAMIC */ 115 /* .bNumEndpoints = DYNAMIC */ 116 .bInterfaceClass = USB_CLASS_AUDIO, 117 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL, 118 /* .iInterface = DYNAMIC */ 119 }; 120 121 /* B.3.2 Class-Specific AC Interface Descriptor */ 122 static struct uac1_ac_header_descriptor_1 ac_header_desc = { 123 .bLength = UAC_DT_AC_HEADER_SIZE(1), 124 .bDescriptorType = USB_DT_CS_INTERFACE, 125 .bDescriptorSubtype = USB_MS_HEADER, 126 .bcdADC = cpu_to_le16(0x0100), 127 .wTotalLength = cpu_to_le16(UAC_DT_AC_HEADER_SIZE(1)), 128 .bInCollection = 1, 129 /* .baInterfaceNr = DYNAMIC */ 130 }; 131 132 /* B.4.1 Standard MS Interface Descriptor */ 133 static struct usb_interface_descriptor ms_interface_desc = { 134 .bLength = USB_DT_INTERFACE_SIZE, 135 .bDescriptorType = USB_DT_INTERFACE, 136 /* .bInterfaceNumber = DYNAMIC */ 137 .bNumEndpoints = 2, 138 .bInterfaceClass = USB_CLASS_AUDIO, 139 .bInterfaceSubClass = USB_SUBCLASS_MIDISTREAMING, 140 /* .iInterface = DYNAMIC */ 141 }; 142 143 /* B.4.2 Class-Specific MS Interface Descriptor */ 144 static struct usb_ms_header_descriptor ms_header_desc = { 145 .bLength = USB_DT_MS_HEADER_SIZE, 146 .bDescriptorType = USB_DT_CS_INTERFACE, 147 .bDescriptorSubtype = USB_MS_HEADER, 148 .bcdMSC = cpu_to_le16(0x0100), 149 /* .wTotalLength = DYNAMIC */ 150 }; 151 152 /* B.5.1 Standard Bulk OUT Endpoint Descriptor */ 153 static struct usb_endpoint_descriptor bulk_out_desc = { 154 .bLength = USB_DT_ENDPOINT_AUDIO_SIZE, 155 .bDescriptorType = USB_DT_ENDPOINT, 156 .bEndpointAddress = USB_DIR_OUT, 157 .bmAttributes = USB_ENDPOINT_XFER_BULK, 158 }; 159 160 /* B.5.2 Class-specific MS Bulk OUT Endpoint Descriptor */ 161 static struct usb_ms_endpoint_descriptor_16 ms_out_desc = { 162 /* .bLength = DYNAMIC */ 163 .bDescriptorType = USB_DT_CS_ENDPOINT, 164 .bDescriptorSubtype = USB_MS_GENERAL, 165 /* .bNumEmbMIDIJack = DYNAMIC */ 166 /* .baAssocJackID = DYNAMIC */ 167 }; 168 169 /* B.6.1 Standard Bulk IN Endpoint Descriptor */ 170 static struct usb_endpoint_descriptor bulk_in_desc = { 171 .bLength = USB_DT_ENDPOINT_AUDIO_SIZE, 172 .bDescriptorType = USB_DT_ENDPOINT, 173 .bEndpointAddress = USB_DIR_IN, 174 .bmAttributes = USB_ENDPOINT_XFER_BULK, 175 }; 176 177 /* B.6.2 Class-specific MS Bulk IN Endpoint Descriptor */ 178 static struct usb_ms_endpoint_descriptor_16 ms_in_desc = { 179 /* .bLength = DYNAMIC */ 180 .bDescriptorType = USB_DT_CS_ENDPOINT, 181 .bDescriptorSubtype = USB_MS_GENERAL, 182 /* .bNumEmbMIDIJack = DYNAMIC */ 183 /* .baAssocJackID = DYNAMIC */ 184 }; 185 186 /* string IDs are assigned dynamically */ 187 188 #define STRING_FUNC_IDX 0 189 190 static struct usb_string midi_string_defs[] = { 191 [STRING_FUNC_IDX].s = "MIDI function", 192 { } /* end of list */ 193 }; 194 195 static struct usb_gadget_strings midi_stringtab = { 196 .language = 0x0409, /* en-us */ 197 .strings = midi_string_defs, 198 }; 199 200 static struct usb_gadget_strings *midi_strings[] = { 201 &midi_stringtab, 202 NULL, 203 }; 204 205 static inline struct usb_request *midi_alloc_ep_req(struct usb_ep *ep, 206 unsigned length) 207 { 208 return alloc_ep_req(ep, length, length); 209 } 210 211 static const uint8_t f_midi_cin_length[] = { 212 0, 0, 2, 3, 3, 1, 2, 3, 3, 3, 3, 3, 2, 2, 3, 1 213 }; 214 215 /* 216 * Receives a chunk of MIDI data. 217 */ 218 static void f_midi_read_data(struct usb_ep *ep, int cable, 219 uint8_t *data, int length) 220 { 221 struct f_midi *midi = ep->driver_data; 222 struct snd_rawmidi_substream *substream = midi->out_substream[cable]; 223 224 if (!substream) 225 /* Nobody is listening - throw it on the floor. */ 226 return; 227 228 if (!test_bit(cable, &midi->out_triggered)) 229 return; 230 231 snd_rawmidi_receive(substream, data, length); 232 } 233 234 static void f_midi_handle_out_data(struct usb_ep *ep, struct usb_request *req) 235 { 236 unsigned int i; 237 u8 *buf = req->buf; 238 239 for (i = 0; i + 3 < req->actual; i += 4) 240 if (buf[i] != 0) { 241 int cable = buf[i] >> 4; 242 int length = f_midi_cin_length[buf[i] & 0x0f]; 243 f_midi_read_data(ep, cable, &buf[i + 1], length); 244 } 245 } 246 247 static void 248 f_midi_complete(struct usb_ep *ep, struct usb_request *req) 249 { 250 struct f_midi *midi = ep->driver_data; 251 struct usb_composite_dev *cdev = midi->func.config->cdev; 252 int status = req->status; 253 254 switch (status) { 255 case 0: /* normal completion */ 256 if (ep == midi->out_ep) { 257 /* We received stuff. req is queued again, below */ 258 f_midi_handle_out_data(ep, req); 259 } else if (ep == midi->in_ep) { 260 /* Our transmit completed. See if there's more to go. 261 * f_midi_transmit eats req, don't queue it again. */ 262 req->length = 0; 263 f_midi_transmit(midi); 264 return; 265 } 266 break; 267 268 /* this endpoint is normally active while we're configured */ 269 case -ECONNABORTED: /* hardware forced ep reset */ 270 case -ECONNRESET: /* request dequeued */ 271 case -ESHUTDOWN: /* disconnect from host */ 272 VDBG(cdev, "%s gone (%d), %d/%d\n", ep->name, status, 273 req->actual, req->length); 274 if (ep == midi->out_ep) { 275 f_midi_handle_out_data(ep, req); 276 /* We don't need to free IN requests because it's handled 277 * by the midi->in_req_fifo. */ 278 free_ep_req(ep, req); 279 } 280 return; 281 282 case -EOVERFLOW: /* buffer overrun on read means that 283 * we didn't provide a big enough buffer. 284 */ 285 default: 286 DBG(cdev, "%s complete --> %d, %d/%d\n", ep->name, 287 status, req->actual, req->length); 288 break; 289 case -EREMOTEIO: /* short read */ 290 break; 291 } 292 293 status = usb_ep_queue(ep, req, GFP_ATOMIC); 294 if (status) { 295 ERROR(cdev, "kill %s: resubmit %d bytes --> %d\n", 296 ep->name, req->length, status); 297 usb_ep_set_halt(ep); 298 /* FIXME recover later ... somehow */ 299 } 300 } 301 302 static int f_midi_start_ep(struct f_midi *midi, 303 struct usb_function *f, 304 struct usb_ep *ep) 305 { 306 int err; 307 struct usb_composite_dev *cdev = f->config->cdev; 308 309 usb_ep_disable(ep); 310 311 err = config_ep_by_speed(midi->gadget, f, ep); 312 if (err) { 313 ERROR(cdev, "can't configure %s: %d\n", ep->name, err); 314 return err; 315 } 316 317 err = usb_ep_enable(ep); 318 if (err) { 319 ERROR(cdev, "can't start %s: %d\n", ep->name, err); 320 return err; 321 } 322 323 ep->driver_data = midi; 324 325 return 0; 326 } 327 328 static int f_midi_set_alt(struct usb_function *f, unsigned intf, unsigned alt) 329 { 330 struct f_midi *midi = func_to_midi(f); 331 unsigned i; 332 int err; 333 334 /* we only set alt for MIDIStreaming interface */ 335 if (intf != midi->ms_id) 336 return 0; 337 338 err = f_midi_start_ep(midi, f, midi->in_ep); 339 if (err) 340 return err; 341 342 err = f_midi_start_ep(midi, f, midi->out_ep); 343 if (err) 344 return err; 345 346 /* pre-allocate write usb requests to use on f_midi_transmit. */ 347 while (kfifo_avail(&midi->in_req_fifo)) { 348 struct usb_request *req = 349 midi_alloc_ep_req(midi->in_ep, midi->buflen); 350 351 if (req == NULL) 352 return -ENOMEM; 353 354 req->length = 0; 355 req->complete = f_midi_complete; 356 357 kfifo_put(&midi->in_req_fifo, req); 358 } 359 360 /* allocate a bunch of read buffers and queue them all at once. */ 361 for (i = 0; i < midi->qlen && err == 0; i++) { 362 struct usb_request *req = 363 midi_alloc_ep_req(midi->out_ep, 364 max_t(unsigned, midi->buflen, 365 bulk_out_desc.wMaxPacketSize)); 366 if (req == NULL) 367 return -ENOMEM; 368 369 req->complete = f_midi_complete; 370 err = usb_ep_queue(midi->out_ep, req, GFP_ATOMIC); 371 if (err) { 372 ERROR(midi, "%s: couldn't enqueue request: %d\n", 373 midi->out_ep->name, err); 374 free_ep_req(midi->out_ep, req); 375 return err; 376 } 377 } 378 379 return 0; 380 } 381 382 static void f_midi_disable(struct usb_function *f) 383 { 384 struct f_midi *midi = func_to_midi(f); 385 struct usb_composite_dev *cdev = f->config->cdev; 386 struct usb_request *req = NULL; 387 388 DBG(cdev, "disable\n"); 389 390 /* 391 * just disable endpoints, forcing completion of pending i/o. 392 * all our completion handlers free their requests in this case. 393 */ 394 usb_ep_disable(midi->in_ep); 395 usb_ep_disable(midi->out_ep); 396 397 /* release IN requests */ 398 while (kfifo_get(&midi->in_req_fifo, &req)) 399 free_ep_req(midi->in_ep, req); 400 } 401 402 static int f_midi_snd_free(struct snd_device *device) 403 { 404 return 0; 405 } 406 407 static void f_midi_transmit_packet(struct usb_request *req, uint8_t p0, 408 uint8_t p1, uint8_t p2, uint8_t p3) 409 { 410 unsigned length = req->length; 411 u8 *buf = (u8 *)req->buf + length; 412 413 buf[0] = p0; 414 buf[1] = p1; 415 buf[2] = p2; 416 buf[3] = p3; 417 req->length = length + 4; 418 } 419 420 /* 421 * Converts MIDI commands to USB MIDI packets. 422 */ 423 static void f_midi_transmit_byte(struct usb_request *req, 424 struct gmidi_in_port *port, uint8_t b) 425 { 426 uint8_t p0 = port->cable << 4; 427 428 if (b >= 0xf8) { 429 f_midi_transmit_packet(req, p0 | 0x0f, b, 0, 0); 430 } else if (b >= 0xf0) { 431 switch (b) { 432 case 0xf0: 433 port->data[0] = b; 434 port->state = STATE_SYSEX_1; 435 break; 436 case 0xf1: 437 case 0xf3: 438 port->data[0] = b; 439 port->state = STATE_1PARAM; 440 break; 441 case 0xf2: 442 port->data[0] = b; 443 port->state = STATE_2PARAM_1; 444 break; 445 case 0xf4: 446 case 0xf5: 447 port->state = STATE_UNKNOWN; 448 break; 449 case 0xf6: 450 f_midi_transmit_packet(req, p0 | 0x05, 0xf6, 0, 0); 451 port->state = STATE_UNKNOWN; 452 break; 453 case 0xf7: 454 switch (port->state) { 455 case STATE_SYSEX_0: 456 f_midi_transmit_packet(req, 457 p0 | 0x05, 0xf7, 0, 0); 458 break; 459 case STATE_SYSEX_1: 460 f_midi_transmit_packet(req, 461 p0 | 0x06, port->data[0], 0xf7, 0); 462 break; 463 case STATE_SYSEX_2: 464 f_midi_transmit_packet(req, 465 p0 | 0x07, port->data[0], 466 port->data[1], 0xf7); 467 break; 468 } 469 port->state = STATE_UNKNOWN; 470 break; 471 } 472 } else if (b >= 0x80) { 473 port->data[0] = b; 474 if (b >= 0xc0 && b <= 0xdf) 475 port->state = STATE_1PARAM; 476 else 477 port->state = STATE_2PARAM_1; 478 } else { /* b < 0x80 */ 479 switch (port->state) { 480 case STATE_1PARAM: 481 if (port->data[0] < 0xf0) { 482 p0 |= port->data[0] >> 4; 483 } else { 484 p0 |= 0x02; 485 port->state = STATE_UNKNOWN; 486 } 487 f_midi_transmit_packet(req, p0, port->data[0], b, 0); 488 break; 489 case STATE_2PARAM_1: 490 port->data[1] = b; 491 port->state = STATE_2PARAM_2; 492 break; 493 case STATE_2PARAM_2: 494 if (port->data[0] < 0xf0) { 495 p0 |= port->data[0] >> 4; 496 port->state = STATE_2PARAM_1; 497 } else { 498 p0 |= 0x03; 499 port->state = STATE_UNKNOWN; 500 } 501 f_midi_transmit_packet(req, 502 p0, port->data[0], port->data[1], b); 503 break; 504 case STATE_SYSEX_0: 505 port->data[0] = b; 506 port->state = STATE_SYSEX_1; 507 break; 508 case STATE_SYSEX_1: 509 port->data[1] = b; 510 port->state = STATE_SYSEX_2; 511 break; 512 case STATE_SYSEX_2: 513 f_midi_transmit_packet(req, 514 p0 | 0x04, port->data[0], port->data[1], b); 515 port->state = STATE_SYSEX_0; 516 break; 517 } 518 } 519 } 520 521 static void f_midi_drop_out_substreams(struct f_midi *midi) 522 { 523 unsigned int i; 524 525 for (i = 0; i < midi->in_ports; i++) { 526 struct gmidi_in_port *port = midi->in_ports_array + i; 527 struct snd_rawmidi_substream *substream = port->substream; 528 if (port->active && substream) 529 snd_rawmidi_drop_output(substream); 530 } 531 } 532 533 static int f_midi_do_transmit(struct f_midi *midi, struct usb_ep *ep) 534 { 535 struct usb_request *req = NULL; 536 unsigned int len, i; 537 bool active = false; 538 int err; 539 540 /* 541 * We peek the request in order to reuse it if it fails to enqueue on 542 * its endpoint 543 */ 544 len = kfifo_peek(&midi->in_req_fifo, &req); 545 if (len != 1) { 546 ERROR(midi, "%s: Couldn't get usb request\n", __func__); 547 return -1; 548 } 549 550 /* 551 * If buffer overrun, then we ignore this transmission. 552 * IMPORTANT: This will cause the user-space rawmidi device to block 553 * until a) usb requests have been completed or b) snd_rawmidi_write() 554 * times out. 555 */ 556 if (req->length > 0) 557 return 0; 558 559 for (i = midi->in_last_port; i < midi->in_ports; ++i) { 560 struct gmidi_in_port *port = midi->in_ports_array + i; 561 struct snd_rawmidi_substream *substream = port->substream; 562 563 if (!port->active || !substream) 564 continue; 565 566 while (req->length + 3 < midi->buflen) { 567 uint8_t b; 568 569 if (snd_rawmidi_transmit(substream, &b, 1) != 1) { 570 port->active = 0; 571 break; 572 } 573 f_midi_transmit_byte(req, port, b); 574 } 575 576 active = !!port->active; 577 if (active) 578 break; 579 } 580 midi->in_last_port = active ? i : 0; 581 582 if (req->length <= 0) 583 goto done; 584 585 err = usb_ep_queue(ep, req, GFP_ATOMIC); 586 if (err < 0) { 587 ERROR(midi, "%s failed to queue req: %d\n", 588 midi->in_ep->name, err); 589 req->length = 0; /* Re-use request next time. */ 590 } else { 591 /* Upon success, put request at the back of the queue. */ 592 kfifo_skip(&midi->in_req_fifo); 593 kfifo_put(&midi->in_req_fifo, req); 594 } 595 596 done: 597 return active; 598 } 599 600 static void f_midi_transmit(struct f_midi *midi) 601 { 602 struct usb_ep *ep = midi->in_ep; 603 int ret; 604 unsigned long flags; 605 606 /* We only care about USB requests if IN endpoint is enabled */ 607 if (!ep || !ep->enabled) 608 goto drop_out; 609 610 spin_lock_irqsave(&midi->transmit_lock, flags); 611 612 do { 613 ret = f_midi_do_transmit(midi, ep); 614 if (ret < 0) { 615 spin_unlock_irqrestore(&midi->transmit_lock, flags); 616 goto drop_out; 617 } 618 } while (ret); 619 620 spin_unlock_irqrestore(&midi->transmit_lock, flags); 621 622 return; 623 624 drop_out: 625 f_midi_drop_out_substreams(midi); 626 } 627 628 static void f_midi_in_tasklet(unsigned long data) 629 { 630 struct f_midi *midi = (struct f_midi *) data; 631 f_midi_transmit(midi); 632 } 633 634 static int f_midi_in_open(struct snd_rawmidi_substream *substream) 635 { 636 struct f_midi *midi = substream->rmidi->private_data; 637 struct gmidi_in_port *port; 638 639 if (substream->number >= midi->in_ports) 640 return -EINVAL; 641 642 VDBG(midi, "%s()\n", __func__); 643 port = midi->in_ports_array + substream->number; 644 port->substream = substream; 645 port->state = STATE_UNKNOWN; 646 return 0; 647 } 648 649 static int f_midi_in_close(struct snd_rawmidi_substream *substream) 650 { 651 struct f_midi *midi = substream->rmidi->private_data; 652 653 VDBG(midi, "%s()\n", __func__); 654 return 0; 655 } 656 657 static void f_midi_in_trigger(struct snd_rawmidi_substream *substream, int up) 658 { 659 struct f_midi *midi = substream->rmidi->private_data; 660 661 if (substream->number >= midi->in_ports) 662 return; 663 664 VDBG(midi, "%s() %d\n", __func__, up); 665 midi->in_ports_array[substream->number].active = up; 666 if (up) 667 tasklet_hi_schedule(&midi->tasklet); 668 } 669 670 static int f_midi_out_open(struct snd_rawmidi_substream *substream) 671 { 672 struct f_midi *midi = substream->rmidi->private_data; 673 674 if (substream->number >= MAX_PORTS) 675 return -EINVAL; 676 677 VDBG(midi, "%s()\n", __func__); 678 midi->out_substream[substream->number] = substream; 679 return 0; 680 } 681 682 static int f_midi_out_close(struct snd_rawmidi_substream *substream) 683 { 684 struct f_midi *midi = substream->rmidi->private_data; 685 686 VDBG(midi, "%s()\n", __func__); 687 return 0; 688 } 689 690 static void f_midi_out_trigger(struct snd_rawmidi_substream *substream, int up) 691 { 692 struct f_midi *midi = substream->rmidi->private_data; 693 694 VDBG(midi, "%s()\n", __func__); 695 696 if (up) 697 set_bit(substream->number, &midi->out_triggered); 698 else 699 clear_bit(substream->number, &midi->out_triggered); 700 } 701 702 static struct snd_rawmidi_ops gmidi_in_ops = { 703 .open = f_midi_in_open, 704 .close = f_midi_in_close, 705 .trigger = f_midi_in_trigger, 706 }; 707 708 static struct snd_rawmidi_ops gmidi_out_ops = { 709 .open = f_midi_out_open, 710 .close = f_midi_out_close, 711 .trigger = f_midi_out_trigger 712 }; 713 714 static inline void f_midi_unregister_card(struct f_midi *midi) 715 { 716 if (midi->card) { 717 snd_card_free(midi->card); 718 midi->card = NULL; 719 } 720 } 721 722 /* register as a sound "card" */ 723 static int f_midi_register_card(struct f_midi *midi) 724 { 725 struct snd_card *card; 726 struct snd_rawmidi *rmidi; 727 int err; 728 static struct snd_device_ops ops = { 729 .dev_free = f_midi_snd_free, 730 }; 731 732 err = snd_card_new(&midi->gadget->dev, midi->index, midi->id, 733 THIS_MODULE, 0, &card); 734 if (err < 0) { 735 ERROR(midi, "snd_card_new() failed\n"); 736 goto fail; 737 } 738 midi->card = card; 739 740 err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, midi, &ops); 741 if (err < 0) { 742 ERROR(midi, "snd_device_new() failed: error %d\n", err); 743 goto fail; 744 } 745 746 strcpy(card->driver, f_midi_longname); 747 strcpy(card->longname, f_midi_longname); 748 strcpy(card->shortname, f_midi_shortname); 749 750 /* Set up rawmidi */ 751 snd_component_add(card, "MIDI"); 752 err = snd_rawmidi_new(card, card->longname, 0, 753 midi->out_ports, midi->in_ports, &rmidi); 754 if (err < 0) { 755 ERROR(midi, "snd_rawmidi_new() failed: error %d\n", err); 756 goto fail; 757 } 758 midi->rmidi = rmidi; 759 midi->in_last_port = 0; 760 strcpy(rmidi->name, card->shortname); 761 rmidi->info_flags = SNDRV_RAWMIDI_INFO_OUTPUT | 762 SNDRV_RAWMIDI_INFO_INPUT | 763 SNDRV_RAWMIDI_INFO_DUPLEX; 764 rmidi->private_data = midi; 765 766 /* 767 * Yes, rawmidi OUTPUT = USB IN, and rawmidi INPUT = USB OUT. 768 * It's an upside-down world being a gadget. 769 */ 770 snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT, &gmidi_in_ops); 771 snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT, &gmidi_out_ops); 772 773 /* register it - we're ready to go */ 774 err = snd_card_register(card); 775 if (err < 0) { 776 ERROR(midi, "snd_card_register() failed\n"); 777 goto fail; 778 } 779 780 VDBG(midi, "%s() finished ok\n", __func__); 781 return 0; 782 783 fail: 784 f_midi_unregister_card(midi); 785 return err; 786 } 787 788 /* MIDI function driver setup/binding */ 789 790 static int f_midi_bind(struct usb_configuration *c, struct usb_function *f) 791 { 792 struct usb_descriptor_header **midi_function; 793 struct usb_midi_in_jack_descriptor jack_in_ext_desc[MAX_PORTS]; 794 struct usb_midi_in_jack_descriptor jack_in_emb_desc[MAX_PORTS]; 795 struct usb_midi_out_jack_descriptor_1 jack_out_ext_desc[MAX_PORTS]; 796 struct usb_midi_out_jack_descriptor_1 jack_out_emb_desc[MAX_PORTS]; 797 struct usb_composite_dev *cdev = c->cdev; 798 struct f_midi *midi = func_to_midi(f); 799 struct usb_string *us; 800 int status, n, jack = 1, i = 0; 801 802 midi->gadget = cdev->gadget; 803 tasklet_init(&midi->tasklet, f_midi_in_tasklet, (unsigned long) midi); 804 status = f_midi_register_card(midi); 805 if (status < 0) 806 goto fail_register; 807 808 /* maybe allocate device-global string ID */ 809 us = usb_gstrings_attach(c->cdev, midi_strings, 810 ARRAY_SIZE(midi_string_defs)); 811 if (IS_ERR(us)) { 812 status = PTR_ERR(us); 813 goto fail; 814 } 815 ac_interface_desc.iInterface = us[STRING_FUNC_IDX].id; 816 817 /* We have two interfaces, AudioControl and MIDIStreaming */ 818 status = usb_interface_id(c, f); 819 if (status < 0) 820 goto fail; 821 ac_interface_desc.bInterfaceNumber = status; 822 823 status = usb_interface_id(c, f); 824 if (status < 0) 825 goto fail; 826 ms_interface_desc.bInterfaceNumber = status; 827 ac_header_desc.baInterfaceNr[0] = status; 828 midi->ms_id = status; 829 830 status = -ENODEV; 831 832 /* allocate instance-specific endpoints */ 833 midi->in_ep = usb_ep_autoconfig(cdev->gadget, &bulk_in_desc); 834 if (!midi->in_ep) 835 goto fail; 836 837 midi->out_ep = usb_ep_autoconfig(cdev->gadget, &bulk_out_desc); 838 if (!midi->out_ep) 839 goto fail; 840 841 /* allocate temporary function list */ 842 midi_function = kcalloc((MAX_PORTS * 4) + 9, sizeof(*midi_function), 843 GFP_KERNEL); 844 if (!midi_function) { 845 status = -ENOMEM; 846 goto fail; 847 } 848 849 /* 850 * construct the function's descriptor set. As the number of 851 * input and output MIDI ports is configurable, we have to do 852 * it that way. 853 */ 854 855 /* add the headers - these are always the same */ 856 midi_function[i++] = (struct usb_descriptor_header *) &ac_interface_desc; 857 midi_function[i++] = (struct usb_descriptor_header *) &ac_header_desc; 858 midi_function[i++] = (struct usb_descriptor_header *) &ms_interface_desc; 859 860 /* calculate the header's wTotalLength */ 861 n = USB_DT_MS_HEADER_SIZE 862 + (midi->in_ports + midi->out_ports) * 863 (USB_DT_MIDI_IN_SIZE + USB_DT_MIDI_OUT_SIZE(1)); 864 ms_header_desc.wTotalLength = cpu_to_le16(n); 865 866 midi_function[i++] = (struct usb_descriptor_header *) &ms_header_desc; 867 868 /* configure the external IN jacks, each linked to an embedded OUT jack */ 869 for (n = 0; n < midi->in_ports; n++) { 870 struct usb_midi_in_jack_descriptor *in_ext = &jack_in_ext_desc[n]; 871 struct usb_midi_out_jack_descriptor_1 *out_emb = &jack_out_emb_desc[n]; 872 873 in_ext->bLength = USB_DT_MIDI_IN_SIZE; 874 in_ext->bDescriptorType = USB_DT_CS_INTERFACE; 875 in_ext->bDescriptorSubtype = USB_MS_MIDI_IN_JACK; 876 in_ext->bJackType = USB_MS_EXTERNAL; 877 in_ext->bJackID = jack++; 878 in_ext->iJack = 0; 879 midi_function[i++] = (struct usb_descriptor_header *) in_ext; 880 881 out_emb->bLength = USB_DT_MIDI_OUT_SIZE(1); 882 out_emb->bDescriptorType = USB_DT_CS_INTERFACE; 883 out_emb->bDescriptorSubtype = USB_MS_MIDI_OUT_JACK; 884 out_emb->bJackType = USB_MS_EMBEDDED; 885 out_emb->bJackID = jack++; 886 out_emb->bNrInputPins = 1; 887 out_emb->pins[0].baSourcePin = 1; 888 out_emb->pins[0].baSourceID = in_ext->bJackID; 889 out_emb->iJack = 0; 890 midi_function[i++] = (struct usb_descriptor_header *) out_emb; 891 892 /* link it to the endpoint */ 893 ms_in_desc.baAssocJackID[n] = out_emb->bJackID; 894 } 895 896 /* configure the external OUT jacks, each linked to an embedded IN jack */ 897 for (n = 0; n < midi->out_ports; n++) { 898 struct usb_midi_in_jack_descriptor *in_emb = &jack_in_emb_desc[n]; 899 struct usb_midi_out_jack_descriptor_1 *out_ext = &jack_out_ext_desc[n]; 900 901 in_emb->bLength = USB_DT_MIDI_IN_SIZE; 902 in_emb->bDescriptorType = USB_DT_CS_INTERFACE; 903 in_emb->bDescriptorSubtype = USB_MS_MIDI_IN_JACK; 904 in_emb->bJackType = USB_MS_EMBEDDED; 905 in_emb->bJackID = jack++; 906 in_emb->iJack = 0; 907 midi_function[i++] = (struct usb_descriptor_header *) in_emb; 908 909 out_ext->bLength = USB_DT_MIDI_OUT_SIZE(1); 910 out_ext->bDescriptorType = USB_DT_CS_INTERFACE; 911 out_ext->bDescriptorSubtype = USB_MS_MIDI_OUT_JACK; 912 out_ext->bJackType = USB_MS_EXTERNAL; 913 out_ext->bJackID = jack++; 914 out_ext->bNrInputPins = 1; 915 out_ext->iJack = 0; 916 out_ext->pins[0].baSourceID = in_emb->bJackID; 917 out_ext->pins[0].baSourcePin = 1; 918 midi_function[i++] = (struct usb_descriptor_header *) out_ext; 919 920 /* link it to the endpoint */ 921 ms_out_desc.baAssocJackID[n] = in_emb->bJackID; 922 } 923 924 /* configure the endpoint descriptors ... */ 925 ms_out_desc.bLength = USB_DT_MS_ENDPOINT_SIZE(midi->in_ports); 926 ms_out_desc.bNumEmbMIDIJack = midi->in_ports; 927 928 ms_in_desc.bLength = USB_DT_MS_ENDPOINT_SIZE(midi->out_ports); 929 ms_in_desc.bNumEmbMIDIJack = midi->out_ports; 930 931 /* ... and add them to the list */ 932 midi_function[i++] = (struct usb_descriptor_header *) &bulk_out_desc; 933 midi_function[i++] = (struct usb_descriptor_header *) &ms_out_desc; 934 midi_function[i++] = (struct usb_descriptor_header *) &bulk_in_desc; 935 midi_function[i++] = (struct usb_descriptor_header *) &ms_in_desc; 936 midi_function[i++] = NULL; 937 938 /* 939 * support all relevant hardware speeds... we expect that when 940 * hardware is dual speed, all bulk-capable endpoints work at 941 * both speeds 942 */ 943 /* copy descriptors, and track endpoint copies */ 944 f->fs_descriptors = usb_copy_descriptors(midi_function); 945 if (!f->fs_descriptors) 946 goto fail_f_midi; 947 948 if (gadget_is_dualspeed(c->cdev->gadget)) { 949 bulk_in_desc.wMaxPacketSize = cpu_to_le16(512); 950 bulk_out_desc.wMaxPacketSize = cpu_to_le16(512); 951 f->hs_descriptors = usb_copy_descriptors(midi_function); 952 if (!f->hs_descriptors) 953 goto fail_f_midi; 954 } 955 956 kfree(midi_function); 957 958 return 0; 959 960 fail_f_midi: 961 kfree(midi_function); 962 usb_free_descriptors(f->hs_descriptors); 963 fail: 964 f_midi_unregister_card(midi); 965 fail_register: 966 ERROR(cdev, "%s: can't bind, err %d\n", f->name, status); 967 968 return status; 969 } 970 971 static inline struct f_midi_opts *to_f_midi_opts(struct config_item *item) 972 { 973 return container_of(to_config_group(item), struct f_midi_opts, 974 func_inst.group); 975 } 976 977 static void midi_attr_release(struct config_item *item) 978 { 979 struct f_midi_opts *opts = to_f_midi_opts(item); 980 981 usb_put_function_instance(&opts->func_inst); 982 } 983 984 static struct configfs_item_operations midi_item_ops = { 985 .release = midi_attr_release, 986 }; 987 988 #define F_MIDI_OPT(name, test_limit, limit) \ 989 static ssize_t f_midi_opts_##name##_show(struct config_item *item, char *page) \ 990 { \ 991 struct f_midi_opts *opts = to_f_midi_opts(item); \ 992 int result; \ 993 \ 994 mutex_lock(&opts->lock); \ 995 result = sprintf(page, "%d\n", opts->name); \ 996 mutex_unlock(&opts->lock); \ 997 \ 998 return result; \ 999 } \ 1000 \ 1001 static ssize_t f_midi_opts_##name##_store(struct config_item *item, \ 1002 const char *page, size_t len) \ 1003 { \ 1004 struct f_midi_opts *opts = to_f_midi_opts(item); \ 1005 int ret; \ 1006 u32 num; \ 1007 \ 1008 mutex_lock(&opts->lock); \ 1009 if (opts->refcnt) { \ 1010 ret = -EBUSY; \ 1011 goto end; \ 1012 } \ 1013 \ 1014 ret = kstrtou32(page, 0, &num); \ 1015 if (ret) \ 1016 goto end; \ 1017 \ 1018 if (test_limit && num > limit) { \ 1019 ret = -EINVAL; \ 1020 goto end; \ 1021 } \ 1022 opts->name = num; \ 1023 ret = len; \ 1024 \ 1025 end: \ 1026 mutex_unlock(&opts->lock); \ 1027 return ret; \ 1028 } \ 1029 \ 1030 CONFIGFS_ATTR(f_midi_opts_, name); 1031 1032 F_MIDI_OPT(index, true, SNDRV_CARDS); 1033 F_MIDI_OPT(buflen, false, 0); 1034 F_MIDI_OPT(qlen, false, 0); 1035 F_MIDI_OPT(in_ports, true, MAX_PORTS); 1036 F_MIDI_OPT(out_ports, true, MAX_PORTS); 1037 1038 static ssize_t f_midi_opts_id_show(struct config_item *item, char *page) 1039 { 1040 struct f_midi_opts *opts = to_f_midi_opts(item); 1041 int result; 1042 1043 mutex_lock(&opts->lock); 1044 if (opts->id) { 1045 result = strlcpy(page, opts->id, PAGE_SIZE); 1046 } else { 1047 page[0] = 0; 1048 result = 0; 1049 } 1050 1051 mutex_unlock(&opts->lock); 1052 1053 return result; 1054 } 1055 1056 static ssize_t f_midi_opts_id_store(struct config_item *item, 1057 const char *page, size_t len) 1058 { 1059 struct f_midi_opts *opts = to_f_midi_opts(item); 1060 int ret; 1061 char *c; 1062 1063 mutex_lock(&opts->lock); 1064 if (opts->refcnt) { 1065 ret = -EBUSY; 1066 goto end; 1067 } 1068 1069 c = kstrndup(page, len, GFP_KERNEL); 1070 if (!c) { 1071 ret = -ENOMEM; 1072 goto end; 1073 } 1074 if (opts->id_allocated) 1075 kfree(opts->id); 1076 opts->id = c; 1077 opts->id_allocated = true; 1078 ret = len; 1079 end: 1080 mutex_unlock(&opts->lock); 1081 return ret; 1082 } 1083 1084 CONFIGFS_ATTR(f_midi_opts_, id); 1085 1086 static struct configfs_attribute *midi_attrs[] = { 1087 &f_midi_opts_attr_index, 1088 &f_midi_opts_attr_buflen, 1089 &f_midi_opts_attr_qlen, 1090 &f_midi_opts_attr_in_ports, 1091 &f_midi_opts_attr_out_ports, 1092 &f_midi_opts_attr_id, 1093 NULL, 1094 }; 1095 1096 static struct config_item_type midi_func_type = { 1097 .ct_item_ops = &midi_item_ops, 1098 .ct_attrs = midi_attrs, 1099 .ct_owner = THIS_MODULE, 1100 }; 1101 1102 static void f_midi_free_inst(struct usb_function_instance *f) 1103 { 1104 struct f_midi_opts *opts; 1105 1106 opts = container_of(f, struct f_midi_opts, func_inst); 1107 1108 if (opts->id_allocated) 1109 kfree(opts->id); 1110 1111 kfree(opts); 1112 } 1113 1114 static struct usb_function_instance *f_midi_alloc_inst(void) 1115 { 1116 struct f_midi_opts *opts; 1117 1118 opts = kzalloc(sizeof(*opts), GFP_KERNEL); 1119 if (!opts) 1120 return ERR_PTR(-ENOMEM); 1121 1122 mutex_init(&opts->lock); 1123 opts->func_inst.free_func_inst = f_midi_free_inst; 1124 opts->index = SNDRV_DEFAULT_IDX1; 1125 opts->id = SNDRV_DEFAULT_STR1; 1126 opts->buflen = 256; 1127 opts->qlen = 32; 1128 opts->in_ports = 1; 1129 opts->out_ports = 1; 1130 1131 config_group_init_type_name(&opts->func_inst.group, "", 1132 &midi_func_type); 1133 1134 return &opts->func_inst; 1135 } 1136 1137 static void f_midi_free(struct usb_function *f) 1138 { 1139 struct f_midi *midi; 1140 struct f_midi_opts *opts; 1141 1142 midi = func_to_midi(f); 1143 opts = container_of(f->fi, struct f_midi_opts, func_inst); 1144 kfree(midi->id); 1145 mutex_lock(&opts->lock); 1146 kfifo_free(&midi->in_req_fifo); 1147 kfree(midi); 1148 --opts->refcnt; 1149 mutex_unlock(&opts->lock); 1150 } 1151 1152 static void f_midi_unbind(struct usb_configuration *c, struct usb_function *f) 1153 { 1154 struct usb_composite_dev *cdev = f->config->cdev; 1155 struct f_midi *midi = func_to_midi(f); 1156 struct snd_card *card; 1157 1158 DBG(cdev, "unbind\n"); 1159 1160 /* just to be sure */ 1161 f_midi_disable(f); 1162 1163 card = midi->card; 1164 midi->card = NULL; 1165 if (card) 1166 snd_card_free(card); 1167 1168 usb_free_all_descriptors(f); 1169 } 1170 1171 static struct usb_function *f_midi_alloc(struct usb_function_instance *fi) 1172 { 1173 struct f_midi *midi = NULL; 1174 struct f_midi_opts *opts; 1175 int status, i; 1176 1177 opts = container_of(fi, struct f_midi_opts, func_inst); 1178 1179 mutex_lock(&opts->lock); 1180 /* sanity check */ 1181 if (opts->in_ports > MAX_PORTS || opts->out_ports > MAX_PORTS) { 1182 status = -EINVAL; 1183 goto setup_fail; 1184 } 1185 1186 /* allocate and initialize one new instance */ 1187 midi = kzalloc( 1188 sizeof(*midi) + opts->in_ports * sizeof(*midi->in_ports_array), 1189 GFP_KERNEL); 1190 if (!midi) { 1191 status = -ENOMEM; 1192 goto setup_fail; 1193 } 1194 1195 for (i = 0; i < opts->in_ports; i++) 1196 midi->in_ports_array[i].cable = i; 1197 1198 /* set up ALSA midi devices */ 1199 midi->id = kstrdup(opts->id, GFP_KERNEL); 1200 if (opts->id && !midi->id) { 1201 status = -ENOMEM; 1202 goto setup_fail; 1203 } 1204 midi->in_ports = opts->in_ports; 1205 midi->out_ports = opts->out_ports; 1206 midi->index = opts->index; 1207 midi->buflen = opts->buflen; 1208 midi->qlen = opts->qlen; 1209 midi->in_last_port = 0; 1210 1211 status = kfifo_alloc(&midi->in_req_fifo, midi->qlen, GFP_KERNEL); 1212 if (status) 1213 goto setup_fail; 1214 1215 spin_lock_init(&midi->transmit_lock); 1216 1217 ++opts->refcnt; 1218 mutex_unlock(&opts->lock); 1219 1220 midi->func.name = "gmidi function"; 1221 midi->func.bind = f_midi_bind; 1222 midi->func.unbind = f_midi_unbind; 1223 midi->func.set_alt = f_midi_set_alt; 1224 midi->func.disable = f_midi_disable; 1225 midi->func.free_func = f_midi_free; 1226 1227 return &midi->func; 1228 1229 setup_fail: 1230 mutex_unlock(&opts->lock); 1231 kfree(midi); 1232 return ERR_PTR(status); 1233 } 1234 1235 DECLARE_USB_FUNCTION_INIT(midi, f_midi_alloc_inst, f_midi_alloc); 1236