drivers/staging/line6/midi.c

   1 /*
   2  * Line6 Linux USB driver - 0.9.1beta
   3  *
   4  * Copyright (C) 2004-2010 Markus Grabner (grabner@icg.tugraz.at)
   5  *
   6  *      This program is free software; you can redistribute it and/or
   7  *      modify it under the terms of the GNU General Public License as
   8  *      published by the Free Software Foundation, version 2.
   9  *
  10  */
  11
  12 #include <linux/slab.h>
  13 #include <linux/usb.h>
  14 #include <sound/core.h>
  15 #include <sound/rawmidi.h>
  16
  17 #include "audio.h"
  18 #include "driver.h"
  19 #include "midi.h"
  20 #include "pod.h"
  21 #include "usbdefs.h"
  22
  23 #define line6_rawmidi_substream_midi(substream) \
  24         ((struct snd_line6_midi *)((substream)->rmidi->private_data))
  25
  26 static int send_midi_async(struct usb_line6 *line6, unsigned char *data,
  27                            int length);
  28
  29 /*
  30         Pass data received via USB to MIDI.
  31 */
  32 void line6_midi_receive(struct usb_line6 *line6, unsigned char *data,
  33                         int length)
  34 {
  35         if (line6->line6midi->substream_receive)
  36                 snd_rawmidi_receive(line6->line6midi->substream_receive,
  37                                     data, length);
  38 }
  39
  40 /*
  41         Read data from MIDI buffer and transmit them via USB.
  42 */
  43 static void line6_midi_transmit(struct snd_rawmidi_substream *substream)
  44 {
  45         struct usb_line6 *line6 =
  46             line6_rawmidi_substream_midi(substream)->line6;
  47         struct snd_line6_midi *line6midi = line6->line6midi;
  48         struct MidiBuffer *mb = &line6midi->midibuf_out;
  49         unsigned long flags;
  50         unsigned char chunk[line6->max_packet_size];
  51         int req, done;
  52
  53         spin_lock_irqsave(&line6->line6midi->midi_transmit_lock, flags);
  54
  55         for (;;) {
  56                 req = min(line6_midibuf_bytes_free(mb), line6->max_packet_size);
  57                 done = snd_rawmidi_transmit_peek(substream, chunk, req);
  58
  59                 if (done == 0)
  60                         break;
  61
  62                 line6_midibuf_write(mb, chunk, done);
  63                 snd_rawmidi_transmit_ack(substream, done);
  64         }
  65
  66         for (;;) {
  67                 done = line6_midibuf_read(mb, chunk, line6->max_packet_size);
  68
  69                 if (done == 0)
  70                         break;
  71
  72                 if (line6_midibuf_skip_message
  73                     (mb, line6midi->midi_mask_transmit))
  74                         continue;
  75
  76                 send_midi_async(line6, chunk, done);
  77         }
  78
  79         spin_unlock_irqrestore(&line6->line6midi->midi_transmit_lock, flags);
  80 }
  81
  82 /*
  83         Notification of completion of MIDI transmission.
  84 */
  85 static void midi_sent(struct urb *urb)
  86 {
  87         unsigned long flags;
  88         int status;
  89         int num;
  90         struct usb_line6 *line6 = (struct usb_line6 *)urb->context;
  91
  92         status = urb->status;
  93         kfree(urb->transfer_buffer);
  94         usb_free_urb(urb);
  95
  96         if (status == -ESHUTDOWN)
  97                 return;
  98
  99         spin_lock_irqsave(&line6->line6midi->send_urb_lock, flags);
 100         num = --line6->line6midi->num_active_send_urbs;
 101
 102         if (num == 0) {
 103                 line6_midi_transmit(line6->line6midi->substream_transmit);
 104                 num = line6->line6midi->num_active_send_urbs;
 105         }
 106
 107         if (num == 0)
 108                 wake_up(&line6->line6midi->send_wait);
 109
 110         spin_unlock_irqrestore(&line6->line6midi->send_urb_lock, flags);
 111 }
 112
 113 /*
 114         Send an asynchronous MIDI message.
 115         Assumes that line6->line6midi->send_urb_lock is held
 116         (i.e., this function is serialized).
 117 */
 118 static int send_midi_async(struct usb_line6 *line6, unsigned char *data,
 119                            int length)
 120 {
 121         struct urb *urb;
 122         int retval;
 123         unsigned char *transfer_buffer;
 124
 125         urb = usb_alloc_urb(0, GFP_ATOMIC);
 126
 127         if (urb == NULL) {
 128                 dev_err(line6->ifcdev, "Out of memory\n");
 129                 return -ENOMEM;
 130         }
 131
 132         transfer_buffer = kmemdup(data, length, GFP_ATOMIC);
 133
 134         if (transfer_buffer == NULL) {
 135                 usb_free_urb(urb);
 136                 dev_err(line6->ifcdev, "Out of memory\n");
 137                 return -ENOMEM;
 138         }
 139
 140         usb_fill_int_urb(urb, line6->usbdev,
 141                          usb_sndbulkpipe(line6->usbdev,
 142                                          line6->ep_control_write),
 143                          transfer_buffer, length, midi_sent, line6,
 144                          line6->interval);
 145         urb->actual_length = 0;
 146         retval = usb_submit_urb(urb, GFP_ATOMIC);
 147
 148         if (retval < 0) {
 149                 dev_err(line6->ifcdev, "usb_submit_urb failed\n");
 150                 usb_free_urb(urb);
 151                 return -EINVAL;
 152         }
 153
 154         ++line6->line6midi->num_active_send_urbs;
 155
 156         switch (line6->usbdev->descriptor.idProduct) {
 157         case LINE6_DEVID_BASSPODXT:
 158         case LINE6_DEVID_BASSPODXTLIVE:
 159         case LINE6_DEVID_BASSPODXTPRO:
 160         case LINE6_DEVID_PODXT:
 161         case LINE6_DEVID_PODXTLIVE:
 162         case LINE6_DEVID_PODXTPRO:
 163         case LINE6_DEVID_POCKETPOD:
 164                 line6_pod_midi_postprocess((struct usb_line6_pod *)line6, data,
 165                                            length);
 166                 break;
 167
 168         case LINE6_DEVID_VARIAX:
 169         case LINE6_DEVID_PODHD300:
 170         case LINE6_DEVID_PODHD500:
 171                 break;
 172
 173         default:
 174                 MISSING_CASE;
 175         }
 176
 177         return 0;
 178 }
 179
 180 static int line6_midi_output_open(struct snd_rawmidi_substream *substream)
 181 {
 182         return 0;
 183 }
 184
 185 static int line6_midi_output_close(struct snd_rawmidi_substream *substream)
 186 {
 187         return 0;
 188 }
 189
 190 static void line6_midi_output_trigger(struct snd_rawmidi_substream *substream,
 191                                       int up)
 192 {
 193         unsigned long flags;
 194         struct usb_line6 *line6 =
 195             line6_rawmidi_substream_midi(substream)->line6;
 196
 197         line6->line6midi->substream_transmit = substream;
 198         spin_lock_irqsave(&line6->line6midi->send_urb_lock, flags);
 199
 200         if (line6->line6midi->num_active_send_urbs == 0)
 201                 line6_midi_transmit(substream);
 202
 203         spin_unlock_irqrestore(&line6->line6midi->send_urb_lock, flags);
 204 }
 205
 206 static void line6_midi_output_drain(struct snd_rawmidi_substream *substream)
 207 {
 208         struct usb_line6 *line6 =
 209             line6_rawmidi_substream_midi(substream)->line6;
 210         struct snd_line6_midi *midi = line6->line6midi;
 211         wait_event_interruptible(midi->send_wait,
 212                                  midi->num_active_send_urbs == 0);
 213 }
 214
 215 static int line6_midi_input_open(struct snd_rawmidi_substream *substream)
 216 {
 217         return 0;
 218 }
 219
 220 static int line6_midi_input_close(struct snd_rawmidi_substream *substream)
 221 {
 222         return 0;
 223 }
 224
 225 static void line6_midi_input_trigger(struct snd_rawmidi_substream *substream,
 226                                      int up)
 227 {
 228         struct usb_line6 *line6 =
 229             line6_rawmidi_substream_midi(substream)->line6;
 230
 231         if (up)
 232                 line6->line6midi->substream_receive = substream;
 233         else
 234                 line6->line6midi->substream_receive = 0;
 235 }
 236
 237 static struct snd_rawmidi_ops line6_midi_output_ops = {
 238         .open = line6_midi_output_open,
 239         .close = line6_midi_output_close,
 240         .trigger = line6_midi_output_trigger,
 241         .drain = line6_midi_output_drain,
 242 };
 243
 244 static struct snd_rawmidi_ops line6_midi_input_ops = {
 245         .open = line6_midi_input_open,
 246         .close = line6_midi_input_close,
 247         .trigger = line6_midi_input_trigger,
 248 };
 249
 250 /*
 251         Cleanup the Line6 MIDI device.
 252 */
 253 static void line6_cleanup_midi(struct snd_rawmidi *rmidi)
 254 {
 255 }
 256
 257 /* Create a MIDI device */
 258 static int snd_line6_new_midi(struct snd_line6_midi *line6midi)
 259 {
 260         struct snd_rawmidi *rmidi;
 261         int err;
 262
 263         err = snd_rawmidi_new(line6midi->line6->card, "Line6 MIDI", 0, 1, 1,
 264                               &rmidi);
 265         if (err < 0)
 266                 return err;
 267
 268         rmidi->private_data = line6midi;
 269         rmidi->private_free = line6_cleanup_midi;
 270         strcpy(rmidi->id, line6midi->line6->properties->id);
 271         strcpy(rmidi->name, line6midi->line6->properties->name);
 272
 273         rmidi->info_flags =
 274             SNDRV_RAWMIDI_INFO_OUTPUT |
 275             SNDRV_RAWMIDI_INFO_INPUT | SNDRV_RAWMIDI_INFO_DUPLEX;
 276
 277         snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT,
 278                             &line6_midi_output_ops);
 279         snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT,
 280                             &line6_midi_input_ops);
 281         return 0;
 282 }
 283
 284 /*
 285         "read" request on "midi_mask_transmit" special file.
 286 */
 287 static ssize_t midi_get_midi_mask_transmit(struct device *dev,
 288                                            struct device_attribute *attr,
 289                                            char *buf)
 290 {
 291         struct usb_interface *interface = to_usb_interface(dev);
 292         struct usb_line6 *line6 = usb_get_intfdata(interface);
 293         return sprintf(buf, "%d\n", line6->line6midi->midi_mask_transmit);
 294 }
 295
 296 /*
 297         "write" request on "midi_mask" special file.
 298 */
 299 static ssize_t midi_set_midi_mask_transmit(struct device *dev,
 300                                            struct device_attribute *attr,
 301                                            const char *buf, size_t count)
 302 {
 303         struct usb_interface *interface = to_usb_interface(dev);
 304         struct usb_line6 *line6 = usb_get_intfdata(interface);
 305         unsigned short value;
 306         int ret;
 307
 308         ret = kstrtou16(buf, 10, &value);
 309         if (ret)
 310                 return ret;
 311
 312         line6->line6midi->midi_mask_transmit = value;
 313         return count;
 314 }
 315
 316 /*
 317         "read" request on "midi_mask_receive" special file.
 318 */
 319 static ssize_t midi_get_midi_mask_receive(struct device *dev,
 320                                           struct device_attribute *attr,
 321                                           char *buf)
 322 {
 323         struct usb_interface *interface = to_usb_interface(dev);
 324         struct usb_line6 *line6 = usb_get_intfdata(interface);
 325         return sprintf(buf, "%d\n", line6->line6midi->midi_mask_receive);
 326 }
 327
 328 /*
 329         "write" request on "midi_mask" special file.
 330 */
 331 static ssize_t midi_set_midi_mask_receive(struct device *dev,
 332                                           struct device_attribute *attr,
 333                                           const char *buf, size_t count)
 334 {
 335         struct usb_interface *interface = to_usb_interface(dev);
 336         struct usb_line6 *line6 = usb_get_intfdata(interface);
 337         unsigned short value;
 338         int ret;
 339
 340         ret = kstrtou16(buf, 10, &value);
 341         if (ret)
 342                 return ret;
 343
 344         line6->line6midi->midi_mask_receive = value;
 345         return count;
 346 }
 347
 348 static DEVICE_ATTR(midi_mask_transmit, S_IWUSR | S_IRUGO,
 349                    midi_get_midi_mask_transmit, midi_set_midi_mask_transmit);
 350 static DEVICE_ATTR(midi_mask_receive, S_IWUSR | S_IRUGO,
 351                    midi_get_midi_mask_receive, midi_set_midi_mask_receive);
 352
 353 /* MIDI device destructor */
 354 static int snd_line6_midi_free(struct snd_device *device)
 355 {
 356         struct snd_line6_midi *line6midi = device->device_data;
 357         device_remove_file(line6midi->line6->ifcdev,
 358                            &dev_attr_midi_mask_transmit);
 359         device_remove_file(line6midi->line6->ifcdev,
 360                            &dev_attr_midi_mask_receive);
 361         line6_midibuf_destroy(&line6midi->midibuf_in);
 362         line6_midibuf_destroy(&line6midi->midibuf_out);
 363         return 0;
 364 }
 365
 366 /*
 367         Initialize the Line6 MIDI subsystem.
 368 */
 369 int line6_init_midi(struct usb_line6 *line6)
 370 {
 371         static struct snd_device_ops midi_ops = {
 372                 .dev_free = snd_line6_midi_free,
 373         };
 374
 375         int err;
 376         struct snd_line6_midi *line6midi;
 377
 378         if (!(line6->properties->capabilities & LINE6_BIT_CONTROL)) {
 379                 /* skip MIDI initialization and report success */
 380                 return 0;
 381         }
 382
 383         line6midi = kzalloc(sizeof(struct snd_line6_midi), GFP_KERNEL);
 384
 385         if (line6midi == NULL)
 386                 return -ENOMEM;
 387
 388         err = line6_midibuf_init(&line6midi->midibuf_in, MIDI_BUFFER_SIZE, 0);
 389         if (err < 0) {
 390                 kfree(line6midi);
 391                 return err;
 392         }
 393
 394         err = line6_midibuf_init(&line6midi->midibuf_out, MIDI_BUFFER_SIZE, 1);
 395         if (err < 0) {
 396                 kfree(line6midi->midibuf_in.buf);
 397                 kfree(line6midi);
 398                 return err;
 399         }
 400
 401         line6midi->line6 = line6;
 402
 403         switch (line6->product) {
 404         case LINE6_DEVID_PODHD300:
 405         case LINE6_DEVID_PODHD500:
 406                 line6midi->midi_mask_transmit = 1;
 407                 line6midi->midi_mask_receive = 1;
 408                 break;
 409
 410         default:
 411                 line6midi->midi_mask_transmit = 1;
 412                 line6midi->midi_mask_receive = 4;
 413         }
 414
 415         line6->line6midi = line6midi;
 416
 417         err = snd_device_new(line6->card, SNDRV_DEV_RAWMIDI, line6midi,
 418                              &midi_ops);
 419         if (err < 0)
 420                 return err;
 421
 422         snd_card_set_dev(line6->card, line6->ifcdev);
 423
 424         err = snd_line6_new_midi(line6midi);
 425         if (err < 0)
 426                 return err;
 427
 428         err = device_create_file(line6->ifcdev, &dev_attr_midi_mask_transmit);
 429         if (err < 0)
 430                 return err;
 431
 432         err = device_create_file(line6->ifcdev, &dev_attr_midi_mask_receive);
 433         if (err < 0)
 434                 return err;
 435
 436         init_waitqueue_head(&line6midi->send_wait);
 437         spin_lock_init(&line6midi->send_urb_lock);
 438         spin_lock_init(&line6midi->midi_transmit_lock);
 439         return 0;
 440 }