aboutsummaryrefslogtreecommitdiffstats
path: root/drivers
diff options
context:
space:
mode:
authorDaniel Mack <zonque@gmail.com>2011-09-28 10:41:33 -0400
committerFelipe Balbi <balbi@ti.com>2011-10-13 13:39:51 -0400
commit2672eea5a38b35e6d28f851e990e110e217271eb (patch)
treef81ddf102229dde2ac37d8940dc6ba56a6de78a5 /drivers
parentd5daf49b58661ec4af7a55b277176efbf945ca05 (diff)
USB: gadget: midi: refactor the device code
Make use of the newly added MIDI function in f_midi.c and strip down the MIDI gadget code radically. Also use the generic framework function to avoid code duplication and rename some symbols to bring them in sync with other code in the gadget framework. [ balbi@ti.com : fix Section mismatch warnings. rebased on top of usb_speed_string() patch to avoid conflicts. ] Signed-off-by: Daniel Mack <zonque@gmail.com> Cc: Greg Kroah-Hartman <gregkh@suse.de> Signed-off-by: Felipe Balbi <balbi@ti.com>
Diffstat (limited to 'drivers')
-rw-r--r--drivers/usb/gadget/f_midi.c2
-rw-r--r--drivers/usb/gadget/gmidi.c1275
2 files changed, 80 insertions, 1197 deletions
diff --git a/drivers/usb/gadget/f_midi.c b/drivers/usb/gadget/f_midi.c
index 5064ea4efbed..84cbf85d23f8 100644
--- a/drivers/usb/gadget/f_midi.c
+++ b/drivers/usb/gadget/f_midi.c
@@ -225,7 +225,7 @@ static const struct usb_ms_endpoint_descriptor_1 ms_in_desc = {
225 } 225 }
226}; 226};
227 227
228static struct usb_descriptor_header *midi_function[] = { 228static struct usb_descriptor_header *midi_function[] __initdata = {
229 (struct usb_descriptor_header *)&ac_interface_desc, 229 (struct usb_descriptor_header *)&ac_interface_desc,
230 (struct usb_descriptor_header *)&ac_header_desc, 230 (struct usb_descriptor_header *)&ac_header_desc,
231 (struct usb_descriptor_header *)&ms_interface_desc, 231 (struct usb_descriptor_header *)&ms_interface_desc,
diff --git a/drivers/usb/gadget/gmidi.c b/drivers/usb/gadget/gmidi.c
index 893b967b0aff..e7c8c3907133 100644
--- a/drivers/usb/gadget/gmidi.c
+++ b/drivers/usb/gadget/gmidi.c
@@ -36,134 +36,35 @@
36 36
37#include "gadget_chips.h" 37#include "gadget_chips.h"
38 38
39 39#include "composite.c"
40/*
41 * Kbuild is not very cooperative with respect to linking separately
42 * compiled library objects into one module. So for now we won't use
43 * separate compilation ... ensuring init/exit sections work to shrink
44 * the runtime footprint, and giving us at least some parts of what
45 * a "gcc --combine ... part1.c part2.c part3.c ... " build would.
46 */
47#include "usbstring.c" 40#include "usbstring.c"
48#include "config.c" 41#include "config.c"
49#include "epautoconf.c" 42#include "epautoconf.c"
43#include "f_midi.c"
50 44
51/*-------------------------------------------------------------------------*/ 45/*-------------------------------------------------------------------------*/
52 46
53
54MODULE_AUTHOR("Ben Williamson"); 47MODULE_AUTHOR("Ben Williamson");
55MODULE_LICENSE("GPL v2"); 48MODULE_LICENSE("GPL v2");
56 49
57#define DRIVER_VERSION "25 Jul 2006"
58
59static const char shortname[] = "g_midi"; 50static const char shortname[] = "g_midi";
60static const char longname[] = "MIDI Gadget"; 51static const char longname[] = "MIDI Gadget";
61 52
62static int index = SNDRV_DEFAULT_IDX1; 53static int index = SNDRV_DEFAULT_IDX1;
63static char *id = SNDRV_DEFAULT_STR1; 54module_param(index, int, S_IRUGO);
64
65module_param(index, int, 0444);
66MODULE_PARM_DESC(index, "Index value for the USB MIDI Gadget adapter."); 55MODULE_PARM_DESC(index, "Index value for the USB MIDI Gadget adapter.");
67module_param(id, charp, 0444);
68MODULE_PARM_DESC(id, "ID string for the USB MIDI Gadget adapter.");
69
70/* Some systems will want different product identifiers published in the
71 * device descriptor, either numbers or strings or both. These string
72 * parameters are in UTF-8 (superset of ASCII's 7 bit characters).
73 */
74
75static ushort idVendor;
76module_param(idVendor, ushort, S_IRUGO);
77MODULE_PARM_DESC(idVendor, "USB Vendor ID");
78
79static ushort idProduct;
80module_param(idProduct, ushort, S_IRUGO);
81MODULE_PARM_DESC(idProduct, "USB Product ID");
82
83static ushort bcdDevice;
84module_param(bcdDevice, ushort, S_IRUGO);
85MODULE_PARM_DESC(bcdDevice, "USB Device version (BCD)");
86
87static char *iManufacturer;
88module_param(iManufacturer, charp, S_IRUGO);
89MODULE_PARM_DESC(iManufacturer, "USB Manufacturer string");
90
91static char *iProduct;
92module_param(iProduct, charp, S_IRUGO);
93MODULE_PARM_DESC(iProduct, "USB Product string");
94
95static char *iSerialNumber;
96module_param(iSerialNumber, charp, S_IRUGO);
97MODULE_PARM_DESC(iSerialNumber, "SerialNumber");
98
99/*
100 * this version autoconfigures as much as possible,
101 * which is reasonable for most "bulk-only" drivers.
102 */
103static const char *EP_IN_NAME;
104static const char *EP_OUT_NAME;
105 56
57static char *id = SNDRV_DEFAULT_STR1;
58module_param(id, charp, S_IRUGO);
59MODULE_PARM_DESC(id, "ID string for the USB MIDI Gadget adapter.");
106 60
107/* big enough to hold our biggest descriptor */ 61static unsigned int buflen = 256;
108#define USB_BUFSIZ 256
109
110
111/* This is a gadget, and the IN/OUT naming is from the host's perspective.
112 USB -> OUT endpoint -> rawmidi
113 USB <- IN endpoint <- rawmidi */
114struct gmidi_in_port {
115 struct gmidi_device* dev;
116 int active;
117 uint8_t cable; /* cable number << 4 */
118 uint8_t state;
119#define STATE_UNKNOWN 0
120#define STATE_1PARAM 1
121#define STATE_2PARAM_1 2
122#define STATE_2PARAM_2 3
123#define STATE_SYSEX_0 4
124#define STATE_SYSEX_1 5
125#define STATE_SYSEX_2 6
126 uint8_t data[2];
127};
128
129struct gmidi_device {
130 spinlock_t lock;
131 struct usb_gadget *gadget;
132 struct usb_request *req; /* for control responses */
133 u8 config;
134 struct usb_ep *in_ep, *out_ep;
135 struct snd_card *card;
136 struct snd_rawmidi *rmidi;
137 struct snd_rawmidi_substream *in_substream;
138 struct snd_rawmidi_substream *out_substream;
139
140 /* For the moment we only support one port in
141 each direction, but in_port is kept as a
142 separate struct so we can have more later. */
143 struct gmidi_in_port in_port;
144 unsigned long out_triggered;
145 struct tasklet_struct tasklet;
146};
147
148static void gmidi_transmit(struct gmidi_device* dev, struct usb_request* req);
149
150
151#define DBG(d, fmt, args...) \
152 dev_dbg(&(d)->gadget->dev , fmt , ## args)
153#define VDBG(d, fmt, args...) \
154 dev_vdbg(&(d)->gadget->dev , fmt , ## args)
155#define ERROR(d, fmt, args...) \
156 dev_err(&(d)->gadget->dev , fmt , ## args)
157#define INFO(d, fmt, args...) \
158 dev_info(&(d)->gadget->dev , fmt , ## args)
159
160
161static unsigned buflen = 256;
162static unsigned qlen = 32;
163
164module_param(buflen, uint, S_IRUGO); 62module_param(buflen, uint, S_IRUGO);
165module_param(qlen, uint, S_IRUGO); 63MODULE_PARM_DESC(buflen, "MIDI buffer length");
166 64
65static unsigned int qlen = 32;
66module_param(qlen, uint, S_IRUGO);
67MODULE_PARM_DESC(qlen, "USB read request queue length");
167 68
168/* Thanks to Grey Innovation for donating this product ID. 69/* Thanks to Grey Innovation for donating this product ID.
169 * 70 *
@@ -173,1140 +74,122 @@ module_param(qlen, uint, S_IRUGO);
173#define DRIVER_VENDOR_NUM 0x17b3 /* Grey Innovation */ 74#define DRIVER_VENDOR_NUM 0x17b3 /* Grey Innovation */
174#define DRIVER_PRODUCT_NUM 0x0004 /* Linux-USB "MIDI Gadget" */ 75#define DRIVER_PRODUCT_NUM 0x0004 /* Linux-USB "MIDI Gadget" */
175 76
77/* string IDs are assigned dynamically */
176 78
177/* 79#define STRING_MANUFACTURER_IDX 0
178 * DESCRIPTORS ... most are static, but strings and (full) 80#define STRING_PRODUCT_IDX 1
179 * configuration descriptors are built on demand. 81#define STRING_DESCRIPTION_IDX 2
180 */
181
182#define STRING_MANUFACTURER 25
183#define STRING_PRODUCT 42
184#define STRING_SERIAL 101
185#define STRING_MIDI_GADGET 250
186
187/* We only have the one configuration, it's number 1. */
188#define GMIDI_CONFIG 1
189
190/* We have two interfaces- AudioControl and MIDIStreaming */
191#define GMIDI_AC_INTERFACE 0
192#define GMIDI_MS_INTERFACE 1
193#define GMIDI_NUM_INTERFACES 2
194 82
195DECLARE_UAC_AC_HEADER_DESCRIPTOR(1);
196DECLARE_USB_MIDI_OUT_JACK_DESCRIPTOR(1);
197DECLARE_USB_MS_ENDPOINT_DESCRIPTOR(1);
198
199/* B.1 Device Descriptor */
200static struct usb_device_descriptor device_desc = { 83static struct usb_device_descriptor device_desc = {
201 .bLength = USB_DT_DEVICE_SIZE, 84 .bLength = USB_DT_DEVICE_SIZE,
202 .bDescriptorType = USB_DT_DEVICE, 85 .bDescriptorType = USB_DT_DEVICE,
203 .bcdUSB = cpu_to_le16(0x0200), 86 .bcdUSB = __constant_cpu_to_le16(0x0200),
204 .bDeviceClass = USB_CLASS_PER_INTERFACE, 87 .bDeviceClass = USB_CLASS_PER_INTERFACE,
205 .idVendor = cpu_to_le16(DRIVER_VENDOR_NUM), 88 .idVendor = __constant_cpu_to_le16(DRIVER_VENDOR_NUM),
206 .idProduct = cpu_to_le16(DRIVER_PRODUCT_NUM), 89 .idProduct = __constant_cpu_to_le16(DRIVER_PRODUCT_NUM),
207 .iManufacturer = STRING_MANUFACTURER, 90 /* .iManufacturer = DYNAMIC */
208 .iProduct = STRING_PRODUCT, 91 /* .iProduct = DYNAMIC */
209 .bNumConfigurations = 1, 92 .bNumConfigurations = 1,
210}; 93};
211 94
212/* B.2 Configuration Descriptor */ 95static struct usb_string strings_dev[] = {
213static struct usb_config_descriptor config_desc = { 96 [STRING_MANUFACTURER_IDX].s = "Grey Innovation",
214 .bLength = USB_DT_CONFIG_SIZE, 97 [STRING_PRODUCT_IDX].s = "MIDI Gadget",
215 .bDescriptorType = USB_DT_CONFIG, 98 [STRING_DESCRIPTION_IDX].s = "MIDI",
216 /* compute wTotalLength on the fly */ 99 { } /* end of list */
217 .bNumInterfaces = GMIDI_NUM_INTERFACES,
218 .bConfigurationValue = GMIDI_CONFIG,
219 .iConfiguration = STRING_MIDI_GADGET,
220 /*
221 * FIXME: When embedding this driver in a device,
222 * these need to be set to reflect the actual
223 * power properties of the device. Is it selfpowered?
224 */
225 .bmAttributes = USB_CONFIG_ATT_ONE,
226 .bMaxPower = CONFIG_USB_GADGET_VBUS_DRAW / 2,
227};
228
229/* B.3.1 Standard AC Interface Descriptor */
230static const struct usb_interface_descriptor ac_interface_desc = {
231 .bLength = USB_DT_INTERFACE_SIZE,
232 .bDescriptorType = USB_DT_INTERFACE,
233 .bInterfaceNumber = GMIDI_AC_INTERFACE,
234 .bNumEndpoints = 0,
235 .bInterfaceClass = USB_CLASS_AUDIO,
236 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
237 .iInterface = STRING_MIDI_GADGET,
238};
239
240/* B.3.2 Class-Specific AC Interface Descriptor */
241static const struct uac1_ac_header_descriptor_1 ac_header_desc = {
242 .bLength = UAC_DT_AC_HEADER_SIZE(1),
243 .bDescriptorType = USB_DT_CS_INTERFACE,
244 .bDescriptorSubtype = USB_MS_HEADER,
245 .bcdADC = cpu_to_le16(0x0100),
246 .wTotalLength = cpu_to_le16(UAC_DT_AC_HEADER_SIZE(1)),
247 .bInCollection = 1,
248 .baInterfaceNr = {
249 [0] = GMIDI_MS_INTERFACE,
250 }
251};
252
253/* B.4.1 Standard MS Interface Descriptor */
254static const struct usb_interface_descriptor ms_interface_desc = {
255 .bLength = USB_DT_INTERFACE_SIZE,
256 .bDescriptorType = USB_DT_INTERFACE,
257 .bInterfaceNumber = GMIDI_MS_INTERFACE,
258 .bNumEndpoints = 2,
259 .bInterfaceClass = USB_CLASS_AUDIO,
260 .bInterfaceSubClass = USB_SUBCLASS_MIDISTREAMING,
261 .iInterface = STRING_MIDI_GADGET,
262};
263
264/* B.4.2 Class-Specific MS Interface Descriptor */
265static const struct usb_ms_header_descriptor ms_header_desc = {
266 .bLength = USB_DT_MS_HEADER_SIZE,
267 .bDescriptorType = USB_DT_CS_INTERFACE,
268 .bDescriptorSubtype = USB_MS_HEADER,
269 .bcdMSC = cpu_to_le16(0x0100),
270 .wTotalLength = cpu_to_le16(USB_DT_MS_HEADER_SIZE
271 + 2*USB_DT_MIDI_IN_SIZE
272 + 2*USB_DT_MIDI_OUT_SIZE(1)),
273};
274
275#define JACK_IN_EMB 1
276#define JACK_IN_EXT 2
277#define JACK_OUT_EMB 3
278#define JACK_OUT_EXT 4
279
280/* B.4.3 MIDI IN Jack Descriptors */
281static const struct usb_midi_in_jack_descriptor jack_in_emb_desc = {
282 .bLength = USB_DT_MIDI_IN_SIZE,
283 .bDescriptorType = USB_DT_CS_INTERFACE,
284 .bDescriptorSubtype = USB_MS_MIDI_IN_JACK,
285 .bJackType = USB_MS_EMBEDDED,
286 .bJackID = JACK_IN_EMB,
287};
288
289static const struct usb_midi_in_jack_descriptor jack_in_ext_desc = {
290 .bLength = USB_DT_MIDI_IN_SIZE,
291 .bDescriptorType = USB_DT_CS_INTERFACE,
292 .bDescriptorSubtype = USB_MS_MIDI_IN_JACK,
293 .bJackType = USB_MS_EXTERNAL,
294 .bJackID = JACK_IN_EXT,
295};
296
297/* B.4.4 MIDI OUT Jack Descriptors */
298static const struct usb_midi_out_jack_descriptor_1 jack_out_emb_desc = {
299 .bLength = USB_DT_MIDI_OUT_SIZE(1),
300 .bDescriptorType = USB_DT_CS_INTERFACE,
301 .bDescriptorSubtype = USB_MS_MIDI_OUT_JACK,
302 .bJackType = USB_MS_EMBEDDED,
303 .bJackID = JACK_OUT_EMB,
304 .bNrInputPins = 1,
305 .pins = {
306 [0] = {
307 .baSourceID = JACK_IN_EXT,
308 .baSourcePin = 1,
309 }
310 }
311};
312
313static const struct usb_midi_out_jack_descriptor_1 jack_out_ext_desc = {
314 .bLength = USB_DT_MIDI_OUT_SIZE(1),
315 .bDescriptorType = USB_DT_CS_INTERFACE,
316 .bDescriptorSubtype = USB_MS_MIDI_OUT_JACK,
317 .bJackType = USB_MS_EXTERNAL,
318 .bJackID = JACK_OUT_EXT,
319 .bNrInputPins = 1,
320 .pins = {
321 [0] = {
322 .baSourceID = JACK_IN_EMB,
323 .baSourcePin = 1,
324 }
325 }
326};
327
328/* B.5.1 Standard Bulk OUT Endpoint Descriptor */
329static struct usb_endpoint_descriptor bulk_out_desc = {
330 .bLength = USB_DT_ENDPOINT_AUDIO_SIZE,
331 .bDescriptorType = USB_DT_ENDPOINT,
332 .bEndpointAddress = USB_DIR_OUT,
333 .bmAttributes = USB_ENDPOINT_XFER_BULK,
334};
335
336/* B.5.2 Class-specific MS Bulk OUT Endpoint Descriptor */
337static const struct usb_ms_endpoint_descriptor_1 ms_out_desc = {
338 .bLength = USB_DT_MS_ENDPOINT_SIZE(1),
339 .bDescriptorType = USB_DT_CS_ENDPOINT,
340 .bDescriptorSubtype = USB_MS_GENERAL,
341 .bNumEmbMIDIJack = 1,
342 .baAssocJackID = {
343 [0] = JACK_IN_EMB,
344 }
345};
346
347/* B.6.1 Standard Bulk IN Endpoint Descriptor */
348static struct usb_endpoint_descriptor bulk_in_desc = {
349 .bLength = USB_DT_ENDPOINT_AUDIO_SIZE,
350 .bDescriptorType = USB_DT_ENDPOINT,
351 .bEndpointAddress = USB_DIR_IN,
352 .bmAttributes = USB_ENDPOINT_XFER_BULK,
353};
354
355/* B.6.2 Class-specific MS Bulk IN Endpoint Descriptor */
356static const struct usb_ms_endpoint_descriptor_1 ms_in_desc = {
357 .bLength = USB_DT_MS_ENDPOINT_SIZE(1),
358 .bDescriptorType = USB_DT_CS_ENDPOINT,
359 .bDescriptorSubtype = USB_MS_GENERAL,
360 .bNumEmbMIDIJack = 1,
361 .baAssocJackID = {
362 [0] = JACK_OUT_EMB,
363 }
364};
365
366static const struct usb_descriptor_header *gmidi_function [] = {
367 (struct usb_descriptor_header *)&ac_interface_desc,
368 (struct usb_descriptor_header *)&ac_header_desc,
369 (struct usb_descriptor_header *)&ms_interface_desc,
370
371 (struct usb_descriptor_header *)&ms_header_desc,
372 (struct usb_descriptor_header *)&jack_in_emb_desc,
373 (struct usb_descriptor_header *)&jack_in_ext_desc,
374 (struct usb_descriptor_header *)&jack_out_emb_desc,
375 (struct usb_descriptor_header *)&jack_out_ext_desc,
376 /* If you add more jacks, update ms_header_desc.wTotalLength */
377
378 (struct usb_descriptor_header *)&bulk_out_desc,
379 (struct usb_descriptor_header *)&ms_out_desc,
380 (struct usb_descriptor_header *)&bulk_in_desc,
381 (struct usb_descriptor_header *)&ms_in_desc,
382 NULL,
383};
384
385static char manufacturer[50];
386static char product_desc[40] = "MIDI Gadget";
387static char serial_number[20];
388
389/* static strings, in UTF-8 */
390static struct usb_string strings [] = {
391 { STRING_MANUFACTURER, manufacturer, },
392 { STRING_PRODUCT, product_desc, },
393 { STRING_SERIAL, serial_number, },
394 { STRING_MIDI_GADGET, longname, },
395 { } /* end of list */
396}; 100};
397 101
398static struct usb_gadget_strings stringtab = { 102static struct usb_gadget_strings stringtab_dev = {
399 .language = 0x0409, /* en-us */ 103 .language = 0x0409, /* en-us */
400 .strings = strings, 104 .strings = strings_dev,
401}; 105};
402 106
403static int config_buf(struct usb_gadget *gadget, 107static struct usb_gadget_strings *dev_strings[] = {
404 u8 *buf, u8 type, unsigned index) 108 &stringtab_dev,
405{ 109 NULL,
406 int len;
407
408 /* only one configuration */
409 if (index != 0) {
410 return -EINVAL;
411 }
412 len = usb_gadget_config_buf(&config_desc,
413 buf, USB_BUFSIZ, gmidi_function);
414 if (len < 0) {
415 return len;
416 }
417 ((struct usb_config_descriptor *)buf)->bDescriptorType = type;
418 return len;
419}
420
421static struct usb_request *alloc_ep_req(struct usb_ep *ep, unsigned length)
422{
423 struct usb_request *req;
424
425 req = usb_ep_alloc_request(ep, GFP_ATOMIC);
426 if (req) {
427 req->length = length;
428 req->buf = kmalloc(length, GFP_ATOMIC);
429 if (!req->buf) {
430 usb_ep_free_request(ep, req);
431 req = NULL;
432 }
433 }
434 return req;
435}
436
437static void free_ep_req(struct usb_ep *ep, struct usb_request *req)
438{
439 kfree(req->buf);
440 usb_ep_free_request(ep, req);
441}
442
443static const uint8_t gmidi_cin_length[] = {
444 0, 0, 2, 3, 3, 1, 2, 3, 3, 3, 3, 3, 2, 2, 3, 1
445}; 110};
446 111
447/* 112static int __exit midi_unbind(struct usb_composite_dev *dev)
448 * Receives a chunk of MIDI data.
449 */
450static void gmidi_read_data(struct usb_ep *ep, int cable,
451 uint8_t *data, int length)
452{
453 struct gmidi_device *dev = ep->driver_data;
454 /* cable is ignored, because for now we only have one. */
455
456 if (!dev->out_substream) {
457 /* Nobody is listening - throw it on the floor. */
458 return;
459 }
460 if (!test_bit(dev->out_substream->number, &dev->out_triggered)) {
461 return;
462 }
463 snd_rawmidi_receive(dev->out_substream, data, length);
464}
465
466static void gmidi_handle_out_data(struct usb_ep *ep, struct usb_request *req)
467{
468 unsigned i;
469 u8 *buf = req->buf;
470
471 for (i = 0; i + 3 < req->actual; i += 4) {
472 if (buf[i] != 0) {
473 int cable = buf[i] >> 4;
474 int length = gmidi_cin_length[buf[i] & 0x0f];
475 gmidi_read_data(ep, cable, &buf[i + 1], length);
476 }
477 }
478}
479
480static void gmidi_complete(struct usb_ep *ep, struct usb_request *req)
481{
482 struct gmidi_device *dev = ep->driver_data;
483 int status = req->status;
484
485 switch (status) {
486 case 0: /* normal completion */
487 if (ep == dev->out_ep) {
488 /* we received stuff.
489 req is queued again, below */
490 gmidi_handle_out_data(ep, req);
491 } else if (ep == dev->in_ep) {
492 /* our transmit completed.
493 see if there's more to go.
494 gmidi_transmit eats req, don't queue it again. */
495 gmidi_transmit(dev, req);
496 return;
497 }
498 break;
499
500 /* this endpoint is normally active while we're configured */
501 case -ECONNABORTED: /* hardware forced ep reset */
502 case -ECONNRESET: /* request dequeued */
503 case -ESHUTDOWN: /* disconnect from host */
504 VDBG(dev, "%s gone (%d), %d/%d\n", ep->name, status,
505 req->actual, req->length);
506 if (ep == dev->out_ep) {
507 gmidi_handle_out_data(ep, req);
508 }
509 free_ep_req(ep, req);
510 return;
511
512 case -EOVERFLOW: /* buffer overrun on read means that
513 * we didn't provide a big enough
514 * buffer.
515 */
516 default:
517 DBG(dev, "%s complete --> %d, %d/%d\n", ep->name,
518 status, req->actual, req->length);
519 break;
520 case -EREMOTEIO: /* short read */
521 break;
522 }
523
524 status = usb_ep_queue(ep, req, GFP_ATOMIC);
525 if (status) {
526 ERROR(dev, "kill %s: resubmit %d bytes --> %d\n",
527 ep->name, req->length, status);
528 usb_ep_set_halt(ep);
529 /* FIXME recover later ... somehow */
530 }
531}
532
533static int set_gmidi_config(struct gmidi_device *dev, gfp_t gfp_flags)
534{
535 int err = 0;
536 struct usb_request *req;
537 struct usb_ep *ep;
538 unsigned i;
539
540 dev->in_ep->desc = &bulk_in_desc;
541 err = usb_ep_enable(dev->in_ep);
542 if (err) {
543 ERROR(dev, "can't start %s: %d\n", dev->in_ep->name, err);
544 goto fail;
545 }
546 dev->in_ep->driver_data = dev;
547
548 dev->out_ep->desc = &bulk_out_desc;
549 err = usb_ep_enable(dev->out_ep);
550 if (err) {
551 ERROR(dev, "can't start %s: %d\n", dev->out_ep->name, err);
552 goto fail;
553 }
554 dev->out_ep->driver_data = dev;
555
556 /* allocate a bunch of read buffers and queue them all at once. */
557 ep = dev->out_ep;
558 for (i = 0; i < qlen && err == 0; i++) {
559 req = alloc_ep_req(ep, buflen);
560 if (req) {
561 req->complete = gmidi_complete;
562 err = usb_ep_queue(ep, req, GFP_ATOMIC);
563 if (err) {
564 DBG(dev, "%s queue req: %d\n", ep->name, err);
565 }
566 } else {
567 err = -ENOMEM;
568 }
569 }
570fail:
571 /* caller is responsible for cleanup on error */
572 return err;
573}
574
575
576static void gmidi_reset_config(struct gmidi_device *dev)
577{
578 if (dev->config == 0) {
579 return;
580 }
581
582 DBG(dev, "reset config\n");
583
584 /* just disable endpoints, forcing completion of pending i/o.
585 * all our completion handlers free their requests in this case.
586 */
587 usb_ep_disable(dev->in_ep);
588 usb_ep_disable(dev->out_ep);
589 dev->config = 0;
590}
591
592/* change our operational config. this code must agree with the code
593 * that returns config descriptors, and altsetting code.
594 *
595 * it's also responsible for power management interactions. some
596 * configurations might not work with our current power sources.
597 *
598 * note that some device controller hardware will constrain what this
599 * code can do, perhaps by disallowing more than one configuration or
600 * by limiting configuration choices (like the pxa2xx).
601 */
602static int
603gmidi_set_config(struct gmidi_device *dev, unsigned number, gfp_t gfp_flags)
604{
605 int result = 0;
606 struct usb_gadget *gadget = dev->gadget;
607
608#if 0
609 /* FIXME */
610 /* Hacking this bit out fixes a bug where on receipt of two
611 USB_REQ_SET_CONFIGURATION messages, we end up with no
612 buffered OUT requests waiting for data. This is clearly
613 hiding a bug elsewhere, because if the config didn't
614 change then we really shouldn't do anything. */
615 /* Having said that, when we do "change" from config 1
616 to config 1, we at least gmidi_reset_config() which
617 clears out any requests on endpoints, so it's not like
618 we leak or anything. */
619 if (number == dev->config) {
620 return 0;
621 }
622#endif
623
624 gmidi_reset_config(dev);
625
626 switch (number) {
627 case GMIDI_CONFIG:
628 result = set_gmidi_config(dev, gfp_flags);
629 break;
630 default:
631 result = -EINVAL;
632 /* FALL THROUGH */
633 case 0:
634 return result;
635 }
636
637 if (!result && (!dev->in_ep || !dev->out_ep)) {
638 result = -ENODEV;
639 }
640 if (result) {
641 gmidi_reset_config(dev);
642 } else {
643 dev->config = number;
644 INFO(dev, "%s speed\n", usb_speed_string(gadget->speed));
645 }
646 return result;
647}
648
649
650static void gmidi_setup_complete(struct usb_ep *ep, struct usb_request *req)
651{ 113{
652 if (req->status || req->actual != req->length) {
653 DBG((struct gmidi_device *) ep->driver_data,
654 "setup complete --> %d, %d/%d\n",
655 req->status, req->actual, req->length);
656 }
657}
658
659/*
660 * The setup() callback implements all the ep0 functionality that's
661 * not handled lower down, in hardware or the hardware driver (like
662 * device and endpoint feature flags, and their status). It's all
663 * housekeeping for the gadget function we're implementing. Most of
664 * the work is in config-specific setup.
665 */
666static int gmidi_setup(struct usb_gadget *gadget,
667 const struct usb_ctrlrequest *ctrl)
668{
669 struct gmidi_device *dev = get_gadget_data(gadget);
670 struct usb_request *req = dev->req;
671 int value = -EOPNOTSUPP;
672 u16 w_index = le16_to_cpu(ctrl->wIndex);
673 u16 w_value = le16_to_cpu(ctrl->wValue);
674 u16 w_length = le16_to_cpu(ctrl->wLength);
675
676 /* usually this stores reply data in the pre-allocated ep0 buffer,
677 * but config change events will reconfigure hardware.
678 */
679 req->zero = 0;
680 switch (ctrl->bRequest) {
681
682 case USB_REQ_GET_DESCRIPTOR:
683 if (ctrl->bRequestType != USB_DIR_IN) {
684 goto unknown;
685 }
686 switch (w_value >> 8) {
687
688 case USB_DT_DEVICE:
689 device_desc.bMaxPacketSize0 = gadget->ep0->maxpacket;
690 value = min(w_length, (u16) sizeof(device_desc));
691 memcpy(req->buf, &device_desc, value);
692 break;
693 case USB_DT_CONFIG:
694 value = config_buf(gadget, req->buf,
695 w_value >> 8,
696 w_value & 0xff);
697 if (value >= 0) {
698 value = min(w_length, (u16)value);
699 }
700 break;
701
702 case USB_DT_STRING:
703 /* wIndex == language code.
704 * this driver only handles one language, you can
705 * add string tables for other languages, using
706 * any UTF-8 characters
707 */
708 value = usb_gadget_get_string(&stringtab,
709 w_value & 0xff, req->buf);
710 if (value >= 0) {
711 value = min(w_length, (u16)value);
712 }
713 break;
714 }
715 break;
716
717 /* currently two configs, two speeds */
718 case USB_REQ_SET_CONFIGURATION:
719 if (ctrl->bRequestType != 0) {
720 goto unknown;
721 }
722 if (gadget->a_hnp_support) {
723 DBG(dev, "HNP available\n");
724 } else if (gadget->a_alt_hnp_support) {
725 DBG(dev, "HNP needs a different root port\n");
726 } else {
727 VDBG(dev, "HNP inactive\n");
728 }
729 spin_lock(&dev->lock);
730 value = gmidi_set_config(dev, w_value, GFP_ATOMIC);
731 spin_unlock(&dev->lock);
732 break;
733 case USB_REQ_GET_CONFIGURATION:
734 if (ctrl->bRequestType != USB_DIR_IN) {
735 goto unknown;
736 }
737 *(u8 *)req->buf = dev->config;
738 value = min(w_length, (u16)1);
739 break;
740
741 /* until we add altsetting support, or other interfaces,
742 * only 0/0 are possible. pxa2xx only supports 0/0 (poorly)
743 * and already killed pending endpoint I/O.
744 */
745 case USB_REQ_SET_INTERFACE:
746 if (ctrl->bRequestType != USB_RECIP_INTERFACE) {
747 goto unknown;
748 }
749 spin_lock(&dev->lock);
750 if (dev->config && w_index < GMIDI_NUM_INTERFACES
751 && w_value == 0)
752 {
753 u8 config = dev->config;
754
755 /* resets interface configuration, forgets about
756 * previous transaction state (queued bufs, etc)
757 * and re-inits endpoint state (toggle etc)
758 * no response queued, just zero status == success.
759 * if we had more than one interface we couldn't
760 * use this "reset the config" shortcut.
761 */
762 gmidi_reset_config(dev);
763 gmidi_set_config(dev, config, GFP_ATOMIC);
764 value = 0;
765 }
766 spin_unlock(&dev->lock);
767 break;
768 case USB_REQ_GET_INTERFACE:
769 if (ctrl->bRequestType != (USB_DIR_IN|USB_RECIP_INTERFACE)) {
770 goto unknown;
771 }
772 if (!dev->config) {
773 break;
774 }
775 if (w_index >= GMIDI_NUM_INTERFACES) {
776 value = -EDOM;
777 break;
778 }
779 *(u8 *)req->buf = 0;
780 value = min(w_length, (u16)1);
781 break;
782
783 default:
784unknown:
785 VDBG(dev, "unknown control req%02x.%02x v%04x i%04x l%d\n",
786 ctrl->bRequestType, ctrl->bRequest,
787 w_value, w_index, w_length);
788 }
789
790 /* respond with data transfer before status phase? */
791 if (value >= 0) {
792 req->length = value;
793 req->zero = value < w_length;
794 value = usb_ep_queue(gadget->ep0, req, GFP_ATOMIC);
795 if (value < 0) {
796 DBG(dev, "ep_queue --> %d\n", value);
797 req->status = 0;
798 gmidi_setup_complete(gadget->ep0, req);
799 }
800 }
801
802 /* device either stalls (value < 0) or reports success */
803 return value;
804}
805
806static void gmidi_disconnect(struct usb_gadget *gadget)
807{
808 struct gmidi_device *dev = get_gadget_data(gadget);
809 unsigned long flags;
810
811 spin_lock_irqsave(&dev->lock, flags);
812 gmidi_reset_config(dev);
813
814 /* a more significant application might have some non-usb
815 * activities to quiesce here, saving resources like power
816 * or pushing the notification up a network stack.
817 */
818 spin_unlock_irqrestore(&dev->lock, flags);
819
820 /* next we may get setup() calls to enumerate new connections;
821 * or an unbind() during shutdown (including removing module).
822 */
823}
824
825static void /* __init_or_exit */ gmidi_unbind(struct usb_gadget *gadget)
826{
827 struct gmidi_device *dev = get_gadget_data(gadget);
828 struct snd_card *card;
829
830 DBG(dev, "unbind\n");
831
832 card = dev->card;
833 dev->card = NULL;
834 if (card) {
835 snd_card_free(card);
836 }
837
838 /* we've already been disconnected ... no i/o is active */
839 if (dev->req) {
840 dev->req->length = USB_BUFSIZ;
841 free_ep_req(gadget->ep0, dev->req);
842 }
843 kfree(dev);
844 set_gadget_data(gadget, NULL);
845}
846
847static int gmidi_snd_free(struct snd_device *device)
848{
849 return 0;
850}
851
852static void gmidi_transmit_packet(struct usb_request *req, uint8_t p0,
853 uint8_t p1, uint8_t p2, uint8_t p3)
854{
855 unsigned length = req->length;
856 u8 *buf = (u8 *)req->buf + length;
857
858 buf[0] = p0;
859 buf[1] = p1;
860 buf[2] = p2;
861 buf[3] = p3;
862 req->length = length + 4;
863}
864
865/*
866 * Converts MIDI commands to USB MIDI packets.
867 */
868static void gmidi_transmit_byte(struct usb_request *req,
869 struct gmidi_in_port *port, uint8_t b)
870{
871 uint8_t p0 = port->cable;
872
873 if (b >= 0xf8) {
874 gmidi_transmit_packet(req, p0 | 0x0f, b, 0, 0);
875 } else if (b >= 0xf0) {
876 switch (b) {
877 case 0xf0:
878 port->data[0] = b;
879 port->state = STATE_SYSEX_1;
880 break;
881 case 0xf1:
882 case 0xf3:
883 port->data[0] = b;
884 port->state = STATE_1PARAM;
885 break;
886 case 0xf2:
887 port->data[0] = b;
888 port->state = STATE_2PARAM_1;
889 break;
890 case 0xf4:
891 case 0xf5:
892 port->state = STATE_UNKNOWN;
893 break;
894 case 0xf6:
895 gmidi_transmit_packet(req, p0 | 0x05, 0xf6, 0, 0);
896 port->state = STATE_UNKNOWN;
897 break;
898 case 0xf7:
899 switch (port->state) {
900 case STATE_SYSEX_0:
901 gmidi_transmit_packet(req,
902 p0 | 0x05, 0xf7, 0, 0);
903 break;
904 case STATE_SYSEX_1:
905 gmidi_transmit_packet(req,
906 p0 | 0x06, port->data[0], 0xf7, 0);
907 break;
908 case STATE_SYSEX_2:
909 gmidi_transmit_packet(req,
910 p0 | 0x07, port->data[0],
911 port->data[1], 0xf7);
912 break;
913 }
914 port->state = STATE_UNKNOWN;
915 break;
916 }
917 } else if (b >= 0x80) {
918 port->data[0] = b;
919 if (b >= 0xc0 && b <= 0xdf)
920 port->state = STATE_1PARAM;
921 else
922 port->state = STATE_2PARAM_1;
923 } else { /* b < 0x80 */
924 switch (port->state) {
925 case STATE_1PARAM:
926 if (port->data[0] < 0xf0) {
927 p0 |= port->data[0] >> 4;
928 } else {
929 p0 |= 0x02;
930 port->state = STATE_UNKNOWN;
931 }
932 gmidi_transmit_packet(req, p0, port->data[0], b, 0);
933 break;
934 case STATE_2PARAM_1:
935 port->data[1] = b;
936 port->state = STATE_2PARAM_2;
937 break;
938 case STATE_2PARAM_2:
939 if (port->data[0] < 0xf0) {
940 p0 |= port->data[0] >> 4;
941 port->state = STATE_2PARAM_1;
942 } else {
943 p0 |= 0x03;
944 port->state = STATE_UNKNOWN;
945 }
946 gmidi_transmit_packet(req,
947 p0, port->data[0], port->data[1], b);
948 break;
949 case STATE_SYSEX_0:
950 port->data[0] = b;
951 port->state = STATE_SYSEX_1;
952 break;
953 case STATE_SYSEX_1:
954 port->data[1] = b;
955 port->state = STATE_SYSEX_2;
956 break;
957 case STATE_SYSEX_2:
958 gmidi_transmit_packet(req,
959 p0 | 0x04, port->data[0], port->data[1], b);
960 port->state = STATE_SYSEX_0;
961 break;
962 }
963 }
964}
965
966static void gmidi_transmit(struct gmidi_device *dev, struct usb_request *req)
967{
968 struct usb_ep *ep = dev->in_ep;
969 struct gmidi_in_port *port = &dev->in_port;
970
971 if (!ep) {
972 return;
973 }
974 if (!req) {
975 req = alloc_ep_req(ep, buflen);
976 }
977 if (!req) {
978 ERROR(dev, "gmidi_transmit: alloc_ep_request failed\n");
979 return;
980 }
981 req->length = 0;
982 req->complete = gmidi_complete;
983
984 if (port->active) {
985 while (req->length + 3 < buflen) {
986 uint8_t b;
987 if (snd_rawmidi_transmit(dev->in_substream, &b, 1)
988 != 1)
989 {
990 port->active = 0;
991 break;
992 }
993 gmidi_transmit_byte(req, port, b);
994 }
995 }
996 if (req->length > 0) {
997 usb_ep_queue(ep, req, GFP_ATOMIC);
998 } else {
999 free_ep_req(ep, req);
1000 }
1001}
1002
1003static void gmidi_in_tasklet(unsigned long data)
1004{
1005 struct gmidi_device *dev = (struct gmidi_device *)data;
1006
1007 gmidi_transmit(dev, NULL);
1008}
1009
1010static int gmidi_in_open(struct snd_rawmidi_substream *substream)
1011{
1012 struct gmidi_device *dev = substream->rmidi->private_data;
1013
1014 VDBG(dev, "gmidi_in_open\n");
1015 dev->in_substream = substream;
1016 dev->in_port.state = STATE_UNKNOWN;
1017 return 0;
1018}
1019
1020static int gmidi_in_close(struct snd_rawmidi_substream *substream)
1021{
1022 struct gmidi_device *dev = substream->rmidi->private_data;
1023
1024 VDBG(dev, "gmidi_in_close\n");
1025 return 0;
1026}
1027
1028static void gmidi_in_trigger(struct snd_rawmidi_substream *substream, int up)
1029{
1030 struct gmidi_device *dev = substream->rmidi->private_data;
1031
1032 VDBG(dev, "gmidi_in_trigger %d\n", up);
1033 dev->in_port.active = up;
1034 if (up) {
1035 tasklet_hi_schedule(&dev->tasklet);
1036 }
1037}
1038
1039static int gmidi_out_open(struct snd_rawmidi_substream *substream)
1040{
1041 struct gmidi_device *dev = substream->rmidi->private_data;
1042
1043 VDBG(dev, "gmidi_out_open\n");
1044 dev->out_substream = substream;
1045 return 0; 114 return 0;
1046} 115}
1047 116
1048static int gmidi_out_close(struct snd_rawmidi_substream *substream) 117static struct usb_configuration midi_config = {
1049{ 118 .label = "MIDI Gadget",
1050 struct gmidi_device *dev = substream->rmidi->private_data; 119 .bConfigurationValue = 1,
1051 120 /* .iConfiguration = DYNAMIC */
1052 VDBG(dev, "gmidi_out_close\n"); 121 .bmAttributes = USB_CONFIG_ATT_ONE,
1053 return 0; 122 .bMaxPower = CONFIG_USB_GADGET_VBUS_DRAW / 2,
1054}
1055
1056static void gmidi_out_trigger(struct snd_rawmidi_substream *substream, int up)
1057{
1058 struct gmidi_device *dev = substream->rmidi->private_data;
1059
1060 VDBG(dev, "gmidi_out_trigger %d\n", up);
1061 if (up) {
1062 set_bit(substream->number, &dev->out_triggered);
1063 } else {
1064 clear_bit(substream->number, &dev->out_triggered);
1065 }
1066}
1067
1068static struct snd_rawmidi_ops gmidi_in_ops = {
1069 .open = gmidi_in_open,
1070 .close = gmidi_in_close,
1071 .trigger = gmidi_in_trigger,
1072}; 123};
1073 124
1074static struct snd_rawmidi_ops gmidi_out_ops = { 125static int __init midi_bind_config(struct usb_configuration *c)
1075 .open = gmidi_out_open,
1076 .close = gmidi_out_close,
1077 .trigger = gmidi_out_trigger
1078};
1079
1080/* register as a sound "card" */
1081static int gmidi_register_card(struct gmidi_device *dev)
1082{ 126{
1083 struct snd_card *card; 127 return f_midi_bind_config(c, index, id, buflen, qlen);
1084 struct snd_rawmidi *rmidi;
1085 int err;
1086 int out_ports = 1;
1087 int in_ports = 1;
1088 static struct snd_device_ops ops = {
1089 .dev_free = gmidi_snd_free,
1090 };
1091
1092 err = snd_card_create(index, id, THIS_MODULE, 0, &card);
1093 if (err < 0) {
1094 ERROR(dev, "snd_card_create failed\n");
1095 goto fail;
1096 }
1097 dev->card = card;
1098
1099 err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, dev, &ops);
1100 if (err < 0) {
1101 ERROR(dev, "snd_device_new failed: error %d\n", err);
1102 goto fail;
1103 }
1104
1105 strcpy(card->driver, longname);
1106 strcpy(card->longname, longname);
1107 strcpy(card->shortname, shortname);
1108
1109 /* Set up rawmidi */
1110 dev->in_port.dev = dev;
1111 dev->in_port.active = 0;
1112 snd_component_add(card, "MIDI");
1113 err = snd_rawmidi_new(card, "USB MIDI Gadget", 0,
1114 out_ports, in_ports, &rmidi);
1115 if (err < 0) {
1116 ERROR(dev, "snd_rawmidi_new failed: error %d\n", err);
1117 goto fail;
1118 }
1119 dev->rmidi = rmidi;
1120 strcpy(rmidi->name, card->shortname);
1121 rmidi->info_flags = SNDRV_RAWMIDI_INFO_OUTPUT |
1122 SNDRV_RAWMIDI_INFO_INPUT |
1123 SNDRV_RAWMIDI_INFO_DUPLEX;
1124 rmidi->private_data = dev;
1125
1126 /* Yes, rawmidi OUTPUT = USB IN, and rawmidi INPUT = USB OUT.
1127 It's an upside-down world being a gadget. */
1128 snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT, &gmidi_in_ops);
1129 snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT, &gmidi_out_ops);
1130
1131 snd_card_set_dev(card, &dev->gadget->dev);
1132
1133 /* register it - we're ready to go */
1134 err = snd_card_register(card);
1135 if (err < 0) {
1136 ERROR(dev, "snd_card_register failed\n");
1137 goto fail;
1138 }
1139
1140 VDBG(dev, "gmidi_register_card finished ok\n");
1141 return 0;
1142
1143fail:
1144 if (dev->card) {
1145 snd_card_free(dev->card);
1146 dev->card = NULL;
1147 }
1148 return err;
1149} 128}
1150 129
1151/* 130static int __init midi_bind(struct usb_composite_dev *cdev)
1152 * Creates an output endpoint, and initializes output ports.
1153 */
1154static int __init gmidi_bind(struct usb_gadget *gadget)
1155{ 131{
1156 struct gmidi_device *dev; 132 struct usb_gadget *gadget = cdev->gadget;
1157 struct usb_ep *in_ep, *out_ep; 133 int gcnum, status;
1158 int gcnum, err = 0;
1159 134
1160 /* support optional vendor/distro customization */ 135 status = usb_string_id(cdev);
1161 if (idVendor) { 136 if (status < 0)
1162 if (!idProduct) { 137 return status;
1163 pr_err("idVendor needs idProduct!\n"); 138 strings_dev[STRING_MANUFACTURER_IDX].id = status;
1164 return -ENODEV; 139 device_desc.iManufacturer = status;
1165 }
1166 device_desc.idVendor = cpu_to_le16(idVendor);
1167 device_desc.idProduct = cpu_to_le16(idProduct);
1168 if (bcdDevice) {
1169 device_desc.bcdDevice = cpu_to_le16(bcdDevice);
1170 }
1171 }
1172 if (iManufacturer) {
1173 strlcpy(manufacturer, iManufacturer, sizeof(manufacturer));
1174 } else {
1175 snprintf(manufacturer, sizeof(manufacturer), "%s %s with %s",
1176 init_utsname()->sysname, init_utsname()->release,
1177 gadget->name);
1178 }
1179 if (iProduct) {
1180 strlcpy(product_desc, iProduct, sizeof(product_desc));
1181 }
1182 if (iSerialNumber) {
1183 device_desc.iSerialNumber = STRING_SERIAL,
1184 strlcpy(serial_number, iSerialNumber, sizeof(serial_number));
1185 }
1186 140
1187 /* Bulk-only drivers like this one SHOULD be able to 141 status = usb_string_id(cdev);
1188 * autoconfigure on any sane usb controller driver, 142 if (status < 0)
1189 * but there may also be important quirks to address. 143 return status;
1190 */ 144 strings_dev[STRING_PRODUCT_IDX].id = status;
1191 usb_ep_autoconfig_reset(gadget); 145 device_desc.iProduct = status;
1192 in_ep = usb_ep_autoconfig(gadget, &bulk_in_desc);
1193 if (!in_ep) {
1194autoconf_fail:
1195 pr_err("%s: can't autoconfigure on %s\n",
1196 shortname, gadget->name);
1197 return -ENODEV;
1198 }
1199 EP_IN_NAME = in_ep->name;
1200 in_ep->driver_data = in_ep; /* claim */
1201 146
1202 out_ep = usb_ep_autoconfig(gadget, &bulk_out_desc); 147 /* config description */
1203 if (!out_ep) { 148 status = usb_string_id(cdev);
1204 goto autoconf_fail; 149 if (status < 0)
1205 } 150 return status;
1206 EP_OUT_NAME = out_ep->name; 151 strings_dev[STRING_DESCRIPTION_IDX].id = status;
1207 out_ep->driver_data = out_ep; /* claim */ 152
153 midi_config.iConfiguration = status;
1208 154
1209 gcnum = usb_gadget_controller_number(gadget); 155 gcnum = usb_gadget_controller_number(gadget);
1210 if (gcnum >= 0) { 156 if (gcnum < 0) {
1211 device_desc.bcdDevice = cpu_to_le16(0x0200 + gcnum);
1212 } else {
1213 /* gmidi is so simple (no altsettings) that 157 /* gmidi is so simple (no altsettings) that
1214 * it SHOULD NOT have problems with bulk-capable hardware. 158 * it SHOULD NOT have problems with bulk-capable hardware.
1215 * so warn about unrecognized controllers, don't panic. 159 * so warn about unrecognized controllers, don't panic.
1216 */ 160 */
1217 pr_warning("%s: controller '%s' not recognized\n", 161 pr_warning("%s: controller '%s' not recognized\n",
1218 shortname, gadget->name); 162 __func__, gadget->name);
1219 device_desc.bcdDevice = cpu_to_le16(0x9999); 163 device_desc.bcdDevice = cpu_to_le16(0x9999);
164 } else {
165 device_desc.bcdDevice = cpu_to_le16(0x0200 + gcnum);
1220 } 166 }
1221 167
168 status = usb_add_config(cdev, &midi_config, midi_bind_config);
169 if (status < 0)
170 return status;
1222 171
1223 /* ok, we made sense of the hardware ... */ 172 pr_info("%s\n", longname);
1224 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1225 if (!dev) {
1226 return -ENOMEM;
1227 }
1228 spin_lock_init(&dev->lock);
1229 dev->gadget = gadget;
1230 dev->in_ep = in_ep;
1231 dev->out_ep = out_ep;
1232 set_gadget_data(gadget, dev);
1233 tasklet_init(&dev->tasklet, gmidi_in_tasklet, (unsigned long)dev);
1234
1235 /* preallocate control response and buffer */
1236 dev->req = alloc_ep_req(gadget->ep0, USB_BUFSIZ);
1237 if (!dev->req) {
1238 err = -ENOMEM;
1239 goto fail;
1240 }
1241
1242 dev->req->complete = gmidi_setup_complete;
1243
1244 gadget->ep0->driver_data = dev;
1245
1246 INFO(dev, "%s, version: " DRIVER_VERSION "\n", longname);
1247 INFO(dev, "using %s, OUT %s IN %s\n", gadget->name,
1248 EP_OUT_NAME, EP_IN_NAME);
1249
1250 /* register as an ALSA sound card */
1251 err = gmidi_register_card(dev);
1252 if (err < 0) {
1253 goto fail;
1254 }
1255
1256 VDBG(dev, "gmidi_bind finished ok\n");
1257 return 0; 173 return 0;
1258
1259fail:
1260 gmidi_unbind(gadget);
1261 return err;
1262}
1263
1264
1265static void gmidi_suspend(struct usb_gadget *gadget)
1266{
1267 struct gmidi_device *dev = get_gadget_data(gadget);
1268
1269 if (gadget->speed == USB_SPEED_UNKNOWN) {
1270 return;
1271 }
1272
1273 DBG(dev, "suspend\n");
1274}
1275
1276static void gmidi_resume(struct usb_gadget *gadget)
1277{
1278 struct gmidi_device *dev = get_gadget_data(gadget);
1279
1280 DBG(dev, "resume\n");
1281} 174}
1282 175
1283 176static struct usb_composite_driver midi_driver = {
1284static struct usb_gadget_driver gmidi_driver = { 177 .name = (char *) longname,
1285 .speed = USB_SPEED_FULL, 178 .dev = &device_desc,
1286 .function = (char *)longname, 179 .strings = dev_strings,
1287 .unbind = gmidi_unbind, 180 .max_speed = USB_SPEED_HIGH,
1288 181 .unbind = __exit_p(midi_unbind),
1289 .setup = gmidi_setup,
1290 .disconnect = gmidi_disconnect,
1291
1292 .suspend = gmidi_suspend,
1293 .resume = gmidi_resume,
1294
1295 .driver = {
1296 .name = (char *)shortname,
1297 .owner = THIS_MODULE,
1298 },
1299}; 182};
1300 183
1301static int __init gmidi_init(void) 184static int __init midi_init(void)
1302{ 185{
1303 return usb_gadget_probe_driver(&gmidi_driver, gmidi_bind); 186 return usb_composite_probe(&midi_driver, midi_bind);
1304} 187}
1305module_init(gmidi_init); 188module_init(midi_init);
1306 189
1307static void __exit gmidi_cleanup(void) 190static void __exit midi_cleanup(void)
1308{ 191{
1309 usb_gadget_unregister_driver(&gmidi_driver); 192 usb_composite_unregister(&midi_driver);
1310} 193}
1311module_exit(gmidi_cleanup); 194module_exit(midi_cleanup);
1312 195
generated by cgit v1.2.2 (git 2.25.0) at 2025-08-27 18:00:47 -0400