sound/usb/6fire/pcm.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Linux driver for TerraTec DMX 6Fire USB
   4  *
   5  * PCM driver
   6  *
   7  * Author:      Torsten Schenk <torsten.schenk@zoho.com>
   8  * Created:     Jan 01, 2011
   9  * Copyright:   (C) Torsten Schenk
  10  */
  11
  12 #include "pcm.h"
  13 #include "chip.h"
  14 #include "comm.h"
  15 #include "control.h"
  16
  17 enum {
  18         OUT_N_CHANNELS = 6, IN_N_CHANNELS = 4
  19 };
  20
  21 /* keep next two synced with
  22  * FW_EP_W_MAX_PACKET_SIZE[] and RATES_MAX_PACKET_SIZE
  23  * and CONTROL_RATE_XXX in control.h */
  24 static const int rates_in_packet_size[] = { 228, 228, 420, 420, 404, 404 };
  25 static const int rates_out_packet_size[] = { 228, 228, 420, 420, 604, 604 };
  26 static const int rates[] = { 44100, 48000, 88200, 96000, 176400, 192000 };
  27 static const int rates_alsaid[] = {
  28         SNDRV_PCM_RATE_44100, SNDRV_PCM_RATE_48000,
  29         SNDRV_PCM_RATE_88200, SNDRV_PCM_RATE_96000,
  30         SNDRV_PCM_RATE_176400, SNDRV_PCM_RATE_192000 };
  31
  32 enum { /* settings for pcm */
  33         OUT_EP = 6, IN_EP = 2, MAX_BUFSIZE = 128 * 1024
  34 };
  35
  36 enum { /* pcm streaming states */
  37         STREAM_DISABLED, /* no pcm streaming */
  38         STREAM_STARTING, /* pcm streaming requested, waiting to become ready */
  39         STREAM_RUNNING, /* pcm streaming running */
  40         STREAM_STOPPING
  41 };
  42
  43 static const struct snd_pcm_hardware pcm_hw = {
  44         .info = SNDRV_PCM_INFO_MMAP |
  45                 SNDRV_PCM_INFO_INTERLEAVED |
  46                 SNDRV_PCM_INFO_BLOCK_TRANSFER |
  47                 SNDRV_PCM_INFO_MMAP_VALID |
  48                 SNDRV_PCM_INFO_BATCH,
  49
  50         .formats = SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S32_LE,
  51
  52         .rates = SNDRV_PCM_RATE_44100 |
  53                 SNDRV_PCM_RATE_48000 |
  54                 SNDRV_PCM_RATE_88200 |
  55                 SNDRV_PCM_RATE_96000 |
  56                 SNDRV_PCM_RATE_176400 |
  57                 SNDRV_PCM_RATE_192000,
  58
  59         .rate_min = 44100,
  60         .rate_max = 192000,
  61         .channels_min = 1,
  62         .channels_max = 0, /* set in pcm_open, depending on capture/playback */
  63         .buffer_bytes_max = MAX_BUFSIZE,
  64         .period_bytes_min = PCM_N_PACKETS_PER_URB * (PCM_MAX_PACKET_SIZE - 4),
  65         .period_bytes_max = MAX_BUFSIZE,
  66         .periods_min = 2,
  67         .periods_max = 1024
  68 };
  69
  70 static int usb6fire_pcm_set_rate(struct pcm_runtime *rt)
  71 {
  72         int ret;
  73         struct control_runtime *ctrl_rt = rt->chip->control;
  74
  75         ctrl_rt->usb_streaming = false;
  76         ret = ctrl_rt->update_streaming(ctrl_rt);
  77         if (ret < 0) {
  78                 dev_err(&rt->chip->dev->dev,
  79                         "error stopping streaming while setting samplerate %d.\n",
  80                         rates[rt->rate]);
  81                 return ret;
  82         }
  83
  84         ret = ctrl_rt->set_rate(ctrl_rt, rt->rate);
  85         if (ret < 0) {
  86                 dev_err(&rt->chip->dev->dev,
  87                         "error setting samplerate %d.\n",
  88                         rates[rt->rate]);
  89                 return ret;
  90         }
  91
  92         ret = ctrl_rt->set_channels(ctrl_rt, OUT_N_CHANNELS, IN_N_CHANNELS,
  93                         false, false);
  94         if (ret < 0) {
  95                 dev_err(&rt->chip->dev->dev,
  96                         "error initializing channels while setting samplerate %d.\n",
  97                         rates[rt->rate]);
  98                 return ret;
  99         }
 100
 101         ctrl_rt->usb_streaming = true;
 102         ret = ctrl_rt->update_streaming(ctrl_rt);
 103         if (ret < 0) {
 104                 dev_err(&rt->chip->dev->dev,
 105                         "error starting streaming while setting samplerate %d.\n",
 106                         rates[rt->rate]);
 107                 return ret;
 108         }
 109
 110         rt->in_n_analog = IN_N_CHANNELS;
 111         rt->out_n_analog = OUT_N_CHANNELS;
 112         rt->in_packet_size = rates_in_packet_size[rt->rate];
 113         rt->out_packet_size = rates_out_packet_size[rt->rate];
 114         return 0;
 115 }
 116
 117 static struct pcm_substream *usb6fire_pcm_get_substream(
 118                 struct snd_pcm_substream *alsa_sub)
 119 {
 120         struct pcm_runtime *rt = snd_pcm_substream_chip(alsa_sub);
 121
 122         if (alsa_sub->stream == SNDRV_PCM_STREAM_PLAYBACK)
 123                 return &rt->playback;
 124         else if (alsa_sub->stream == SNDRV_PCM_STREAM_CAPTURE)
 125                 return &rt->capture;
 126         dev_err(&rt->chip->dev->dev, "error getting pcm substream slot.\n");
 127         return NULL;
 128 }
 129
 130 /* call with stream_mutex locked */
 131 static void usb6fire_pcm_stream_stop(struct pcm_runtime *rt)
 132 {
 133         int i;
 134         struct control_runtime *ctrl_rt = rt->chip->control;
 135
 136         if (rt->stream_state != STREAM_DISABLED) {
 137
 138                 rt->stream_state = STREAM_STOPPING;
 139
 140                 for (i = 0; i < PCM_N_URBS; i++) {
 141                         usb_kill_urb(&rt->in_urbs[i].instance);
 142                         usb_kill_urb(&rt->out_urbs[i].instance);
 143                 }
 144                 ctrl_rt->usb_streaming = false;
 145                 ctrl_rt->update_streaming(ctrl_rt);
 146                 rt->stream_state = STREAM_DISABLED;
 147         }
 148 }
 149
 150 /* call with stream_mutex locked */
 151 static int usb6fire_pcm_stream_start(struct pcm_runtime *rt)
 152 {
 153         int ret;
 154         int i;
 155         int k;
 156         struct usb_iso_packet_descriptor *packet;
 157
 158         if (rt->stream_state == STREAM_DISABLED) {
 159                 /* submit our in urbs */
 160                 rt->stream_wait_cond = false;
 161                 rt->stream_state = STREAM_STARTING;
 162                 for (i = 0; i < PCM_N_URBS; i++) {
 163                         for (k = 0; k < PCM_N_PACKETS_PER_URB; k++) {
 164                                 packet = &rt->in_urbs[i].packets[k];
 165                                 packet->offset = k * rt->in_packet_size;
 166                                 packet->length = rt->in_packet_size;
 167                                 packet->actual_length = 0;
 168                                 packet->status = 0;
 169                         }
 170                         ret = usb_submit_urb(&rt->in_urbs[i].instance,
 171                                         GFP_ATOMIC);
 172                         if (ret) {
 173                                 usb6fire_pcm_stream_stop(rt);
 174                                 return ret;
 175                         }
 176                 }
 177
 178                 /* wait for first out urb to return (sent in in urb handler) */
 179                 wait_event_timeout(rt->stream_wait_queue, rt->stream_wait_cond,
 180                                 HZ);
 181                 if (rt->stream_wait_cond)
 182                         rt->stream_state = STREAM_RUNNING;
 183                 else {
 184                         usb6fire_pcm_stream_stop(rt);
 185                         return -EIO;
 186                 }
 187         }
 188         return 0;
 189 }
 190
 191 /* call with substream locked */
 192 static void usb6fire_pcm_capture(struct pcm_substream *sub, struct pcm_urb *urb)
 193 {
 194         int i;
 195         int frame;
 196         int frame_count;
 197         unsigned int total_length = 0;
 198         struct pcm_runtime *rt = snd_pcm_substream_chip(sub->instance);
 199         struct snd_pcm_runtime *alsa_rt = sub->instance->runtime;
 200         u32 *src = NULL;
 201         u32 *dest = (u32 *) (alsa_rt->dma_area + sub->dma_off
 202                         * (alsa_rt->frame_bits >> 3));
 203         u32 *dest_end = (u32 *) (alsa_rt->dma_area + alsa_rt->buffer_size
 204                         * (alsa_rt->frame_bits >> 3));
 205         int bytes_per_frame = alsa_rt->channels << 2;
 206
 207         for (i = 0; i < PCM_N_PACKETS_PER_URB; i++) {
 208                 /* at least 4 header bytes for valid packet.
 209                  * after that: 32 bits per sample for analog channels */
 210                 if (urb->packets[i].actual_length > 4)
 211                         frame_count = (urb->packets[i].actual_length - 4)
 212                                         / (rt->in_n_analog << 2);
 213                 else
 214                         frame_count = 0;
 215
 216                 if (alsa_rt->format == SNDRV_PCM_FORMAT_S24_LE)
 217                         src = (u32 *) (urb->buffer + total_length);
 218                 else if (alsa_rt->format == SNDRV_PCM_FORMAT_S32_LE)
 219                         src = (u32 *) (urb->buffer - 1 + total_length);
 220                 else
 221                         return;
 222                 src++; /* skip leading 4 bytes of every packet */
 223                 total_length += urb->packets[i].length;
 224                 for (frame = 0; frame < frame_count; frame++) {
 225                         memcpy(dest, src, bytes_per_frame);
 226                         dest += alsa_rt->channels;
 227                         src += rt->in_n_analog;
 228                         sub->dma_off++;
 229                         sub->period_off++;
 230                         if (dest == dest_end) {
 231                                 sub->dma_off = 0;
 232                                 dest = (u32 *) alsa_rt->dma_area;
 233                         }
 234                 }
 235         }
 236 }
 237
 238 /* call with substream locked */
 239 static void usb6fire_pcm_playback(struct pcm_substream *sub,
 240                 struct pcm_urb *urb)
 241 {
 242         int i;
 243         int frame;
 244         int frame_count;
 245         struct pcm_runtime *rt = snd_pcm_substream_chip(sub->instance);
 246         struct snd_pcm_runtime *alsa_rt = sub->instance->runtime;
 247         u32 *src = (u32 *) (alsa_rt->dma_area + sub->dma_off
 248                         * (alsa_rt->frame_bits >> 3));
 249         u32 *src_end = (u32 *) (alsa_rt->dma_area + alsa_rt->buffer_size
 250                         * (alsa_rt->frame_bits >> 3));
 251         u32 *dest;
 252         int bytes_per_frame = alsa_rt->channels << 2;
 253
 254         if (alsa_rt->format == SNDRV_PCM_FORMAT_S32_LE)
 255                 dest = (u32 *) (urb->buffer - 1);
 256         else if (alsa_rt->format == SNDRV_PCM_FORMAT_S24_LE)
 257                 dest = (u32 *) (urb->buffer);
 258         else {
 259                 dev_err(&rt->chip->dev->dev, "Unknown sample format.");
 260                 return;
 261         }
 262
 263         for (i = 0; i < PCM_N_PACKETS_PER_URB; i++) {
 264                 /* at least 4 header bytes for valid packet.
 265                  * after that: 32 bits per sample for analog channels */
 266                 if (urb->packets[i].length > 4)
 267                         frame_count = (urb->packets[i].length - 4)
 268                                         / (rt->out_n_analog << 2);
 269                 else
 270                         frame_count = 0;
 271                 dest++; /* skip leading 4 bytes of every frame */
 272                 for (frame = 0; frame < frame_count; frame++) {
 273                         memcpy(dest, src, bytes_per_frame);
 274                         src += alsa_rt->channels;
 275                         dest += rt->out_n_analog;
 276                         sub->dma_off++;
 277                         sub->period_off++;
 278                         if (src == src_end) {
 279                                 src = (u32 *) alsa_rt->dma_area;
 280                                 sub->dma_off = 0;
 281                         }
 282                 }
 283         }
 284 }
 285
 286 static void usb6fire_pcm_in_urb_handler(struct urb *usb_urb)
 287 {
 288         struct pcm_urb *in_urb = usb_urb->context;
 289         struct pcm_urb *out_urb = in_urb->peer;
 290         struct pcm_runtime *rt = in_urb->chip->pcm;
 291         struct pcm_substream *sub;
 292         unsigned long flags;
 293         int total_length = 0;
 294         int frame_count;
 295         int frame;
 296         int channel;
 297         int i;
 298         u8 *dest;
 299
 300         if (usb_urb->status || rt->panic || rt->stream_state == STREAM_STOPPING)
 301                 return;
 302         for (i = 0; i < PCM_N_PACKETS_PER_URB; i++)
 303                 if (in_urb->packets[i].status) {
 304                         rt->panic = true;
 305                         return;
 306                 }
 307
 308         if (rt->stream_state == STREAM_DISABLED) {
 309                 dev_err(&rt->chip->dev->dev,
 310                         "internal error: stream disabled in in-urb handler.\n");
 311                 return;
 312         }
 313
 314         /* receive our capture data */
 315         sub = &rt->capture;
 316         spin_lock_irqsave(&sub->lock, flags);
 317         if (sub->active) {
 318                 usb6fire_pcm_capture(sub, in_urb);
 319                 if (sub->period_off >= sub->instance->runtime->period_size) {
 320                         sub->period_off %= sub->instance->runtime->period_size;
 321                         spin_unlock_irqrestore(&sub->lock, flags);
 322                         snd_pcm_period_elapsed(sub->instance);
 323                 } else
 324                         spin_unlock_irqrestore(&sub->lock, flags);
 325         } else
 326                 spin_unlock_irqrestore(&sub->lock, flags);
 327
 328         /* setup out urb structure */
 329         for (i = 0; i < PCM_N_PACKETS_PER_URB; i++) {
 330                 out_urb->packets[i].offset = total_length;
 331                 out_urb->packets[i].length = (in_urb->packets[i].actual_length
 332                                 - 4) / (rt->in_n_analog << 2)
 333                                 * (rt->out_n_analog << 2) + 4;
 334                 out_urb->packets[i].status = 0;
 335                 total_length += out_urb->packets[i].length;
 336         }
 337         memset(out_urb->buffer, 0, total_length);
 338
 339         /* now send our playback data (if a free out urb was found) */
 340         sub = &rt->playback;
 341         spin_lock_irqsave(&sub->lock, flags);
 342         if (sub->active) {
 343                 usb6fire_pcm_playback(sub, out_urb);
 344                 if (sub->period_off >= sub->instance->runtime->period_size) {
 345                         sub->period_off %= sub->instance->runtime->period_size;
 346                         spin_unlock_irqrestore(&sub->lock, flags);
 347                         snd_pcm_period_elapsed(sub->instance);
 348                 } else
 349                         spin_unlock_irqrestore(&sub->lock, flags);
 350         } else
 351                 spin_unlock_irqrestore(&sub->lock, flags);
 352
 353         /* setup the 4th byte of each sample (0x40 for analog channels) */
 354         dest = out_urb->buffer;
 355         for (i = 0; i < PCM_N_PACKETS_PER_URB; i++)
 356                 if (out_urb->packets[i].length >= 4) {
 357                         frame_count = (out_urb->packets[i].length - 4)
 358                                         / (rt->out_n_analog << 2);
 359                         *(dest++) = 0xaa;
 360                         *(dest++) = 0xaa;
 361                         *(dest++) = frame_count;
 362                         *(dest++) = 0x00;
 363                         for (frame = 0; frame < frame_count; frame++)
 364                                 for (channel = 0;
 365                                                 channel < rt->out_n_analog;
 366                                                 channel++) {
 367                                         dest += 3; /* skip sample data */
 368                                         *(dest++) = 0x40;
 369                                 }
 370                 }
 371         usb_submit_urb(&out_urb->instance, GFP_ATOMIC);
 372         usb_submit_urb(&in_urb->instance, GFP_ATOMIC);
 373 }
 374
 375 static void usb6fire_pcm_out_urb_handler(struct urb *usb_urb)
 376 {
 377         struct pcm_urb *urb = usb_urb->context;
 378         struct pcm_runtime *rt = urb->chip->pcm;
 379
 380         if (rt->stream_state == STREAM_STARTING) {
 381                 rt->stream_wait_cond = true;
 382                 wake_up(&rt->stream_wait_queue);
 383         }
 384 }
 385
 386 static int usb6fire_pcm_open(struct snd_pcm_substream *alsa_sub)
 387 {
 388         struct pcm_runtime *rt = snd_pcm_substream_chip(alsa_sub);
 389         struct pcm_substream *sub = NULL;
 390         struct snd_pcm_runtime *alsa_rt = alsa_sub->runtime;
 391
 392         if (rt->panic)
 393                 return -EPIPE;
 394
 395         mutex_lock(&rt->stream_mutex);
 396         alsa_rt->hw = pcm_hw;
 397
 398         if (alsa_sub->stream == SNDRV_PCM_STREAM_PLAYBACK) {
 399                 if (rt->rate < ARRAY_SIZE(rates))
 400                         alsa_rt->hw.rates = rates_alsaid[rt->rate];
 401                 alsa_rt->hw.channels_max = OUT_N_CHANNELS;
 402                 sub = &rt->playback;
 403         } else if (alsa_sub->stream == SNDRV_PCM_STREAM_CAPTURE) {
 404                 if (rt->rate < ARRAY_SIZE(rates))
 405                         alsa_rt->hw.rates = rates_alsaid[rt->rate];
 406                 alsa_rt->hw.channels_max = IN_N_CHANNELS;
 407                 sub = &rt->capture;
 408         }
 409
 410         if (!sub) {
 411                 mutex_unlock(&rt->stream_mutex);
 412                 dev_err(&rt->chip->dev->dev, "invalid stream type.\n");
 413                 return -EINVAL;
 414         }
 415
 416         sub->instance = alsa_sub;
 417         sub->active = false;
 418         mutex_unlock(&rt->stream_mutex);
 419         return 0;
 420 }
 421
 422 static int usb6fire_pcm_close(struct snd_pcm_substream *alsa_sub)
 423 {
 424         struct pcm_runtime *rt = snd_pcm_substream_chip(alsa_sub);
 425         struct pcm_substream *sub = usb6fire_pcm_get_substream(alsa_sub);
 426         unsigned long flags;
 427
 428         if (rt->panic)
 429                 return 0;
 430
 431         mutex_lock(&rt->stream_mutex);
 432         if (sub) {
 433                 /* deactivate substream */
 434                 spin_lock_irqsave(&sub->lock, flags);
 435                 sub->instance = NULL;
 436                 sub->active = false;
 437                 spin_unlock_irqrestore(&sub->lock, flags);
 438
 439                 /* all substreams closed? if so, stop streaming */
 440                 if (!rt->playback.instance && !rt->capture.instance) {
 441                         usb6fire_pcm_stream_stop(rt);
 442                         rt->rate = ARRAY_SIZE(rates);
 443                 }
 444         }
 445         mutex_unlock(&rt->stream_mutex);
 446         return 0;
 447 }
 448
 449 static int usb6fire_pcm_prepare(struct snd_pcm_substream *alsa_sub)
 450 {
 451         struct pcm_runtime *rt = snd_pcm_substream_chip(alsa_sub);
 452         struct pcm_substream *sub = usb6fire_pcm_get_substream(alsa_sub);
 453         struct snd_pcm_runtime *alsa_rt = alsa_sub->runtime;
 454         int ret;
 455
 456         if (rt->panic)
 457                 return -EPIPE;
 458         if (!sub)
 459                 return -ENODEV;
 460
 461         mutex_lock(&rt->stream_mutex);
 462         sub->dma_off = 0;
 463         sub->period_off = 0;
 464
 465         if (rt->stream_state == STREAM_DISABLED) {
 466                 for (rt->rate = 0; rt->rate < ARRAY_SIZE(rates); rt->rate++)
 467                         if (alsa_rt->rate == rates[rt->rate])
 468                                 break;
 469                 if (rt->rate == ARRAY_SIZE(rates)) {
 470                         mutex_unlock(&rt->stream_mutex);
 471                         dev_err(&rt->chip->dev->dev,
 472                                 "invalid rate %d in prepare.\n",
 473                                 alsa_rt->rate);
 474                         return -EINVAL;
 475                 }
 476
 477                 ret = usb6fire_pcm_set_rate(rt);
 478                 if (ret) {
 479                         mutex_unlock(&rt->stream_mutex);
 480                         return ret;
 481                 }
 482                 ret = usb6fire_pcm_stream_start(rt);
 483                 if (ret) {
 484                         mutex_unlock(&rt->stream_mutex);
 485                         dev_err(&rt->chip->dev->dev,
 486                                 "could not start pcm stream.\n");
 487                         return ret;
 488                 }
 489         }
 490         mutex_unlock(&rt->stream_mutex);
 491         return 0;
 492 }
 493
 494 static int usb6fire_pcm_trigger(struct snd_pcm_substream *alsa_sub, int cmd)
 495 {
 496         struct pcm_substream *sub = usb6fire_pcm_get_substream(alsa_sub);
 497         struct pcm_runtime *rt = snd_pcm_substream_chip(alsa_sub);
 498         unsigned long flags;
 499
 500         if (rt->panic)
 501                 return -EPIPE;
 502         if (!sub)
 503                 return -ENODEV;
 504
 505         switch (cmd) {
 506         case SNDRV_PCM_TRIGGER_START:
 507         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
 508                 spin_lock_irqsave(&sub->lock, flags);
 509                 sub->active = true;
 510                 spin_unlock_irqrestore(&sub->lock, flags);
 511                 return 0;
 512
 513         case SNDRV_PCM_TRIGGER_STOP:
 514         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
 515                 spin_lock_irqsave(&sub->lock, flags);
 516                 sub->active = false;
 517                 spin_unlock_irqrestore(&sub->lock, flags);
 518                 return 0;
 519
 520         default:
 521                 return -EINVAL;
 522         }
 523 }
 524
 525 static snd_pcm_uframes_t usb6fire_pcm_pointer(
 526                 struct snd_pcm_substream *alsa_sub)
 527 {
 528         struct pcm_substream *sub = usb6fire_pcm_get_substream(alsa_sub);
 529         struct pcm_runtime *rt = snd_pcm_substream_chip(alsa_sub);
 530         unsigned long flags;
 531         snd_pcm_uframes_t ret;
 532
 533         if (rt->panic || !sub)
 534                 return SNDRV_PCM_POS_XRUN;
 535
 536         spin_lock_irqsave(&sub->lock, flags);
 537         ret = sub->dma_off;
 538         spin_unlock_irqrestore(&sub->lock, flags);
 539         return ret;
 540 }
 541
 542 static const struct snd_pcm_ops pcm_ops = {
 543         .open = usb6fire_pcm_open,
 544         .close = usb6fire_pcm_close,
 545         .prepare = usb6fire_pcm_prepare,
 546         .trigger = usb6fire_pcm_trigger,
 547         .pointer = usb6fire_pcm_pointer,
 548 };
 549
 550 static void usb6fire_pcm_init_urb(struct pcm_urb *urb,
 551                                   struct sfire_chip *chip, bool in, int ep,
 552                                   void (*handler)(struct urb *))
 553 {
 554         urb->chip = chip;
 555         usb_init_urb(&urb->instance);
 556         urb->instance.transfer_buffer = urb->buffer;
 557         urb->instance.transfer_buffer_length =
 558                         PCM_N_PACKETS_PER_URB * PCM_MAX_PACKET_SIZE;
 559         urb->instance.dev = chip->dev;
 560         urb->instance.pipe = in ? usb_rcvisocpipe(chip->dev, ep)
 561                         : usb_sndisocpipe(chip->dev, ep);
 562         urb->instance.interval = 1;
 563         urb->instance.complete = handler;
 564         urb->instance.context = urb;
 565         urb->instance.number_of_packets = PCM_N_PACKETS_PER_URB;
 566 }
 567
 568 static int usb6fire_pcm_buffers_init(struct pcm_runtime *rt)
 569 {
 570         int i;
 571
 572         for (i = 0; i < PCM_N_URBS; i++) {
 573                 rt->out_urbs[i].buffer = kcalloc(PCM_MAX_PACKET_SIZE,
 574                                                  PCM_N_PACKETS_PER_URB,
 575                                                  GFP_KERNEL);
 576                 if (!rt->out_urbs[i].buffer)
 577                         return -ENOMEM;
 578                 rt->in_urbs[i].buffer = kcalloc(PCM_MAX_PACKET_SIZE,
 579                                                 PCM_N_PACKETS_PER_URB,
 580                                                 GFP_KERNEL);
 581                 if (!rt->in_urbs[i].buffer)
 582                         return -ENOMEM;
 583         }
 584         return 0;
 585 }
 586
 587 static void usb6fire_pcm_buffers_destroy(struct pcm_runtime *rt)
 588 {
 589         int i;
 590
 591         for (i = 0; i < PCM_N_URBS; i++) {
 592                 kfree(rt->out_urbs[i].buffer);
 593                 kfree(rt->in_urbs[i].buffer);
 594         }
 595 }
 596
 597 int usb6fire_pcm_init(struct sfire_chip *chip)
 598 {
 599         int i;
 600         int ret;
 601         struct snd_pcm *pcm;
 602         struct pcm_runtime *rt =
 603                         kzalloc(sizeof(struct pcm_runtime), GFP_KERNEL);
 604
 605         if (!rt)
 606                 return -ENOMEM;
 607
 608         ret = usb6fire_pcm_buffers_init(rt);
 609         if (ret) {
 610                 usb6fire_pcm_buffers_destroy(rt);
 611                 kfree(rt);
 612                 return ret;
 613         }
 614
 615         rt->chip = chip;
 616         rt->stream_state = STREAM_DISABLED;
 617         rt->rate = ARRAY_SIZE(rates);
 618         init_waitqueue_head(&rt->stream_wait_queue);
 619         mutex_init(&rt->stream_mutex);
 620
 621         spin_lock_init(&rt->playback.lock);
 622         spin_lock_init(&rt->capture.lock);
 623
 624         for (i = 0; i < PCM_N_URBS; i++) {
 625                 usb6fire_pcm_init_urb(&rt->in_urbs[i], chip, true, IN_EP,
 626                                 usb6fire_pcm_in_urb_handler);
 627                 usb6fire_pcm_init_urb(&rt->out_urbs[i], chip, false, OUT_EP,
 628                                 usb6fire_pcm_out_urb_handler);
 629
 630                 rt->in_urbs[i].peer = &rt->out_urbs[i];
 631                 rt->out_urbs[i].peer = &rt->in_urbs[i];
 632         }
 633
 634         ret = snd_pcm_new(chip->card, "DMX6FireUSB", 0, 1, 1, &pcm);
 635         if (ret < 0) {
 636                 usb6fire_pcm_buffers_destroy(rt);
 637                 kfree(rt);
 638                 dev_err(&chip->dev->dev, "cannot create pcm instance.\n");
 639                 return ret;
 640         }
 641
 642         pcm->private_data = rt;
 643         strcpy(pcm->name, "DMX 6Fire USB");
 644         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &pcm_ops);
 645         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &pcm_ops);
 646         snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_VMALLOC, NULL, 0, 0);
 647
 648         rt->instance = pcm;
 649
 650         chip->pcm = rt;
 651         return 0;
 652 }
 653
 654 void usb6fire_pcm_abort(struct sfire_chip *chip)
 655 {
 656         struct pcm_runtime *rt = chip->pcm;
 657         int i;
 658
 659         if (rt) {
 660                 rt->panic = true;
 661
 662                 if (rt->playback.instance)
 663                         snd_pcm_stop_xrun(rt->playback.instance);
 664
 665                 if (rt->capture.instance)
 666                         snd_pcm_stop_xrun(rt->capture.instance);
 667
 668                 for (i = 0; i < PCM_N_URBS; i++) {
 669                         usb_poison_urb(&rt->in_urbs[i].instance);
 670                         usb_poison_urb(&rt->out_urbs[i].instance);
 671                 }
 672
 673         }
 674 }
 675
 676 void usb6fire_pcm_destroy(struct sfire_chip *chip)
 677 {
 678         struct pcm_runtime *rt = chip->pcm;
 679
 680         usb6fire_pcm_buffers_destroy(rt);
 681         kfree(rt);
 682         chip->pcm = NULL;
 683 }