linux/sound/usb/usx2y/usbusx2yaudio.c
<<
>>
Prefs
   1/*
   2 *   US-X2Y AUDIO
   3 *   Copyright (c) 2002-2004 by Karsten Wiese
   4 *
   5 *   based on
   6 *
   7 *   (Tentative) USB Audio Driver for ALSA
   8 *
   9 *   Main and PCM part
  10 *
  11 *   Copyright (c) 2002 by Takashi Iwai <tiwai@suse.de>
  12 *
  13 *   Many codes borrowed from audio.c by 
  14 *          Alan Cox (alan@lxorguk.ukuu.org.uk)
  15 *          Thomas Sailer (sailer@ife.ee.ethz.ch)
  16 *
  17 *
  18 *   This program is free software; you can redistribute it and/or modify
  19 *   it under the terms of the GNU General Public License as published by
  20 *   the Free Software Foundation; either version 2 of the License, or
  21 *   (at your option) any later version.
  22 *
  23 *   This program is distributed in the hope that it will be useful,
  24 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  25 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  26 *   GNU General Public License for more details.
  27 *
  28 *   You should have received a copy of the GNU General Public License
  29 *   along with this program; if not, write to the Free Software
  30 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  31 */
  32
  33
  34#include <linux/interrupt.h>
  35#include <linux/slab.h>
  36#include <linux/usb.h>
  37#include <linux/moduleparam.h>
  38#include <sound/core.h>
  39#include <sound/info.h>
  40#include <sound/pcm.h>
  41#include <sound/pcm_params.h>
  42#include "usx2y.h"
  43#include "usbusx2y.h"
  44
  45#define USX2Y_NRPACKS 4                 /* Default value used for nr of packs per urb.
  46                                          1 to 4 have been tested ok on uhci.
  47                                          To use 3 on ohci, you'd need a patch:
  48                                          look for "0000425-linux-2.6.9-rc4-mm1_ohci-hcd.patch.gz" on
  49                                          "https://bugtrack.alsa-project.org/alsa-bug/bug_view_page.php?bug_id=0000425"
  50                                          .
  51                                          1, 2 and 4 work out of the box on ohci, if I recall correctly.
  52                                          Bigger is safer operation,
  53                                          smaller gives lower latencies.
  54                                        */
  55#define USX2Y_NRPACKS_VARIABLE y        /* If your system works ok with this module's parameter
  56                                           nrpacks set to 1, you might as well comment 
  57                                           this #define out, and thereby produce smaller, faster code.
  58                                           You'd also set USX2Y_NRPACKS to 1 then.
  59                                        */
  60
  61#ifdef USX2Y_NRPACKS_VARIABLE
  62 static int nrpacks = USX2Y_NRPACKS; /* number of packets per urb */
  63 #define  nr_of_packs() nrpacks
  64 module_param(nrpacks, int, 0444);
  65 MODULE_PARM_DESC(nrpacks, "Number of packets per URB.");
  66#else
  67 #define nr_of_packs() USX2Y_NRPACKS
  68#endif
  69
  70
  71static int usX2Y_urb_capt_retire(struct snd_usX2Y_substream *subs)
  72{
  73        struct urb      *urb = subs->completed_urb;
  74        struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime;
  75        unsigned char   *cp;
  76        int             i, len, lens = 0, hwptr_done = subs->hwptr_done;
  77        struct usX2Ydev *usX2Y = subs->usX2Y;
  78
  79        for (i = 0; i < nr_of_packs(); i++) {
  80                cp = (unsigned char*)urb->transfer_buffer + urb->iso_frame_desc[i].offset;
  81                if (urb->iso_frame_desc[i].status) { /* active? hmm, skip this */
  82                        snd_printk(KERN_ERR "active frame status %i. "
  83                                   "Most probably some hardware problem.\n",
  84                                   urb->iso_frame_desc[i].status);
  85                        return urb->iso_frame_desc[i].status;
  86                }
  87                len = urb->iso_frame_desc[i].actual_length / usX2Y->stride;
  88                if (! len) {
  89                        snd_printd("0 == len ERROR!\n");
  90                        continue;
  91                }
  92
  93                /* copy a data chunk */
  94                if ((hwptr_done + len) > runtime->buffer_size) {
  95                        int cnt = runtime->buffer_size - hwptr_done;
  96                        int blen = cnt * usX2Y->stride;
  97                        memcpy(runtime->dma_area + hwptr_done * usX2Y->stride, cp, blen);
  98                        memcpy(runtime->dma_area, cp + blen, len * usX2Y->stride - blen);
  99                } else {
 100                        memcpy(runtime->dma_area + hwptr_done * usX2Y->stride, cp,
 101                               len * usX2Y->stride);
 102                }
 103                lens += len;
 104                if ((hwptr_done += len) >= runtime->buffer_size)
 105                        hwptr_done -= runtime->buffer_size;
 106        }
 107
 108        subs->hwptr_done = hwptr_done;
 109        subs->transfer_done += lens;
 110        /* update the pointer, call callback if necessary */
 111        if (subs->transfer_done >= runtime->period_size) {
 112                subs->transfer_done -= runtime->period_size;
 113                snd_pcm_period_elapsed(subs->pcm_substream);
 114        }
 115        return 0;
 116}
 117/*
 118 * prepare urb for playback data pipe
 119 *
 120 * we copy the data directly from the pcm buffer.
 121 * the current position to be copied is held in hwptr field.
 122 * since a urb can handle only a single linear buffer, if the total
 123 * transferred area overflows the buffer boundary, we cannot send
 124 * it directly from the buffer.  thus the data is once copied to
 125 * a temporary buffer and urb points to that.
 126 */
 127static int usX2Y_urb_play_prepare(struct snd_usX2Y_substream *subs,
 128                                  struct urb *cap_urb,
 129                                  struct urb *urb)
 130{
 131        int count, counts, pack;
 132        struct usX2Ydev *usX2Y = subs->usX2Y;
 133        struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime;
 134
 135        count = 0;
 136        for (pack = 0; pack <  nr_of_packs(); pack++) {
 137                /* calculate the size of a packet */
 138                counts = cap_urb->iso_frame_desc[pack].actual_length / usX2Y->stride;
 139                count += counts;
 140                if (counts < 43 || counts > 50) {
 141                        snd_printk(KERN_ERR "should not be here with counts=%i\n", counts);
 142                        return -EPIPE;
 143                }
 144                /* set up descriptor */
 145                urb->iso_frame_desc[pack].offset = pack ?
 146                        urb->iso_frame_desc[pack - 1].offset +
 147                        urb->iso_frame_desc[pack - 1].length :
 148                        0;
 149                urb->iso_frame_desc[pack].length = cap_urb->iso_frame_desc[pack].actual_length;
 150        }
 151        if (atomic_read(&subs->state) >= state_PRERUNNING)
 152                if (subs->hwptr + count > runtime->buffer_size) {
 153                        /* err, the transferred area goes over buffer boundary.
 154                         * copy the data to the temp buffer.
 155                         */
 156                        int len;
 157                        len = runtime->buffer_size - subs->hwptr;
 158                        urb->transfer_buffer = subs->tmpbuf;
 159                        memcpy(subs->tmpbuf, runtime->dma_area +
 160                               subs->hwptr * usX2Y->stride, len * usX2Y->stride);
 161                        memcpy(subs->tmpbuf + len * usX2Y->stride,
 162                               runtime->dma_area, (count - len) * usX2Y->stride);
 163                        subs->hwptr += count;
 164                        subs->hwptr -= runtime->buffer_size;
 165                } else {
 166                        /* set the buffer pointer */
 167                        urb->transfer_buffer = runtime->dma_area + subs->hwptr * usX2Y->stride;
 168                        if ((subs->hwptr += count) >= runtime->buffer_size)
 169                        subs->hwptr -= runtime->buffer_size;                    
 170                }
 171        else
 172                urb->transfer_buffer = subs->tmpbuf;
 173        urb->transfer_buffer_length = count * usX2Y->stride;
 174        return 0;
 175}
 176
 177/*
 178 * process after playback data complete
 179 *
 180 * update the current position and call callback if a period is processed.
 181 */
 182static void usX2Y_urb_play_retire(struct snd_usX2Y_substream *subs, struct urb *urb)
 183{
 184        struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime;
 185        int             len = urb->actual_length / subs->usX2Y->stride;
 186
 187        subs->transfer_done += len;
 188        subs->hwptr_done +=  len;
 189        if (subs->hwptr_done >= runtime->buffer_size)
 190                subs->hwptr_done -= runtime->buffer_size;
 191        if (subs->transfer_done >= runtime->period_size) {
 192                subs->transfer_done -= runtime->period_size;
 193                snd_pcm_period_elapsed(subs->pcm_substream);
 194        }
 195}
 196
 197static int usX2Y_urb_submit(struct snd_usX2Y_substream *subs, struct urb *urb, int frame)
 198{
 199        int err;
 200        if (!urb)
 201                return -ENODEV;
 202        urb->start_frame = (frame + NRURBS * nr_of_packs());  // let hcd do rollover sanity checks
 203        urb->hcpriv = NULL;
 204        urb->dev = subs->usX2Y->dev; /* we need to set this at each time */
 205        if ((err = usb_submit_urb(urb, GFP_ATOMIC)) < 0) {
 206                snd_printk(KERN_ERR "usb_submit_urb() returned %i\n", err);
 207                return err;
 208        }
 209        return 0;
 210}
 211
 212static inline int usX2Y_usbframe_complete(struct snd_usX2Y_substream *capsubs,
 213                                          struct snd_usX2Y_substream *playbacksubs,
 214                                          int frame)
 215{
 216        int err, state;
 217        struct urb *urb = playbacksubs->completed_urb;
 218
 219        state = atomic_read(&playbacksubs->state);
 220        if (NULL != urb) {
 221                if (state == state_RUNNING)
 222                        usX2Y_urb_play_retire(playbacksubs, urb);
 223                else if (state >= state_PRERUNNING)
 224                        atomic_inc(&playbacksubs->state);
 225        } else {
 226                switch (state) {
 227                case state_STARTING1:
 228                        urb = playbacksubs->urb[0];
 229                        atomic_inc(&playbacksubs->state);
 230                        break;
 231                case state_STARTING2:
 232                        urb = playbacksubs->urb[1];
 233                        atomic_inc(&playbacksubs->state);
 234                        break;
 235                }
 236        }
 237        if (urb) {
 238                if ((err = usX2Y_urb_play_prepare(playbacksubs, capsubs->completed_urb, urb)) ||
 239                    (err = usX2Y_urb_submit(playbacksubs, urb, frame))) {
 240                        return err;
 241                }
 242        }
 243
 244        playbacksubs->completed_urb = NULL;
 245
 246        state = atomic_read(&capsubs->state);
 247        if (state >= state_PREPARED) {
 248                if (state == state_RUNNING) {
 249                        if ((err = usX2Y_urb_capt_retire(capsubs)))
 250                                return err;
 251                } else if (state >= state_PRERUNNING)
 252                        atomic_inc(&capsubs->state);
 253                if ((err = usX2Y_urb_submit(capsubs, capsubs->completed_urb, frame)))
 254                        return err;
 255        }
 256        capsubs->completed_urb = NULL;
 257        return 0;
 258}
 259
 260
 261static void usX2Y_clients_stop(struct usX2Ydev *usX2Y)
 262{
 263        int s, u;
 264
 265        for (s = 0; s < 4; s++) {
 266                struct snd_usX2Y_substream *subs = usX2Y->subs[s];
 267                if (subs) {
 268                        snd_printdd("%i %p state=%i\n", s, subs, atomic_read(&subs->state));
 269                        atomic_set(&subs->state, state_STOPPED);
 270                }
 271        }
 272        for (s = 0; s < 4; s++) {
 273                struct snd_usX2Y_substream *subs = usX2Y->subs[s];
 274                if (subs) {
 275                        if (atomic_read(&subs->state) >= state_PRERUNNING) {
 276                                unsigned long flags;
 277
 278                                snd_pcm_stream_lock_irqsave(subs->pcm_substream, flags);
 279                                snd_pcm_stop(subs->pcm_substream, SNDRV_PCM_STATE_XRUN);
 280                                snd_pcm_stream_unlock_irqrestore(subs->pcm_substream, flags);
 281                        }
 282                        for (u = 0; u < NRURBS; u++) {
 283                                struct urb *urb = subs->urb[u];
 284                                if (NULL != urb)
 285                                        snd_printdd("%i status=%i start_frame=%i\n",
 286                                                    u, urb->status, urb->start_frame);
 287                        }
 288                }
 289        }
 290        usX2Y->prepare_subs = NULL;
 291        wake_up(&usX2Y->prepare_wait_queue);
 292}
 293
 294static void usX2Y_error_urb_status(struct usX2Ydev *usX2Y,
 295                                   struct snd_usX2Y_substream *subs, struct urb *urb)
 296{
 297        snd_printk(KERN_ERR "ep=%i stalled with status=%i\n", subs->endpoint, urb->status);
 298        urb->status = 0;
 299        usX2Y_clients_stop(usX2Y);
 300}
 301
 302static void i_usX2Y_urb_complete(struct urb *urb)
 303{
 304        struct snd_usX2Y_substream *subs = urb->context;
 305        struct usX2Ydev *usX2Y = subs->usX2Y;
 306
 307        if (unlikely(atomic_read(&subs->state) < state_PREPARED)) {
 308                snd_printdd("hcd_frame=%i ep=%i%s status=%i start_frame=%i\n",
 309                            usb_get_current_frame_number(usX2Y->dev),
 310                            subs->endpoint, usb_pipein(urb->pipe) ? "in" : "out",
 311                            urb->status, urb->start_frame);
 312                return;
 313        }
 314        if (unlikely(urb->status)) {
 315                usX2Y_error_urb_status(usX2Y, subs, urb);
 316                return;
 317        }
 318
 319        subs->completed_urb = urb;
 320
 321        {
 322                struct snd_usX2Y_substream *capsubs = usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE],
 323                        *playbacksubs = usX2Y->subs[SNDRV_PCM_STREAM_PLAYBACK];
 324                if (capsubs->completed_urb &&
 325                    atomic_read(&capsubs->state) >= state_PREPARED &&
 326                    (playbacksubs->completed_urb ||
 327                     atomic_read(&playbacksubs->state) < state_PREPARED)) {
 328                        if (!usX2Y_usbframe_complete(capsubs, playbacksubs, urb->start_frame))
 329                                usX2Y->wait_iso_frame += nr_of_packs();
 330                        else {
 331                                snd_printdd("\n");
 332                                usX2Y_clients_stop(usX2Y);
 333                        }
 334                }
 335        }
 336}
 337
 338static void usX2Y_urbs_set_complete(struct usX2Ydev * usX2Y,
 339                                    void (*complete)(struct urb *))
 340{
 341        int s, u;
 342        for (s = 0; s < 4; s++) {
 343                struct snd_usX2Y_substream *subs = usX2Y->subs[s];
 344                if (NULL != subs)
 345                        for (u = 0; u < NRURBS; u++) {
 346                                struct urb * urb = subs->urb[u];
 347                                if (NULL != urb)
 348                                        urb->complete = complete;
 349                        }
 350        }
 351}
 352
 353static void usX2Y_subs_startup_finish(struct usX2Ydev * usX2Y)
 354{
 355        usX2Y_urbs_set_complete(usX2Y, i_usX2Y_urb_complete);
 356        usX2Y->prepare_subs = NULL;
 357}
 358
 359static void i_usX2Y_subs_startup(struct urb *urb)
 360{
 361        struct snd_usX2Y_substream *subs = urb->context;
 362        struct usX2Ydev *usX2Y = subs->usX2Y;
 363        struct snd_usX2Y_substream *prepare_subs = usX2Y->prepare_subs;
 364        if (NULL != prepare_subs)
 365                if (urb->start_frame == prepare_subs->urb[0]->start_frame) {
 366                        usX2Y_subs_startup_finish(usX2Y);
 367                        atomic_inc(&prepare_subs->state);
 368                        wake_up(&usX2Y->prepare_wait_queue);
 369                }
 370
 371        i_usX2Y_urb_complete(urb);
 372}
 373
 374static void usX2Y_subs_prepare(struct snd_usX2Y_substream *subs)
 375{
 376        snd_printdd("usX2Y_substream_prepare(%p) ep=%i urb0=%p urb1=%p\n",
 377                    subs, subs->endpoint, subs->urb[0], subs->urb[1]);
 378        /* reset the pointer */
 379        subs->hwptr = 0;
 380        subs->hwptr_done = 0;
 381        subs->transfer_done = 0;
 382}
 383
 384
 385static void usX2Y_urb_release(struct urb **urb, int free_tb)
 386{
 387        if (*urb) {
 388                usb_kill_urb(*urb);
 389                if (free_tb)
 390                        kfree((*urb)->transfer_buffer);
 391                usb_free_urb(*urb);
 392                *urb = NULL;
 393        }
 394}
 395/*
 396 * release a substreams urbs
 397 */
 398static void usX2Y_urbs_release(struct snd_usX2Y_substream *subs)
 399{
 400        int i;
 401        snd_printdd("usX2Y_urbs_release() %i\n", subs->endpoint);
 402        for (i = 0; i < NRURBS; i++)
 403                usX2Y_urb_release(subs->urb + i,
 404                                  subs != subs->usX2Y->subs[SNDRV_PCM_STREAM_PLAYBACK]);
 405
 406        kfree(subs->tmpbuf);
 407        subs->tmpbuf = NULL;
 408}
 409/*
 410 * initialize a substream's urbs
 411 */
 412static int usX2Y_urbs_allocate(struct snd_usX2Y_substream *subs)
 413{
 414        int i;
 415        unsigned int pipe;
 416        int is_playback = subs == subs->usX2Y->subs[SNDRV_PCM_STREAM_PLAYBACK];
 417        struct usb_device *dev = subs->usX2Y->dev;
 418
 419        pipe = is_playback ? usb_sndisocpipe(dev, subs->endpoint) :
 420                        usb_rcvisocpipe(dev, subs->endpoint);
 421        subs->maxpacksize = usb_maxpacket(dev, pipe, is_playback);
 422        if (!subs->maxpacksize)
 423                return -EINVAL;
 424
 425        if (is_playback && NULL == subs->tmpbuf) {      /* allocate a temporary buffer for playback */
 426                subs->tmpbuf = kcalloc(nr_of_packs(), subs->maxpacksize, GFP_KERNEL);
 427                if (NULL == subs->tmpbuf) {
 428                        snd_printk(KERN_ERR "cannot malloc tmpbuf\n");
 429                        return -ENOMEM;
 430                }
 431        }
 432        /* allocate and initialize data urbs */
 433        for (i = 0; i < NRURBS; i++) {
 434                struct urb **purb = subs->urb + i;
 435                if (*purb) {
 436                        usb_kill_urb(*purb);
 437                        continue;
 438                }
 439                *purb = usb_alloc_urb(nr_of_packs(), GFP_KERNEL);
 440                if (NULL == *purb) {
 441                        usX2Y_urbs_release(subs);
 442                        return -ENOMEM;
 443                }
 444                if (!is_playback && !(*purb)->transfer_buffer) {
 445                        /* allocate a capture buffer per urb */
 446                        (*purb)->transfer_buffer = kmalloc(subs->maxpacksize * nr_of_packs(), GFP_KERNEL);
 447                        if (NULL == (*purb)->transfer_buffer) {
 448                                usX2Y_urbs_release(subs);
 449                                return -ENOMEM;
 450                        }
 451                }
 452                (*purb)->dev = dev;
 453                (*purb)->pipe = pipe;
 454                (*purb)->number_of_packets = nr_of_packs();
 455                (*purb)->context = subs;
 456                (*purb)->interval = 1;
 457                (*purb)->complete = i_usX2Y_subs_startup;
 458        }
 459        return 0;
 460}
 461
 462static void usX2Y_subs_startup(struct snd_usX2Y_substream *subs)
 463{
 464        struct usX2Ydev *usX2Y = subs->usX2Y;
 465        usX2Y->prepare_subs = subs;
 466        subs->urb[0]->start_frame = -1;
 467        wmb();
 468        usX2Y_urbs_set_complete(usX2Y, i_usX2Y_subs_startup);
 469}
 470
 471static int usX2Y_urbs_start(struct snd_usX2Y_substream *subs)
 472{
 473        int i, err;
 474        struct usX2Ydev *usX2Y = subs->usX2Y;
 475
 476        if ((err = usX2Y_urbs_allocate(subs)) < 0)
 477                return err;
 478        subs->completed_urb = NULL;
 479        for (i = 0; i < 4; i++) {
 480                struct snd_usX2Y_substream *subs = usX2Y->subs[i];
 481                if (subs != NULL && atomic_read(&subs->state) >= state_PREPARED)
 482                        goto start;
 483        }
 484
 485 start:
 486        usX2Y_subs_startup(subs);
 487        for (i = 0; i < NRURBS; i++) {
 488                struct urb *urb = subs->urb[i];
 489                if (usb_pipein(urb->pipe)) {
 490                        unsigned long pack;
 491                        if (0 == i)
 492                                atomic_set(&subs->state, state_STARTING3);
 493                        urb->dev = usX2Y->dev;
 494                        for (pack = 0; pack < nr_of_packs(); pack++) {
 495                                urb->iso_frame_desc[pack].offset = subs->maxpacksize * pack;
 496                                urb->iso_frame_desc[pack].length = subs->maxpacksize;
 497                        }
 498                        urb->transfer_buffer_length = subs->maxpacksize * nr_of_packs(); 
 499                        if ((err = usb_submit_urb(urb, GFP_ATOMIC)) < 0) {
 500                                snd_printk (KERN_ERR "cannot submit datapipe for urb %d, err = %d\n", i, err);
 501                                err = -EPIPE;
 502                                goto cleanup;
 503                        } else
 504                                if (i == 0)
 505                                        usX2Y->wait_iso_frame = urb->start_frame;
 506                        urb->transfer_flags = 0;
 507                } else {
 508                        atomic_set(&subs->state, state_STARTING1);
 509                        break;
 510                }
 511        }
 512        err = 0;
 513        wait_event(usX2Y->prepare_wait_queue, NULL == usX2Y->prepare_subs);
 514        if (atomic_read(&subs->state) != state_PREPARED)
 515                err = -EPIPE;
 516
 517 cleanup:
 518        if (err) {
 519                usX2Y_subs_startup_finish(usX2Y);
 520                usX2Y_clients_stop(usX2Y);              // something is completely wroong > stop evrything
 521        }
 522        return err;
 523}
 524
 525/*
 526 * return the current pcm pointer.  just return the hwptr_done value.
 527 */
 528static snd_pcm_uframes_t snd_usX2Y_pcm_pointer(struct snd_pcm_substream *substream)
 529{
 530        struct snd_usX2Y_substream *subs = substream->runtime->private_data;
 531        return subs->hwptr_done;
 532}
 533/*
 534 * start/stop substream
 535 */
 536static int snd_usX2Y_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
 537{
 538        struct snd_usX2Y_substream *subs = substream->runtime->private_data;
 539
 540        switch (cmd) {
 541        case SNDRV_PCM_TRIGGER_START:
 542                snd_printdd("snd_usX2Y_pcm_trigger(START)\n");
 543                if (atomic_read(&subs->state) == state_PREPARED &&
 544                    atomic_read(&subs->usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE]->state) >= state_PREPARED) {
 545                        atomic_set(&subs->state, state_PRERUNNING);
 546                } else {
 547                        snd_printdd("\n");
 548                        return -EPIPE;
 549                }
 550                break;
 551        case SNDRV_PCM_TRIGGER_STOP:
 552                snd_printdd("snd_usX2Y_pcm_trigger(STOP)\n");
 553                if (atomic_read(&subs->state) >= state_PRERUNNING)
 554                        atomic_set(&subs->state, state_PREPARED);
 555                break;
 556        default:
 557                return -EINVAL;
 558        }
 559        return 0;
 560}
 561
 562
 563/*
 564 * allocate a buffer, setup samplerate
 565 *
 566 * so far we use a physically linear buffer although packetize transfer
 567 * doesn't need a continuous area.
 568 * if sg buffer is supported on the later version of alsa, we'll follow
 569 * that.
 570 */
 571static struct s_c2
 572{
 573        char c1, c2;
 574}
 575        SetRate44100[] =
 576{
 577        { 0x14, 0x08},  // this line sets 44100, well actually a little less
 578        { 0x18, 0x40},  // only tascam / frontier design knows the further lines .......
 579        { 0x18, 0x42},
 580        { 0x18, 0x45},
 581        { 0x18, 0x46},
 582        { 0x18, 0x48},
 583        { 0x18, 0x4A},
 584        { 0x18, 0x4C},
 585        { 0x18, 0x4E},
 586        { 0x18, 0x50},
 587        { 0x18, 0x52},
 588        { 0x18, 0x54},
 589        { 0x18, 0x56},
 590        { 0x18, 0x58},
 591        { 0x18, 0x5A},
 592        { 0x18, 0x5C},
 593        { 0x18, 0x5E},
 594        { 0x18, 0x60},
 595        { 0x18, 0x62},
 596        { 0x18, 0x64},
 597        { 0x18, 0x66},
 598        { 0x18, 0x68},
 599        { 0x18, 0x6A},
 600        { 0x18, 0x6C},
 601        { 0x18, 0x6E},
 602        { 0x18, 0x70},
 603        { 0x18, 0x72},
 604        { 0x18, 0x74},
 605        { 0x18, 0x76},
 606        { 0x18, 0x78},
 607        { 0x18, 0x7A},
 608        { 0x18, 0x7C},
 609        { 0x18, 0x7E}
 610};
 611static struct s_c2 SetRate48000[] =
 612{
 613        { 0x14, 0x09},  // this line sets 48000, well actually a little less
 614        { 0x18, 0x40},  // only tascam / frontier design knows the further lines .......
 615        { 0x18, 0x42},
 616        { 0x18, 0x45},
 617        { 0x18, 0x46},
 618        { 0x18, 0x48},
 619        { 0x18, 0x4A},
 620        { 0x18, 0x4C},
 621        { 0x18, 0x4E},
 622        { 0x18, 0x50},
 623        { 0x18, 0x52},
 624        { 0x18, 0x54},
 625        { 0x18, 0x56},
 626        { 0x18, 0x58},
 627        { 0x18, 0x5A},
 628        { 0x18, 0x5C},
 629        { 0x18, 0x5E},
 630        { 0x18, 0x60},
 631        { 0x18, 0x62},
 632        { 0x18, 0x64},
 633        { 0x18, 0x66},
 634        { 0x18, 0x68},
 635        { 0x18, 0x6A},
 636        { 0x18, 0x6C},
 637        { 0x18, 0x6E},
 638        { 0x18, 0x70},
 639        { 0x18, 0x73},
 640        { 0x18, 0x74},
 641        { 0x18, 0x76},
 642        { 0x18, 0x78},
 643        { 0x18, 0x7A},
 644        { 0x18, 0x7C},
 645        { 0x18, 0x7E}
 646};
 647#define NOOF_SETRATE_URBS ARRAY_SIZE(SetRate48000)
 648
 649static void i_usX2Y_04Int(struct urb *urb)
 650{
 651        struct usX2Ydev *usX2Y = urb->context;
 652        
 653        if (urb->status)
 654                snd_printk(KERN_ERR "snd_usX2Y_04Int() urb->status=%i\n", urb->status);
 655        if (0 == --usX2Y->US04->len)
 656                wake_up(&usX2Y->In04WaitQueue);
 657}
 658
 659static int usX2Y_rate_set(struct usX2Ydev *usX2Y, int rate)
 660{
 661        int                     err = 0, i;
 662        struct snd_usX2Y_urbSeq *us = NULL;
 663        int                     *usbdata = NULL;
 664        struct s_c2             *ra = rate == 48000 ? SetRate48000 : SetRate44100;
 665
 666        if (usX2Y->rate != rate) {
 667                us = kzalloc(sizeof(*us) + sizeof(struct urb*) * NOOF_SETRATE_URBS, GFP_KERNEL);
 668                if (NULL == us) {
 669                        err = -ENOMEM;
 670                        goto cleanup;
 671                }
 672                usbdata = kmalloc(sizeof(int) * NOOF_SETRATE_URBS, GFP_KERNEL);
 673                if (NULL == usbdata) {
 674                        err = -ENOMEM;
 675                        goto cleanup;
 676                }
 677                for (i = 0; i < NOOF_SETRATE_URBS; ++i) {
 678                        if (NULL == (us->urb[i] = usb_alloc_urb(0, GFP_KERNEL))) {
 679                                err = -ENOMEM;
 680                                goto cleanup;
 681                        }
 682                        ((char*)(usbdata + i))[0] = ra[i].c1;
 683                        ((char*)(usbdata + i))[1] = ra[i].c2;
 684                        usb_fill_bulk_urb(us->urb[i], usX2Y->dev, usb_sndbulkpipe(usX2Y->dev, 4),
 685                                          usbdata + i, 2, i_usX2Y_04Int, usX2Y);
 686                }
 687                us->submitted = 0;
 688                us->len =       NOOF_SETRATE_URBS;
 689                usX2Y->US04 =   us;
 690                wait_event_timeout(usX2Y->In04WaitQueue, 0 == us->len, HZ);
 691                usX2Y->US04 =   NULL;
 692                if (us->len)
 693                        err = -ENODEV;
 694        cleanup:
 695                if (us) {
 696                        us->submitted = 2*NOOF_SETRATE_URBS;
 697                        for (i = 0; i < NOOF_SETRATE_URBS; ++i) {
 698                                struct urb *urb = us->urb[i];
 699                                if (urb->status) {
 700                                        if (!err)
 701                                                err = -ENODEV;
 702                                        usb_kill_urb(urb);
 703                                }
 704                                usb_free_urb(urb);
 705                        }
 706                        usX2Y->US04 = NULL;
 707                        kfree(usbdata);
 708                        kfree(us);
 709                        if (!err)
 710                                usX2Y->rate = rate;
 711                }
 712        }
 713
 714        return err;
 715}
 716
 717
 718static int usX2Y_format_set(struct usX2Ydev *usX2Y, snd_pcm_format_t format)
 719{
 720        int alternate, err;
 721        struct list_head* p;
 722        if (format == SNDRV_PCM_FORMAT_S24_3LE) {
 723                alternate = 2;
 724                usX2Y->stride = 6;
 725        } else {
 726                alternate = 1;
 727                usX2Y->stride = 4;
 728        }
 729        list_for_each(p, &usX2Y->midi_list) {
 730                snd_usbmidi_input_stop(p);
 731        }
 732        usb_kill_urb(usX2Y->In04urb);
 733        if ((err = usb_set_interface(usX2Y->dev, 0, alternate))) {
 734                snd_printk(KERN_ERR "usb_set_interface error \n");
 735                return err;
 736        }
 737        usX2Y->In04urb->dev = usX2Y->dev;
 738        err = usb_submit_urb(usX2Y->In04urb, GFP_KERNEL);
 739        list_for_each(p, &usX2Y->midi_list) {
 740                snd_usbmidi_input_start(p);
 741        }
 742        usX2Y->format = format;
 743        usX2Y->rate = 0;
 744        return err;
 745}
 746
 747
 748static int snd_usX2Y_pcm_hw_params(struct snd_pcm_substream *substream,
 749                                   struct snd_pcm_hw_params *hw_params)
 750{
 751        int                     err = 0;
 752        unsigned int            rate = params_rate(hw_params);
 753        snd_pcm_format_t        format = params_format(hw_params);
 754        struct snd_card *card = substream->pstr->pcm->card;
 755        struct usX2Ydev *dev = usX2Y(card);
 756        int i;
 757
 758        mutex_lock(&usX2Y(card)->pcm_mutex);
 759        snd_printdd("snd_usX2Y_hw_params(%p, %p)\n", substream, hw_params);
 760        /* all pcm substreams off one usX2Y have to operate at the same
 761         * rate & format
 762         */
 763        for (i = 0; i < dev->pcm_devs * 2; i++) {
 764                struct snd_usX2Y_substream *subs = dev->subs[i];
 765                struct snd_pcm_substream *test_substream;
 766
 767                if (!subs)
 768                        continue;
 769                test_substream = subs->pcm_substream;
 770                if (!test_substream || test_substream == substream ||
 771                    !test_substream->runtime)
 772                        continue;
 773                if ((test_substream->runtime->format &&
 774                     test_substream->runtime->format != format) ||
 775                    (test_substream->runtime->rate &&
 776                     test_substream->runtime->rate != rate)) {
 777                        err = -EINVAL;
 778                        goto error;
 779                }
 780        }
 781
 782        err = snd_pcm_lib_malloc_pages(substream,
 783                                       params_buffer_bytes(hw_params));
 784        if (err < 0) {
 785                snd_printk(KERN_ERR "snd_pcm_lib_malloc_pages(%p, %i) returned %i\n",
 786                           substream, params_buffer_bytes(hw_params), err);
 787                goto error;
 788        }
 789
 790 error:
 791        mutex_unlock(&usX2Y(card)->pcm_mutex);
 792        return err;
 793}
 794
 795/*
 796 * free the buffer
 797 */
 798static int snd_usX2Y_pcm_hw_free(struct snd_pcm_substream *substream)
 799{
 800        struct snd_pcm_runtime *runtime = substream->runtime;
 801        struct snd_usX2Y_substream *subs = runtime->private_data;
 802        mutex_lock(&subs->usX2Y->pcm_mutex);
 803        snd_printdd("snd_usX2Y_hw_free(%p)\n", substream);
 804
 805        if (SNDRV_PCM_STREAM_PLAYBACK == substream->stream) {
 806                struct snd_usX2Y_substream *cap_subs = subs->usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE];
 807                atomic_set(&subs->state, state_STOPPED);
 808                usX2Y_urbs_release(subs);
 809                if (!cap_subs->pcm_substream ||
 810                    !cap_subs->pcm_substream->runtime ||
 811                    !cap_subs->pcm_substream->runtime->status ||
 812                    cap_subs->pcm_substream->runtime->status->state < SNDRV_PCM_STATE_PREPARED) {
 813                        atomic_set(&cap_subs->state, state_STOPPED);
 814                        usX2Y_urbs_release(cap_subs);
 815                }
 816        } else {
 817                struct snd_usX2Y_substream *playback_subs = subs->usX2Y->subs[SNDRV_PCM_STREAM_PLAYBACK];
 818                if (atomic_read(&playback_subs->state) < state_PREPARED) {
 819                        atomic_set(&subs->state, state_STOPPED);
 820                        usX2Y_urbs_release(subs);
 821                }
 822        }
 823        mutex_unlock(&subs->usX2Y->pcm_mutex);
 824        return snd_pcm_lib_free_pages(substream);
 825}
 826/*
 827 * prepare callback
 828 *
 829 * set format and initialize urbs
 830 */
 831static int snd_usX2Y_pcm_prepare(struct snd_pcm_substream *substream)
 832{
 833        struct snd_pcm_runtime *runtime = substream->runtime;
 834        struct snd_usX2Y_substream *subs = runtime->private_data;
 835        struct usX2Ydev *usX2Y = subs->usX2Y;
 836        struct snd_usX2Y_substream *capsubs = subs->usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE];
 837        int err = 0;
 838        snd_printdd("snd_usX2Y_pcm_prepare(%p)\n", substream);
 839
 840        mutex_lock(&usX2Y->pcm_mutex);
 841        usX2Y_subs_prepare(subs);
 842// Start hardware streams
 843// SyncStream first....
 844        if (atomic_read(&capsubs->state) < state_PREPARED) {
 845                if (usX2Y->format != runtime->format)
 846                        if ((err = usX2Y_format_set(usX2Y, runtime->format)) < 0)
 847                                goto up_prepare_mutex;
 848                if (usX2Y->rate != runtime->rate)
 849                        if ((err = usX2Y_rate_set(usX2Y, runtime->rate)) < 0)
 850                                goto up_prepare_mutex;
 851                snd_printdd("starting capture pipe for %s\n", subs == capsubs ? "self" : "playpipe");
 852                if (0 > (err = usX2Y_urbs_start(capsubs)))
 853                        goto up_prepare_mutex;
 854        }
 855
 856        if (subs != capsubs && atomic_read(&subs->state) < state_PREPARED)
 857                err = usX2Y_urbs_start(subs);
 858
 859 up_prepare_mutex:
 860        mutex_unlock(&usX2Y->pcm_mutex);
 861        return err;
 862}
 863
 864static struct snd_pcm_hardware snd_usX2Y_2c =
 865{
 866        .info =                 (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
 867                                 SNDRV_PCM_INFO_BLOCK_TRANSFER |
 868                                 SNDRV_PCM_INFO_MMAP_VALID |
 869                                 SNDRV_PCM_INFO_BATCH),
 870        .formats =                 SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_3LE,
 871        .rates =                   SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000,
 872        .rate_min =                44100,
 873        .rate_max =                48000,
 874        .channels_min =            2,
 875        .channels_max =            2,
 876        .buffer_bytes_max =     (2*128*1024),
 877        .period_bytes_min =     64,
 878        .period_bytes_max =     (128*1024),
 879        .periods_min =          2,
 880        .periods_max =          1024,
 881        .fifo_size =              0
 882};
 883
 884
 885
 886static int snd_usX2Y_pcm_open(struct snd_pcm_substream *substream)
 887{
 888        struct snd_usX2Y_substream      *subs = ((struct snd_usX2Y_substream **)
 889                                         snd_pcm_substream_chip(substream))[substream->stream];
 890        struct snd_pcm_runtime  *runtime = substream->runtime;
 891
 892        if (subs->usX2Y->chip_status & USX2Y_STAT_CHIP_MMAP_PCM_URBS)
 893                return -EBUSY;
 894
 895        runtime->hw = snd_usX2Y_2c;
 896        runtime->private_data = subs;
 897        subs->pcm_substream = substream;
 898        snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIOD_TIME, 1000, 200000);
 899        return 0;
 900}
 901
 902
 903
 904static int snd_usX2Y_pcm_close(struct snd_pcm_substream *substream)
 905{
 906        struct snd_pcm_runtime *runtime = substream->runtime;
 907        struct snd_usX2Y_substream *subs = runtime->private_data;
 908
 909        subs->pcm_substream = NULL;
 910
 911        return 0;
 912}
 913
 914
 915static struct snd_pcm_ops snd_usX2Y_pcm_ops = 
 916{
 917        .open =         snd_usX2Y_pcm_open,
 918        .close =        snd_usX2Y_pcm_close,
 919        .ioctl =        snd_pcm_lib_ioctl,
 920        .hw_params =    snd_usX2Y_pcm_hw_params,
 921        .hw_free =      snd_usX2Y_pcm_hw_free,
 922        .prepare =      snd_usX2Y_pcm_prepare,
 923        .trigger =      snd_usX2Y_pcm_trigger,
 924        .pointer =      snd_usX2Y_pcm_pointer,
 925};
 926
 927
 928/*
 929 * free a usb stream instance
 930 */
 931static void usX2Y_audio_stream_free(struct snd_usX2Y_substream **usX2Y_substream)
 932{
 933        kfree(usX2Y_substream[SNDRV_PCM_STREAM_PLAYBACK]);
 934        usX2Y_substream[SNDRV_PCM_STREAM_PLAYBACK] = NULL;
 935
 936        kfree(usX2Y_substream[SNDRV_PCM_STREAM_CAPTURE]);
 937        usX2Y_substream[SNDRV_PCM_STREAM_CAPTURE] = NULL;
 938}
 939
 940static void snd_usX2Y_pcm_private_free(struct snd_pcm *pcm)
 941{
 942        struct snd_usX2Y_substream **usX2Y_stream = pcm->private_data;
 943        if (usX2Y_stream)
 944                usX2Y_audio_stream_free(usX2Y_stream);
 945}
 946
 947static int usX2Y_audio_stream_new(struct snd_card *card, int playback_endpoint, int capture_endpoint)
 948{
 949        struct snd_pcm *pcm;
 950        int err, i;
 951        struct snd_usX2Y_substream **usX2Y_substream =
 952                usX2Y(card)->subs + 2 * usX2Y(card)->pcm_devs;
 953
 954        for (i = playback_endpoint ? SNDRV_PCM_STREAM_PLAYBACK : SNDRV_PCM_STREAM_CAPTURE;
 955             i <= SNDRV_PCM_STREAM_CAPTURE; ++i) {
 956                usX2Y_substream[i] = kzalloc(sizeof(struct snd_usX2Y_substream), GFP_KERNEL);
 957                if (NULL == usX2Y_substream[i]) {
 958                        snd_printk(KERN_ERR "cannot malloc\n");
 959                        return -ENOMEM;
 960                }
 961                usX2Y_substream[i]->usX2Y = usX2Y(card);
 962        }
 963
 964        if (playback_endpoint)
 965                usX2Y_substream[SNDRV_PCM_STREAM_PLAYBACK]->endpoint = playback_endpoint;
 966        usX2Y_substream[SNDRV_PCM_STREAM_CAPTURE]->endpoint = capture_endpoint;
 967
 968        err = snd_pcm_new(card, NAME_ALLCAPS" Audio", usX2Y(card)->pcm_devs,
 969                          playback_endpoint ? 1 : 0, 1,
 970                          &pcm);
 971        if (err < 0) {
 972                usX2Y_audio_stream_free(usX2Y_substream);
 973                return err;
 974        }
 975
 976        if (playback_endpoint)
 977                snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_usX2Y_pcm_ops);
 978        snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_usX2Y_pcm_ops);
 979
 980        pcm->private_data = usX2Y_substream;
 981        pcm->private_free = snd_usX2Y_pcm_private_free;
 982        pcm->info_flags = 0;
 983
 984        sprintf(pcm->name, NAME_ALLCAPS" Audio #%d", usX2Y(card)->pcm_devs);
 985
 986        if ((playback_endpoint &&
 987             0 > (err = snd_pcm_lib_preallocate_pages(pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream,
 988                                                     SNDRV_DMA_TYPE_CONTINUOUS,
 989                                                     snd_dma_continuous_data(GFP_KERNEL),
 990                                                     64*1024, 128*1024))) ||
 991            0 > (err = snd_pcm_lib_preallocate_pages(pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream,
 992                                                     SNDRV_DMA_TYPE_CONTINUOUS,
 993                                                     snd_dma_continuous_data(GFP_KERNEL),
 994                                                     64*1024, 128*1024))) {
 995                snd_usX2Y_pcm_private_free(pcm);
 996                return err;
 997        }
 998        usX2Y(card)->pcm_devs++;
 999
1000        return 0;
1001}
1002
1003/*
1004 * create a chip instance and set its names.
1005 */
1006int usX2Y_audio_create(struct snd_card *card)
1007{
1008        int err = 0;
1009        
1010        INIT_LIST_HEAD(&usX2Y(card)->pcm_list);
1011
1012        if (0 > (err = usX2Y_audio_stream_new(card, 0xA, 0x8)))
1013                return err;
1014        if (le16_to_cpu(usX2Y(card)->dev->descriptor.idProduct) == USB_ID_US428)
1015             if (0 > (err = usX2Y_audio_stream_new(card, 0, 0xA)))
1016                     return err;
1017        if (le16_to_cpu(usX2Y(card)->dev->descriptor.idProduct) != USB_ID_US122)
1018                err = usX2Y_rate_set(usX2Y(card), 44100);       // Lets us428 recognize output-volume settings, disturbs us122.
1019        return err;
1020}
1021