Back to home page

OSCL-LXR
 
 

     

0001 /*
0002  * usbmidi.c - ALSA USB MIDI driver
0003  *
0004  * Copyright (c) 2002-2009 Clemens Ladisch
0005  * All rights reserved.
0006  *
0007  * Based on the OSS usb-midi driver by NAGANO Daisuke,
0008  *          NetBSD's umidi driver by Takuya SHIOZAKI,
0009  *          the "USB Device Class Definition for MIDI Devices" by Roland
0010  *
0011  * Redistribution and use in source and binary forms, with or without
0012  * modification, are permitted provided that the following conditions
0013  * are met:
0014  * 1. Redistributions of source code must retain the above copyright
0015  *    notice, this list of conditions, and the following disclaimer,
0016  *    without modification.
0017  * 2. The name of the author may not be used to endorse or promote products
0018  *    derived from this software without specific prior written permission.
0019  *
0020  * Alternatively, this software may be distributed and/or modified under the
0021  * terms of the GNU General Public License as published by the Free Software
0022  * Foundation; either version 2 of the License, or (at your option) any later
0023  * version.
0024  *
0025  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
0026  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
0027  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
0028  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
0029  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
0030  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
0031  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
0032  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
0033  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
0034  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
0035  * SUCH DAMAGE.
0036  */
0037 
0038 #include <linux/kernel.h>
0039 #include <linux/types.h>
0040 #include <linux/bitops.h>
0041 #include <linux/interrupt.h>
0042 #include <linux/spinlock.h>
0043 #include <linux/string.h>
0044 #include <linux/init.h>
0045 #include <linux/slab.h>
0046 #include <linux/timer.h>
0047 #include <linux/usb.h>
0048 #include <linux/wait.h>
0049 #include <linux/usb/audio.h>
0050 #include <linux/usb/midi.h>
0051 #include <linux/module.h>
0052 
0053 #include <sound/core.h>
0054 #include <sound/control.h>
0055 #include <sound/rawmidi.h>
0056 #include <sound/asequencer.h>
0057 #include "usbaudio.h"
0058 #include "midi.h"
0059 #include "power.h"
0060 #include "helper.h"
0061 
0062 /*
0063  * define this to log all USB packets
0064  */
0065 /* #define DUMP_PACKETS */
0066 
0067 /*
0068  * how long to wait after some USB errors, so that hub_wq can disconnect() us
0069  * without too many spurious errors
0070  */
0071 #define ERROR_DELAY_JIFFIES (HZ / 10)
0072 
0073 #define OUTPUT_URBS 7
0074 #define INPUT_URBS 7
0075 
0076 
0077 MODULE_AUTHOR("Clemens Ladisch <clemens@ladisch.de>");
0078 MODULE_DESCRIPTION("USB Audio/MIDI helper module");
0079 MODULE_LICENSE("Dual BSD/GPL");
0080 
0081 struct snd_usb_midi_in_endpoint;
0082 struct snd_usb_midi_out_endpoint;
0083 struct snd_usb_midi_endpoint;
0084 
0085 struct usb_protocol_ops {
0086     void (*input)(struct snd_usb_midi_in_endpoint*, uint8_t*, int);
0087     void (*output)(struct snd_usb_midi_out_endpoint *ep, struct urb *urb);
0088     void (*output_packet)(struct urb*, uint8_t, uint8_t, uint8_t, uint8_t);
0089     void (*init_out_endpoint)(struct snd_usb_midi_out_endpoint *);
0090     void (*finish_out_endpoint)(struct snd_usb_midi_out_endpoint *);
0091 };
0092 
0093 struct snd_usb_midi {
0094     struct usb_device *dev;
0095     struct snd_card *card;
0096     struct usb_interface *iface;
0097     const struct snd_usb_audio_quirk *quirk;
0098     struct snd_rawmidi *rmidi;
0099     const struct usb_protocol_ops *usb_protocol_ops;
0100     struct list_head list;
0101     struct timer_list error_timer;
0102     spinlock_t disc_lock;
0103     struct rw_semaphore disc_rwsem;
0104     struct mutex mutex;
0105     u32 usb_id;
0106     int next_midi_device;
0107 
0108     struct snd_usb_midi_endpoint {
0109         struct snd_usb_midi_out_endpoint *out;
0110         struct snd_usb_midi_in_endpoint *in;
0111     } endpoints[MIDI_MAX_ENDPOINTS];
0112     unsigned long input_triggered;
0113     unsigned int opened[2];
0114     unsigned char disconnected;
0115     unsigned char input_running;
0116 
0117     struct snd_kcontrol *roland_load_ctl;
0118 };
0119 
0120 struct snd_usb_midi_out_endpoint {
0121     struct snd_usb_midi *umidi;
0122     struct out_urb_context {
0123         struct urb *urb;
0124         struct snd_usb_midi_out_endpoint *ep;
0125     } urbs[OUTPUT_URBS];
0126     unsigned int active_urbs;
0127     unsigned int drain_urbs;
0128     int max_transfer;       /* size of urb buffer */
0129     struct work_struct work;
0130     unsigned int next_urb;
0131     spinlock_t buffer_lock;
0132 
0133     struct usbmidi_out_port {
0134         struct snd_usb_midi_out_endpoint *ep;
0135         struct snd_rawmidi_substream *substream;
0136         int active;
0137         uint8_t cable;      /* cable number << 4 */
0138         uint8_t state;
0139 #define STATE_UNKNOWN   0
0140 #define STATE_1PARAM    1
0141 #define STATE_2PARAM_1  2
0142 #define STATE_2PARAM_2  3
0143 #define STATE_SYSEX_0   4
0144 #define STATE_SYSEX_1   5
0145 #define STATE_SYSEX_2   6
0146         uint8_t data[2];
0147     } ports[0x10];
0148     int current_port;
0149 
0150     wait_queue_head_t drain_wait;
0151 };
0152 
0153 struct snd_usb_midi_in_endpoint {
0154     struct snd_usb_midi *umidi;
0155     struct urb *urbs[INPUT_URBS];
0156     struct usbmidi_in_port {
0157         struct snd_rawmidi_substream *substream;
0158         u8 running_status_length;
0159     } ports[0x10];
0160     u8 seen_f5;
0161     bool in_sysex;
0162     u8 last_cin;
0163     u8 error_resubmit;
0164     int current_port;
0165 };
0166 
0167 static void snd_usbmidi_do_output(struct snd_usb_midi_out_endpoint *ep);
0168 
0169 static const uint8_t snd_usbmidi_cin_length[] = {
0170     0, 0, 2, 3, 3, 1, 2, 3, 3, 3, 3, 3, 2, 2, 3, 1
0171 };
0172 
0173 /*
0174  * Submits the URB, with error handling.
0175  */
0176 static int snd_usbmidi_submit_urb(struct urb *urb, gfp_t flags)
0177 {
0178     int err = usb_submit_urb(urb, flags);
0179     if (err < 0 && err != -ENODEV)
0180         dev_err(&urb->dev->dev, "usb_submit_urb: %d\n", err);
0181     return err;
0182 }
0183 
0184 /*
0185  * Error handling for URB completion functions.
0186  */
0187 static int snd_usbmidi_urb_error(const struct urb *urb)
0188 {
0189     switch (urb->status) {
0190     /* manually unlinked, or device gone */
0191     case -ENOENT:
0192     case -ECONNRESET:
0193     case -ESHUTDOWN:
0194     case -ENODEV:
0195         return -ENODEV;
0196     /* errors that might occur during unplugging */
0197     case -EPROTO:
0198     case -ETIME:
0199     case -EILSEQ:
0200         return -EIO;
0201     default:
0202         dev_err(&urb->dev->dev, "urb status %d\n", urb->status);
0203         return 0; /* continue */
0204     }
0205 }
0206 
0207 /*
0208  * Receives a chunk of MIDI data.
0209  */
0210 static void snd_usbmidi_input_data(struct snd_usb_midi_in_endpoint *ep,
0211                    int portidx, uint8_t *data, int length)
0212 {
0213     struct usbmidi_in_port *port = &ep->ports[portidx];
0214 
0215     if (!port->substream) {
0216         dev_dbg(&ep->umidi->dev->dev, "unexpected port %d!\n", portidx);
0217         return;
0218     }
0219     if (!test_bit(port->substream->number, &ep->umidi->input_triggered))
0220         return;
0221     snd_rawmidi_receive(port->substream, data, length);
0222 }
0223 
0224 #ifdef DUMP_PACKETS
0225 static void dump_urb(const char *type, const u8 *data, int length)
0226 {
0227     snd_printk(KERN_DEBUG "%s packet: [", type);
0228     for (; length > 0; ++data, --length)
0229         printk(KERN_CONT " %02x", *data);
0230     printk(KERN_CONT " ]\n");
0231 }
0232 #else
0233 #define dump_urb(type, data, length) /* nothing */
0234 #endif
0235 
0236 /*
0237  * Processes the data read from the device.
0238  */
0239 static void snd_usbmidi_in_urb_complete(struct urb *urb)
0240 {
0241     struct snd_usb_midi_in_endpoint *ep = urb->context;
0242 
0243     if (urb->status == 0) {
0244         dump_urb("received", urb->transfer_buffer, urb->actual_length);
0245         ep->umidi->usb_protocol_ops->input(ep, urb->transfer_buffer,
0246                            urb->actual_length);
0247     } else {
0248         int err = snd_usbmidi_urb_error(urb);
0249         if (err < 0) {
0250             if (err != -ENODEV) {
0251                 ep->error_resubmit = 1;
0252                 mod_timer(&ep->umidi->error_timer,
0253                       jiffies + ERROR_DELAY_JIFFIES);
0254             }
0255             return;
0256         }
0257     }
0258 
0259     urb->dev = ep->umidi->dev;
0260     snd_usbmidi_submit_urb(urb, GFP_ATOMIC);
0261 }
0262 
0263 static void snd_usbmidi_out_urb_complete(struct urb *urb)
0264 {
0265     struct out_urb_context *context = urb->context;
0266     struct snd_usb_midi_out_endpoint *ep = context->ep;
0267     unsigned int urb_index;
0268     unsigned long flags;
0269 
0270     spin_lock_irqsave(&ep->buffer_lock, flags);
0271     urb_index = context - ep->urbs;
0272     ep->active_urbs &= ~(1 << urb_index);
0273     if (unlikely(ep->drain_urbs)) {
0274         ep->drain_urbs &= ~(1 << urb_index);
0275         wake_up(&ep->drain_wait);
0276     }
0277     spin_unlock_irqrestore(&ep->buffer_lock, flags);
0278     if (urb->status < 0) {
0279         int err = snd_usbmidi_urb_error(urb);
0280         if (err < 0) {
0281             if (err != -ENODEV)
0282                 mod_timer(&ep->umidi->error_timer,
0283                       jiffies + ERROR_DELAY_JIFFIES);
0284             return;
0285         }
0286     }
0287     snd_usbmidi_do_output(ep);
0288 }
0289 
0290 /*
0291  * This is called when some data should be transferred to the device
0292  * (from one or more substreams).
0293  */
0294 static void snd_usbmidi_do_output(struct snd_usb_midi_out_endpoint *ep)
0295 {
0296     unsigned int urb_index;
0297     struct urb *urb;
0298     unsigned long flags;
0299 
0300     spin_lock_irqsave(&ep->buffer_lock, flags);
0301     if (ep->umidi->disconnected) {
0302         spin_unlock_irqrestore(&ep->buffer_lock, flags);
0303         return;
0304     }
0305 
0306     urb_index = ep->next_urb;
0307     for (;;) {
0308         if (!(ep->active_urbs & (1 << urb_index))) {
0309             urb = ep->urbs[urb_index].urb;
0310             urb->transfer_buffer_length = 0;
0311             ep->umidi->usb_protocol_ops->output(ep, urb);
0312             if (urb->transfer_buffer_length == 0)
0313                 break;
0314 
0315             dump_urb("sending", urb->transfer_buffer,
0316                  urb->transfer_buffer_length);
0317             urb->dev = ep->umidi->dev;
0318             if (snd_usbmidi_submit_urb(urb, GFP_ATOMIC) < 0)
0319                 break;
0320             ep->active_urbs |= 1 << urb_index;
0321         }
0322         if (++urb_index >= OUTPUT_URBS)
0323             urb_index = 0;
0324         if (urb_index == ep->next_urb)
0325             break;
0326     }
0327     ep->next_urb = urb_index;
0328     spin_unlock_irqrestore(&ep->buffer_lock, flags);
0329 }
0330 
0331 static void snd_usbmidi_out_work(struct work_struct *work)
0332 {
0333     struct snd_usb_midi_out_endpoint *ep =
0334         container_of(work, struct snd_usb_midi_out_endpoint, work);
0335 
0336     snd_usbmidi_do_output(ep);
0337 }
0338 
0339 /* called after transfers had been interrupted due to some USB error */
0340 static void snd_usbmidi_error_timer(struct timer_list *t)
0341 {
0342     struct snd_usb_midi *umidi = from_timer(umidi, t, error_timer);
0343     unsigned int i, j;
0344 
0345     spin_lock(&umidi->disc_lock);
0346     if (umidi->disconnected) {
0347         spin_unlock(&umidi->disc_lock);
0348         return;
0349     }
0350     for (i = 0; i < MIDI_MAX_ENDPOINTS; ++i) {
0351         struct snd_usb_midi_in_endpoint *in = umidi->endpoints[i].in;
0352         if (in && in->error_resubmit) {
0353             in->error_resubmit = 0;
0354             for (j = 0; j < INPUT_URBS; ++j) {
0355                 if (atomic_read(&in->urbs[j]->use_count))
0356                     continue;
0357                 in->urbs[j]->dev = umidi->dev;
0358                 snd_usbmidi_submit_urb(in->urbs[j], GFP_ATOMIC);
0359             }
0360         }
0361         if (umidi->endpoints[i].out)
0362             snd_usbmidi_do_output(umidi->endpoints[i].out);
0363     }
0364     spin_unlock(&umidi->disc_lock);
0365 }
0366 
0367 /* helper function to send static data that may not DMA-able */
0368 static int send_bulk_static_data(struct snd_usb_midi_out_endpoint *ep,
0369                  const void *data, int len)
0370 {
0371     int err = 0;
0372     void *buf = kmemdup(data, len, GFP_KERNEL);
0373     if (!buf)
0374         return -ENOMEM;
0375     dump_urb("sending", buf, len);
0376     if (ep->urbs[0].urb)
0377         err = usb_bulk_msg(ep->umidi->dev, ep->urbs[0].urb->pipe,
0378                    buf, len, NULL, 250);
0379     kfree(buf);
0380     return err;
0381 }
0382 
0383 /*
0384  * Standard USB MIDI protocol: see the spec.
0385  * Midiman protocol: like the standard protocol, but the control byte is the
0386  * fourth byte in each packet, and uses length instead of CIN.
0387  */
0388 
0389 static void snd_usbmidi_standard_input(struct snd_usb_midi_in_endpoint *ep,
0390                        uint8_t *buffer, int buffer_length)
0391 {
0392     int i;
0393 
0394     for (i = 0; i + 3 < buffer_length; i += 4)
0395         if (buffer[i] != 0) {
0396             int cable = buffer[i] >> 4;
0397             int length = snd_usbmidi_cin_length[buffer[i] & 0x0f];
0398             snd_usbmidi_input_data(ep, cable, &buffer[i + 1],
0399                            length);
0400         }
0401 }
0402 
0403 static void snd_usbmidi_midiman_input(struct snd_usb_midi_in_endpoint *ep,
0404                       uint8_t *buffer, int buffer_length)
0405 {
0406     int i;
0407 
0408     for (i = 0; i + 3 < buffer_length; i += 4)
0409         if (buffer[i + 3] != 0) {
0410             int port = buffer[i + 3] >> 4;
0411             int length = buffer[i + 3] & 3;
0412             snd_usbmidi_input_data(ep, port, &buffer[i], length);
0413         }
0414 }
0415 
0416 /*
0417  * Buggy M-Audio device: running status on input results in a packet that has
0418  * the data bytes but not the status byte and that is marked with CIN 4.
0419  */
0420 static void snd_usbmidi_maudio_broken_running_status_input(
0421                     struct snd_usb_midi_in_endpoint *ep,
0422                     uint8_t *buffer, int buffer_length)
0423 {
0424     int i;
0425 
0426     for (i = 0; i + 3 < buffer_length; i += 4)
0427         if (buffer[i] != 0) {
0428             int cable = buffer[i] >> 4;
0429             u8 cin = buffer[i] & 0x0f;
0430             struct usbmidi_in_port *port = &ep->ports[cable];
0431             int length;
0432 
0433             length = snd_usbmidi_cin_length[cin];
0434             if (cin == 0xf && buffer[i + 1] >= 0xf8)
0435                 ; /* realtime msg: no running status change */
0436             else if (cin >= 0x8 && cin <= 0xe)
0437                 /* channel msg */
0438                 port->running_status_length = length - 1;
0439             else if (cin == 0x4 &&
0440                  port->running_status_length != 0 &&
0441                  buffer[i + 1] < 0x80)
0442                 /* CIN 4 that is not a SysEx */
0443                 length = port->running_status_length;
0444             else
0445                 /*
0446                  * All other msgs cannot begin running status.
0447                  * (A channel msg sent as two or three CIN 0xF
0448                  * packets could in theory, but this device
0449                  * doesn't use this format.)
0450                  */
0451                 port->running_status_length = 0;
0452             snd_usbmidi_input_data(ep, cable, &buffer[i + 1],
0453                            length);
0454         }
0455 }
0456 
0457 /*
0458  * QinHeng CH345 is buggy: every second packet inside a SysEx has not CIN 4
0459  * but the previously seen CIN, but still with three data bytes.
0460  */
0461 static void ch345_broken_sysex_input(struct snd_usb_midi_in_endpoint *ep,
0462                      uint8_t *buffer, int buffer_length)
0463 {
0464     unsigned int i, cin, length;
0465 
0466     for (i = 0; i + 3 < buffer_length; i += 4) {
0467         if (buffer[i] == 0 && i > 0)
0468             break;
0469         cin = buffer[i] & 0x0f;
0470         if (ep->in_sysex &&
0471             cin == ep->last_cin &&
0472             (buffer[i + 1 + (cin == 0x6)] & 0x80) == 0)
0473             cin = 0x4;
0474 #if 0
0475         if (buffer[i + 1] == 0x90) {
0476             /*
0477              * Either a corrupted running status or a real note-on
0478              * message; impossible to detect reliably.
0479              */
0480         }
0481 #endif
0482         length = snd_usbmidi_cin_length[cin];
0483         snd_usbmidi_input_data(ep, 0, &buffer[i + 1], length);
0484         ep->in_sysex = cin == 0x4;
0485         if (!ep->in_sysex)
0486             ep->last_cin = cin;
0487     }
0488 }
0489 
0490 /*
0491  * CME protocol: like the standard protocol, but SysEx commands are sent as a
0492  * single USB packet preceded by a 0x0F byte.
0493  */
0494 static void snd_usbmidi_cme_input(struct snd_usb_midi_in_endpoint *ep,
0495                   uint8_t *buffer, int buffer_length)
0496 {
0497     if (buffer_length < 2 || (buffer[0] & 0x0f) != 0x0f)
0498         snd_usbmidi_standard_input(ep, buffer, buffer_length);
0499     else
0500         snd_usbmidi_input_data(ep, buffer[0] >> 4,
0501                        &buffer[1], buffer_length - 1);
0502 }
0503 
0504 /*
0505  * Adds one USB MIDI packet to the output buffer.
0506  */
0507 static void snd_usbmidi_output_standard_packet(struct urb *urb, uint8_t p0,
0508                            uint8_t p1, uint8_t p2,
0509                            uint8_t p3)
0510 {
0511 
0512     uint8_t *buf =
0513         (uint8_t *)urb->transfer_buffer + urb->transfer_buffer_length;
0514     buf[0] = p0;
0515     buf[1] = p1;
0516     buf[2] = p2;
0517     buf[3] = p3;
0518     urb->transfer_buffer_length += 4;
0519 }
0520 
0521 /*
0522  * Adds one Midiman packet to the output buffer.
0523  */
0524 static void snd_usbmidi_output_midiman_packet(struct urb *urb, uint8_t p0,
0525                           uint8_t p1, uint8_t p2,
0526                           uint8_t p3)
0527 {
0528 
0529     uint8_t *buf =
0530         (uint8_t *)urb->transfer_buffer + urb->transfer_buffer_length;
0531     buf[0] = p1;
0532     buf[1] = p2;
0533     buf[2] = p3;
0534     buf[3] = (p0 & 0xf0) | snd_usbmidi_cin_length[p0 & 0x0f];
0535     urb->transfer_buffer_length += 4;
0536 }
0537 
0538 /*
0539  * Converts MIDI commands to USB MIDI packets.
0540  */
0541 static void snd_usbmidi_transmit_byte(struct usbmidi_out_port *port,
0542                       uint8_t b, struct urb *urb)
0543 {
0544     uint8_t p0 = port->cable;
0545     void (*output_packet)(struct urb*, uint8_t, uint8_t, uint8_t, uint8_t) =
0546         port->ep->umidi->usb_protocol_ops->output_packet;
0547 
0548     if (b >= 0xf8) {
0549         output_packet(urb, p0 | 0x0f, b, 0, 0);
0550     } else if (b >= 0xf0) {
0551         switch (b) {
0552         case 0xf0:
0553             port->data[0] = b;
0554             port->state = STATE_SYSEX_1;
0555             break;
0556         case 0xf1:
0557         case 0xf3:
0558             port->data[0] = b;
0559             port->state = STATE_1PARAM;
0560             break;
0561         case 0xf2:
0562             port->data[0] = b;
0563             port->state = STATE_2PARAM_1;
0564             break;
0565         case 0xf4:
0566         case 0xf5:
0567             port->state = STATE_UNKNOWN;
0568             break;
0569         case 0xf6:
0570             output_packet(urb, p0 | 0x05, 0xf6, 0, 0);
0571             port->state = STATE_UNKNOWN;
0572             break;
0573         case 0xf7:
0574             switch (port->state) {
0575             case STATE_SYSEX_0:
0576                 output_packet(urb, p0 | 0x05, 0xf7, 0, 0);
0577                 break;
0578             case STATE_SYSEX_1:
0579                 output_packet(urb, p0 | 0x06, port->data[0],
0580                           0xf7, 0);
0581                 break;
0582             case STATE_SYSEX_2:
0583                 output_packet(urb, p0 | 0x07, port->data[0],
0584                           port->data[1], 0xf7);
0585                 break;
0586             }
0587             port->state = STATE_UNKNOWN;
0588             break;
0589         }
0590     } else if (b >= 0x80) {
0591         port->data[0] = b;
0592         if (b >= 0xc0 && b <= 0xdf)
0593             port->state = STATE_1PARAM;
0594         else
0595             port->state = STATE_2PARAM_1;
0596     } else { /* b < 0x80 */
0597         switch (port->state) {
0598         case STATE_1PARAM:
0599             if (port->data[0] < 0xf0) {
0600                 p0 |= port->data[0] >> 4;
0601             } else {
0602                 p0 |= 0x02;
0603                 port->state = STATE_UNKNOWN;
0604             }
0605             output_packet(urb, p0, port->data[0], b, 0);
0606             break;
0607         case STATE_2PARAM_1:
0608             port->data[1] = b;
0609             port->state = STATE_2PARAM_2;
0610             break;
0611         case STATE_2PARAM_2:
0612             if (port->data[0] < 0xf0) {
0613                 p0 |= port->data[0] >> 4;
0614                 port->state = STATE_2PARAM_1;
0615             } else {
0616                 p0 |= 0x03;
0617                 port->state = STATE_UNKNOWN;
0618             }
0619             output_packet(urb, p0, port->data[0], port->data[1], b);
0620             break;
0621         case STATE_SYSEX_0:
0622             port->data[0] = b;
0623             port->state = STATE_SYSEX_1;
0624             break;
0625         case STATE_SYSEX_1:
0626             port->data[1] = b;
0627             port->state = STATE_SYSEX_2;
0628             break;
0629         case STATE_SYSEX_2:
0630             output_packet(urb, p0 | 0x04, port->data[0],
0631                       port->data[1], b);
0632             port->state = STATE_SYSEX_0;
0633             break;
0634         }
0635     }
0636 }
0637 
0638 static void snd_usbmidi_standard_output(struct snd_usb_midi_out_endpoint *ep,
0639                     struct urb *urb)
0640 {
0641     int p;
0642 
0643     /* FIXME: lower-numbered ports can starve higher-numbered ports */
0644     for (p = 0; p < 0x10; ++p) {
0645         struct usbmidi_out_port *port = &ep->ports[p];
0646         if (!port->active)
0647             continue;
0648         while (urb->transfer_buffer_length + 3 < ep->max_transfer) {
0649             uint8_t b;
0650             if (snd_rawmidi_transmit(port->substream, &b, 1) != 1) {
0651                 port->active = 0;
0652                 break;
0653             }
0654             snd_usbmidi_transmit_byte(port, b, urb);
0655         }
0656     }
0657 }
0658 
0659 static const struct usb_protocol_ops snd_usbmidi_standard_ops = {
0660     .input = snd_usbmidi_standard_input,
0661     .output = snd_usbmidi_standard_output,
0662     .output_packet = snd_usbmidi_output_standard_packet,
0663 };
0664 
0665 static const struct usb_protocol_ops snd_usbmidi_midiman_ops = {
0666     .input = snd_usbmidi_midiman_input,
0667     .output = snd_usbmidi_standard_output,
0668     .output_packet = snd_usbmidi_output_midiman_packet,
0669 };
0670 
0671 static const
0672 struct usb_protocol_ops snd_usbmidi_maudio_broken_running_status_ops = {
0673     .input = snd_usbmidi_maudio_broken_running_status_input,
0674     .output = snd_usbmidi_standard_output,
0675     .output_packet = snd_usbmidi_output_standard_packet,
0676 };
0677 
0678 static const struct usb_protocol_ops snd_usbmidi_cme_ops = {
0679     .input = snd_usbmidi_cme_input,
0680     .output = snd_usbmidi_standard_output,
0681     .output_packet = snd_usbmidi_output_standard_packet,
0682 };
0683 
0684 static const struct usb_protocol_ops snd_usbmidi_ch345_broken_sysex_ops = {
0685     .input = ch345_broken_sysex_input,
0686     .output = snd_usbmidi_standard_output,
0687     .output_packet = snd_usbmidi_output_standard_packet,
0688 };
0689 
0690 /*
0691  * AKAI MPD16 protocol:
0692  *
0693  * For control port (endpoint 1):
0694  * ==============================
0695  * One or more chunks consisting of first byte of (0x10 | msg_len) and then a
0696  * SysEx message (msg_len=9 bytes long).
0697  *
0698  * For data port (endpoint 2):
0699  * ===========================
0700  * One or more chunks consisting of first byte of (0x20 | msg_len) and then a
0701  * MIDI message (msg_len bytes long)
0702  *
0703  * Messages sent: Active Sense, Note On, Poly Pressure, Control Change.
0704  */
0705 static void snd_usbmidi_akai_input(struct snd_usb_midi_in_endpoint *ep,
0706                    uint8_t *buffer, int buffer_length)
0707 {
0708     unsigned int pos = 0;
0709     unsigned int len = (unsigned int)buffer_length;
0710     while (pos < len) {
0711         unsigned int port = (buffer[pos] >> 4) - 1;
0712         unsigned int msg_len = buffer[pos] & 0x0f;
0713         pos++;
0714         if (pos + msg_len <= len && port < 2)
0715             snd_usbmidi_input_data(ep, 0, &buffer[pos], msg_len);
0716         pos += msg_len;
0717     }
0718 }
0719 
0720 #define MAX_AKAI_SYSEX_LEN 9
0721 
0722 static void snd_usbmidi_akai_output(struct snd_usb_midi_out_endpoint *ep,
0723                     struct urb *urb)
0724 {
0725     uint8_t *msg;
0726     int pos, end, count, buf_end;
0727     uint8_t tmp[MAX_AKAI_SYSEX_LEN];
0728     struct snd_rawmidi_substream *substream = ep->ports[0].substream;
0729 
0730     if (!ep->ports[0].active)
0731         return;
0732 
0733     msg = urb->transfer_buffer + urb->transfer_buffer_length;
0734     buf_end = ep->max_transfer - MAX_AKAI_SYSEX_LEN - 1;
0735 
0736     /* only try adding more data when there's space for at least 1 SysEx */
0737     while (urb->transfer_buffer_length < buf_end) {
0738         count = snd_rawmidi_transmit_peek(substream,
0739                           tmp, MAX_AKAI_SYSEX_LEN);
0740         if (!count) {
0741             ep->ports[0].active = 0;
0742             return;
0743         }
0744         /* try to skip non-SysEx data */
0745         for (pos = 0; pos < count && tmp[pos] != 0xF0; pos++)
0746             ;
0747 
0748         if (pos > 0) {
0749             snd_rawmidi_transmit_ack(substream, pos);
0750             continue;
0751         }
0752 
0753         /* look for the start or end marker */
0754         for (end = 1; end < count && tmp[end] < 0xF0; end++)
0755             ;
0756 
0757         /* next SysEx started before the end of current one */
0758         if (end < count && tmp[end] == 0xF0) {
0759             /* it's incomplete - drop it */
0760             snd_rawmidi_transmit_ack(substream, end);
0761             continue;
0762         }
0763         /* SysEx complete */
0764         if (end < count && tmp[end] == 0xF7) {
0765             /* queue it, ack it, and get the next one */
0766             count = end + 1;
0767             msg[0] = 0x10 | count;
0768             memcpy(&msg[1], tmp, count);
0769             snd_rawmidi_transmit_ack(substream, count);
0770             urb->transfer_buffer_length += count + 1;
0771             msg += count + 1;
0772             continue;
0773         }
0774         /* less than 9 bytes and no end byte - wait for more */
0775         if (count < MAX_AKAI_SYSEX_LEN) {
0776             ep->ports[0].active = 0;
0777             return;
0778         }
0779         /* 9 bytes and no end marker in sight - malformed, skip it */
0780         snd_rawmidi_transmit_ack(substream, count);
0781     }
0782 }
0783 
0784 static const struct usb_protocol_ops snd_usbmidi_akai_ops = {
0785     .input = snd_usbmidi_akai_input,
0786     .output = snd_usbmidi_akai_output,
0787 };
0788 
0789 /*
0790  * Novation USB MIDI protocol: number of data bytes is in the first byte
0791  * (when receiving) (+1!) or in the second byte (when sending); data begins
0792  * at the third byte.
0793  */
0794 
0795 static void snd_usbmidi_novation_input(struct snd_usb_midi_in_endpoint *ep,
0796                        uint8_t *buffer, int buffer_length)
0797 {
0798     if (buffer_length < 2 || !buffer[0] || buffer_length < buffer[0] + 1)
0799         return;
0800     snd_usbmidi_input_data(ep, 0, &buffer[2], buffer[0] - 1);
0801 }
0802 
0803 static void snd_usbmidi_novation_output(struct snd_usb_midi_out_endpoint *ep,
0804                     struct urb *urb)
0805 {
0806     uint8_t *transfer_buffer;
0807     int count;
0808 
0809     if (!ep->ports[0].active)
0810         return;
0811     transfer_buffer = urb->transfer_buffer;
0812     count = snd_rawmidi_transmit(ep->ports[0].substream,
0813                      &transfer_buffer[2],
0814                      ep->max_transfer - 2);
0815     if (count < 1) {
0816         ep->ports[0].active = 0;
0817         return;
0818     }
0819     transfer_buffer[0] = 0;
0820     transfer_buffer[1] = count;
0821     urb->transfer_buffer_length = 2 + count;
0822 }
0823 
0824 static const struct usb_protocol_ops snd_usbmidi_novation_ops = {
0825     .input = snd_usbmidi_novation_input,
0826     .output = snd_usbmidi_novation_output,
0827 };
0828 
0829 /*
0830  * "raw" protocol: just move raw MIDI bytes from/to the endpoint
0831  */
0832 
0833 static void snd_usbmidi_raw_input(struct snd_usb_midi_in_endpoint *ep,
0834                   uint8_t *buffer, int buffer_length)
0835 {
0836     snd_usbmidi_input_data(ep, 0, buffer, buffer_length);
0837 }
0838 
0839 static void snd_usbmidi_raw_output(struct snd_usb_midi_out_endpoint *ep,
0840                    struct urb *urb)
0841 {
0842     int count;
0843 
0844     if (!ep->ports[0].active)
0845         return;
0846     count = snd_rawmidi_transmit(ep->ports[0].substream,
0847                      urb->transfer_buffer,
0848                      ep->max_transfer);
0849     if (count < 1) {
0850         ep->ports[0].active = 0;
0851         return;
0852     }
0853     urb->transfer_buffer_length = count;
0854 }
0855 
0856 static const struct usb_protocol_ops snd_usbmidi_raw_ops = {
0857     .input = snd_usbmidi_raw_input,
0858     .output = snd_usbmidi_raw_output,
0859 };
0860 
0861 /*
0862  * FTDI protocol: raw MIDI bytes, but input packets have two modem status bytes.
0863  */
0864 
0865 static void snd_usbmidi_ftdi_input(struct snd_usb_midi_in_endpoint *ep,
0866                    uint8_t *buffer, int buffer_length)
0867 {
0868     if (buffer_length > 2)
0869         snd_usbmidi_input_data(ep, 0, buffer + 2, buffer_length - 2);
0870 }
0871 
0872 static const struct usb_protocol_ops snd_usbmidi_ftdi_ops = {
0873     .input = snd_usbmidi_ftdi_input,
0874     .output = snd_usbmidi_raw_output,
0875 };
0876 
0877 static void snd_usbmidi_us122l_input(struct snd_usb_midi_in_endpoint *ep,
0878                      uint8_t *buffer, int buffer_length)
0879 {
0880     if (buffer_length != 9)
0881         return;
0882     buffer_length = 8;
0883     while (buffer_length && buffer[buffer_length - 1] == 0xFD)
0884         buffer_length--;
0885     if (buffer_length)
0886         snd_usbmidi_input_data(ep, 0, buffer, buffer_length);
0887 }
0888 
0889 static void snd_usbmidi_us122l_output(struct snd_usb_midi_out_endpoint *ep,
0890                       struct urb *urb)
0891 {
0892     int count;
0893 
0894     if (!ep->ports[0].active)
0895         return;
0896     switch (snd_usb_get_speed(ep->umidi->dev)) {
0897     case USB_SPEED_HIGH:
0898     case USB_SPEED_SUPER:
0899     case USB_SPEED_SUPER_PLUS:
0900         count = 1;
0901         break;
0902     default:
0903         count = 2;
0904     }
0905     count = snd_rawmidi_transmit(ep->ports[0].substream,
0906                      urb->transfer_buffer,
0907                      count);
0908     if (count < 1) {
0909         ep->ports[0].active = 0;
0910         return;
0911     }
0912 
0913     memset(urb->transfer_buffer + count, 0xFD, ep->max_transfer - count);
0914     urb->transfer_buffer_length = ep->max_transfer;
0915 }
0916 
0917 static const struct usb_protocol_ops snd_usbmidi_122l_ops = {
0918     .input = snd_usbmidi_us122l_input,
0919     .output = snd_usbmidi_us122l_output,
0920 };
0921 
0922 /*
0923  * Emagic USB MIDI protocol: raw MIDI with "F5 xx" port switching.
0924  */
0925 
0926 static void snd_usbmidi_emagic_init_out(struct snd_usb_midi_out_endpoint *ep)
0927 {
0928     static const u8 init_data[] = {
0929         /* initialization magic: "get version" */
0930         0xf0,
0931         0x00, 0x20, 0x31,   /* Emagic */
0932         0x64,           /* Unitor8 */
0933         0x0b,           /* version number request */
0934         0x00,           /* command version */
0935         0x00,           /* EEPROM, box 0 */
0936         0xf7
0937     };
0938     send_bulk_static_data(ep, init_data, sizeof(init_data));
0939     /* while we're at it, pour on more magic */
0940     send_bulk_static_data(ep, init_data, sizeof(init_data));
0941 }
0942 
0943 static void snd_usbmidi_emagic_finish_out(struct snd_usb_midi_out_endpoint *ep)
0944 {
0945     static const u8 finish_data[] = {
0946         /* switch to patch mode with last preset */
0947         0xf0,
0948         0x00, 0x20, 0x31,   /* Emagic */
0949         0x64,           /* Unitor8 */
0950         0x10,           /* patch switch command */
0951         0x00,           /* command version */
0952         0x7f,           /* to all boxes */
0953         0x40,           /* last preset in EEPROM */
0954         0xf7
0955     };
0956     send_bulk_static_data(ep, finish_data, sizeof(finish_data));
0957 }
0958 
0959 static void snd_usbmidi_emagic_input(struct snd_usb_midi_in_endpoint *ep,
0960                      uint8_t *buffer, int buffer_length)
0961 {
0962     int i;
0963 
0964     /* FF indicates end of valid data */
0965     for (i = 0; i < buffer_length; ++i)
0966         if (buffer[i] == 0xff) {
0967             buffer_length = i;
0968             break;
0969         }
0970 
0971     /* handle F5 at end of last buffer */
0972     if (ep->seen_f5)
0973         goto switch_port;
0974 
0975     while (buffer_length > 0) {
0976         /* determine size of data until next F5 */
0977         for (i = 0; i < buffer_length; ++i)
0978             if (buffer[i] == 0xf5)
0979                 break;
0980         snd_usbmidi_input_data(ep, ep->current_port, buffer, i);
0981         buffer += i;
0982         buffer_length -= i;
0983 
0984         if (buffer_length <= 0)
0985             break;
0986         /* assert(buffer[0] == 0xf5); */
0987         ep->seen_f5 = 1;
0988         ++buffer;
0989         --buffer_length;
0990 
0991     switch_port:
0992         if (buffer_length <= 0)
0993             break;
0994         if (buffer[0] < 0x80) {
0995             ep->current_port = (buffer[0] - 1) & 15;
0996             ++buffer;
0997             --buffer_length;
0998         }
0999         ep->seen_f5 = 0;
1000     }
1001 }
1002 
1003 static void snd_usbmidi_emagic_output(struct snd_usb_midi_out_endpoint *ep,
1004                       struct urb *urb)
1005 {
1006     int port0 = ep->current_port;
1007     uint8_t *buf = urb->transfer_buffer;
1008     int buf_free = ep->max_transfer;
1009     int length, i;
1010 
1011     for (i = 0; i < 0x10; ++i) {
1012         /* round-robin, starting at the last current port */
1013         int portnum = (port0 + i) & 15;
1014         struct usbmidi_out_port *port = &ep->ports[portnum];
1015 
1016         if (!port->active)
1017             continue;
1018         if (snd_rawmidi_transmit_peek(port->substream, buf, 1) != 1) {
1019             port->active = 0;
1020             continue;
1021         }
1022 
1023         if (portnum != ep->current_port) {
1024             if (buf_free < 2)
1025                 break;
1026             ep->current_port = portnum;
1027             buf[0] = 0xf5;
1028             buf[1] = (portnum + 1) & 15;
1029             buf += 2;
1030             buf_free -= 2;
1031         }
1032 
1033         if (buf_free < 1)
1034             break;
1035         length = snd_rawmidi_transmit(port->substream, buf, buf_free);
1036         if (length > 0) {
1037             buf += length;
1038             buf_free -= length;
1039             if (buf_free < 1)
1040                 break;
1041         }
1042     }
1043     if (buf_free < ep->max_transfer && buf_free > 0) {
1044         *buf = 0xff;
1045         --buf_free;
1046     }
1047     urb->transfer_buffer_length = ep->max_transfer - buf_free;
1048 }
1049 
1050 static const struct usb_protocol_ops snd_usbmidi_emagic_ops = {
1051     .input = snd_usbmidi_emagic_input,
1052     .output = snd_usbmidi_emagic_output,
1053     .init_out_endpoint = snd_usbmidi_emagic_init_out,
1054     .finish_out_endpoint = snd_usbmidi_emagic_finish_out,
1055 };
1056 
1057 
1058 static void update_roland_altsetting(struct snd_usb_midi *umidi)
1059 {
1060     struct usb_interface *intf;
1061     struct usb_host_interface *hostif;
1062     struct usb_interface_descriptor *intfd;
1063     int is_light_load;
1064 
1065     intf = umidi->iface;
1066     is_light_load = intf->cur_altsetting != intf->altsetting;
1067     if (umidi->roland_load_ctl->private_value == is_light_load)
1068         return;
1069     hostif = &intf->altsetting[umidi->roland_load_ctl->private_value];
1070     intfd = get_iface_desc(hostif);
1071     snd_usbmidi_input_stop(&umidi->list);
1072     usb_set_interface(umidi->dev, intfd->bInterfaceNumber,
1073               intfd->bAlternateSetting);
1074     snd_usbmidi_input_start(&umidi->list);
1075 }
1076 
1077 static int substream_open(struct snd_rawmidi_substream *substream, int dir,
1078               int open)
1079 {
1080     struct snd_usb_midi *umidi = substream->rmidi->private_data;
1081     struct snd_kcontrol *ctl;
1082 
1083     down_read(&umidi->disc_rwsem);
1084     if (umidi->disconnected) {
1085         up_read(&umidi->disc_rwsem);
1086         return open ? -ENODEV : 0;
1087     }
1088 
1089     mutex_lock(&umidi->mutex);
1090     if (open) {
1091         if (!umidi->opened[0] && !umidi->opened[1]) {
1092             if (umidi->roland_load_ctl) {
1093                 ctl = umidi->roland_load_ctl;
1094                 ctl->vd[0].access |=
1095                     SNDRV_CTL_ELEM_ACCESS_INACTIVE;
1096                 snd_ctl_notify(umidi->card,
1097                        SNDRV_CTL_EVENT_MASK_INFO, &ctl->id);
1098                 update_roland_altsetting(umidi);
1099             }
1100         }
1101         umidi->opened[dir]++;
1102         if (umidi->opened[1])
1103             snd_usbmidi_input_start(&umidi->list);
1104     } else {
1105         umidi->opened[dir]--;
1106         if (!umidi->opened[1])
1107             snd_usbmidi_input_stop(&umidi->list);
1108         if (!umidi->opened[0] && !umidi->opened[1]) {
1109             if (umidi->roland_load_ctl) {
1110                 ctl = umidi->roland_load_ctl;
1111                 ctl->vd[0].access &=
1112                     ~SNDRV_CTL_ELEM_ACCESS_INACTIVE;
1113                 snd_ctl_notify(umidi->card,
1114                        SNDRV_CTL_EVENT_MASK_INFO, &ctl->id);
1115             }
1116         }
1117     }
1118     mutex_unlock(&umidi->mutex);
1119     up_read(&umidi->disc_rwsem);
1120     return 0;
1121 }
1122 
1123 static int snd_usbmidi_output_open(struct snd_rawmidi_substream *substream)
1124 {
1125     struct snd_usb_midi *umidi = substream->rmidi->private_data;
1126     struct usbmidi_out_port *port = NULL;
1127     int i, j;
1128 
1129     for (i = 0; i < MIDI_MAX_ENDPOINTS; ++i)
1130         if (umidi->endpoints[i].out)
1131             for (j = 0; j < 0x10; ++j)
1132                 if (umidi->endpoints[i].out->ports[j].substream == substream) {
1133                     port = &umidi->endpoints[i].out->ports[j];
1134                     break;
1135                 }
1136     if (!port) {
1137         snd_BUG();
1138         return -ENXIO;
1139     }
1140 
1141     substream->runtime->private_data = port;
1142     port->state = STATE_UNKNOWN;
1143     return substream_open(substream, 0, 1);
1144 }
1145 
1146 static int snd_usbmidi_output_close(struct snd_rawmidi_substream *substream)
1147 {
1148     struct usbmidi_out_port *port = substream->runtime->private_data;
1149 
1150     cancel_work_sync(&port->ep->work);
1151     return substream_open(substream, 0, 0);
1152 }
1153 
1154 static void snd_usbmidi_output_trigger(struct snd_rawmidi_substream *substream,
1155                        int up)
1156 {
1157     struct usbmidi_out_port *port =
1158         (struct usbmidi_out_port *)substream->runtime->private_data;
1159 
1160     port->active = up;
1161     if (up) {
1162         if (port->ep->umidi->disconnected) {
1163             /* gobble up remaining bytes to prevent wait in
1164              * snd_rawmidi_drain_output */
1165             snd_rawmidi_proceed(substream);
1166             return;
1167         }
1168         queue_work(system_highpri_wq, &port->ep->work);
1169     }
1170 }
1171 
1172 static void snd_usbmidi_output_drain(struct snd_rawmidi_substream *substream)
1173 {
1174     struct usbmidi_out_port *port = substream->runtime->private_data;
1175     struct snd_usb_midi_out_endpoint *ep = port->ep;
1176     unsigned int drain_urbs;
1177     DEFINE_WAIT(wait);
1178     long timeout = msecs_to_jiffies(50);
1179 
1180     if (ep->umidi->disconnected)
1181         return;
1182     /*
1183      * The substream buffer is empty, but some data might still be in the
1184      * currently active URBs, so we have to wait for those to complete.
1185      */
1186     spin_lock_irq(&ep->buffer_lock);
1187     drain_urbs = ep->active_urbs;
1188     if (drain_urbs) {
1189         ep->drain_urbs |= drain_urbs;
1190         do {
1191             prepare_to_wait(&ep->drain_wait, &wait,
1192                     TASK_UNINTERRUPTIBLE);
1193             spin_unlock_irq(&ep->buffer_lock);
1194             timeout = schedule_timeout(timeout);
1195             spin_lock_irq(&ep->buffer_lock);
1196             drain_urbs &= ep->drain_urbs;
1197         } while (drain_urbs && timeout);
1198         finish_wait(&ep->drain_wait, &wait);
1199     }
1200     port->active = 0;
1201     spin_unlock_irq(&ep->buffer_lock);
1202 }
1203 
1204 static int snd_usbmidi_input_open(struct snd_rawmidi_substream *substream)
1205 {
1206     return substream_open(substream, 1, 1);
1207 }
1208 
1209 static int snd_usbmidi_input_close(struct snd_rawmidi_substream *substream)
1210 {
1211     return substream_open(substream, 1, 0);
1212 }
1213 
1214 static void snd_usbmidi_input_trigger(struct snd_rawmidi_substream *substream,
1215                       int up)
1216 {
1217     struct snd_usb_midi *umidi = substream->rmidi->private_data;
1218 
1219     if (up)
1220         set_bit(substream->number, &umidi->input_triggered);
1221     else
1222         clear_bit(substream->number, &umidi->input_triggered);
1223 }
1224 
1225 static const struct snd_rawmidi_ops snd_usbmidi_output_ops = {
1226     .open = snd_usbmidi_output_open,
1227     .close = snd_usbmidi_output_close,
1228     .trigger = snd_usbmidi_output_trigger,
1229     .drain = snd_usbmidi_output_drain,
1230 };
1231 
1232 static const struct snd_rawmidi_ops snd_usbmidi_input_ops = {
1233     .open = snd_usbmidi_input_open,
1234     .close = snd_usbmidi_input_close,
1235     .trigger = snd_usbmidi_input_trigger
1236 };
1237 
1238 static void free_urb_and_buffer(struct snd_usb_midi *umidi, struct urb *urb,
1239                 unsigned int buffer_length)
1240 {
1241     usb_free_coherent(umidi->dev, buffer_length,
1242               urb->transfer_buffer, urb->transfer_dma);
1243     usb_free_urb(urb);
1244 }
1245 
1246 /*
1247  * Frees an input endpoint.
1248  * May be called when ep hasn't been initialized completely.
1249  */
1250 static void snd_usbmidi_in_endpoint_delete(struct snd_usb_midi_in_endpoint *ep)
1251 {
1252     unsigned int i;
1253 
1254     for (i = 0; i < INPUT_URBS; ++i)
1255         if (ep->urbs[i])
1256             free_urb_and_buffer(ep->umidi, ep->urbs[i],
1257                         ep->urbs[i]->transfer_buffer_length);
1258     kfree(ep);
1259 }
1260 
1261 /*
1262  * Creates an input endpoint.
1263  */
1264 static int snd_usbmidi_in_endpoint_create(struct snd_usb_midi *umidi,
1265                       struct snd_usb_midi_endpoint_info *ep_info,
1266                       struct snd_usb_midi_endpoint *rep)
1267 {
1268     struct snd_usb_midi_in_endpoint *ep;
1269     void *buffer;
1270     unsigned int pipe;
1271     int length;
1272     unsigned int i;
1273     int err;
1274 
1275     rep->in = NULL;
1276     ep = kzalloc(sizeof(*ep), GFP_KERNEL);
1277     if (!ep)
1278         return -ENOMEM;
1279     ep->umidi = umidi;
1280 
1281     for (i = 0; i < INPUT_URBS; ++i) {
1282         ep->urbs[i] = usb_alloc_urb(0, GFP_KERNEL);
1283         if (!ep->urbs[i]) {
1284             err = -ENOMEM;
1285             goto error;
1286         }
1287     }
1288     if (ep_info->in_interval)
1289         pipe = usb_rcvintpipe(umidi->dev, ep_info->in_ep);
1290     else
1291         pipe = usb_rcvbulkpipe(umidi->dev, ep_info->in_ep);
1292     length = usb_maxpacket(umidi->dev, pipe);
1293     for (i = 0; i < INPUT_URBS; ++i) {
1294         buffer = usb_alloc_coherent(umidi->dev, length, GFP_KERNEL,
1295                         &ep->urbs[i]->transfer_dma);
1296         if (!buffer) {
1297             err = -ENOMEM;
1298             goto error;
1299         }
1300         if (ep_info->in_interval)
1301             usb_fill_int_urb(ep->urbs[i], umidi->dev,
1302                      pipe, buffer, length,
1303                      snd_usbmidi_in_urb_complete,
1304                      ep, ep_info->in_interval);
1305         else
1306             usb_fill_bulk_urb(ep->urbs[i], umidi->dev,
1307                       pipe, buffer, length,
1308                       snd_usbmidi_in_urb_complete, ep);
1309         ep->urbs[i]->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
1310         err = usb_urb_ep_type_check(ep->urbs[i]);
1311         if (err < 0) {
1312             dev_err(&umidi->dev->dev, "invalid MIDI in EP %x\n",
1313                 ep_info->in_ep);
1314             goto error;
1315         }
1316     }
1317 
1318     rep->in = ep;
1319     return 0;
1320 
1321  error:
1322     snd_usbmidi_in_endpoint_delete(ep);
1323     return err;
1324 }
1325 
1326 /*
1327  * Frees an output endpoint.
1328  * May be called when ep hasn't been initialized completely.
1329  */
1330 static void snd_usbmidi_out_endpoint_clear(struct snd_usb_midi_out_endpoint *ep)
1331 {
1332     unsigned int i;
1333 
1334     for (i = 0; i < OUTPUT_URBS; ++i)
1335         if (ep->urbs[i].urb) {
1336             free_urb_and_buffer(ep->umidi, ep->urbs[i].urb,
1337                         ep->max_transfer);
1338             ep->urbs[i].urb = NULL;
1339         }
1340 }
1341 
1342 static void snd_usbmidi_out_endpoint_delete(struct snd_usb_midi_out_endpoint *ep)
1343 {
1344     snd_usbmidi_out_endpoint_clear(ep);
1345     kfree(ep);
1346 }
1347 
1348 /*
1349  * Creates an output endpoint, and initializes output ports.
1350  */
1351 static int snd_usbmidi_out_endpoint_create(struct snd_usb_midi *umidi,
1352                        struct snd_usb_midi_endpoint_info *ep_info,
1353                        struct snd_usb_midi_endpoint *rep)
1354 {
1355     struct snd_usb_midi_out_endpoint *ep;
1356     unsigned int i;
1357     unsigned int pipe;
1358     void *buffer;
1359     int err;
1360 
1361     rep->out = NULL;
1362     ep = kzalloc(sizeof(*ep), GFP_KERNEL);
1363     if (!ep)
1364         return -ENOMEM;
1365     ep->umidi = umidi;
1366 
1367     for (i = 0; i < OUTPUT_URBS; ++i) {
1368         ep->urbs[i].urb = usb_alloc_urb(0, GFP_KERNEL);
1369         if (!ep->urbs[i].urb) {
1370             err = -ENOMEM;
1371             goto error;
1372         }
1373         ep->urbs[i].ep = ep;
1374     }
1375     if (ep_info->out_interval)
1376         pipe = usb_sndintpipe(umidi->dev, ep_info->out_ep);
1377     else
1378         pipe = usb_sndbulkpipe(umidi->dev, ep_info->out_ep);
1379     switch (umidi->usb_id) {
1380     default:
1381         ep->max_transfer = usb_maxpacket(umidi->dev, pipe);
1382         break;
1383         /*
1384          * Various chips declare a packet size larger than 4 bytes, but
1385          * do not actually work with larger packets:
1386          */
1387     case USB_ID(0x0a67, 0x5011): /* Medeli DD305 */
1388     case USB_ID(0x0a92, 0x1020): /* ESI M4U */
1389     case USB_ID(0x1430, 0x474b): /* RedOctane GH MIDI INTERFACE */
1390     case USB_ID(0x15ca, 0x0101): /* Textech USB Midi Cable */
1391     case USB_ID(0x15ca, 0x1806): /* Textech USB Midi Cable */
1392     case USB_ID(0x1a86, 0x752d): /* QinHeng CH345 "USB2.0-MIDI" */
1393     case USB_ID(0xfc08, 0x0101): /* Unknown vendor Cable */
1394         ep->max_transfer = 4;
1395         break;
1396         /*
1397          * Some devices only work with 9 bytes packet size:
1398          */
1399     case USB_ID(0x0644, 0x800e): /* Tascam US-122L */
1400     case USB_ID(0x0644, 0x800f): /* Tascam US-144 */
1401         ep->max_transfer = 9;
1402         break;
1403     }
1404     for (i = 0; i < OUTPUT_URBS; ++i) {
1405         buffer = usb_alloc_coherent(umidi->dev,
1406                         ep->max_transfer, GFP_KERNEL,
1407                         &ep->urbs[i].urb->transfer_dma);
1408         if (!buffer) {
1409             err = -ENOMEM;
1410             goto error;
1411         }
1412         if (ep_info->out_interval)
1413             usb_fill_int_urb(ep->urbs[i].urb, umidi->dev,
1414                      pipe, buffer, ep->max_transfer,
1415                      snd_usbmidi_out_urb_complete,
1416                      &ep->urbs[i], ep_info->out_interval);
1417         else
1418             usb_fill_bulk_urb(ep->urbs[i].urb, umidi->dev,
1419                       pipe, buffer, ep->max_transfer,
1420                       snd_usbmidi_out_urb_complete,
1421                       &ep->urbs[i]);
1422         err = usb_urb_ep_type_check(ep->urbs[i].urb);
1423         if (err < 0) {
1424             dev_err(&umidi->dev->dev, "invalid MIDI out EP %x\n",
1425                 ep_info->out_ep);
1426             goto error;
1427         }
1428         ep->urbs[i].urb->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
1429     }
1430 
1431     spin_lock_init(&ep->buffer_lock);
1432     INIT_WORK(&ep->work, snd_usbmidi_out_work);
1433     init_waitqueue_head(&ep->drain_wait);
1434 
1435     for (i = 0; i < 0x10; ++i)
1436         if (ep_info->out_cables & (1 << i)) {
1437             ep->ports[i].ep = ep;
1438             ep->ports[i].cable = i << 4;
1439         }
1440 
1441     if (umidi->usb_protocol_ops->init_out_endpoint)
1442         umidi->usb_protocol_ops->init_out_endpoint(ep);
1443 
1444     rep->out = ep;
1445     return 0;
1446 
1447  error:
1448     snd_usbmidi_out_endpoint_delete(ep);
1449     return err;
1450 }
1451 
1452 /*
1453  * Frees everything.
1454  */
1455 static void snd_usbmidi_free(struct snd_usb_midi *umidi)
1456 {
1457     int i;
1458 
1459     for (i = 0; i < MIDI_MAX_ENDPOINTS; ++i) {
1460         struct snd_usb_midi_endpoint *ep = &umidi->endpoints[i];
1461         if (ep->out)
1462             snd_usbmidi_out_endpoint_delete(ep->out);
1463         if (ep->in)
1464             snd_usbmidi_in_endpoint_delete(ep->in);
1465     }
1466     mutex_destroy(&umidi->mutex);
1467     kfree(umidi);
1468 }
1469 
1470 /*
1471  * Unlinks all URBs (must be done before the usb_device is deleted).
1472  */
1473 void snd_usbmidi_disconnect(struct list_head *p)
1474 {
1475     struct snd_usb_midi *umidi;
1476     unsigned int i, j;
1477 
1478     umidi = list_entry(p, struct snd_usb_midi, list);
1479     /*
1480      * an URB's completion handler may start the timer and
1481      * a timer may submit an URB. To reliably break the cycle
1482      * a flag under lock must be used
1483      */
1484     down_write(&umidi->disc_rwsem);
1485     spin_lock_irq(&umidi->disc_lock);
1486     umidi->disconnected = 1;
1487     spin_unlock_irq(&umidi->disc_lock);
1488     up_write(&umidi->disc_rwsem);
1489 
1490     del_timer_sync(&umidi->error_timer);
1491 
1492     for (i = 0; i < MIDI_MAX_ENDPOINTS; ++i) {
1493         struct snd_usb_midi_endpoint *ep = &umidi->endpoints[i];
1494         if (ep->out)
1495             cancel_work_sync(&ep->out->work);
1496         if (ep->out) {
1497             for (j = 0; j < OUTPUT_URBS; ++j)
1498                 usb_kill_urb(ep->out->urbs[j].urb);
1499             if (umidi->usb_protocol_ops->finish_out_endpoint)
1500                 umidi->usb_protocol_ops->finish_out_endpoint(ep->out);
1501             ep->out->active_urbs = 0;
1502             if (ep->out->drain_urbs) {
1503                 ep->out->drain_urbs = 0;
1504                 wake_up(&ep->out->drain_wait);
1505             }
1506         }
1507         if (ep->in)
1508             for (j = 0; j < INPUT_URBS; ++j)
1509                 usb_kill_urb(ep->in->urbs[j]);
1510         /* free endpoints here; later call can result in Oops */
1511         if (ep->out)
1512             snd_usbmidi_out_endpoint_clear(ep->out);
1513         if (ep->in) {
1514             snd_usbmidi_in_endpoint_delete(ep->in);
1515             ep->in = NULL;
1516         }
1517     }
1518 }
1519 EXPORT_SYMBOL(snd_usbmidi_disconnect);
1520 
1521 static void snd_usbmidi_rawmidi_free(struct snd_rawmidi *rmidi)
1522 {
1523     struct snd_usb_midi *umidi = rmidi->private_data;
1524     snd_usbmidi_free(umidi);
1525 }
1526 
1527 static struct snd_rawmidi_substream *snd_usbmidi_find_substream(struct snd_usb_midi *umidi,
1528                                 int stream,
1529                                 int number)
1530 {
1531     struct snd_rawmidi_substream *substream;
1532 
1533     list_for_each_entry(substream, &umidi->rmidi->streams[stream].substreams,
1534                 list) {
1535         if (substream->number == number)
1536             return substream;
1537     }
1538     return NULL;
1539 }
1540 
1541 /*
1542  * This list specifies names for ports that do not fit into the standard
1543  * "(product) MIDI (n)" schema because they aren't external MIDI ports,
1544  * such as internal control or synthesizer ports.
1545  */
1546 static struct port_info {
1547     u32 id;
1548     short int port;
1549     short int voices;
1550     const char *name;
1551     unsigned int seq_flags;
1552 } snd_usbmidi_port_info[] = {
1553 #define PORT_INFO(vendor, product, num, name_, voices_, flags) \
1554     { .id = USB_ID(vendor, product), \
1555       .port = num, .voices = voices_, \
1556       .name = name_, .seq_flags = flags }
1557 #define EXTERNAL_PORT(vendor, product, num, name) \
1558     PORT_INFO(vendor, product, num, name, 0, \
1559           SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC | \
1560           SNDRV_SEQ_PORT_TYPE_HARDWARE | \
1561           SNDRV_SEQ_PORT_TYPE_PORT)
1562 #define CONTROL_PORT(vendor, product, num, name) \
1563     PORT_INFO(vendor, product, num, name, 0, \
1564           SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC | \
1565           SNDRV_SEQ_PORT_TYPE_HARDWARE)
1566 #define GM_SYNTH_PORT(vendor, product, num, name, voices) \
1567     PORT_INFO(vendor, product, num, name, voices, \
1568           SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC | \
1569           SNDRV_SEQ_PORT_TYPE_MIDI_GM | \
1570           SNDRV_SEQ_PORT_TYPE_HARDWARE | \
1571           SNDRV_SEQ_PORT_TYPE_SYNTHESIZER)
1572 #define ROLAND_SYNTH_PORT(vendor, product, num, name, voices) \
1573     PORT_INFO(vendor, product, num, name, voices, \
1574           SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC | \
1575           SNDRV_SEQ_PORT_TYPE_MIDI_GM | \
1576           SNDRV_SEQ_PORT_TYPE_MIDI_GM2 | \
1577           SNDRV_SEQ_PORT_TYPE_MIDI_GS | \
1578           SNDRV_SEQ_PORT_TYPE_MIDI_XG | \
1579           SNDRV_SEQ_PORT_TYPE_HARDWARE | \
1580           SNDRV_SEQ_PORT_TYPE_SYNTHESIZER)
1581 #define SOUNDCANVAS_PORT(vendor, product, num, name, voices) \
1582     PORT_INFO(vendor, product, num, name, voices, \
1583           SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC | \
1584           SNDRV_SEQ_PORT_TYPE_MIDI_GM | \
1585           SNDRV_SEQ_PORT_TYPE_MIDI_GM2 | \
1586           SNDRV_SEQ_PORT_TYPE_MIDI_GS | \
1587           SNDRV_SEQ_PORT_TYPE_MIDI_XG | \
1588           SNDRV_SEQ_PORT_TYPE_MIDI_MT32 | \
1589           SNDRV_SEQ_PORT_TYPE_HARDWARE | \
1590           SNDRV_SEQ_PORT_TYPE_SYNTHESIZER)
1591     /* Yamaha MOTIF XF */
1592     GM_SYNTH_PORT(0x0499, 0x105c, 0, "%s Tone Generator", 128),
1593     CONTROL_PORT(0x0499, 0x105c, 1, "%s Remote Control"),
1594     EXTERNAL_PORT(0x0499, 0x105c, 2, "%s Thru"),
1595     CONTROL_PORT(0x0499, 0x105c, 3, "%s Editor"),
1596     /* Roland UA-100 */
1597     CONTROL_PORT(0x0582, 0x0000, 2, "%s Control"),
1598     /* Roland SC-8850 */
1599     SOUNDCANVAS_PORT(0x0582, 0x0003, 0, "%s Part A", 128),
1600     SOUNDCANVAS_PORT(0x0582, 0x0003, 1, "%s Part B", 128),
1601     SOUNDCANVAS_PORT(0x0582, 0x0003, 2, "%s Part C", 128),
1602     SOUNDCANVAS_PORT(0x0582, 0x0003, 3, "%s Part D", 128),
1603     EXTERNAL_PORT(0x0582, 0x0003, 4, "%s MIDI 1"),
1604     EXTERNAL_PORT(0x0582, 0x0003, 5, "%s MIDI 2"),
1605     /* Roland U-8 */
1606     EXTERNAL_PORT(0x0582, 0x0004, 0, "%s MIDI"),
1607     CONTROL_PORT(0x0582, 0x0004, 1, "%s Control"),
1608     /* Roland SC-8820 */
1609     SOUNDCANVAS_PORT(0x0582, 0x0007, 0, "%s Part A", 64),
1610     SOUNDCANVAS_PORT(0x0582, 0x0007, 1, "%s Part B", 64),
1611     EXTERNAL_PORT(0x0582, 0x0007, 2, "%s MIDI"),
1612     /* Roland SK-500 */
1613     SOUNDCANVAS_PORT(0x0582, 0x000b, 0, "%s Part A", 64),
1614     SOUNDCANVAS_PORT(0x0582, 0x000b, 1, "%s Part B", 64),
1615     EXTERNAL_PORT(0x0582, 0x000b, 2, "%s MIDI"),
1616     /* Roland SC-D70 */
1617     SOUNDCANVAS_PORT(0x0582, 0x000c, 0, "%s Part A", 64),
1618     SOUNDCANVAS_PORT(0x0582, 0x000c, 1, "%s Part B", 64),
1619     EXTERNAL_PORT(0x0582, 0x000c, 2, "%s MIDI"),
1620     /* Edirol UM-880 */
1621     CONTROL_PORT(0x0582, 0x0014, 8, "%s Control"),
1622     /* Edirol SD-90 */
1623     ROLAND_SYNTH_PORT(0x0582, 0x0016, 0, "%s Part A", 128),
1624     ROLAND_SYNTH_PORT(0x0582, 0x0016, 1, "%s Part B", 128),
1625     EXTERNAL_PORT(0x0582, 0x0016, 2, "%s MIDI 1"),
1626     EXTERNAL_PORT(0x0582, 0x0016, 3, "%s MIDI 2"),
1627     /* Edirol UM-550 */
1628     CONTROL_PORT(0x0582, 0x0023, 5, "%s Control"),
1629     /* Edirol SD-20 */
1630     ROLAND_SYNTH_PORT(0x0582, 0x0027, 0, "%s Part A", 64),
1631     ROLAND_SYNTH_PORT(0x0582, 0x0027, 1, "%s Part B", 64),
1632     EXTERNAL_PORT(0x0582, 0x0027, 2, "%s MIDI"),
1633     /* Edirol SD-80 */
1634     ROLAND_SYNTH_PORT(0x0582, 0x0029, 0, "%s Part A", 128),
1635     ROLAND_SYNTH_PORT(0x0582, 0x0029, 1, "%s Part B", 128),
1636     EXTERNAL_PORT(0x0582, 0x0029, 2, "%s MIDI 1"),
1637     EXTERNAL_PORT(0x0582, 0x0029, 3, "%s MIDI 2"),
1638     /* Edirol UA-700 */
1639     EXTERNAL_PORT(0x0582, 0x002b, 0, "%s MIDI"),
1640     CONTROL_PORT(0x0582, 0x002b, 1, "%s Control"),
1641     /* Roland VariOS */
1642     EXTERNAL_PORT(0x0582, 0x002f, 0, "%s MIDI"),
1643     EXTERNAL_PORT(0x0582, 0x002f, 1, "%s External MIDI"),
1644     EXTERNAL_PORT(0x0582, 0x002f, 2, "%s Sync"),
1645     /* Edirol PCR */
1646     EXTERNAL_PORT(0x0582, 0x0033, 0, "%s MIDI"),
1647     EXTERNAL_PORT(0x0582, 0x0033, 1, "%s 1"),
1648     EXTERNAL_PORT(0x0582, 0x0033, 2, "%s 2"),
1649     /* BOSS GS-10 */
1650     EXTERNAL_PORT(0x0582, 0x003b, 0, "%s MIDI"),
1651     CONTROL_PORT(0x0582, 0x003b, 1, "%s Control"),
1652     /* Edirol UA-1000 */
1653     EXTERNAL_PORT(0x0582, 0x0044, 0, "%s MIDI"),
1654     CONTROL_PORT(0x0582, 0x0044, 1, "%s Control"),
1655     /* Edirol UR-80 */
1656     EXTERNAL_PORT(0x0582, 0x0048, 0, "%s MIDI"),
1657     EXTERNAL_PORT(0x0582, 0x0048, 1, "%s 1"),
1658     EXTERNAL_PORT(0x0582, 0x0048, 2, "%s 2"),
1659     /* Edirol PCR-A */
1660     EXTERNAL_PORT(0x0582, 0x004d, 0, "%s MIDI"),
1661     EXTERNAL_PORT(0x0582, 0x004d, 1, "%s 1"),
1662     EXTERNAL_PORT(0x0582, 0x004d, 2, "%s 2"),
1663     /* BOSS GT-PRO */
1664     CONTROL_PORT(0x0582, 0x0089, 0, "%s Control"),
1665     /* Edirol UM-3EX */
1666     CONTROL_PORT(0x0582, 0x009a, 3, "%s Control"),
1667     /* Roland VG-99 */
1668     CONTROL_PORT(0x0582, 0x00b2, 0, "%s Control"),
1669     EXTERNAL_PORT(0x0582, 0x00b2, 1, "%s MIDI"),
1670     /* Cakewalk Sonar V-Studio 100 */
1671     EXTERNAL_PORT(0x0582, 0x00eb, 0, "%s MIDI"),
1672     CONTROL_PORT(0x0582, 0x00eb, 1, "%s Control"),
1673     /* Roland VB-99 */
1674     CONTROL_PORT(0x0582, 0x0102, 0, "%s Control"),
1675     EXTERNAL_PORT(0x0582, 0x0102, 1, "%s MIDI"),
1676     /* Roland A-PRO */
1677     EXTERNAL_PORT(0x0582, 0x010f, 0, "%s MIDI"),
1678     CONTROL_PORT(0x0582, 0x010f, 1, "%s 1"),
1679     CONTROL_PORT(0x0582, 0x010f, 2, "%s 2"),
1680     /* Roland SD-50 */
1681     ROLAND_SYNTH_PORT(0x0582, 0x0114, 0, "%s Synth", 128),
1682     EXTERNAL_PORT(0x0582, 0x0114, 1, "%s MIDI"),
1683     CONTROL_PORT(0x0582, 0x0114, 2, "%s Control"),
1684     /* Roland OCTA-CAPTURE */
1685     EXTERNAL_PORT(0x0582, 0x0120, 0, "%s MIDI"),
1686     CONTROL_PORT(0x0582, 0x0120, 1, "%s Control"),
1687     EXTERNAL_PORT(0x0582, 0x0121, 0, "%s MIDI"),
1688     CONTROL_PORT(0x0582, 0x0121, 1, "%s Control"),
1689     /* Roland SPD-SX */
1690     CONTROL_PORT(0x0582, 0x0145, 0, "%s Control"),
1691     EXTERNAL_PORT(0x0582, 0x0145, 1, "%s MIDI"),
1692     /* Roland A-Series */
1693     CONTROL_PORT(0x0582, 0x0156, 0, "%s Keyboard"),
1694     EXTERNAL_PORT(0x0582, 0x0156, 1, "%s MIDI"),
1695     /* Roland INTEGRA-7 */
1696     ROLAND_SYNTH_PORT(0x0582, 0x015b, 0, "%s Synth", 128),
1697     CONTROL_PORT(0x0582, 0x015b, 1, "%s Control"),
1698     /* M-Audio MidiSport 8x8 */
1699     CONTROL_PORT(0x0763, 0x1031, 8, "%s Control"),
1700     CONTROL_PORT(0x0763, 0x1033, 8, "%s Control"),
1701     /* MOTU Fastlane */
1702     EXTERNAL_PORT(0x07fd, 0x0001, 0, "%s MIDI A"),
1703     EXTERNAL_PORT(0x07fd, 0x0001, 1, "%s MIDI B"),
1704     /* Emagic Unitor8/AMT8/MT4 */
1705     EXTERNAL_PORT(0x086a, 0x0001, 8, "%s Broadcast"),
1706     EXTERNAL_PORT(0x086a, 0x0002, 8, "%s Broadcast"),
1707     EXTERNAL_PORT(0x086a, 0x0003, 4, "%s Broadcast"),
1708     /* Akai MPD16 */
1709     CONTROL_PORT(0x09e8, 0x0062, 0, "%s Control"),
1710     PORT_INFO(0x09e8, 0x0062, 1, "%s MIDI", 0,
1711         SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC |
1712         SNDRV_SEQ_PORT_TYPE_HARDWARE),
1713     /* Access Music Virus TI */
1714     EXTERNAL_PORT(0x133e, 0x0815, 0, "%s MIDI"),
1715     PORT_INFO(0x133e, 0x0815, 1, "%s Synth", 0,
1716         SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC |
1717         SNDRV_SEQ_PORT_TYPE_HARDWARE |
1718         SNDRV_SEQ_PORT_TYPE_SYNTHESIZER),
1719 };
1720 
1721 static struct port_info *find_port_info(struct snd_usb_midi *umidi, int number)
1722 {
1723     int i;
1724 
1725     for (i = 0; i < ARRAY_SIZE(snd_usbmidi_port_info); ++i) {
1726         if (snd_usbmidi_port_info[i].id == umidi->usb_id &&
1727             snd_usbmidi_port_info[i].port == number)
1728             return &snd_usbmidi_port_info[i];
1729     }
1730     return NULL;
1731 }
1732 
1733 static void snd_usbmidi_get_port_info(struct snd_rawmidi *rmidi, int number,
1734                       struct snd_seq_port_info *seq_port_info)
1735 {
1736     struct snd_usb_midi *umidi = rmidi->private_data;
1737     struct port_info *port_info;
1738 
1739     /* TODO: read port flags from descriptors */
1740     port_info = find_port_info(umidi, number);
1741     if (port_info) {
1742         seq_port_info->type = port_info->seq_flags;
1743         seq_port_info->midi_voices = port_info->voices;
1744     }
1745 }
1746 
1747 static struct usb_midi_in_jack_descriptor *find_usb_in_jack_descriptor(
1748                     struct usb_host_interface *hostif, uint8_t jack_id)
1749 {
1750     unsigned char *extra = hostif->extra;
1751     int extralen = hostif->extralen;
1752 
1753     while (extralen > 4) {
1754         struct usb_midi_in_jack_descriptor *injd =
1755                 (struct usb_midi_in_jack_descriptor *)extra;
1756 
1757         if (injd->bLength >= sizeof(*injd) &&
1758             injd->bDescriptorType == USB_DT_CS_INTERFACE &&
1759             injd->bDescriptorSubtype == UAC_MIDI_IN_JACK &&
1760                 injd->bJackID == jack_id)
1761             return injd;
1762         if (!extra[0])
1763             break;
1764         extralen -= extra[0];
1765         extra += extra[0];
1766     }
1767     return NULL;
1768 }
1769 
1770 static struct usb_midi_out_jack_descriptor *find_usb_out_jack_descriptor(
1771                     struct usb_host_interface *hostif, uint8_t jack_id)
1772 {
1773     unsigned char *extra = hostif->extra;
1774     int extralen = hostif->extralen;
1775 
1776     while (extralen > 4) {
1777         struct usb_midi_out_jack_descriptor *outjd =
1778                 (struct usb_midi_out_jack_descriptor *)extra;
1779 
1780         if (outjd->bLength >= sizeof(*outjd) &&
1781             outjd->bDescriptorType == USB_DT_CS_INTERFACE &&
1782             outjd->bDescriptorSubtype == UAC_MIDI_OUT_JACK &&
1783                 outjd->bJackID == jack_id)
1784             return outjd;
1785         if (!extra[0])
1786             break;
1787         extralen -= extra[0];
1788         extra += extra[0];
1789     }
1790     return NULL;
1791 }
1792 
1793 static void snd_usbmidi_init_substream(struct snd_usb_midi *umidi,
1794                        int stream, int number, int jack_id,
1795                        struct snd_rawmidi_substream **rsubstream)
1796 {
1797     struct port_info *port_info;
1798     const char *name_format;
1799     struct usb_interface *intf;
1800     struct usb_host_interface *hostif;
1801     struct usb_midi_in_jack_descriptor *injd;
1802     struct usb_midi_out_jack_descriptor *outjd;
1803     uint8_t jack_name_buf[32];
1804     uint8_t *default_jack_name = "MIDI";
1805     uint8_t *jack_name = default_jack_name;
1806     uint8_t iJack;
1807     size_t sz;
1808     int res;
1809 
1810     struct snd_rawmidi_substream *substream =
1811         snd_usbmidi_find_substream(umidi, stream, number);
1812     if (!substream) {
1813         dev_err(&umidi->dev->dev, "substream %d:%d not found\n", stream,
1814             number);
1815         return;
1816     }
1817 
1818     intf = umidi->iface;
1819     if (intf && jack_id >= 0) {
1820         hostif = intf->cur_altsetting;
1821         iJack = 0;
1822         if (stream != SNDRV_RAWMIDI_STREAM_OUTPUT) {
1823             /* in jacks connect to outs */
1824             outjd = find_usb_out_jack_descriptor(hostif, jack_id);
1825             if (outjd) {
1826                 sz = USB_DT_MIDI_OUT_SIZE(outjd->bNrInputPins);
1827                 if (outjd->bLength >= sz)
1828                     iJack = *(((uint8_t *) outjd) + sz - sizeof(uint8_t));
1829             }
1830         } else {
1831             /* and out jacks connect to ins */
1832             injd = find_usb_in_jack_descriptor(hostif, jack_id);
1833             if (injd)
1834                 iJack = injd->iJack;
1835         }
1836         if (iJack != 0) {
1837             res = usb_string(umidi->dev, iJack, jack_name_buf,
1838               ARRAY_SIZE(jack_name_buf));
1839             if (res)
1840                 jack_name = jack_name_buf;
1841         }
1842     }
1843 
1844     port_info = find_port_info(umidi, number);
1845     name_format = port_info ? port_info->name :
1846         (jack_name != default_jack_name  ? "%s %s" : "%s %s %d");
1847     snprintf(substream->name, sizeof(substream->name),
1848          name_format, umidi->card->shortname, jack_name, number + 1);
1849 
1850     *rsubstream = substream;
1851 }
1852 
1853 /*
1854  * Creates the endpoints and their ports.
1855  */
1856 static int snd_usbmidi_create_endpoints(struct snd_usb_midi *umidi,
1857                     struct snd_usb_midi_endpoint_info *endpoints)
1858 {
1859     int i, j, err;
1860     int out_ports = 0, in_ports = 0;
1861 
1862     for (i = 0; i < MIDI_MAX_ENDPOINTS; ++i) {
1863         if (endpoints[i].out_cables) {
1864             err = snd_usbmidi_out_endpoint_create(umidi,
1865                                   &endpoints[i],
1866                                   &umidi->endpoints[i]);
1867             if (err < 0)
1868                 return err;
1869         }
1870         if (endpoints[i].in_cables) {
1871             err = snd_usbmidi_in_endpoint_create(umidi,
1872                                  &endpoints[i],
1873                                  &umidi->endpoints[i]);
1874             if (err < 0)
1875                 return err;
1876         }
1877 
1878         for (j = 0; j < 0x10; ++j) {
1879             if (endpoints[i].out_cables & (1 << j)) {
1880                 snd_usbmidi_init_substream(umidi,
1881                                SNDRV_RAWMIDI_STREAM_OUTPUT,
1882                                out_ports,
1883                                endpoints[i].assoc_out_jacks[j],
1884                                &umidi->endpoints[i].out->ports[j].substream);
1885                 ++out_ports;
1886             }
1887             if (endpoints[i].in_cables & (1 << j)) {
1888                 snd_usbmidi_init_substream(umidi,
1889                                SNDRV_RAWMIDI_STREAM_INPUT,
1890                                in_ports,
1891                                endpoints[i].assoc_in_jacks[j],
1892                                &umidi->endpoints[i].in->ports[j].substream);
1893                 ++in_ports;
1894             }
1895         }
1896     }
1897     dev_dbg(&umidi->dev->dev, "created %d output and %d input ports\n",
1898             out_ports, in_ports);
1899     return 0;
1900 }
1901 
1902 static struct usb_ms_endpoint_descriptor *find_usb_ms_endpoint_descriptor(
1903                     struct usb_host_endpoint *hostep)
1904 {
1905     unsigned char *extra = hostep->extra;
1906     int extralen = hostep->extralen;
1907 
1908     while (extralen > 3) {
1909         struct usb_ms_endpoint_descriptor *ms_ep =
1910                 (struct usb_ms_endpoint_descriptor *)extra;
1911 
1912         if (ms_ep->bLength > 3 &&
1913             ms_ep->bDescriptorType == USB_DT_CS_ENDPOINT &&
1914             ms_ep->bDescriptorSubtype == UAC_MS_GENERAL)
1915             return ms_ep;
1916         if (!extra[0])
1917             break;
1918         extralen -= extra[0];
1919         extra += extra[0];
1920     }
1921     return NULL;
1922 }
1923 
1924 /*
1925  * Returns MIDIStreaming device capabilities.
1926  */
1927 static int snd_usbmidi_get_ms_info(struct snd_usb_midi *umidi,
1928                    struct snd_usb_midi_endpoint_info *endpoints)
1929 {
1930     struct usb_interface *intf;
1931     struct usb_host_interface *hostif;
1932     struct usb_interface_descriptor *intfd;
1933     struct usb_ms_header_descriptor *ms_header;
1934     struct usb_host_endpoint *hostep;
1935     struct usb_endpoint_descriptor *ep;
1936     struct usb_ms_endpoint_descriptor *ms_ep;
1937     int i, j, epidx;
1938 
1939     intf = umidi->iface;
1940     if (!intf)
1941         return -ENXIO;
1942     hostif = &intf->altsetting[0];
1943     intfd = get_iface_desc(hostif);
1944     ms_header = (struct usb_ms_header_descriptor *)hostif->extra;
1945     if (hostif->extralen >= 7 &&
1946         ms_header->bLength >= 7 &&
1947         ms_header->bDescriptorType == USB_DT_CS_INTERFACE &&
1948         ms_header->bDescriptorSubtype == UAC_HEADER)
1949         dev_dbg(&umidi->dev->dev, "MIDIStreaming version %02x.%02x\n",
1950                 ((uint8_t *)&ms_header->bcdMSC)[1], ((uint8_t *)&ms_header->bcdMSC)[0]);
1951     else
1952         dev_warn(&umidi->dev->dev,
1953              "MIDIStreaming interface descriptor not found\n");
1954 
1955     epidx = 0;
1956     for (i = 0; i < intfd->bNumEndpoints; ++i) {
1957         hostep = &hostif->endpoint[i];
1958         ep = get_ep_desc(hostep);
1959         if (!usb_endpoint_xfer_bulk(ep) && !usb_endpoint_xfer_int(ep))
1960             continue;
1961         ms_ep = find_usb_ms_endpoint_descriptor(hostep);
1962         if (!ms_ep)
1963             continue;
1964         if (ms_ep->bLength <= sizeof(*ms_ep))
1965             continue;
1966         if (ms_ep->bNumEmbMIDIJack > 0x10)
1967             continue;
1968         if (ms_ep->bLength < sizeof(*ms_ep) + ms_ep->bNumEmbMIDIJack)
1969             continue;
1970         if (usb_endpoint_dir_out(ep)) {
1971             if (endpoints[epidx].out_ep) {
1972                 if (++epidx >= MIDI_MAX_ENDPOINTS) {
1973                     dev_warn(&umidi->dev->dev,
1974                          "too many endpoints\n");
1975                     break;
1976                 }
1977             }
1978             endpoints[epidx].out_ep = usb_endpoint_num(ep);
1979             if (usb_endpoint_xfer_int(ep))
1980                 endpoints[epidx].out_interval = ep->bInterval;
1981             else if (snd_usb_get_speed(umidi->dev) == USB_SPEED_LOW)
1982                 /*
1983                  * Low speed bulk transfers don't exist, so
1984                  * force interrupt transfers for devices like
1985                  * ESI MIDI Mate that try to use them anyway.
1986                  */
1987                 endpoints[epidx].out_interval = 1;
1988             endpoints[epidx].out_cables =
1989                 (1 << ms_ep->bNumEmbMIDIJack) - 1;
1990             for (j = 0; j < ms_ep->bNumEmbMIDIJack; ++j)
1991                 endpoints[epidx].assoc_out_jacks[j] = ms_ep->baAssocJackID[j];
1992             for (; j < ARRAY_SIZE(endpoints[epidx].assoc_out_jacks); ++j)
1993                 endpoints[epidx].assoc_out_jacks[j] = -1;
1994             dev_dbg(&umidi->dev->dev, "EP %02X: %d jack(s)\n",
1995                 ep->bEndpointAddress, ms_ep->bNumEmbMIDIJack);
1996         } else {
1997             if (endpoints[epidx].in_ep) {
1998                 if (++epidx >= MIDI_MAX_ENDPOINTS) {
1999                     dev_warn(&umidi->dev->dev,
2000                          "too many endpoints\n");
2001                     break;
2002                 }
2003             }
2004             endpoints[epidx].in_ep = usb_endpoint_num(ep);
2005             if (usb_endpoint_xfer_int(ep))
2006                 endpoints[epidx].in_interval = ep->bInterval;
2007             else if (snd_usb_get_speed(umidi->dev) == USB_SPEED_LOW)
2008                 endpoints[epidx].in_interval = 1;
2009             endpoints[epidx].in_cables =
2010                 (1 << ms_ep->bNumEmbMIDIJack) - 1;
2011             for (j = 0; j < ms_ep->bNumEmbMIDIJack; ++j)
2012                 endpoints[epidx].assoc_in_jacks[j] = ms_ep->baAssocJackID[j];
2013             for (; j < ARRAY_SIZE(endpoints[epidx].assoc_in_jacks); ++j)
2014                 endpoints[epidx].assoc_in_jacks[j] = -1;
2015             dev_dbg(&umidi->dev->dev, "EP %02X: %d jack(s)\n",
2016                 ep->bEndpointAddress, ms_ep->bNumEmbMIDIJack);
2017         }
2018     }
2019     return 0;
2020 }
2021 
2022 static int roland_load_info(struct snd_kcontrol *kcontrol,
2023                 struct snd_ctl_elem_info *info)
2024 {
2025     static const char *const names[] = { "High Load", "Light Load" };
2026 
2027     return snd_ctl_enum_info(info, 1, 2, names);
2028 }
2029 
2030 static int roland_load_get(struct snd_kcontrol *kcontrol,
2031                struct snd_ctl_elem_value *value)
2032 {
2033     value->value.enumerated.item[0] = kcontrol->private_value;
2034     return 0;
2035 }
2036 
2037 static int roland_load_put(struct snd_kcontrol *kcontrol,
2038                struct snd_ctl_elem_value *value)
2039 {
2040     struct snd_usb_midi *umidi = kcontrol->private_data;
2041     int changed;
2042 
2043     if (value->value.enumerated.item[0] > 1)
2044         return -EINVAL;
2045     mutex_lock(&umidi->mutex);
2046     changed = value->value.enumerated.item[0] != kcontrol->private_value;
2047     if (changed)
2048         kcontrol->private_value = value->value.enumerated.item[0];
2049     mutex_unlock(&umidi->mutex);
2050     return changed;
2051 }
2052 
2053 static const struct snd_kcontrol_new roland_load_ctl = {
2054     .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2055     .name = "MIDI Input Mode",
2056     .info = roland_load_info,
2057     .get = roland_load_get,
2058     .put = roland_load_put,
2059     .private_value = 1,
2060 };
2061 
2062 /*
2063  * On Roland devices, use the second alternate setting to be able to use
2064  * the interrupt input endpoint.
2065  */
2066 static void snd_usbmidi_switch_roland_altsetting(struct snd_usb_midi *umidi)
2067 {
2068     struct usb_interface *intf;
2069     struct usb_host_interface *hostif;
2070     struct usb_interface_descriptor *intfd;
2071 
2072     intf = umidi->iface;
2073     if (!intf || intf->num_altsetting != 2)
2074         return;
2075 
2076     hostif = &intf->altsetting[1];
2077     intfd = get_iface_desc(hostif);
2078        /* If either or both of the endpoints support interrupt transfer,
2079         * then use the alternate setting
2080         */
2081     if (intfd->bNumEndpoints != 2 ||
2082         !((get_endpoint(hostif, 0)->bmAttributes &
2083            USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_INT ||
2084           (get_endpoint(hostif, 1)->bmAttributes &
2085            USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_INT))
2086         return;
2087 
2088     dev_dbg(&umidi->dev->dev, "switching to altsetting %d with int ep\n",
2089             intfd->bAlternateSetting);
2090     usb_set_interface(umidi->dev, intfd->bInterfaceNumber,
2091               intfd->bAlternateSetting);
2092 
2093     umidi->roland_load_ctl = snd_ctl_new1(&roland_load_ctl, umidi);
2094     if (snd_ctl_add(umidi->card, umidi->roland_load_ctl) < 0)
2095         umidi->roland_load_ctl = NULL;
2096 }
2097 
2098 /*
2099  * Try to find any usable endpoints in the interface.
2100  */
2101 static int snd_usbmidi_detect_endpoints(struct snd_usb_midi *umidi,
2102                     struct snd_usb_midi_endpoint_info *endpoint,
2103                     int max_endpoints)
2104 {
2105     struct usb_interface *intf;
2106     struct usb_host_interface *hostif;
2107     struct usb_interface_descriptor *intfd;
2108     struct usb_endpoint_descriptor *epd;
2109     int i, out_eps = 0, in_eps = 0;
2110 
2111     if (USB_ID_VENDOR(umidi->usb_id) == 0x0582)
2112         snd_usbmidi_switch_roland_altsetting(umidi);
2113 
2114     if (endpoint[0].out_ep || endpoint[0].in_ep)
2115         return 0;
2116 
2117     intf = umidi->iface;
2118     if (!intf || intf->num_altsetting < 1)
2119         return -ENOENT;
2120     hostif = intf->cur_altsetting;
2121     intfd = get_iface_desc(hostif);
2122 
2123     for (i = 0; i < intfd->bNumEndpoints; ++i) {
2124         epd = get_endpoint(hostif, i);
2125         if (!usb_endpoint_xfer_bulk(epd) &&
2126             !usb_endpoint_xfer_int(epd))
2127             continue;
2128         if (out_eps < max_endpoints &&
2129             usb_endpoint_dir_out(epd)) {
2130             endpoint[out_eps].out_ep = usb_endpoint_num(epd);
2131             if (usb_endpoint_xfer_int(epd))
2132                 endpoint[out_eps].out_interval = epd->bInterval;
2133             ++out_eps;
2134         }
2135         if (in_eps < max_endpoints &&
2136             usb_endpoint_dir_in(epd)) {
2137             endpoint[in_eps].in_ep = usb_endpoint_num(epd);
2138             if (usb_endpoint_xfer_int(epd))
2139                 endpoint[in_eps].in_interval = epd->bInterval;
2140             ++in_eps;
2141         }
2142     }
2143     return (out_eps || in_eps) ? 0 : -ENOENT;
2144 }
2145 
2146 /*
2147  * Detects the endpoints for one-port-per-endpoint protocols.
2148  */
2149 static int snd_usbmidi_detect_per_port_endpoints(struct snd_usb_midi *umidi,
2150                          struct snd_usb_midi_endpoint_info *endpoints)
2151 {
2152     int err, i;
2153 
2154     err = snd_usbmidi_detect_endpoints(umidi, endpoints, MIDI_MAX_ENDPOINTS);
2155     for (i = 0; i < MIDI_MAX_ENDPOINTS; ++i) {
2156         if (endpoints[i].out_ep)
2157             endpoints[i].out_cables = 0x0001;
2158         if (endpoints[i].in_ep)
2159             endpoints[i].in_cables = 0x0001;
2160     }
2161     return err;
2162 }
2163 
2164 /*
2165  * Detects the endpoints and ports of Yamaha devices.
2166  */
2167 static int snd_usbmidi_detect_yamaha(struct snd_usb_midi *umidi,
2168                      struct snd_usb_midi_endpoint_info *endpoint)
2169 {
2170     struct usb_interface *intf;
2171     struct usb_host_interface *hostif;
2172     struct usb_interface_descriptor *intfd;
2173     uint8_t *cs_desc;
2174 
2175     intf = umidi->iface;
2176     if (!intf)
2177         return -ENOENT;
2178     hostif = intf->altsetting;
2179     intfd = get_iface_desc(hostif);
2180     if (intfd->bNumEndpoints < 1)
2181         return -ENOENT;
2182 
2183     /*
2184      * For each port there is one MIDI_IN/OUT_JACK descriptor, not
2185      * necessarily with any useful contents.  So simply count 'em.
2186      */
2187     for (cs_desc = hostif->extra;
2188          cs_desc < hostif->extra + hostif->extralen && cs_desc[0] >= 2;
2189          cs_desc += cs_desc[0]) {
2190         if (cs_desc[1] == USB_DT_CS_INTERFACE) {
2191             if (cs_desc[2] == UAC_MIDI_IN_JACK)
2192                 endpoint->in_cables =
2193                     (endpoint->in_cables << 1) | 1;
2194             else if (cs_desc[2] == UAC_MIDI_OUT_JACK)
2195                 endpoint->out_cables =
2196                     (endpoint->out_cables << 1) | 1;
2197         }
2198     }
2199     if (!endpoint->in_cables && !endpoint->out_cables)
2200         return -ENOENT;
2201 
2202     return snd_usbmidi_detect_endpoints(umidi, endpoint, 1);
2203 }
2204 
2205 /*
2206  * Detects the endpoints and ports of Roland devices.
2207  */
2208 static int snd_usbmidi_detect_roland(struct snd_usb_midi *umidi,
2209                      struct snd_usb_midi_endpoint_info *endpoint)
2210 {
2211     struct usb_interface *intf;
2212     struct usb_host_interface *hostif;
2213     u8 *cs_desc;
2214 
2215     intf = umidi->iface;
2216     if (!intf)
2217         return -ENOENT;
2218     hostif = intf->altsetting;
2219     /*
2220      * Some devices have a descriptor <06 24 F1 02 <inputs> <outputs>>,
2221      * some have standard class descriptors, or both kinds, or neither.
2222      */
2223     for (cs_desc = hostif->extra;
2224          cs_desc < hostif->extra + hostif->extralen && cs_desc[0] >= 2;
2225          cs_desc += cs_desc[0]) {
2226         if (cs_desc[0] >= 6 &&
2227             cs_desc[1] == USB_DT_CS_INTERFACE &&
2228             cs_desc[2] == 0xf1 &&
2229             cs_desc[3] == 0x02) {
2230             if (cs_desc[4] > 0x10 || cs_desc[5] > 0x10)
2231                 continue;
2232             endpoint->in_cables  = (1 << cs_desc[4]) - 1;
2233             endpoint->out_cables = (1 << cs_desc[5]) - 1;
2234             return snd_usbmidi_detect_endpoints(umidi, endpoint, 1);
2235         } else if (cs_desc[0] >= 7 &&
2236                cs_desc[1] == USB_DT_CS_INTERFACE &&
2237                cs_desc[2] == UAC_HEADER) {
2238             return snd_usbmidi_get_ms_info(umidi, endpoint);
2239         }
2240     }
2241 
2242     return -ENODEV;
2243 }
2244 
2245 /*
2246  * Creates the endpoints and their ports for Midiman devices.
2247  */
2248 static int snd_usbmidi_create_endpoints_midiman(struct snd_usb_midi *umidi,
2249                         struct snd_usb_midi_endpoint_info *endpoint)
2250 {
2251     struct snd_usb_midi_endpoint_info ep_info;
2252     struct usb_interface *intf;
2253     struct usb_host_interface *hostif;
2254     struct usb_interface_descriptor *intfd;
2255     struct usb_endpoint_descriptor *epd;
2256     int cable, err;
2257 
2258     intf = umidi->iface;
2259     if (!intf)
2260         return -ENOENT;
2261     hostif = intf->altsetting;
2262     intfd = get_iface_desc(hostif);
2263     /*
2264      * The various MidiSport devices have more or less random endpoint
2265      * numbers, so we have to identify the endpoints by their index in
2266      * the descriptor array, like the driver for that other OS does.
2267      *
2268      * There is one interrupt input endpoint for all input ports, one
2269      * bulk output endpoint for even-numbered ports, and one for odd-
2270      * numbered ports.  Both bulk output endpoints have corresponding
2271      * input bulk endpoints (at indices 1 and 3) which aren't used.
2272      */
2273     if (intfd->bNumEndpoints < (endpoint->out_cables > 0x0001 ? 5 : 3)) {
2274         dev_dbg(&umidi->dev->dev, "not enough endpoints\n");
2275         return -ENOENT;
2276     }
2277 
2278     epd = get_endpoint(hostif, 0);
2279     if (!usb_endpoint_dir_in(epd) || !usb_endpoint_xfer_int(epd)) {
2280         dev_dbg(&umidi->dev->dev, "endpoint[0] isn't interrupt\n");
2281         return -ENXIO;
2282     }
2283     epd = get_endpoint(hostif, 2);
2284     if (!usb_endpoint_dir_out(epd) || !usb_endpoint_xfer_bulk(epd)) {
2285         dev_dbg(&umidi->dev->dev, "endpoint[2] isn't bulk output\n");
2286         return -ENXIO;
2287     }
2288     if (endpoint->out_cables > 0x0001) {
2289         epd = get_endpoint(hostif, 4);
2290         if (!usb_endpoint_dir_out(epd) ||
2291             !usb_endpoint_xfer_bulk(epd)) {
2292             dev_dbg(&umidi->dev->dev,
2293                 "endpoint[4] isn't bulk output\n");
2294             return -ENXIO;
2295         }
2296     }
2297 
2298     ep_info.out_ep = get_endpoint(hostif, 2)->bEndpointAddress &
2299         USB_ENDPOINT_NUMBER_MASK;
2300     ep_info.out_interval = 0;
2301     ep_info.out_cables = endpoint->out_cables & 0x5555;
2302     err = snd_usbmidi_out_endpoint_create(umidi, &ep_info,
2303                           &umidi->endpoints[0]);
2304     if (err < 0)
2305         return err;
2306 
2307     ep_info.in_ep = get_endpoint(hostif, 0)->bEndpointAddress &
2308         USB_ENDPOINT_NUMBER_MASK;
2309     ep_info.in_interval = get_endpoint(hostif, 0)->bInterval;
2310     ep_info.in_cables = endpoint->in_cables;
2311     err = snd_usbmidi_in_endpoint_create(umidi, &ep_info,
2312                          &umidi->endpoints[0]);
2313     if (err < 0)
2314         return err;
2315 
2316     if (endpoint->out_cables > 0x0001) {
2317         ep_info.out_ep = get_endpoint(hostif, 4)->bEndpointAddress &
2318             USB_ENDPOINT_NUMBER_MASK;
2319         ep_info.out_cables = endpoint->out_cables & 0xaaaa;
2320         err = snd_usbmidi_out_endpoint_create(umidi, &ep_info,
2321                               &umidi->endpoints[1]);
2322         if (err < 0)
2323             return err;
2324     }
2325 
2326     for (cable = 0; cable < 0x10; ++cable) {
2327         if (endpoint->out_cables & (1 << cable))
2328             snd_usbmidi_init_substream(umidi,
2329                            SNDRV_RAWMIDI_STREAM_OUTPUT,
2330                            cable,
2331                            -1 /* prevent trying to find jack */,
2332                            &umidi->endpoints[cable & 1].out->ports[cable].substream);
2333         if (endpoint->in_cables & (1 << cable))
2334             snd_usbmidi_init_substream(umidi,
2335                            SNDRV_RAWMIDI_STREAM_INPUT,
2336                            cable,
2337                            -1 /* prevent trying to find jack */,
2338                            &umidi->endpoints[0].in->ports[cable].substream);
2339     }
2340     return 0;
2341 }
2342 
2343 static const struct snd_rawmidi_global_ops snd_usbmidi_ops = {
2344     .get_port_info = snd_usbmidi_get_port_info,
2345 };
2346 
2347 static int snd_usbmidi_create_rawmidi(struct snd_usb_midi *umidi,
2348                       int out_ports, int in_ports)
2349 {
2350     struct snd_rawmidi *rmidi;
2351     int err;
2352 
2353     err = snd_rawmidi_new(umidi->card, "USB MIDI",
2354                   umidi->next_midi_device++,
2355                   out_ports, in_ports, &rmidi);
2356     if (err < 0)
2357         return err;
2358     strcpy(rmidi->name, umidi->card->shortname);
2359     rmidi->info_flags = SNDRV_RAWMIDI_INFO_OUTPUT |
2360                 SNDRV_RAWMIDI_INFO_INPUT |
2361                 SNDRV_RAWMIDI_INFO_DUPLEX;
2362     rmidi->ops = &snd_usbmidi_ops;
2363     rmidi->private_data = umidi;
2364     rmidi->private_free = snd_usbmidi_rawmidi_free;
2365     snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT,
2366                 &snd_usbmidi_output_ops);
2367     snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT,
2368                 &snd_usbmidi_input_ops);
2369 
2370     umidi->rmidi = rmidi;
2371     return 0;
2372 }
2373 
2374 /*
2375  * Temporarily stop input.
2376  */
2377 void snd_usbmidi_input_stop(struct list_head *p)
2378 {
2379     struct snd_usb_midi *umidi;
2380     unsigned int i, j;
2381 
2382     umidi = list_entry(p, struct snd_usb_midi, list);
2383     if (!umidi->input_running)
2384         return;
2385     for (i = 0; i < MIDI_MAX_ENDPOINTS; ++i) {
2386         struct snd_usb_midi_endpoint *ep = &umidi->endpoints[i];
2387         if (ep->in)
2388             for (j = 0; j < INPUT_URBS; ++j)
2389                 usb_kill_urb(ep->in->urbs[j]);
2390     }
2391     umidi->input_running = 0;
2392 }
2393 EXPORT_SYMBOL(snd_usbmidi_input_stop);
2394 
2395 static void snd_usbmidi_input_start_ep(struct snd_usb_midi *umidi,
2396                        struct snd_usb_midi_in_endpoint *ep)
2397 {
2398     unsigned int i;
2399     unsigned long flags;
2400 
2401     if (!ep)
2402         return;
2403     for (i = 0; i < INPUT_URBS; ++i) {
2404         struct urb *urb = ep->urbs[i];
2405         spin_lock_irqsave(&umidi->disc_lock, flags);
2406         if (!atomic_read(&urb->use_count)) {
2407             urb->dev = ep->umidi->dev;
2408             snd_usbmidi_submit_urb(urb, GFP_ATOMIC);
2409         }
2410         spin_unlock_irqrestore(&umidi->disc_lock, flags);
2411     }
2412 }
2413 
2414 /*
2415  * Resume input after a call to snd_usbmidi_input_stop().
2416  */
2417 void snd_usbmidi_input_start(struct list_head *p)
2418 {
2419     struct snd_usb_midi *umidi;
2420     int i;
2421 
2422     umidi = list_entry(p, struct snd_usb_midi, list);
2423     if (umidi->input_running || !umidi->opened[1])
2424         return;
2425     for (i = 0; i < MIDI_MAX_ENDPOINTS; ++i)
2426         snd_usbmidi_input_start_ep(umidi, umidi->endpoints[i].in);
2427     umidi->input_running = 1;
2428 }
2429 EXPORT_SYMBOL(snd_usbmidi_input_start);
2430 
2431 /*
2432  * Prepare for suspend. Typically called from the USB suspend callback.
2433  */
2434 void snd_usbmidi_suspend(struct list_head *p)
2435 {
2436     struct snd_usb_midi *umidi;
2437 
2438     umidi = list_entry(p, struct snd_usb_midi, list);
2439     mutex_lock(&umidi->mutex);
2440     snd_usbmidi_input_stop(p);
2441     mutex_unlock(&umidi->mutex);
2442 }
2443 EXPORT_SYMBOL(snd_usbmidi_suspend);
2444 
2445 /*
2446  * Resume. Typically called from the USB resume callback.
2447  */
2448 void snd_usbmidi_resume(struct list_head *p)
2449 {
2450     struct snd_usb_midi *umidi;
2451 
2452     umidi = list_entry(p, struct snd_usb_midi, list);
2453     mutex_lock(&umidi->mutex);
2454     snd_usbmidi_input_start(p);
2455     mutex_unlock(&umidi->mutex);
2456 }
2457 EXPORT_SYMBOL(snd_usbmidi_resume);
2458 
2459 /*
2460  * Creates and registers everything needed for a MIDI streaming interface.
2461  */
2462 int __snd_usbmidi_create(struct snd_card *card,
2463              struct usb_interface *iface,
2464              struct list_head *midi_list,
2465              const struct snd_usb_audio_quirk *quirk,
2466              unsigned int usb_id)
2467 {
2468     struct snd_usb_midi *umidi;
2469     struct snd_usb_midi_endpoint_info endpoints[MIDI_MAX_ENDPOINTS];
2470     int out_ports, in_ports;
2471     int i, err;
2472 
2473     umidi = kzalloc(sizeof(*umidi), GFP_KERNEL);
2474     if (!umidi)
2475         return -ENOMEM;
2476     umidi->dev = interface_to_usbdev(iface);
2477     umidi->card = card;
2478     umidi->iface = iface;
2479     umidi->quirk = quirk;
2480     umidi->usb_protocol_ops = &snd_usbmidi_standard_ops;
2481     spin_lock_init(&umidi->disc_lock);
2482     init_rwsem(&umidi->disc_rwsem);
2483     mutex_init(&umidi->mutex);
2484     if (!usb_id)
2485         usb_id = USB_ID(le16_to_cpu(umidi->dev->descriptor.idVendor),
2486                    le16_to_cpu(umidi->dev->descriptor.idProduct));
2487     umidi->usb_id = usb_id;
2488     timer_setup(&umidi->error_timer, snd_usbmidi_error_timer, 0);
2489 
2490     /* detect the endpoint(s) to use */
2491     memset(endpoints, 0, sizeof(endpoints));
2492     switch (quirk ? quirk->type : QUIRK_MIDI_STANDARD_INTERFACE) {
2493     case QUIRK_MIDI_STANDARD_INTERFACE:
2494         err = snd_usbmidi_get_ms_info(umidi, endpoints);
2495         if (umidi->usb_id == USB_ID(0x0763, 0x0150)) /* M-Audio Uno */
2496             umidi->usb_protocol_ops =
2497                 &snd_usbmidi_maudio_broken_running_status_ops;
2498         break;
2499     case QUIRK_MIDI_US122L:
2500         umidi->usb_protocol_ops = &snd_usbmidi_122l_ops;
2501         fallthrough;
2502     case QUIRK_MIDI_FIXED_ENDPOINT:
2503         memcpy(&endpoints[0], quirk->data,
2504                sizeof(struct snd_usb_midi_endpoint_info));
2505         err = snd_usbmidi_detect_endpoints(umidi, &endpoints[0], 1);
2506         break;
2507     case QUIRK_MIDI_YAMAHA:
2508         err = snd_usbmidi_detect_yamaha(umidi, &endpoints[0]);
2509         break;
2510     case QUIRK_MIDI_ROLAND:
2511         err = snd_usbmidi_detect_roland(umidi, &endpoints[0]);
2512         break;
2513     case QUIRK_MIDI_MIDIMAN:
2514         umidi->usb_protocol_ops = &snd_usbmidi_midiman_ops;
2515         memcpy(&endpoints[0], quirk->data,
2516                sizeof(struct snd_usb_midi_endpoint_info));
2517         err = 0;
2518         break;
2519     case QUIRK_MIDI_NOVATION:
2520         umidi->usb_protocol_ops = &snd_usbmidi_novation_ops;
2521         err = snd_usbmidi_detect_per_port_endpoints(umidi, endpoints);
2522         break;
2523     case QUIRK_MIDI_RAW_BYTES:
2524         umidi->usb_protocol_ops = &snd_usbmidi_raw_ops;
2525         /*
2526          * Interface 1 contains isochronous endpoints, but with the same
2527          * numbers as in interface 0.  Since it is interface 1 that the
2528          * USB core has most recently seen, these descriptors are now
2529          * associated with the endpoint numbers.  This will foul up our
2530          * attempts to submit bulk/interrupt URBs to the endpoints in
2531          * interface 0, so we have to make sure that the USB core looks
2532          * again at interface 0 by calling usb_set_interface() on it.
2533          */
2534         if (umidi->usb_id == USB_ID(0x07fd, 0x0001)) /* MOTU Fastlane */
2535             usb_set_interface(umidi->dev, 0, 0);
2536         err = snd_usbmidi_detect_per_port_endpoints(umidi, endpoints);
2537         break;
2538     case QUIRK_MIDI_EMAGIC:
2539         umidi->usb_protocol_ops = &snd_usbmidi_emagic_ops;
2540         memcpy(&endpoints[0], quirk->data,
2541                sizeof(struct snd_usb_midi_endpoint_info));
2542         err = snd_usbmidi_detect_endpoints(umidi, &endpoints[0], 1);
2543         break;
2544     case QUIRK_MIDI_CME:
2545         umidi->usb_protocol_ops = &snd_usbmidi_cme_ops;
2546         err = snd_usbmidi_detect_per_port_endpoints(umidi, endpoints);
2547         break;
2548     case QUIRK_MIDI_AKAI:
2549         umidi->usb_protocol_ops = &snd_usbmidi_akai_ops;
2550         err = snd_usbmidi_detect_per_port_endpoints(umidi, endpoints);
2551         /* endpoint 1 is input-only */
2552         endpoints[1].out_cables = 0;
2553         break;
2554     case QUIRK_MIDI_FTDI:
2555         umidi->usb_protocol_ops = &snd_usbmidi_ftdi_ops;
2556 
2557         /* set baud rate to 31250 (48 MHz / 16 / 96) */
2558         err = usb_control_msg(umidi->dev, usb_sndctrlpipe(umidi->dev, 0),
2559                       3, 0x40, 0x60, 0, NULL, 0, 1000);
2560         if (err < 0)
2561             break;
2562 
2563         err = snd_usbmidi_detect_per_port_endpoints(umidi, endpoints);
2564         break;
2565     case QUIRK_MIDI_CH345:
2566         umidi->usb_protocol_ops = &snd_usbmidi_ch345_broken_sysex_ops;
2567         err = snd_usbmidi_detect_per_port_endpoints(umidi, endpoints);
2568         break;
2569     default:
2570         dev_err(&umidi->dev->dev, "invalid quirk type %d\n",
2571             quirk->type);
2572         err = -ENXIO;
2573         break;
2574     }
2575     if (err < 0)
2576         goto free_midi;
2577 
2578     /* create rawmidi device */
2579     out_ports = 0;
2580     in_ports = 0;
2581     for (i = 0; i < MIDI_MAX_ENDPOINTS; ++i) {
2582         out_ports += hweight16(endpoints[i].out_cables);
2583         in_ports += hweight16(endpoints[i].in_cables);
2584     }
2585     err = snd_usbmidi_create_rawmidi(umidi, out_ports, in_ports);
2586     if (err < 0)
2587         goto free_midi;
2588 
2589     /* create endpoint/port structures */
2590     if (quirk && quirk->type == QUIRK_MIDI_MIDIMAN)
2591         err = snd_usbmidi_create_endpoints_midiman(umidi, &endpoints[0]);
2592     else
2593         err = snd_usbmidi_create_endpoints(umidi, endpoints);
2594     if (err < 0)
2595         goto exit;
2596 
2597     usb_autopm_get_interface_no_resume(umidi->iface);
2598 
2599     list_add_tail(&umidi->list, midi_list);
2600     return 0;
2601 
2602 free_midi:
2603     kfree(umidi);
2604 exit:
2605     return err;
2606 }
2607 EXPORT_SYMBOL(__snd_usbmidi_create);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!