| /* |
| * gmidi.c -- USB MIDI Gadget Driver |
| * |
| * Copyright (C) 2006 Thumtronics Pty Ltd. |
| * Developed for Thumtronics by Grey Innovation |
| * Ben Williamson <ben.williamson@greyinnovation.com> |
| * |
| * This software is distributed under the terms of the GNU General Public |
| * License ("GPL") version 2, as published by the Free Software Foundation. |
| * |
| * This code is based in part on: |
| * |
| * Gadget Zero driver, Copyright (C) 2003-2004 David Brownell. |
| * USB Audio driver, Copyright (C) 2002 by Takashi Iwai. |
| * USB MIDI driver, Copyright (C) 2002-2005 Clemens Ladisch. |
| * |
| * Refer to the USB Device Class Definition for MIDI Devices: |
| * http://www.usb.org/developers/devclass_docs/midi10.pdf |
| */ |
| |
| /* #define VERBOSE_DEBUG */ |
| |
| #include <linux/kernel.h> |
| #include <linux/utsname.h> |
| #include <linux/device.h> |
| |
| #include <sound/core.h> |
| #include <sound/initval.h> |
| #include <sound/rawmidi.h> |
| |
| #include <linux/usb/ch9.h> |
| #include <linux/usb/gadget.h> |
| #include <linux/usb/audio.h> |
| #include <linux/usb/midi.h> |
| |
| #include "gadget_chips.h" |
| |
| |
| /* |
| * Kbuild is not very cooperative with respect to linking separately |
| * compiled library objects into one module. So for now we won't use |
| * separate compilation ... ensuring init/exit sections work to shrink |
| * the runtime footprint, and giving us at least some parts of what |
| * a "gcc --combine ... part1.c part2.c part3.c ... " build would. |
| */ |
| #include "usbstring.c" |
| #include "config.c" |
| #include "epautoconf.c" |
| |
| /*-------------------------------------------------------------------------*/ |
| |
| |
| MODULE_AUTHOR("Ben Williamson"); |
| MODULE_LICENSE("GPL v2"); |
| |
| #define DRIVER_VERSION "25 Jul 2006" |
| |
| static const char shortname[] = "g_midi"; |
| static const char longname[] = "MIDI Gadget"; |
| |
| static int index = SNDRV_DEFAULT_IDX1; |
| static char *id = SNDRV_DEFAULT_STR1; |
| |
| module_param(index, int, 0444); |
| MODULE_PARM_DESC(index, "Index value for the USB MIDI Gadget adapter."); |
| module_param(id, charp, 0444); |
| MODULE_PARM_DESC(id, "ID string for the USB MIDI Gadget adapter."); |
| |
| /* Some systems will want different product identifers published in the |
| * device descriptor, either numbers or strings or both. These string |
| * parameters are in UTF-8 (superset of ASCII's 7 bit characters). |
| */ |
| |
| static ushort idVendor; |
| module_param(idVendor, ushort, S_IRUGO); |
| MODULE_PARM_DESC(idVendor, "USB Vendor ID"); |
| |
| static ushort idProduct; |
| module_param(idProduct, ushort, S_IRUGO); |
| MODULE_PARM_DESC(idProduct, "USB Product ID"); |
| |
| static ushort bcdDevice; |
| module_param(bcdDevice, ushort, S_IRUGO); |
| MODULE_PARM_DESC(bcdDevice, "USB Device version (BCD)"); |
| |
| static char *iManufacturer; |
| module_param(iManufacturer, charp, S_IRUGO); |
| MODULE_PARM_DESC(iManufacturer, "USB Manufacturer string"); |
| |
| static char *iProduct; |
| module_param(iProduct, charp, S_IRUGO); |
| MODULE_PARM_DESC(iProduct, "USB Product string"); |
| |
| static char *iSerialNumber; |
| module_param(iSerialNumber, charp, S_IRUGO); |
| MODULE_PARM_DESC(iSerialNumber, "SerialNumber"); |
| |
| /* |
| * this version autoconfigures as much as possible, |
| * which is reasonable for most "bulk-only" drivers. |
| */ |
| static const char *EP_IN_NAME; |
| static const char *EP_OUT_NAME; |
| |
| |
| /* big enough to hold our biggest descriptor */ |
| #define USB_BUFSIZ 256 |
| |
| |
| /* This is a gadget, and the IN/OUT naming is from the host's perspective. |
| USB -> OUT endpoint -> rawmidi |
| USB <- IN endpoint <- rawmidi */ |
| struct gmidi_in_port { |
| struct gmidi_device* dev; |
| int active; |
| uint8_t cable; /* cable number << 4 */ |
| uint8_t state; |
| #define STATE_UNKNOWN 0 |
| #define STATE_1PARAM 1 |
| #define STATE_2PARAM_1 2 |
| #define STATE_2PARAM_2 3 |
| #define STATE_SYSEX_0 4 |
| #define STATE_SYSEX_1 5 |
| #define STATE_SYSEX_2 6 |
| uint8_t data[2]; |
| }; |
| |
| struct gmidi_device { |
| spinlock_t lock; |
| struct usb_gadget *gadget; |
| struct usb_request *req; /* for control responses */ |
| u8 config; |
| struct usb_ep *in_ep, *out_ep; |
| struct snd_card *card; |
| struct snd_rawmidi *rmidi; |
| struct snd_rawmidi_substream *in_substream; |
| struct snd_rawmidi_substream *out_substream; |
| |
| /* For the moment we only support one port in |
| each direction, but in_port is kept as a |
| separate struct so we can have more later. */ |
| struct gmidi_in_port in_port; |
| unsigned long out_triggered; |
| struct tasklet_struct tasklet; |
| }; |
| |
| static void gmidi_transmit(struct gmidi_device* dev, struct usb_request* req); |
| |
| |
| #define DBG(d, fmt, args...) \ |
| dev_dbg(&(d)->gadget->dev , fmt , ## args) |
| #define VDBG(d, fmt, args...) \ |
| dev_vdbg(&(d)->gadget->dev , fmt , ## args) |
| #define ERROR(d, fmt, args...) \ |
| dev_err(&(d)->gadget->dev , fmt , ## args) |
| #define INFO(d, fmt, args...) \ |
| dev_info(&(d)->gadget->dev , fmt , ## args) |
| |
| |
| static unsigned buflen = 256; |
| static unsigned qlen = 32; |
| |
| module_param(buflen, uint, S_IRUGO); |
| module_param(qlen, uint, S_IRUGO); |
| |
| |
| /* Thanks to Grey Innovation for donating this product ID. |
| * |
| * DO NOT REUSE THESE IDs with a protocol-incompatible driver!! Ever!! |
| * Instead: allocate your own, using normal USB-IF procedures. |
| */ |
| #define DRIVER_VENDOR_NUM 0x17b3 /* Grey Innovation */ |
| #define DRIVER_PRODUCT_NUM 0x0004 /* Linux-USB "MIDI Gadget" */ |
| |
| |
| /* |
| * DESCRIPTORS ... most are static, but strings and (full) |
| * configuration descriptors are built on demand. |
| */ |
| |
| #define STRING_MANUFACTURER 25 |
| #define STRING_PRODUCT 42 |
| #define STRING_SERIAL 101 |
| #define STRING_MIDI_GADGET 250 |
| |
| /* We only have the one configuration, it's number 1. */ |
| #define GMIDI_CONFIG 1 |
| |
| /* We have two interfaces- AudioControl and MIDIStreaming */ |
| #define GMIDI_AC_INTERFACE 0 |
| #define GMIDI_MS_INTERFACE 1 |
| #define GMIDI_NUM_INTERFACES 2 |
| |
| DECLARE_UAC_AC_HEADER_DESCRIPTOR(1); |
| DECLARE_USB_MIDI_OUT_JACK_DESCRIPTOR(1); |
| DECLARE_USB_MS_ENDPOINT_DESCRIPTOR(1); |
| |
| /* B.1 Device Descriptor */ |
| static struct usb_device_descriptor device_desc = { |
| .bLength = USB_DT_DEVICE_SIZE, |
| .bDescriptorType = USB_DT_DEVICE, |
| .bcdUSB = cpu_to_le16(0x0200), |
| .bDeviceClass = USB_CLASS_PER_INTERFACE, |
| .idVendor = cpu_to_le16(DRIVER_VENDOR_NUM), |
| .idProduct = cpu_to_le16(DRIVER_PRODUCT_NUM), |
| .iManufacturer = STRING_MANUFACTURER, |
| .iProduct = STRING_PRODUCT, |
| .bNumConfigurations = 1, |
| }; |
| |
| /* B.2 Configuration Descriptor */ |
| static struct usb_config_descriptor config_desc = { |
| .bLength = USB_DT_CONFIG_SIZE, |
| .bDescriptorType = USB_DT_CONFIG, |
| /* compute wTotalLength on the fly */ |
| .bNumInterfaces = GMIDI_NUM_INTERFACES, |
| .bConfigurationValue = GMIDI_CONFIG, |
| .iConfiguration = STRING_MIDI_GADGET, |
| /* |
| * FIXME: When embedding this driver in a device, |
| * these need to be set to reflect the actual |
| * power properties of the device. Is it selfpowered? |
| */ |
| .bmAttributes = USB_CONFIG_ATT_ONE, |
| .bMaxPower = CONFIG_USB_GADGET_VBUS_DRAW / 2, |
| }; |
| |
| /* B.3.1 Standard AC Interface Descriptor */ |
| static const struct usb_interface_descriptor ac_interface_desc = { |
| .bLength = USB_DT_INTERFACE_SIZE, |
| .bDescriptorType = USB_DT_INTERFACE, |
| .bInterfaceNumber = GMIDI_AC_INTERFACE, |
| .bNumEndpoints = 0, |
| .bInterfaceClass = USB_CLASS_AUDIO, |
| .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL, |
| .iInterface = STRING_MIDI_GADGET, |
| }; |
| |
| /* B.3.2 Class-Specific AC Interface Descriptor */ |
| static const struct uac_ac_header_descriptor_v1_1 ac_header_desc = { |
| .bLength = UAC_DT_AC_HEADER_SIZE(1), |
| .bDescriptorType = USB_DT_CS_INTERFACE, |
| .bDescriptorSubtype = USB_MS_HEADER, |
| .bcdADC = cpu_to_le16(0x0100), |
| .wTotalLength = cpu_to_le16(UAC_DT_AC_HEADER_SIZE(1)), |
| .bInCollection = 1, |
| .baInterfaceNr = { |
| [0] = GMIDI_MS_INTERFACE, |
| } |
| }; |
| |
| /* B.4.1 Standard MS Interface Descriptor */ |
| static const struct usb_interface_descriptor ms_interface_desc = { |
| .bLength = USB_DT_INTERFACE_SIZE, |
| .bDescriptorType = USB_DT_INTERFACE, |
| .bInterfaceNumber = GMIDI_MS_INTERFACE, |
| .bNumEndpoints = 2, |
| .bInterfaceClass = USB_CLASS_AUDIO, |
| .bInterfaceSubClass = USB_SUBCLASS_MIDISTREAMING, |
| .iInterface = STRING_MIDI_GADGET, |
| }; |
| |
| /* B.4.2 Class-Specific MS Interface Descriptor */ |
| static const struct usb_ms_header_descriptor ms_header_desc = { |
| .bLength = USB_DT_MS_HEADER_SIZE, |
| .bDescriptorType = USB_DT_CS_INTERFACE, |
| .bDescriptorSubtype = USB_MS_HEADER, |
| .bcdMSC = cpu_to_le16(0x0100), |
| .wTotalLength = cpu_to_le16(USB_DT_MS_HEADER_SIZE |
| + 2*USB_DT_MIDI_IN_SIZE |
| + 2*USB_DT_MIDI_OUT_SIZE(1)), |
| }; |
| |
| #define JACK_IN_EMB 1 |
| #define JACK_IN_EXT 2 |
| #define JACK_OUT_EMB 3 |
| #define JACK_OUT_EXT 4 |
| |
| /* B.4.3 MIDI IN Jack Descriptors */ |
| static const struct usb_midi_in_jack_descriptor jack_in_emb_desc = { |
| .bLength = USB_DT_MIDI_IN_SIZE, |
| .bDescriptorType = USB_DT_CS_INTERFACE, |
| .bDescriptorSubtype = USB_MS_MIDI_IN_JACK, |
| .bJackType = USB_MS_EMBEDDED, |
| .bJackID = JACK_IN_EMB, |
| }; |
| |
| static const struct usb_midi_in_jack_descriptor jack_in_ext_desc = { |
| .bLength = USB_DT_MIDI_IN_SIZE, |
| .bDescriptorType = USB_DT_CS_INTERFACE, |
| .bDescriptorSubtype = USB_MS_MIDI_IN_JACK, |
| .bJackType = USB_MS_EXTERNAL, |
| .bJackID = JACK_IN_EXT, |
| }; |
| |
| /* B.4.4 MIDI OUT Jack Descriptors */ |
| static const struct usb_midi_out_jack_descriptor_1 jack_out_emb_desc = { |
| .bLength = USB_DT_MIDI_OUT_SIZE(1), |
| .bDescriptorType = USB_DT_CS_INTERFACE, |
| .bDescriptorSubtype = USB_MS_MIDI_OUT_JACK, |
| .bJackType = USB_MS_EMBEDDED, |
| .bJackID = JACK_OUT_EMB, |
| .bNrInputPins = 1, |
| .pins = { |
| [0] = { |
| .baSourceID = JACK_IN_EXT, |
| .baSourcePin = 1, |
| } |
| } |
| }; |
| |
| static const struct usb_midi_out_jack_descriptor_1 jack_out_ext_desc = { |
| .bLength = USB_DT_MIDI_OUT_SIZE(1), |
| .bDescriptorType = USB_DT_CS_INTERFACE, |
| .bDescriptorSubtype = USB_MS_MIDI_OUT_JACK, |
| .bJackType = USB_MS_EXTERNAL, |
| .bJackID = JACK_OUT_EXT, |
| .bNrInputPins = 1, |
| .pins = { |
| [0] = { |
| .baSourceID = JACK_IN_EMB, |
| .baSourcePin = 1, |
| } |
| } |
| }; |
| |
| /* B.5.1 Standard Bulk OUT Endpoint Descriptor */ |
| static struct usb_endpoint_descriptor bulk_out_desc = { |
| .bLength = USB_DT_ENDPOINT_AUDIO_SIZE, |
| .bDescriptorType = USB_DT_ENDPOINT, |
| .bEndpointAddress = USB_DIR_OUT, |
| .bmAttributes = USB_ENDPOINT_XFER_BULK, |
| }; |
| |
| /* B.5.2 Class-specific MS Bulk OUT Endpoint Descriptor */ |
| static const struct usb_ms_endpoint_descriptor_1 ms_out_desc = { |
| .bLength = USB_DT_MS_ENDPOINT_SIZE(1), |
| .bDescriptorType = USB_DT_CS_ENDPOINT, |
| .bDescriptorSubtype = USB_MS_GENERAL, |
| .bNumEmbMIDIJack = 1, |
| .baAssocJackID = { |
| [0] = JACK_IN_EMB, |
| } |
| }; |
| |
| /* B.6.1 Standard Bulk IN Endpoint Descriptor */ |
| static struct usb_endpoint_descriptor bulk_in_desc = { |
| .bLength = USB_DT_ENDPOINT_AUDIO_SIZE, |
| .bDescriptorType = USB_DT_ENDPOINT, |
| .bEndpointAddress = USB_DIR_IN, |
| .bmAttributes = USB_ENDPOINT_XFER_BULK, |
| }; |
| |
| /* B.6.2 Class-specific MS Bulk IN Endpoint Descriptor */ |
| static const struct usb_ms_endpoint_descriptor_1 ms_in_desc = { |
| .bLength = USB_DT_MS_ENDPOINT_SIZE(1), |
| .bDescriptorType = USB_DT_CS_ENDPOINT, |
| .bDescriptorSubtype = USB_MS_GENERAL, |
| .bNumEmbMIDIJack = 1, |
| .baAssocJackID = { |
| [0] = JACK_OUT_EMB, |
| } |
| }; |
| |
| static const struct usb_descriptor_header *gmidi_function [] = { |
| (struct usb_descriptor_header *)&ac_interface_desc, |
| (struct usb_descriptor_header *)&ac_header_desc, |
| (struct usb_descriptor_header *)&ms_interface_desc, |
| |
| (struct usb_descriptor_header *)&ms_header_desc, |
| (struct usb_descriptor_header *)&jack_in_emb_desc, |
| (struct usb_descriptor_header *)&jack_in_ext_desc, |
| (struct usb_descriptor_header *)&jack_out_emb_desc, |
| (struct usb_descriptor_header *)&jack_out_ext_desc, |
| /* If you add more jacks, update ms_header_desc.wTotalLength */ |
| |
| (struct usb_descriptor_header *)&bulk_out_desc, |
| (struct usb_descriptor_header *)&ms_out_desc, |
| (struct usb_descriptor_header *)&bulk_in_desc, |
| (struct usb_descriptor_header *)&ms_in_desc, |
| NULL, |
| }; |
| |
| static char manufacturer[50]; |
| static char product_desc[40] = "MIDI Gadget"; |
| static char serial_number[20]; |
| |
| /* static strings, in UTF-8 */ |
| static struct usb_string strings [] = { |
| { STRING_MANUFACTURER, manufacturer, }, |
| { STRING_PRODUCT, product_desc, }, |
| { STRING_SERIAL, serial_number, }, |
| { STRING_MIDI_GADGET, longname, }, |
| { } /* end of list */ |
| }; |
| |
| static struct usb_gadget_strings stringtab = { |
| .language = 0x0409, /* en-us */ |
| .strings = strings, |
| }; |
| |
| static int config_buf(struct usb_gadget *gadget, |
| u8 *buf, u8 type, unsigned index) |
| { |
| int len; |
| |
| /* only one configuration */ |
| if (index != 0) { |
| return -EINVAL; |
| } |
| len = usb_gadget_config_buf(&config_desc, |
| buf, USB_BUFSIZ, gmidi_function); |
| if (len < 0) { |
| return len; |
| } |
| ((struct usb_config_descriptor *)buf)->bDescriptorType = type; |
| return len; |
| } |
| |
| static struct usb_request *alloc_ep_req(struct usb_ep *ep, unsigned length) |
| { |
| struct usb_request *req; |
| |
| req = usb_ep_alloc_request(ep, GFP_ATOMIC); |
| if (req) { |
| req->length = length; |
| req->buf = kmalloc(length, GFP_ATOMIC); |
| if (!req->buf) { |
| usb_ep_free_request(ep, req); |
| req = NULL; |
| } |
| } |
| return req; |
| } |
| |
| static void free_ep_req(struct usb_ep *ep, struct usb_request *req) |
| { |
| kfree(req->buf); |
| usb_ep_free_request(ep, req); |
| } |
| |
| static const uint8_t gmidi_cin_length[] = { |
| 0, 0, 2, 3, 3, 1, 2, 3, 3, 3, 3, 3, 2, 2, 3, 1 |
| }; |
| |
| /* |
| * Receives a chunk of MIDI data. |
| */ |
| static void gmidi_read_data(struct usb_ep *ep, int cable, |
| uint8_t *data, int length) |
| { |
| struct gmidi_device *dev = ep->driver_data; |
| /* cable is ignored, because for now we only have one. */ |
| |
| if (!dev->out_substream) { |
| /* Nobody is listening - throw it on the floor. */ |
| return; |
| } |
| if (!test_bit(dev->out_substream->number, &dev->out_triggered)) { |
| return; |
| } |
| snd_rawmidi_receive(dev->out_substream, data, length); |
| } |
| |
| static void gmidi_handle_out_data(struct usb_ep *ep, struct usb_request *req) |
| { |
| unsigned i; |
| u8 *buf = req->buf; |
| |
| for (i = 0; i + 3 < req->actual; i += 4) { |
| if (buf[i] != 0) { |
| int cable = buf[i] >> 4; |
| int length = gmidi_cin_length[buf[i] & 0x0f]; |
| gmidi_read_data(ep, cable, &buf[i + 1], length); |
| } |
| } |
| } |
| |
| static void gmidi_complete(struct usb_ep *ep, struct usb_request *req) |
| { |
| struct gmidi_device *dev = ep->driver_data; |
| int status = req->status; |
| |
| switch (status) { |
| case 0: /* normal completion */ |
| if (ep == dev->out_ep) { |
| /* we received stuff. |
| req is queued again, below */ |
| gmidi_handle_out_data(ep, req); |
| } else if (ep == dev->in_ep) { |
| /* our transmit completed. |
| see if there's more to go. |
| gmidi_transmit eats req, don't queue it again. */ |
| gmidi_transmit(dev, req); |
| return; |
| } |
| break; |
| |
| /* this endpoint is normally active while we're configured */ |
| case -ECONNABORTED: /* hardware forced ep reset */ |
| case -ECONNRESET: /* request dequeued */ |
| case -ESHUTDOWN: /* disconnect from host */ |
| VDBG(dev, "%s gone (%d), %d/%d\n", ep->name, status, |
| req->actual, req->length); |
| if (ep == dev->out_ep) { |
| gmidi_handle_out_data(ep, req); |
| } |
| free_ep_req(ep, req); |
| return; |
| |
| case -EOVERFLOW: /* buffer overrun on read means that |
| * we didn't provide a big enough |
| * buffer. |
| */ |
| default: |
| DBG(dev, "%s complete --> %d, %d/%d\n", ep->name, |
| status, req->actual, req->length); |
| break; |
| case -EREMOTEIO: /* short read */ |
| break; |
| } |
| |
| status = usb_ep_queue(ep, req, GFP_ATOMIC); |
| if (status) { |
| ERROR(dev, "kill %s: resubmit %d bytes --> %d\n", |
| ep->name, req->length, status); |
| usb_ep_set_halt(ep); |
| /* FIXME recover later ... somehow */ |
| } |
| } |
| |
| static int set_gmidi_config(struct gmidi_device *dev, gfp_t gfp_flags) |
| { |
| int err = 0; |
| struct usb_request *req; |
| struct usb_ep *ep; |
| unsigned i; |
| |
| err = usb_ep_enable(dev->in_ep, &bulk_in_desc); |
| if (err) { |
| ERROR(dev, "can't start %s: %d\n", dev->in_ep->name, err); |
| goto fail; |
| } |
| dev->in_ep->driver_data = dev; |
| |
| err = usb_ep_enable(dev->out_ep, &bulk_out_desc); |
| if (err) { |
| ERROR(dev, "can't start %s: %d\n", dev->out_ep->name, err); |
| goto fail; |
| } |
| dev->out_ep->driver_data = dev; |
| |
| /* allocate a bunch of read buffers and queue them all at once. */ |
| ep = dev->out_ep; |
| for (i = 0; i < qlen && err == 0; i++) { |
| req = alloc_ep_req(ep, buflen); |
| if (req) { |
| req->complete = gmidi_complete; |
| err = usb_ep_queue(ep, req, GFP_ATOMIC); |
| if (err) { |
| DBG(dev, "%s queue req: %d\n", ep->name, err); |
| } |
| } else { |
| err = -ENOMEM; |
| } |
| } |
| fail: |
| /* caller is responsible for cleanup on error */ |
| return err; |
| } |
| |
| |
| static void gmidi_reset_config(struct gmidi_device *dev) |
| { |
| if (dev->config == 0) { |
| return; |
| } |
| |
| DBG(dev, "reset config\n"); |
| |
| /* just disable endpoints, forcing completion of pending i/o. |
| * all our completion handlers free their requests in this case. |
| */ |
| usb_ep_disable(dev->in_ep); |
| usb_ep_disable(dev->out_ep); |
| dev->config = 0; |
| } |
| |
| /* change our operational config. this code must agree with the code |
| * that returns config descriptors, and altsetting code. |
| * |
| * it's also responsible for power management interactions. some |
| * configurations might not work with our current power sources. |
| * |
| * note that some device controller hardware will constrain what this |
| * code can do, perhaps by disallowing more than one configuration or |
| * by limiting configuration choices (like the pxa2xx). |
| */ |
| static int |
| gmidi_set_config(struct gmidi_device *dev, unsigned number, gfp_t gfp_flags) |
| { |
| int result = 0; |
| struct usb_gadget *gadget = dev->gadget; |
| |
| #if 0 |
| /* FIXME */ |
| /* Hacking this bit out fixes a bug where on receipt of two |
| USB_REQ_SET_CONFIGURATION messages, we end up with no |
| buffered OUT requests waiting for data. This is clearly |
| hiding a bug elsewhere, because if the config didn't |
| change then we really shouldn't do anything. */ |
| /* Having said that, when we do "change" from config 1 |
| to config 1, we at least gmidi_reset_config() which |
| clears out any requests on endpoints, so it's not like |
| we leak or anything. */ |
| if (number == dev->config) { |
| return 0; |
| } |
| #endif |
| |
| if (gadget_is_sa1100(gadget) && dev->config) { |
| /* tx fifo is full, but we can't clear it...*/ |
| ERROR(dev, "can't change configurations\n"); |
| return -ESPIPE; |
| } |
| gmidi_reset_config(dev); |
| |
| switch (number) { |
| case GMIDI_CONFIG: |
| result = set_gmidi_config(dev, gfp_flags); |
| break; |
| default: |
| result = -EINVAL; |
| /* FALL THROUGH */ |
| case 0: |
| return result; |
| } |
| |
| if (!result && (!dev->in_ep || !dev->out_ep)) { |
| result = -ENODEV; |
| } |
| if (result) { |
| gmidi_reset_config(dev); |
| } else { |
| char *speed; |
| |
| switch (gadget->speed) { |
| case USB_SPEED_LOW: speed = "low"; break; |
| case USB_SPEED_FULL: speed = "full"; break; |
| case USB_SPEED_HIGH: speed = "high"; break; |
| default: speed = "?"; break; |
| } |
| |
| dev->config = number; |
| INFO(dev, "%s speed\n", speed); |
| } |
| return result; |
| } |
| |
| |
| static void gmidi_setup_complete(struct usb_ep *ep, struct usb_request *req) |
| { |
| if (req->status || req->actual != req->length) { |
| DBG((struct gmidi_device *) ep->driver_data, |
| "setup complete --> %d, %d/%d\n", |
| req->status, req->actual, req->length); |
| } |
| } |
| |
| /* |
| * The setup() callback implements all the ep0 functionality that's |
| * not handled lower down, in hardware or the hardware driver (like |
| * device and endpoint feature flags, and their status). It's all |
| * housekeeping for the gadget function we're implementing. Most of |
| * the work is in config-specific setup. |
| */ |
| static int gmidi_setup(struct usb_gadget *gadget, |
| const struct usb_ctrlrequest *ctrl) |
| { |
| struct gmidi_device *dev = get_gadget_data(gadget); |
| struct usb_request *req = dev->req; |
| int value = -EOPNOTSUPP; |
| u16 w_index = le16_to_cpu(ctrl->wIndex); |
| u16 w_value = le16_to_cpu(ctrl->wValue); |
| u16 w_length = le16_to_cpu(ctrl->wLength); |
| |
| /* usually this stores reply data in the pre-allocated ep0 buffer, |
| * but config change events will reconfigure hardware. |
| */ |
| req->zero = 0; |
| switch (ctrl->bRequest) { |
| |
| case USB_REQ_GET_DESCRIPTOR: |
| if (ctrl->bRequestType != USB_DIR_IN) { |
| goto unknown; |
| } |
| switch (w_value >> 8) { |
| |
| case USB_DT_DEVICE: |
| value = min(w_length, (u16) sizeof(device_desc)); |
| memcpy(req->buf, &device_desc, value); |
| break; |
| case USB_DT_CONFIG: |
| value = config_buf(gadget, req->buf, |
| w_value >> 8, |
| w_value & 0xff); |
| if (value >= 0) { |
| value = min(w_length, (u16)value); |
| } |
| break; |
| |
| case USB_DT_STRING: |
| /* wIndex == language code. |
| * this driver only handles one language, you can |
| * add string tables for other languages, using |
| * any UTF-8 characters |
| */ |
| value = usb_gadget_get_string(&stringtab, |
| w_value & 0xff, req->buf); |
| if (value >= 0) { |
| value = min(w_length, (u16)value); |
| } |
| break; |
| } |
| break; |
| |
| /* currently two configs, two speeds */ |
| case USB_REQ_SET_CONFIGURATION: |
| if (ctrl->bRequestType != 0) { |
| goto unknown; |
| } |
| if (gadget->a_hnp_support) { |
| DBG(dev, "HNP available\n"); |
| } else if (gadget->a_alt_hnp_support) { |
| DBG(dev, "HNP needs a different root port\n"); |
| } else { |
| VDBG(dev, "HNP inactive\n"); |
| } |
| spin_lock(&dev->lock); |
| value = gmidi_set_config(dev, w_value, GFP_ATOMIC); |
| spin_unlock(&dev->lock); |
| break; |
| case USB_REQ_GET_CONFIGURATION: |
| if (ctrl->bRequestType != USB_DIR_IN) { |
| goto unknown; |
| } |
| *(u8 *)req->buf = dev->config; |
| value = min(w_length, (u16)1); |
| break; |
| |
| /* until we add altsetting support, or other interfaces, |
| * only 0/0 are possible. pxa2xx only supports 0/0 (poorly) |
| * and already killed pending endpoint I/O. |
| */ |
| case USB_REQ_SET_INTERFACE: |
| if (ctrl->bRequestType != USB_RECIP_INTERFACE) { |
| goto unknown; |
| } |
| spin_lock(&dev->lock); |
| if (dev->config && w_index < GMIDI_NUM_INTERFACES |
| && w_value == 0) |
| { |
| u8 config = dev->config; |
| |
| /* resets interface configuration, forgets about |
| * previous transaction state (queued bufs, etc) |
| * and re-inits endpoint state (toggle etc) |
| * no response queued, just zero status == success. |
| * if we had more than one interface we couldn't |
| * use this "reset the config" shortcut. |
| */ |
| gmidi_reset_config(dev); |
| gmidi_set_config(dev, config, GFP_ATOMIC); |
| value = 0; |
| } |
| spin_unlock(&dev->lock); |
| break; |
| case USB_REQ_GET_INTERFACE: |
| if (ctrl->bRequestType != (USB_DIR_IN|USB_RECIP_INTERFACE)) { |
| goto unknown; |
| } |
| if (!dev->config) { |
| break; |
| } |
| if (w_index >= GMIDI_NUM_INTERFACES) { |
| value = -EDOM; |
| break; |
| } |
| *(u8 *)req->buf = 0; |
| value = min(w_length, (u16)1); |
| break; |
| |
| default: |
| unknown: |
| VDBG(dev, "unknown control req%02x.%02x v%04x i%04x l%d\n", |
| ctrl->bRequestType, ctrl->bRequest, |
| w_value, w_index, w_length); |
| } |
| |
| /* respond with data transfer before status phase? */ |
| if (value >= 0) { |
| req->length = value; |
| req->zero = value < w_length; |
| value = usb_ep_queue(gadget->ep0, req, GFP_ATOMIC); |
| if (value < 0) { |
| DBG(dev, "ep_queue --> %d\n", value); |
| req->status = 0; |
| gmidi_setup_complete(gadget->ep0, req); |
| } |
| } |
| |
| /* device either stalls (value < 0) or reports success */ |
| return value; |
| } |
| |
| static void gmidi_disconnect(struct usb_gadget *gadget) |
| { |
| struct gmidi_device *dev = get_gadget_data(gadget); |
| unsigned long flags; |
| |
| spin_lock_irqsave(&dev->lock, flags); |
| gmidi_reset_config(dev); |
| |
| /* a more significant application might have some non-usb |
| * activities to quiesce here, saving resources like power |
| * or pushing the notification up a network stack. |
| */ |
| spin_unlock_irqrestore(&dev->lock, flags); |
| |
| /* next we may get setup() calls to enumerate new connections; |
| * or an unbind() during shutdown (including removing module). |
| */ |
| } |
| |
| static void /* __init_or_exit */ gmidi_unbind(struct usb_gadget *gadget) |
| { |
| struct gmidi_device *dev = get_gadget_data(gadget); |
| struct snd_card *card; |
| |
| DBG(dev, "unbind\n"); |
| |
| card = dev->card; |
| dev->card = NULL; |
| if (card) { |
| snd_card_free(card); |
| } |
| |
| /* we've already been disconnected ... no i/o is active */ |
| if (dev->req) { |
| dev->req->length = USB_BUFSIZ; |
| free_ep_req(gadget->ep0, dev->req); |
| } |
| kfree(dev); |
| set_gadget_data(gadget, NULL); |
| } |
| |
| static int gmidi_snd_free(struct snd_device *device) |
| { |
| return 0; |
| } |
| |
| static void gmidi_transmit_packet(struct usb_request *req, uint8_t p0, |
| uint8_t p1, uint8_t p2, uint8_t p3) |
| { |
| unsigned length = req->length; |
| u8 *buf = (u8 *)req->buf + length; |
| |
| buf[0] = p0; |
| buf[1] = p1; |
| buf[2] = p2; |
| buf[3] = p3; |
| req->length = length + 4; |
| } |
| |
| /* |
| * Converts MIDI commands to USB MIDI packets. |
| */ |
| static void gmidi_transmit_byte(struct usb_request *req, |
| struct gmidi_in_port *port, uint8_t b) |
| { |
| uint8_t p0 = port->cable; |
| |
| if (b >= 0xf8) { |
| gmidi_transmit_packet(req, p0 | 0x0f, b, 0, 0); |
| } else if (b >= 0xf0) { |
| switch (b) { |
| case 0xf0: |
| port->data[0] = b; |
| port->state = STATE_SYSEX_1; |
| break; |
| case 0xf1: |
| case 0xf3: |
| port->data[0] = b; |
| port->state = STATE_1PARAM; |
| break; |
| case 0xf2: |
| port->data[0] = b; |
| port->state = STATE_2PARAM_1; |
| break; |
| case 0xf4: |
| case 0xf5: |
| port->state = STATE_UNKNOWN; |
| break; |
| case 0xf6: |
| gmidi_transmit_packet(req, p0 | 0x05, 0xf6, 0, 0); |
| port->state = STATE_UNKNOWN; |
| break; |
| case 0xf7: |
| switch (port->state) { |
| case STATE_SYSEX_0: |
| gmidi_transmit_packet(req, |
| p0 | 0x05, 0xf7, 0, 0); |
| break; |
| case STATE_SYSEX_1: |
| gmidi_transmit_packet(req, |
| p0 | 0x06, port->data[0], 0xf7, 0); |
| break; |
| case STATE_SYSEX_2: |
| gmidi_transmit_packet(req, |
| p0 | 0x07, port->data[0], |
| port->data[1], 0xf7); |
| break; |
| } |
| port->state = STATE_UNKNOWN; |
| break; |
| } |
| } else if (b >= 0x80) { |
| port->data[0] = b; |
| if (b >= 0xc0 && b <= 0xdf) |
| port->state = STATE_1PARAM; |
| else |
| port->state = STATE_2PARAM_1; |
| } else { /* b < 0x80 */ |
| switch (port->state) { |
| case STATE_1PARAM: |
| if (port->data[0] < 0xf0) { |
| p0 |= port->data[0] >> 4; |
| } else { |
| p0 |= 0x02; |
| port->state = STATE_UNKNOWN; |
| } |
| gmidi_transmit_packet(req, p0, port->data[0], b, 0); |
| break; |
| case STATE_2PARAM_1: |
| port->data[1] = b; |
| port->state = STATE_2PARAM_2; |
| break; |
| case STATE_2PARAM_2: |
| if (port->data[0] < 0xf0) { |
| p0 |= port->data[0] >> 4; |
| port->state = STATE_2PARAM_1; |
| } else { |
| p0 |= 0x03; |
| port->state = STATE_UNKNOWN; |
| } |
| gmidi_transmit_packet(req, |
| p0, port->data[0], port->data[1], b); |
| break; |
| case STATE_SYSEX_0: |
| port->data[0] = b; |
| port->state = STATE_SYSEX_1; |
| break; |
| case STATE_SYSEX_1: |
| port->data[1] = b; |
| port->state = STATE_SYSEX_2; |
| break; |
| case STATE_SYSEX_2: |
| gmidi_transmit_packet(req, |
| p0 | 0x04, port->data[0], port->data[1], b); |
| port->state = STATE_SYSEX_0; |
| break; |
| } |
| } |
| } |
| |
| static void gmidi_transmit(struct gmidi_device *dev, struct usb_request *req) |
| { |
| struct usb_ep *ep = dev->in_ep; |
| struct gmidi_in_port *port = &dev->in_port; |
| |
| if (!ep) { |
| return; |
| } |
| if (!req) { |
| req = alloc_ep_req(ep, buflen); |
| } |
| if (!req) { |
| ERROR(dev, "gmidi_transmit: alloc_ep_request failed\n"); |
| return; |
| } |
| req->length = 0; |
| req->complete = gmidi_complete; |
| |
| if (port->active) { |
| while (req->length + 3 < buflen) { |
| uint8_t b; |
| if (snd_rawmidi_transmit(dev->in_substream, &b, 1) |
| != 1) |
| { |
| port->active = 0; |
| break; |
| } |
| gmidi_transmit_byte(req, port, b); |
| } |
| } |
| if (req->length > 0) { |
| usb_ep_queue(ep, req, GFP_ATOMIC); |
| } else { |
| free_ep_req(ep, req); |
| } |
| } |
| |
| static void gmidi_in_tasklet(unsigned long data) |
| { |
| struct gmidi_device *dev = (struct gmidi_device *)data; |
| |
| gmidi_transmit(dev, NULL); |
| } |
| |
| static int gmidi_in_open(struct snd_rawmidi_substream *substream) |
| { |
| struct gmidi_device *dev = substream->rmidi->private_data; |
| |
| VDBG(dev, "gmidi_in_open\n"); |
| dev->in_substream = substream; |
| dev->in_port.state = STATE_UNKNOWN; |
| return 0; |
| } |
| |
| static int gmidi_in_close(struct snd_rawmidi_substream *substream) |
| { |
| struct gmidi_device *dev = substream->rmidi->private_data; |
| |
| VDBG(dev, "gmidi_in_close\n"); |
| return 0; |
| } |
| |
| static void gmidi_in_trigger(struct snd_rawmidi_substream *substream, int up) |
| { |
| struct gmidi_device *dev = substream->rmidi->private_data; |
| |
| VDBG(dev, "gmidi_in_trigger %d\n", up); |
| dev->in_port.active = up; |
| if (up) { |
| tasklet_hi_schedule(&dev->tasklet); |
| } |
| } |
| |
| static int gmidi_out_open(struct snd_rawmidi_substream *substream) |
| { |
| struct gmidi_device *dev = substream->rmidi->private_data; |
| |
| VDBG(dev, "gmidi_out_open\n"); |
| dev->out_substream = substream; |
| return 0; |
| } |
| |
| static int gmidi_out_close(struct snd_rawmidi_substream *substream) |
| { |
| struct gmidi_device *dev = substream->rmidi->private_data; |
| |
| VDBG(dev, "gmidi_out_close\n"); |
| return 0; |
| } |
| |
| static void gmidi_out_trigger(struct snd_rawmidi_substream *substream, int up) |
| { |
| struct gmidi_device *dev = substream->rmidi->private_data; |
| |
| VDBG(dev, "gmidi_out_trigger %d\n", up); |
| if (up) { |
| set_bit(substream->number, &dev->out_triggered); |
| } else { |
| clear_bit(substream->number, &dev->out_triggered); |
| } |
| } |
| |
| static struct snd_rawmidi_ops gmidi_in_ops = { |
| .open = gmidi_in_open, |
| .close = gmidi_in_close, |
| .trigger = gmidi_in_trigger, |
| }; |
| |
| static struct snd_rawmidi_ops gmidi_out_ops = { |
| .open = gmidi_out_open, |
| .close = gmidi_out_close, |
| .trigger = gmidi_out_trigger |
| }; |
| |
| /* register as a sound "card" */ |
| static int gmidi_register_card(struct gmidi_device *dev) |
| { |
| struct snd_card *card; |
| struct snd_rawmidi *rmidi; |
| int err; |
| int out_ports = 1; |
| int in_ports = 1; |
| static struct snd_device_ops ops = { |
| .dev_free = gmidi_snd_free, |
| }; |
| |
| err = snd_card_create(index, id, THIS_MODULE, 0, &card); |
| if (err < 0) { |
| ERROR(dev, "snd_card_create failed\n"); |
| goto fail; |
| } |
| dev->card = card; |
| |
| err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, dev, &ops); |
| if (err < 0) { |
| ERROR(dev, "snd_device_new failed: error %d\n", err); |
| goto fail; |
| } |
| |
| strcpy(card->driver, longname); |
| strcpy(card->longname, longname); |
| strcpy(card->shortname, shortname); |
| |
| /* Set up rawmidi */ |
| dev->in_port.dev = dev; |
| dev->in_port.active = 0; |
| snd_component_add(card, "MIDI"); |
| err = snd_rawmidi_new(card, "USB MIDI Gadget", 0, |
| out_ports, in_ports, &rmidi); |
| if (err < 0) { |
| ERROR(dev, "snd_rawmidi_new failed: error %d\n", err); |
| goto fail; |
| } |
| dev->rmidi = rmidi; |
| strcpy(rmidi->name, card->shortname); |
| rmidi->info_flags = SNDRV_RAWMIDI_INFO_OUTPUT | |
| SNDRV_RAWMIDI_INFO_INPUT | |
| SNDRV_RAWMIDI_INFO_DUPLEX; |
| rmidi->private_data = dev; |
| |
| /* Yes, rawmidi OUTPUT = USB IN, and rawmidi INPUT = USB OUT. |
| It's an upside-down world being a gadget. */ |
| snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT, &gmidi_in_ops); |
| snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT, &gmidi_out_ops); |
| |
| snd_card_set_dev(card, &dev->gadget->dev); |
| |
| /* register it - we're ready to go */ |
| err = snd_card_register(card); |
| if (err < 0) { |
| ERROR(dev, "snd_card_register failed\n"); |
| goto fail; |
| } |
| |
| VDBG(dev, "gmidi_register_card finished ok\n"); |
| return 0; |
| |
| fail: |
| if (dev->card) { |
| snd_card_free(dev->card); |
| dev->card = NULL; |
| } |
| return err; |
| } |
| |
| /* |
| * Creates an output endpoint, and initializes output ports. |
| */ |
| static int __init gmidi_bind(struct usb_gadget *gadget) |
| { |
| struct gmidi_device *dev; |
| struct usb_ep *in_ep, *out_ep; |
| int gcnum, err = 0; |
| |
| /* support optional vendor/distro customization */ |
| if (idVendor) { |
| if (!idProduct) { |
| pr_err("idVendor needs idProduct!\n"); |
| return -ENODEV; |
| } |
| device_desc.idVendor = cpu_to_le16(idVendor); |
| device_desc.idProduct = cpu_to_le16(idProduct); |
| if (bcdDevice) { |
| device_desc.bcdDevice = cpu_to_le16(bcdDevice); |
| } |
| } |
| if (iManufacturer) { |
| strlcpy(manufacturer, iManufacturer, sizeof(manufacturer)); |
| } else { |
| snprintf(manufacturer, sizeof(manufacturer), "%s %s with %s", |
| init_utsname()->sysname, init_utsname()->release, |
| gadget->name); |
| } |
| if (iProduct) { |
| strlcpy(product_desc, iProduct, sizeof(product_desc)); |
| } |
| if (iSerialNumber) { |
| device_desc.iSerialNumber = STRING_SERIAL, |
| strlcpy(serial_number, iSerialNumber, sizeof(serial_number)); |
| } |
| |
| /* Bulk-only drivers like this one SHOULD be able to |
| * autoconfigure on any sane usb controller driver, |
| * but there may also be important quirks to address. |
| */ |
| usb_ep_autoconfig_reset(gadget); |
| in_ep = usb_ep_autoconfig(gadget, &bulk_in_desc); |
| if (!in_ep) { |
| autoconf_fail: |
| pr_err("%s: can't autoconfigure on %s\n", |
| shortname, gadget->name); |
| return -ENODEV; |
| } |
| EP_IN_NAME = in_ep->name; |
| in_ep->driver_data = in_ep; /* claim */ |
| |
| out_ep = usb_ep_autoconfig(gadget, &bulk_out_desc); |
| if (!out_ep) { |
| goto autoconf_fail; |
| } |
| EP_OUT_NAME = out_ep->name; |
| out_ep->driver_data = out_ep; /* claim */ |
| |
| gcnum = usb_gadget_controller_number(gadget); |
| if (gcnum >= 0) { |
| device_desc.bcdDevice = cpu_to_le16(0x0200 + gcnum); |
| } else { |
| /* gmidi is so simple (no altsettings) that |
| * it SHOULD NOT have problems with bulk-capable hardware. |
| * so warn about unrecognized controllers, don't panic. |
| */ |
| pr_warning("%s: controller '%s' not recognized\n", |
| shortname, gadget->name); |
| device_desc.bcdDevice = cpu_to_le16(0x9999); |
| } |
| |
| |
| /* ok, we made sense of the hardware ... */ |
| dev = kzalloc(sizeof(*dev), GFP_KERNEL); |
| if (!dev) { |
| return -ENOMEM; |
| } |
| spin_lock_init(&dev->lock); |
| dev->gadget = gadget; |
| dev->in_ep = in_ep; |
| dev->out_ep = out_ep; |
| set_gadget_data(gadget, dev); |
| tasklet_init(&dev->tasklet, gmidi_in_tasklet, (unsigned long)dev); |
| |
| /* preallocate control response and buffer */ |
| dev->req = alloc_ep_req(gadget->ep0, USB_BUFSIZ); |
| if (!dev->req) { |
| err = -ENOMEM; |
| goto fail; |
| } |
| |
| dev->req->complete = gmidi_setup_complete; |
| |
| device_desc.bMaxPacketSize0 = gadget->ep0->maxpacket; |
| |
| gadget->ep0->driver_data = dev; |
| |
| INFO(dev, "%s, version: " DRIVER_VERSION "\n", longname); |
| INFO(dev, "using %s, OUT %s IN %s\n", gadget->name, |
| EP_OUT_NAME, EP_IN_NAME); |
| |
| /* register as an ALSA sound card */ |
| err = gmidi_register_card(dev); |
| if (err < 0) { |
| goto fail; |
| } |
| |
| VDBG(dev, "gmidi_bind finished ok\n"); |
| return 0; |
| |
| fail: |
| gmidi_unbind(gadget); |
| return err; |
| } |
| |
| |
| static void gmidi_suspend(struct usb_gadget *gadget) |
| { |
| struct gmidi_device *dev = get_gadget_data(gadget); |
| |
| if (gadget->speed == USB_SPEED_UNKNOWN) { |
| return; |
| } |
| |
| DBG(dev, "suspend\n"); |
| } |
| |
| static void gmidi_resume(struct usb_gadget *gadget) |
| { |
| struct gmidi_device *dev = get_gadget_data(gadget); |
| |
| DBG(dev, "resume\n"); |
| } |
| |
| |
| static struct usb_gadget_driver gmidi_driver = { |
| .speed = USB_SPEED_FULL, |
| .function = (char *)longname, |
| .bind = gmidi_bind, |
| .unbind = gmidi_unbind, |
| |
| .setup = gmidi_setup, |
| .disconnect = gmidi_disconnect, |
| |
| .suspend = gmidi_suspend, |
| .resume = gmidi_resume, |
| |
| .driver = { |
| .name = (char *)shortname, |
| .owner = THIS_MODULE, |
| }, |
| }; |
| |
| static int __init gmidi_init(void) |
| { |
| return usb_gadget_register_driver(&gmidi_driver); |
| } |
| module_init(gmidi_init); |
| |
| static void __exit gmidi_cleanup(void) |
| { |
| usb_gadget_unregister_driver(&gmidi_driver); |
| } |
| module_exit(gmidi_cleanup); |
| |