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