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