kernel/sound/usb/line6/capture.c

   1 /*
   2  * Line 6 Linux USB driver
   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 <sound/core.h>
  14 #include <sound/pcm.h>
  15 #include <sound/pcm_params.h>
  16
  17 #include "capture.h"
  18 #include "driver.h"
  19 #include "pcm.h"
  20
  21 /*
  22         Find a free URB and submit it.
  23         must be called in line6pcm->in.lock context
  24 */
  25 static int submit_audio_in_urb(struct snd_line6_pcm *line6pcm)
  26 {
  27         int index;
  28         int i, urb_size;
  29         int ret;
  30         struct urb *urb_in;
  31
  32         index =
  33             find_first_zero_bit(&line6pcm->in.active_urbs, LINE6_ISO_BUFFERS);
  34
  35         if (index < 0 || index >= LINE6_ISO_BUFFERS) {
  36                 dev_err(line6pcm->line6->ifcdev, "no free URB found\n");
  37                 return -EINVAL;
  38         }
  39
  40         urb_in = line6pcm->in.urbs[index];
  41         urb_size = 0;
  42
  43         for (i = 0; i < LINE6_ISO_PACKETS; ++i) {
  44                 struct usb_iso_packet_descriptor *fin =
  45                     &urb_in->iso_frame_desc[i];
  46                 fin->offset = urb_size;
  47                 fin->length = line6pcm->max_packet_size;
  48                 urb_size += line6pcm->max_packet_size;
  49         }
  50
  51         urb_in->transfer_buffer =
  52             line6pcm->in.buffer +
  53             index * LINE6_ISO_PACKETS * line6pcm->max_packet_size;
  54         urb_in->transfer_buffer_length = urb_size;
  55         urb_in->context = line6pcm;
  56
  57         ret = usb_submit_urb(urb_in, GFP_ATOMIC);
  58
  59         if (ret == 0)
  60                 set_bit(index, &line6pcm->in.active_urbs);
  61         else
  62                 dev_err(line6pcm->line6->ifcdev,
  63                         "URB in #%d submission failed (%d)\n", index, ret);
  64
  65         return 0;
  66 }
  67
  68 /*
  69         Submit all currently available capture URBs.
  70         must be called in line6pcm->in.lock context
  71 */
  72 int line6_submit_audio_in_all_urbs(struct snd_line6_pcm *line6pcm)
  73 {
  74         int ret = 0, i;
  75
  76         for (i = 0; i < LINE6_ISO_BUFFERS; ++i) {
  77                 ret = submit_audio_in_urb(line6pcm);
  78                 if (ret < 0)
  79                         break;
  80         }
  81
  82         return ret;
  83 }
  84
  85 /*
  86         Copy data into ALSA capture buffer.
  87 */
  88 void line6_capture_copy(struct snd_line6_pcm *line6pcm, char *fbuf, int fsize)
  89 {
  90         struct snd_pcm_substream *substream =
  91             get_substream(line6pcm, SNDRV_PCM_STREAM_CAPTURE);
  92         struct snd_pcm_runtime *runtime = substream->runtime;
  93         const int bytes_per_frame = line6pcm->properties->bytes_per_frame;
  94         int frames = fsize / bytes_per_frame;
  95
  96         if (runtime == NULL)
  97                 return;
  98
  99         if (line6pcm->in.pos_done + frames > runtime->buffer_size) {
 100                 /*
 101                    The transferred area goes over buffer boundary,
 102                    copy two separate chunks.
 103                  */
 104                 int len;
 105
 106                 len = runtime->buffer_size - line6pcm->in.pos_done;
 107
 108                 if (len > 0) {
 109                         memcpy(runtime->dma_area +
 110                                line6pcm->in.pos_done * bytes_per_frame, fbuf,
 111                                len * bytes_per_frame);
 112                         memcpy(runtime->dma_area, fbuf + len * bytes_per_frame,
 113                                (frames - len) * bytes_per_frame);
 114                 } else {
 115                         /* this is somewhat paranoid */
 116                         dev_err(line6pcm->line6->ifcdev,
 117                                 "driver bug: len = %d\n", len);
 118                 }
 119         } else {
 120                 /* copy single chunk */
 121                 memcpy(runtime->dma_area +
 122                        line6pcm->in.pos_done * bytes_per_frame, fbuf, fsize);
 123         }
 124
 125         line6pcm->in.pos_done += frames;
 126         if (line6pcm->in.pos_done >= runtime->buffer_size)
 127                 line6pcm->in.pos_done -= runtime->buffer_size;
 128 }
 129
 130 void line6_capture_check_period(struct snd_line6_pcm *line6pcm, int length)
 131 {
 132         struct snd_pcm_substream *substream =
 133             get_substream(line6pcm, SNDRV_PCM_STREAM_CAPTURE);
 134
 135         line6pcm->in.bytes += length;
 136         if (line6pcm->in.bytes >= line6pcm->in.period) {
 137                 line6pcm->in.bytes %= line6pcm->in.period;
 138                 spin_unlock(&line6pcm->in.lock);
 139                 snd_pcm_period_elapsed(substream);
 140                 spin_lock(&line6pcm->in.lock);
 141         }
 142 }
 143
 144 /*
 145  * Callback for completed capture URB.
 146  */
 147 static void audio_in_callback(struct urb *urb)
 148 {
 149         int i, index, length = 0, shutdown = 0;
 150         unsigned long flags;
 151
 152         struct snd_line6_pcm *line6pcm = (struct snd_line6_pcm *)urb->context;
 153
 154         line6pcm->in.last_frame = urb->start_frame;
 155
 156         /* find index of URB */
 157         for (index = 0; index < LINE6_ISO_BUFFERS; ++index)
 158                 if (urb == line6pcm->in.urbs[index])
 159                         break;
 160
 161         spin_lock_irqsave(&line6pcm->in.lock, flags);
 162
 163         for (i = 0; i < LINE6_ISO_PACKETS; ++i) {
 164                 char *fbuf;
 165                 int fsize;
 166                 struct usb_iso_packet_descriptor *fin = &urb->iso_frame_desc[i];
 167
 168                 if (fin->status == -EXDEV) {
 169                         shutdown = 1;
 170                         break;
 171                 }
 172
 173                 fbuf = urb->transfer_buffer + fin->offset;
 174                 fsize = fin->actual_length;
 175
 176                 if (fsize > line6pcm->max_packet_size) {
 177                         dev_err(line6pcm->line6->ifcdev,
 178                                 "driver and/or device bug: packet too large (%d > %d)\n",
 179                                 fsize, line6pcm->max_packet_size);
 180                 }
 181
 182                 length += fsize;
 183
 184                 /* the following assumes LINE6_ISO_PACKETS == 1: */
 185                 line6pcm->prev_fbuf = fbuf;
 186                 line6pcm->prev_fsize = fsize;
 187
 188                 if (!test_bit(LINE6_STREAM_IMPULSE, &line6pcm->in.running) &&
 189                     test_bit(LINE6_STREAM_PCM, &line6pcm->in.running) &&
 190                     fsize > 0)
 191                         line6_capture_copy(line6pcm, fbuf, fsize);
 192         }
 193
 194         clear_bit(index, &line6pcm->in.active_urbs);
 195
 196         if (test_and_clear_bit(index, &line6pcm->in.unlink_urbs))
 197                 shutdown = 1;
 198
 199         if (!shutdown) {
 200                 submit_audio_in_urb(line6pcm);
 201
 202                 if (!test_bit(LINE6_STREAM_IMPULSE, &line6pcm->in.running) &&
 203                     test_bit(LINE6_STREAM_PCM, &line6pcm->in.running))
 204                         line6_capture_check_period(line6pcm, length);
 205         }
 206
 207         spin_unlock_irqrestore(&line6pcm->in.lock, flags);
 208 }
 209
 210 /* open capture callback */
 211 static int snd_line6_capture_open(struct snd_pcm_substream *substream)
 212 {
 213         int err;
 214         struct snd_pcm_runtime *runtime = substream->runtime;
 215         struct snd_line6_pcm *line6pcm = snd_pcm_substream_chip(substream);
 216
 217         err = snd_pcm_hw_constraint_ratdens(runtime, 0,
 218                                             SNDRV_PCM_HW_PARAM_RATE,
 219                                             &line6pcm->properties->rates);
 220         if (err < 0)
 221                 return err;
 222
 223         runtime->hw = line6pcm->properties->capture_hw;
 224         return 0;
 225 }
 226
 227 /* close capture callback */
 228 static int snd_line6_capture_close(struct snd_pcm_substream *substream)
 229 {
 230         return 0;
 231 }
 232
 233 /* capture operators */
 234 struct snd_pcm_ops snd_line6_capture_ops = {
 235         .open = snd_line6_capture_open,
 236         .close = snd_line6_capture_close,
 237         .ioctl = snd_pcm_lib_ioctl,
 238         .hw_params = snd_line6_hw_params,
 239         .hw_free = snd_line6_hw_free,
 240         .prepare = snd_line6_prepare,
 241         .trigger = snd_line6_trigger,
 242         .pointer = snd_line6_pointer,
 243 };
 244
 245 int line6_create_audio_in_urbs(struct snd_line6_pcm *line6pcm)
 246 {
 247         struct usb_line6 *line6 = line6pcm->line6;
 248         int i;
 249
 250         /* create audio URBs and fill in constant values: */
 251         for (i = 0; i < LINE6_ISO_BUFFERS; ++i) {
 252                 struct urb *urb;
 253
 254                 /* URB for audio in: */
 255                 urb = line6pcm->in.urbs[i] =
 256                     usb_alloc_urb(LINE6_ISO_PACKETS, GFP_KERNEL);
 257
 258                 if (urb == NULL)
 259                         return -ENOMEM;
 260
 261                 urb->dev = line6->usbdev;
 262                 urb->pipe =
 263                     usb_rcvisocpipe(line6->usbdev,
 264                                     line6->properties->ep_audio_r &
 265                                     USB_ENDPOINT_NUMBER_MASK);
 266                 urb->transfer_flags = URB_ISO_ASAP;
 267                 urb->start_frame = -1;
 268                 urb->number_of_packets = LINE6_ISO_PACKETS;
 269                 urb->interval = LINE6_ISO_INTERVAL;
 270                 urb->error_count = 0;
 271                 urb->complete = audio_in_callback;
 272         }
 273
 274         return 0;
 275 }