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