sound/usb/line6/playback.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 <sound/core.h>
  14 #include <sound/pcm.h>
  15 #include <sound/pcm_params.h>
  16
  17 #include "audio.h"
  18 #include "capture.h"
  19 #include "driver.h"
  20 #include "pcm.h"
  21 #include "playback.h"
  22
  23 /*
  24         Software stereo volume control.
  25 */
  26 static void change_volume(struct urb *urb_out, int volume[],
  27                           int bytes_per_frame)
  28 {
  29         int chn = 0;
  30
  31         if (volume[0] == 256 && volume[1] == 256)
  32                 return;         /* maximum volume - no change */
  33
  34         if (bytes_per_frame == 4) {
  35                 short *p, *buf_end;
  36
  37                 p = (short *)urb_out->transfer_buffer;
  38                 buf_end = p + urb_out->transfer_buffer_length / sizeof(*p);
  39
  40                 for (; p < buf_end; ++p) {
  41                         *p = (*p * volume[chn & 1]) >> 8;
  42                         ++chn;
  43                 }
  44         } else if (bytes_per_frame == 6) {
  45                 unsigned char *p, *buf_end;
  46
  47                 p = (unsigned char *)urb_out->transfer_buffer;
  48                 buf_end = p + urb_out->transfer_buffer_length;
  49
  50                 for (; p < buf_end; p += 3) {
  51                         int val;
  52
  53                         val = p[0] + (p[1] << 8) + ((signed char)p[2] << 16);
  54                         val = (val * volume[chn & 1]) >> 8;
  55                         p[0] = val;
  56                         p[1] = val >> 8;
  57                         p[2] = val >> 16;
  58                         ++chn;
  59                 }
  60         }
  61 }
  62
  63 /*
  64         Create signal for impulse response test.
  65 */
  66 static void create_impulse_test_signal(struct snd_line6_pcm *line6pcm,
  67                                        struct urb *urb_out, int bytes_per_frame)
  68 {
  69         int frames = urb_out->transfer_buffer_length / bytes_per_frame;
  70
  71         if (bytes_per_frame == 4) {
  72                 int i;
  73                 short *pi = (short *)line6pcm->prev_fbuf;
  74                 short *po = (short *)urb_out->transfer_buffer;
  75
  76                 for (i = 0; i < frames; ++i) {
  77                         po[0] = pi[0];
  78                         po[1] = 0;
  79                         pi += 2;
  80                         po += 2;
  81                 }
  82         } else if (bytes_per_frame == 6) {
  83                 int i, j;
  84                 unsigned char *pi = line6pcm->prev_fbuf;
  85                 unsigned char *po = urb_out->transfer_buffer;
  86
  87                 for (i = 0; i < frames; ++i) {
  88                         for (j = 0; j < bytes_per_frame / 2; ++j)
  89                                 po[j] = pi[j];
  90
  91                         for (; j < bytes_per_frame; ++j)
  92                                 po[j] = 0;
  93
  94                         pi += bytes_per_frame;
  95                         po += bytes_per_frame;
  96                 }
  97         }
  98         if (--line6pcm->impulse_count <= 0) {
  99                 ((unsigned char *)(urb_out->transfer_buffer))[bytes_per_frame -
 100                                                               1] =
 101                     line6pcm->impulse_volume;
 102                 line6pcm->impulse_count = line6pcm->impulse_period;
 103         }
 104 }
 105
 106 /*
 107         Add signal to buffer for software monitoring.
 108 */
 109 static void add_monitor_signal(struct urb *urb_out, unsigned char *signal,
 110                                int volume, int bytes_per_frame)
 111 {
 112         if (volume == 0)
 113                 return;         /* zero volume - no change */
 114
 115         if (bytes_per_frame == 4) {
 116                 short *pi, *po, *buf_end;
 117
 118                 pi = (short *)signal;
 119                 po = (short *)urb_out->transfer_buffer;
 120                 buf_end = po + urb_out->transfer_buffer_length / sizeof(*po);
 121
 122                 for (; po < buf_end; ++pi, ++po)
 123                         *po += (*pi * volume) >> 8;
 124         }
 125
 126         /*
 127            We don't need to handle devices with 6 bytes per frame here
 128            since they all support hardware monitoring.
 129          */
 130 }
 131
 132 /*
 133         Find a free URB, prepare audio data, and submit URB.
 134 */
 135 static int submit_audio_out_urb(struct snd_line6_pcm *line6pcm)
 136 {
 137         int index;
 138         unsigned long flags;
 139         int i, urb_size, urb_frames;
 140         int ret;
 141         const int bytes_per_frame = line6pcm->properties->bytes_per_frame;
 142         const int frame_increment =
 143             line6pcm->properties->snd_line6_rates.rats[0].num_min;
 144         const int frame_factor =
 145             line6pcm->properties->snd_line6_rates.rats[0].den *
 146             (USB_INTERVALS_PER_SECOND / LINE6_ISO_INTERVAL);
 147         struct urb *urb_out;
 148
 149         spin_lock_irqsave(&line6pcm->lock_audio_out, flags);
 150         index =
 151             find_first_zero_bit(&line6pcm->active_urb_out, LINE6_ISO_BUFFERS);
 152
 153         if (index < 0 || index >= LINE6_ISO_BUFFERS) {
 154                 spin_unlock_irqrestore(&line6pcm->lock_audio_out, flags);
 155                 dev_err(line6pcm->line6->ifcdev, "no free URB found\n");
 156                 return -EINVAL;
 157         }
 158
 159         urb_out = line6pcm->urb_audio_out[index];
 160         urb_size = 0;
 161
 162         for (i = 0; i < LINE6_ISO_PACKETS; ++i) {
 163                 /* compute frame size for given sampling rate */
 164                 int fsize = 0;
 165                 struct usb_iso_packet_descriptor *fout =
 166                     &urb_out->iso_frame_desc[i];
 167
 168                 if (line6pcm->flags & LINE6_BITS_CAPTURE_STREAM)
 169                         fsize = line6pcm->prev_fsize;
 170
 171                 if (fsize == 0) {
 172                         int n;
 173
 174                         line6pcm->count_out += frame_increment;
 175                         n = line6pcm->count_out / frame_factor;
 176                         line6pcm->count_out -= n * frame_factor;
 177                         fsize = n * bytes_per_frame;
 178                 }
 179
 180                 fout->offset = urb_size;
 181                 fout->length = fsize;
 182                 urb_size += fsize;
 183         }
 184
 185         if (urb_size == 0) {
 186                 /* can't determine URB size */
 187                 spin_unlock_irqrestore(&line6pcm->lock_audio_out, flags);
 188                 dev_err(line6pcm->line6->ifcdev, "driver bug: urb_size = 0\n");
 189                 return -EINVAL;
 190         }
 191
 192         urb_frames = urb_size / bytes_per_frame;
 193         urb_out->transfer_buffer =
 194             line6pcm->buffer_out +
 195             index * LINE6_ISO_PACKETS * line6pcm->max_packet_size;
 196         urb_out->transfer_buffer_length = urb_size;
 197         urb_out->context = line6pcm;
 198
 199         if (test_bit(LINE6_INDEX_PCM_ALSA_PLAYBACK_STREAM, &line6pcm->flags) &&
 200             !test_bit(LINE6_INDEX_PAUSE_PLAYBACK, &line6pcm->flags)) {
 201                 struct snd_pcm_runtime *runtime =
 202                     get_substream(line6pcm, SNDRV_PCM_STREAM_PLAYBACK)->runtime;
 203
 204                 if (line6pcm->pos_out + urb_frames > runtime->buffer_size) {
 205                         /*
 206                            The transferred area goes over buffer boundary,
 207                            copy the data to the temp buffer.
 208                          */
 209                         int len;
 210
 211                         len = runtime->buffer_size - line6pcm->pos_out;
 212
 213                         if (len > 0) {
 214                                 memcpy(urb_out->transfer_buffer,
 215                                        runtime->dma_area +
 216                                        line6pcm->pos_out * bytes_per_frame,
 217                                        len * bytes_per_frame);
 218                                 memcpy(urb_out->transfer_buffer +
 219                                        len * bytes_per_frame, runtime->dma_area,
 220                                        (urb_frames - len) * bytes_per_frame);
 221                         } else
 222                                 dev_err(line6pcm->line6->ifcdev, "driver bug: len = %d\n",
 223                                         len);
 224                 } else {
 225                         memcpy(urb_out->transfer_buffer,
 226                                runtime->dma_area +
 227                                line6pcm->pos_out * bytes_per_frame,
 228                                urb_out->transfer_buffer_length);
 229                 }
 230
 231                 line6pcm->pos_out += urb_frames;
 232                 if (line6pcm->pos_out >= runtime->buffer_size)
 233                         line6pcm->pos_out -= runtime->buffer_size;
 234         } else {
 235                 memset(urb_out->transfer_buffer, 0,
 236                        urb_out->transfer_buffer_length);
 237         }
 238
 239         change_volume(urb_out, line6pcm->volume_playback, bytes_per_frame);
 240
 241         if (line6pcm->prev_fbuf != NULL) {
 242                 if (line6pcm->flags & LINE6_BITS_PCM_IMPULSE) {
 243                         create_impulse_test_signal(line6pcm, urb_out,
 244                                                    bytes_per_frame);
 245                         if (line6pcm->flags &
 246                             LINE6_BIT_PCM_ALSA_CAPTURE_STREAM) {
 247                                 line6_capture_copy(line6pcm,
 248                                                    urb_out->transfer_buffer,
 249                                                    urb_out->
 250                                                    transfer_buffer_length);
 251                                 line6_capture_check_period(line6pcm,
 252                                         urb_out->transfer_buffer_length);
 253                         }
 254                 } else {
 255                         if (!
 256                             (line6pcm->line6->
 257                              properties->capabilities & LINE6_CAP_HWMON)
 258                             && (line6pcm->flags & LINE6_BITS_PLAYBACK_STREAM)
 259                             && (line6pcm->flags & LINE6_BITS_CAPTURE_STREAM))
 260                                 add_monitor_signal(urb_out, line6pcm->prev_fbuf,
 261                                                    line6pcm->volume_monitor,
 262                                                    bytes_per_frame);
 263                 }
 264         }
 265
 266         ret = usb_submit_urb(urb_out, GFP_ATOMIC);
 267
 268         if (ret == 0)
 269                 set_bit(index, &line6pcm->active_urb_out);
 270         else
 271                 dev_err(line6pcm->line6->ifcdev,
 272                         "URB out #%d submission failed (%d)\n", index, ret);
 273
 274         spin_unlock_irqrestore(&line6pcm->lock_audio_out, flags);
 275         return 0;
 276 }
 277
 278 /*
 279         Submit all currently available playback URBs.
 280 */
 281 int line6_submit_audio_out_all_urbs(struct snd_line6_pcm *line6pcm)
 282 {
 283         int ret, i;
 284
 285         for (i = 0; i < LINE6_ISO_BUFFERS; ++i) {
 286                 ret = submit_audio_out_urb(line6pcm);
 287                 if (ret < 0)
 288                         return ret;
 289         }
 290
 291         return 0;
 292 }
 293
 294 /*
 295         Unlink all currently active playback URBs.
 296 */
 297 void line6_unlink_audio_out_urbs(struct snd_line6_pcm *line6pcm)
 298 {
 299         unsigned int i;
 300
 301         for (i = LINE6_ISO_BUFFERS; i--;) {
 302                 if (test_bit(i, &line6pcm->active_urb_out)) {
 303                         if (!test_and_set_bit(i, &line6pcm->unlink_urb_out)) {
 304                                 struct urb *u = line6pcm->urb_audio_out[i];
 305
 306                                 usb_unlink_urb(u);
 307                         }
 308                 }
 309         }
 310 }
 311
 312 /*
 313         Wait until unlinking of all currently active playback URBs has been
 314         finished.
 315 */
 316 void line6_wait_clear_audio_out_urbs(struct snd_line6_pcm *line6pcm)
 317 {
 318         int timeout = HZ;
 319         unsigned int i;
 320         int alive;
 321
 322         do {
 323                 alive = 0;
 324                 for (i = LINE6_ISO_BUFFERS; i--;) {
 325                         if (test_bit(i, &line6pcm->active_urb_out))
 326                                 alive++;
 327                 }
 328                 if (!alive)
 329                         break;
 330                 set_current_state(TASK_UNINTERRUPTIBLE);
 331                 schedule_timeout(1);
 332         } while (--timeout > 0);
 333         if (alive)
 334                 snd_printk(KERN_ERR "timeout: still %d active urbs..\n", alive);
 335 }
 336
 337 /*
 338         Unlink all currently active playback URBs, and wait for finishing.
 339 */
 340 void line6_unlink_wait_clear_audio_out_urbs(struct snd_line6_pcm *line6pcm)
 341 {
 342         line6_unlink_audio_out_urbs(line6pcm);
 343         line6_wait_clear_audio_out_urbs(line6pcm);
 344 }
 345
 346 void line6_free_playback_buffer(struct snd_line6_pcm *line6pcm)
 347 {
 348         kfree(line6pcm->buffer_out);
 349         line6pcm->buffer_out = NULL;
 350 }
 351
 352 /*
 353         Callback for completed playback URB.
 354 */
 355 static void audio_out_callback(struct urb *urb)
 356 {
 357         int i, index, length = 0, shutdown = 0;
 358         unsigned long flags;
 359         struct snd_line6_pcm *line6pcm = (struct snd_line6_pcm *)urb->context;
 360         struct snd_pcm_substream *substream =
 361             get_substream(line6pcm, SNDRV_PCM_STREAM_PLAYBACK);
 362
 363 #if USE_CLEAR_BUFFER_WORKAROUND
 364         memset(urb->transfer_buffer, 0, urb->transfer_buffer_length);
 365 #endif
 366
 367         line6pcm->last_frame_out = urb->start_frame;
 368
 369         /* find index of URB */
 370         for (index = LINE6_ISO_BUFFERS; index--;)
 371                 if (urb == line6pcm->urb_audio_out[index])
 372                         break;
 373
 374         if (index < 0)
 375                 return;         /* URB has been unlinked asynchronously */
 376
 377         for (i = LINE6_ISO_PACKETS; i--;)
 378                 length += urb->iso_frame_desc[i].length;
 379
 380         spin_lock_irqsave(&line6pcm->lock_audio_out, flags);
 381
 382         if (test_bit(LINE6_INDEX_PCM_ALSA_PLAYBACK_STREAM, &line6pcm->flags)) {
 383                 struct snd_pcm_runtime *runtime = substream->runtime;
 384
 385                 line6pcm->pos_out_done +=
 386                     length / line6pcm->properties->bytes_per_frame;
 387
 388                 if (line6pcm->pos_out_done >= runtime->buffer_size)
 389                         line6pcm->pos_out_done -= runtime->buffer_size;
 390         }
 391
 392         clear_bit(index, &line6pcm->active_urb_out);
 393
 394         for (i = LINE6_ISO_PACKETS; i--;)
 395                 if (urb->iso_frame_desc[i].status == -EXDEV) {
 396                         shutdown = 1;
 397                         break;
 398                 }
 399
 400         if (test_and_clear_bit(index, &line6pcm->unlink_urb_out))
 401                 shutdown = 1;
 402
 403         spin_unlock_irqrestore(&line6pcm->lock_audio_out, flags);
 404
 405         if (!shutdown) {
 406                 submit_audio_out_urb(line6pcm);
 407
 408                 if (test_bit(LINE6_INDEX_PCM_ALSA_PLAYBACK_STREAM,
 409                              &line6pcm->flags)) {
 410                         line6pcm->bytes_out += length;
 411                         if (line6pcm->bytes_out >= line6pcm->period_out) {
 412                                 line6pcm->bytes_out %= line6pcm->period_out;
 413                                 snd_pcm_period_elapsed(substream);
 414                         }
 415                 }
 416         }
 417 }
 418
 419 /* open playback callback */
 420 static int snd_line6_playback_open(struct snd_pcm_substream *substream)
 421 {
 422         int err;
 423         struct snd_pcm_runtime *runtime = substream->runtime;
 424         struct snd_line6_pcm *line6pcm = snd_pcm_substream_chip(substream);
 425
 426         err = snd_pcm_hw_constraint_ratdens(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
 427                                             (&line6pcm->
 428                                              properties->snd_line6_rates));
 429         if (err < 0)
 430                 return err;
 431
 432         runtime->hw = line6pcm->properties->snd_line6_playback_hw;
 433         return 0;
 434 }
 435
 436 /* close playback callback */
 437 static int snd_line6_playback_close(struct snd_pcm_substream *substream)
 438 {
 439         return 0;
 440 }
 441
 442 /* hw_params playback callback */
 443 static int snd_line6_playback_hw_params(struct snd_pcm_substream *substream,
 444                                         struct snd_pcm_hw_params *hw_params)
 445 {
 446         int ret;
 447         struct snd_line6_pcm *line6pcm = snd_pcm_substream_chip(substream);
 448
 449         /* -- Florian Demski [FD] */
 450         /* don't ask me why, but this fixes the bug on my machine */
 451         if (line6pcm == NULL) {
 452                 if (substream->pcm == NULL)
 453                         return -ENOMEM;
 454                 if (substream->pcm->private_data == NULL)
 455                         return -ENOMEM;
 456                 substream->private_data = substream->pcm->private_data;
 457                 line6pcm = snd_pcm_substream_chip(substream);
 458         }
 459         /* -- [FD] end */
 460
 461         ret = line6_pcm_acquire(line6pcm, LINE6_BIT_PCM_ALSA_PLAYBACK_BUFFER);
 462
 463         if (ret < 0)
 464                 return ret;
 465
 466         ret = snd_pcm_lib_malloc_pages(substream,
 467                                        params_buffer_bytes(hw_params));
 468         if (ret < 0) {
 469                 line6_pcm_release(line6pcm, LINE6_BIT_PCM_ALSA_PLAYBACK_BUFFER);
 470                 return ret;
 471         }
 472
 473         line6pcm->period_out = params_period_bytes(hw_params);
 474         return 0;
 475 }
 476
 477 /* hw_free playback callback */
 478 static int snd_line6_playback_hw_free(struct snd_pcm_substream *substream)
 479 {
 480         struct snd_line6_pcm *line6pcm = snd_pcm_substream_chip(substream);
 481
 482         line6_pcm_release(line6pcm, LINE6_BIT_PCM_ALSA_PLAYBACK_BUFFER);
 483         return snd_pcm_lib_free_pages(substream);
 484 }
 485
 486 /* trigger playback callback */
 487 int snd_line6_playback_trigger(struct snd_line6_pcm *line6pcm, int cmd)
 488 {
 489         int err;
 490
 491         switch (cmd) {
 492         case SNDRV_PCM_TRIGGER_START:
 493 #ifdef CONFIG_PM
 494         case SNDRV_PCM_TRIGGER_RESUME:
 495 #endif
 496                 err = line6_pcm_acquire(line6pcm,
 497                                         LINE6_BIT_PCM_ALSA_PLAYBACK_STREAM);
 498
 499                 if (err < 0)
 500                         return err;
 501
 502                 break;
 503
 504         case SNDRV_PCM_TRIGGER_STOP:
 505 #ifdef CONFIG_PM
 506         case SNDRV_PCM_TRIGGER_SUSPEND:
 507 #endif
 508                 err = line6_pcm_release(line6pcm,
 509                                         LINE6_BIT_PCM_ALSA_PLAYBACK_STREAM);
 510
 511                 if (err < 0)
 512                         return err;
 513
 514                 break;
 515
 516         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
 517                 set_bit(LINE6_INDEX_PAUSE_PLAYBACK, &line6pcm->flags);
 518                 break;
 519
 520         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
 521                 clear_bit(LINE6_INDEX_PAUSE_PLAYBACK, &line6pcm->flags);
 522                 break;
 523
 524         default:
 525                 return -EINVAL;
 526         }
 527
 528         return 0;
 529 }
 530
 531 /* playback pointer callback */
 532 static snd_pcm_uframes_t
 533 snd_line6_playback_pointer(struct snd_pcm_substream *substream)
 534 {
 535         struct snd_line6_pcm *line6pcm = snd_pcm_substream_chip(substream);
 536
 537         return line6pcm->pos_out_done;
 538 }
 539
 540 /* playback operators */
 541 struct snd_pcm_ops snd_line6_playback_ops = {
 542         .open = snd_line6_playback_open,
 543         .close = snd_line6_playback_close,
 544         .ioctl = snd_pcm_lib_ioctl,
 545         .hw_params = snd_line6_playback_hw_params,
 546         .hw_free = snd_line6_playback_hw_free,
 547         .prepare = snd_line6_prepare,
 548         .trigger = snd_line6_trigger,
 549         .pointer = snd_line6_playback_pointer,
 550 };
 551
 552 int line6_create_audio_out_urbs(struct snd_line6_pcm *line6pcm)
 553 {
 554         struct usb_line6 *line6 = line6pcm->line6;
 555         int i;
 556
 557         /* create audio URBs and fill in constant values: */
 558         for (i = 0; i < LINE6_ISO_BUFFERS; ++i) {
 559                 struct urb *urb;
 560
 561                 /* URB for audio out: */
 562                 urb = line6pcm->urb_audio_out[i] =
 563                     usb_alloc_urb(LINE6_ISO_PACKETS, GFP_KERNEL);
 564
 565                 if (urb == NULL) {
 566                         dev_err(line6->ifcdev, "Out of memory\n");
 567                         return -ENOMEM;
 568                 }
 569
 570                 urb->dev = line6->usbdev;
 571                 urb->pipe =
 572                     usb_sndisocpipe(line6->usbdev,
 573                                     line6->properties->ep_audio_w &
 574                                     USB_ENDPOINT_NUMBER_MASK);
 575                 urb->transfer_flags = URB_ISO_ASAP;
 576                 urb->start_frame = -1;
 577                 urb->number_of_packets = LINE6_ISO_PACKETS;
 578                 urb->interval = LINE6_ISO_INTERVAL;
 579                 urb->error_count = 0;
 580                 urb->complete = audio_out_callback;
 581         }
 582
 583         return 0;
 584 }