sound/usb/6fire/pcm.c

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