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