drivers/usb/gadget/function/f_midi.c

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