Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
f_midi.c
Go to the documentation of this file.
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 <[email protected]>
7  *
8  * Rewritten for the composite framework
9  * Copyright (C) 2011 Daniel Mack <[email protected]>
10  *
11  * Based on drivers/usb/gadget/f_audio.c,
12  * Copyright (C) 2008 Bryan Wu <[email protected]>
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 <[email protected]>
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 
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 
Generated on Thu Jan 10 2013 14:36:10 for Linux Kernel by   doxygen 1.8.2