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_hw_params(struct snd_pcm_substream *alsa_sub,
 450                 struct snd_pcm_hw_params *hw_params)
 451 {
 452         return snd_pcm_lib_malloc_pages(alsa_sub,
 453                                         params_buffer_bytes(hw_params));
 454 }
 455
 456 static int usb6fire_pcm_hw_free(struct snd_pcm_substream *alsa_sub)
 457 {
 458         return snd_pcm_lib_free_pages(alsa_sub);
 459 }
 460
 461 static int usb6fire_pcm_prepare(struct snd_pcm_substream *alsa_sub)
 462 {
 463         struct pcm_runtime *rt = snd_pcm_substream_chip(alsa_sub);
 464         struct pcm_substream *sub = usb6fire_pcm_get_substream(alsa_sub);
 465         struct snd_pcm_runtime *alsa_rt = alsa_sub->runtime;
 466         int ret;
 467
 468         if (rt->panic)
 469                 return -EPIPE;
 470         if (!sub)
 471                 return -ENODEV;
 472
 473         mutex_lock(&rt->stream_mutex);
 474         sub->dma_off = 0;
 475         sub->period_off = 0;
 476
 477         if (rt->stream_state == STREAM_DISABLED) {
 478                 for (rt->rate = 0; rt->rate < ARRAY_SIZE(rates); rt->rate++)
 479                         if (alsa_rt->rate == rates[rt->rate])
 480                                 break;
 481                 if (rt->rate == ARRAY_SIZE(rates)) {
 482                         mutex_unlock(&rt->stream_mutex);
 483                         dev_err(&rt->chip->dev->dev,
 484                                 "invalid rate %d in prepare.\n",
 485                                 alsa_rt->rate);
 486                         return -EINVAL;
 487                 }
 488
 489                 ret = usb6fire_pcm_set_rate(rt);
 490                 if (ret) {
 491                         mutex_unlock(&rt->stream_mutex);
 492                         return ret;
 493                 }
 494                 ret = usb6fire_pcm_stream_start(rt);
 495                 if (ret) {
 496                         mutex_unlock(&rt->stream_mutex);
 497                         dev_err(&rt->chip->dev->dev,
 498                                 "could not start pcm stream.\n");
 499                         return ret;
 500                 }
 501         }
 502         mutex_unlock(&rt->stream_mutex);
 503         return 0;
 504 }
 505
 506 static int usb6fire_pcm_trigger(struct snd_pcm_substream *alsa_sub, int cmd)
 507 {
 508         struct pcm_substream *sub = usb6fire_pcm_get_substream(alsa_sub);
 509         struct pcm_runtime *rt = snd_pcm_substream_chip(alsa_sub);
 510         unsigned long flags;
 511
 512         if (rt->panic)
 513                 return -EPIPE;
 514         if (!sub)
 515                 return -ENODEV;
 516
 517         switch (cmd) {
 518         case SNDRV_PCM_TRIGGER_START:
 519         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
 520                 spin_lock_irqsave(&sub->lock, flags);
 521                 sub->active = true;
 522                 spin_unlock_irqrestore(&sub->lock, flags);
 523                 return 0;
 524
 525         case SNDRV_PCM_TRIGGER_STOP:
 526         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
 527                 spin_lock_irqsave(&sub->lock, flags);
 528                 sub->active = false;
 529                 spin_unlock_irqrestore(&sub->lock, flags);
 530                 return 0;
 531
 532         default:
 533                 return -EINVAL;
 534         }
 535 }
 536
 537 static snd_pcm_uframes_t usb6fire_pcm_pointer(
 538                 struct snd_pcm_substream *alsa_sub)
 539 {
 540         struct pcm_substream *sub = usb6fire_pcm_get_substream(alsa_sub);
 541         struct pcm_runtime *rt = snd_pcm_substream_chip(alsa_sub);
 542         unsigned long flags;
 543         snd_pcm_uframes_t ret;
 544
 545         if (rt->panic || !sub)
 546                 return SNDRV_PCM_POS_XRUN;
 547
 548         spin_lock_irqsave(&sub->lock, flags);
 549         ret = sub->dma_off;
 550         spin_unlock_irqrestore(&sub->lock, flags);
 551         return ret;
 552 }
 553
 554 static const struct snd_pcm_ops pcm_ops = {
 555         .open = usb6fire_pcm_open,
 556         .close = usb6fire_pcm_close,
 557         .ioctl = snd_pcm_lib_ioctl,
 558         .hw_params = usb6fire_pcm_hw_params,
 559         .hw_free = usb6fire_pcm_hw_free,
 560         .prepare = usb6fire_pcm_prepare,
 561         .trigger = usb6fire_pcm_trigger,
 562         .pointer = usb6fire_pcm_pointer,
 563 };
 564
 565 static void usb6fire_pcm_init_urb(struct pcm_urb *urb,
 566                                   struct sfire_chip *chip, bool in, int ep,
 567                                   void (*handler)(struct urb *))
 568 {
 569         urb->chip = chip;
 570         usb_init_urb(&urb->instance);
 571         urb->instance.transfer_buffer = urb->buffer;
 572         urb->instance.transfer_buffer_length =
 573                         PCM_N_PACKETS_PER_URB * PCM_MAX_PACKET_SIZE;
 574         urb->instance.dev = chip->dev;
 575         urb->instance.pipe = in ? usb_rcvisocpipe(chip->dev, ep)
 576                         : usb_sndisocpipe(chip->dev, ep);
 577         urb->instance.interval = 1;
 578         urb->instance.complete = handler;
 579         urb->instance.context = urb;
 580         urb->instance.number_of_packets = PCM_N_PACKETS_PER_URB;
 581 }
 582
 583 static int usb6fire_pcm_buffers_init(struct pcm_runtime *rt)
 584 {
 585         int i;
 586
 587         for (i = 0; i < PCM_N_URBS; i++) {
 588                 rt->out_urbs[i].buffer = kcalloc(PCM_MAX_PACKET_SIZE,
 589                                                  PCM_N_PACKETS_PER_URB,
 590                                                  GFP_KERNEL);
 591                 if (!rt->out_urbs[i].buffer)
 592                         return -ENOMEM;
 593                 rt->in_urbs[i].buffer = kcalloc(PCM_MAX_PACKET_SIZE,
 594                                                 PCM_N_PACKETS_PER_URB,
 595                                                 GFP_KERNEL);
 596                 if (!rt->in_urbs[i].buffer)
 597                         return -ENOMEM;
 598         }
 599         return 0;
 600 }
 601
 602 static void usb6fire_pcm_buffers_destroy(struct pcm_runtime *rt)
 603 {
 604         int i;
 605
 606         for (i = 0; i < PCM_N_URBS; i++) {
 607                 kfree(rt->out_urbs[i].buffer);
 608                 kfree(rt->in_urbs[i].buffer);
 609         }
 610 }
 611
 612 int usb6fire_pcm_init(struct sfire_chip *chip)
 613 {
 614         int i;
 615         int ret;
 616         struct snd_pcm *pcm;
 617         struct pcm_runtime *rt =
 618                         kzalloc(sizeof(struct pcm_runtime), GFP_KERNEL);
 619
 620         if (!rt)
 621                 return -ENOMEM;
 622
 623         ret = usb6fire_pcm_buffers_init(rt);
 624         if (ret) {
 625                 usb6fire_pcm_buffers_destroy(rt);
 626                 kfree(rt);
 627                 return ret;
 628         }
 629
 630         rt->chip = chip;
 631         rt->stream_state = STREAM_DISABLED;
 632         rt->rate = ARRAY_SIZE(rates);
 633         init_waitqueue_head(&rt->stream_wait_queue);
 634         mutex_init(&rt->stream_mutex);
 635
 636         spin_lock_init(&rt->playback.lock);
 637         spin_lock_init(&rt->capture.lock);
 638
 639         for (i = 0; i < PCM_N_URBS; i++) {
 640                 usb6fire_pcm_init_urb(&rt->in_urbs[i], chip, true, IN_EP,
 641                                 usb6fire_pcm_in_urb_handler);
 642                 usb6fire_pcm_init_urb(&rt->out_urbs[i], chip, false, OUT_EP,
 643                                 usb6fire_pcm_out_urb_handler);
 644
 645                 rt->in_urbs[i].peer = &rt->out_urbs[i];
 646                 rt->out_urbs[i].peer = &rt->in_urbs[i];
 647         }
 648
 649         ret = snd_pcm_new(chip->card, "DMX6FireUSB", 0, 1, 1, &pcm);
 650         if (ret < 0) {
 651                 usb6fire_pcm_buffers_destroy(rt);
 652                 kfree(rt);
 653                 dev_err(&chip->dev->dev, "cannot create pcm instance.\n");
 654                 return ret;
 655         }
 656
 657         pcm->private_data = rt;
 658         strcpy(pcm->name, "DMX 6Fire USB");
 659         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &pcm_ops);
 660         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &pcm_ops);
 661         snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_VMALLOC,
 662                                               NULL, 0, 0);
 663
 664         rt->instance = pcm;
 665
 666         chip->pcm = rt;
 667         return 0;
 668 }
 669
 670 void usb6fire_pcm_abort(struct sfire_chip *chip)
 671 {
 672         struct pcm_runtime *rt = chip->pcm;
 673         int i;
 674
 675         if (rt) {
 676                 rt->panic = true;
 677
 678                 if (rt->playback.instance)
 679                         snd_pcm_stop_xrun(rt->playback.instance);
 680
 681                 if (rt->capture.instance)
 682                         snd_pcm_stop_xrun(rt->capture.instance);
 683
 684                 for (i = 0; i < PCM_N_URBS; i++) {
 685                         usb_poison_urb(&rt->in_urbs[i].instance);
 686                         usb_poison_urb(&rt->out_urbs[i].instance);
 687                 }
 688
 689         }
 690 }
 691
 692 void usb6fire_pcm_destroy(struct sfire_chip *chip)
 693 {
 694         struct pcm_runtime *rt = chip->pcm;
 695
 696         usb6fire_pcm_buffers_destroy(rt);
 697         kfree(rt);
 698         chip->pcm = NULL;
 699 }