sound/usb/usbaudio.c

   1 /*
   2  *   (Tentative) USB Audio Driver for ALSA
   3  *
   4  *   Main and PCM part
   5  *
   6  *   Copyright (c) 2002 by Takashi Iwai <tiwai@suse.de>
   7  *
   8  *   Many codes borrowed from audio.c by
   9  *          Alan Cox (alan@lxorguk.ukuu.org.uk)
  10  *          Thomas Sailer (sailer@ife.ee.ethz.ch)
  11  *
  12  *
  13  *   This program is free software; you can redistribute it and/or modify
  14  *   it under the terms of the GNU General Public License as published by
  15  *   the Free Software Foundation; either version 2 of the License, or
  16  *   (at your option) any later version.
  17  *
  18  *   This program is distributed in the hope that it will be useful,
  19  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  *   GNU General Public License for more details.
  22  *
  23  *   You should have received a copy of the GNU General Public License
  24  *   along with this program; if not, write to the Free Software
  25  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  26  *
  27  *
  28  *  NOTES:
  29  *
  30  *   - async unlink should be used for avoiding the sleep inside lock.
  31  *     2.4.22 usb-uhci seems buggy for async unlinking and results in
  32  *     oops.  in such a cse, pass async_unlink=0 option.
  33  *   - the linked URBs would be preferred but not used so far because of
  34  *     the instability of unlinking.
  35  *   - type II is not supported properly.  there is no device which supports
  36  *     this type *correctly*.  SB extigy looks as if it supports, but it's
  37  *     indeed an AC3 stream packed in SPDIF frames (i.e. no real AC3 stream).
  38  */
  39
  40
  41 #include <linux/bitops.h>
  42 #include <linux/init.h>
  43 #include <linux/list.h>
  44 #include <linux/slab.h>
  45 #include <linux/string.h>
  46 #include <linux/usb.h>
  47 #include <linux/vmalloc.h>
  48 #include <linux/moduleparam.h>
  49 #include <linux/mutex.h>
  50 #include <sound/core.h>
  51 #include <sound/info.h>
  52 #include <sound/pcm.h>
  53 #include <sound/pcm_params.h>
  54 #include <sound/initval.h>
  55
  56 #include "usbaudio.h"
  57
  58
  59 MODULE_AUTHOR("Takashi Iwai <tiwai@suse.de>");
  60 MODULE_DESCRIPTION("USB Audio");
  61 MODULE_LICENSE("GPL");
  62 MODULE_SUPPORTED_DEVICE("{{Generic,USB Audio}}");
  63
  64
  65 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;      /* Index 0-MAX */
  66 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;       /* ID for this card */
  67 static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;/* Enable this card */
  68 /* Vendor/product IDs for this card */
  69 static int vid[SNDRV_CARDS] = { [0 ... (SNDRV_CARDS-1)] = -1 };
  70 static int pid[SNDRV_CARDS] = { [0 ... (SNDRV_CARDS-1)] = -1 };
  71 static int nrpacks = 8;         /* max. number of packets per urb */
  72 static int async_unlink = 1;
  73 static int device_setup[SNDRV_CARDS]; /* device parameter for this card*/
  74 static int ignore_ctl_error;
  75
  76 module_param_array(index, int, NULL, 0444);
  77 MODULE_PARM_DESC(index, "Index value for the USB audio adapter.");
  78 module_param_array(id, charp, NULL, 0444);
  79 MODULE_PARM_DESC(id, "ID string for the USB audio adapter.");
  80 module_param_array(enable, bool, NULL, 0444);
  81 MODULE_PARM_DESC(enable, "Enable USB audio adapter.");
  82 module_param_array(vid, int, NULL, 0444);
  83 MODULE_PARM_DESC(vid, "Vendor ID for the USB audio device.");
  84 module_param_array(pid, int, NULL, 0444);
  85 MODULE_PARM_DESC(pid, "Product ID for the USB audio device.");
  86 module_param(nrpacks, int, 0644);
  87 MODULE_PARM_DESC(nrpacks, "Max. number of packets per URB.");
  88 module_param(async_unlink, bool, 0444);
  89 MODULE_PARM_DESC(async_unlink, "Use async unlink mode.");
  90 module_param_array(device_setup, int, NULL, 0444);
  91 MODULE_PARM_DESC(device_setup, "Specific device setup (if needed).");
  92 module_param(ignore_ctl_error, bool, 0444);
  93 MODULE_PARM_DESC(ignore_ctl_error,
  94                  "Ignore errors from USB controller for mixer interfaces.");
  95
  96 /*
  97  * debug the h/w constraints
  98  */
  99 /* #define HW_CONST_DEBUG */
 100
 101
 102 /*
 103  *
 104  */
 105
 106 #define MAX_PACKS       20
 107 #define MAX_PACKS_HS    (MAX_PACKS * 8) /* in high speed mode */
 108 #define MAX_URBS        8
 109 #define SYNC_URBS       4       /* always four urbs for sync */
 110 #define MIN_PACKS_URB   1       /* minimum 1 packet per urb */
 111 #define MAX_QUEUE       24      /* try not to exceed this queue length, in ms */
 112
 113 struct audioformat {
 114         struct list_head list;
 115         snd_pcm_format_t format;        /* format type */
 116         unsigned int channels;          /* # channels */
 117         unsigned int fmt_type;          /* USB audio format type (1-3) */
 118         unsigned int frame_size;        /* samples per frame for non-audio */
 119         int iface;                      /* interface number */
 120         unsigned char altsetting;       /* corresponding alternate setting */
 121         unsigned char altset_idx;       /* array index of altenate setting */
 122         unsigned char attributes;       /* corresponding attributes of cs endpoint */
 123         unsigned char endpoint;         /* endpoint */
 124         unsigned char ep_attr;          /* endpoint attributes */
 125         unsigned int maxpacksize;       /* max. packet size */
 126         unsigned int rates;             /* rate bitmasks */
 127         unsigned int rate_min, rate_max;        /* min/max rates */
 128         unsigned int nr_rates;          /* number of rate table entries */
 129         unsigned int *rate_table;       /* rate table */
 130 };
 131
 132 struct snd_usb_substream;
 133
 134 struct snd_urb_ctx {
 135         struct urb *urb;
 136         unsigned int buffer_size;       /* size of data buffer, if data URB */
 137         struct snd_usb_substream *subs;
 138         int index;      /* index for urb array */
 139         int packets;    /* number of packets per urb */
 140 };
 141
 142 struct snd_urb_ops {
 143         int (*prepare)(struct snd_usb_substream *subs, struct snd_pcm_runtime *runtime, struct urb *u);
 144         int (*retire)(struct snd_usb_substream *subs, struct snd_pcm_runtime *runtime, struct urb *u);
 145         int (*prepare_sync)(struct snd_usb_substream *subs, struct snd_pcm_runtime *runtime, struct urb *u);
 146         int (*retire_sync)(struct snd_usb_substream *subs, struct snd_pcm_runtime *runtime, struct urb *u);
 147 };
 148
 149 struct snd_usb_substream {
 150         struct snd_usb_stream *stream;
 151         struct usb_device *dev;
 152         struct snd_pcm_substream *pcm_substream;
 153         int direction;  /* playback or capture */
 154         int interface;  /* current interface */
 155         int endpoint;   /* assigned endpoint */
 156         struct audioformat *cur_audiofmt;       /* current audioformat pointer (for hw_params callback) */
 157         unsigned int cur_rate;          /* current rate (for hw_params callback) */
 158         unsigned int period_bytes;      /* current period bytes (for hw_params callback) */
 159         unsigned int format;     /* USB data format */
 160         unsigned int datapipe;   /* the data i/o pipe */
 161         unsigned int syncpipe;   /* 1 - async out or adaptive in */
 162         unsigned int datainterval;      /* log_2 of data packet interval */
 163         unsigned int syncinterval;  /* P for adaptive mode, 0 otherwise */
 164         unsigned int freqn;      /* nominal sampling rate in fs/fps in Q16.16 format */
 165         unsigned int freqm;      /* momentary sampling rate in fs/fps in Q16.16 format */
 166         unsigned int freqmax;    /* maximum sampling rate, used for buffer management */
 167         unsigned int phase;      /* phase accumulator */
 168         unsigned int maxpacksize;       /* max packet size in bytes */
 169         unsigned int maxframesize;      /* max packet size in frames */
 170         unsigned int curpacksize;       /* current packet size in bytes (for capture) */
 171         unsigned int curframesize;      /* current packet size in frames (for capture) */
 172         unsigned int fill_max: 1;       /* fill max packet size always */
 173         unsigned int fmt_type;          /* USB audio format type (1-3) */
 174         unsigned int packs_per_ms;      /* packets per millisecond (for playback) */
 175
 176         unsigned int running: 1;        /* running status */
 177
 178         unsigned int hwptr_done;                        /* processed frame position in the buffer */
 179         unsigned int transfer_done;             /* processed frames since last period update */
 180         unsigned long active_mask;      /* bitmask of active urbs */
 181         unsigned long unlink_mask;      /* bitmask of unlinked urbs */
 182
 183         unsigned int nurbs;                     /* # urbs */
 184         struct snd_urb_ctx dataurb[MAX_URBS];   /* data urb table */
 185         struct snd_urb_ctx syncurb[SYNC_URBS];  /* sync urb table */
 186         char *syncbuf;                          /* sync buffer for all sync URBs */
 187         dma_addr_t sync_dma;                    /* DMA address of syncbuf */
 188
 189         u64 formats;                    /* format bitmasks (all or'ed) */
 190         unsigned int num_formats;               /* number of supported audio formats (list) */
 191         struct list_head fmt_list;      /* format list */
 192         struct snd_pcm_hw_constraint_list rate_list;    /* limited rates */
 193         spinlock_t lock;
 194
 195         struct snd_urb_ops ops;         /* callbacks (must be filled at init) */
 196 };
 197
 198
 199 struct snd_usb_stream {
 200         struct snd_usb_audio *chip;
 201         struct snd_pcm *pcm;
 202         int pcm_index;
 203         unsigned int fmt_type;          /* USB audio format type (1-3) */
 204         struct snd_usb_substream substream[2];
 205         struct list_head list;
 206 };
 207
 208
 209 /*
 210  * we keep the snd_usb_audio_t instances by ourselves for merging
 211  * the all interfaces on the same card as one sound device.
 212  */
 213
 214 static DEFINE_MUTEX(register_mutex);
 215 static struct snd_usb_audio *usb_chip[SNDRV_CARDS];
 216
 217
 218 /*
 219  * convert a sampling rate into our full speed format (fs/1000 in Q16.16)
 220  * this will overflow at approx 524 kHz
 221  */
 222 static inline unsigned get_usb_full_speed_rate(unsigned int rate)
 223 {
 224         return ((rate << 13) + 62) / 125;
 225 }
 226
 227 /*
 228  * convert a sampling rate into USB high speed format (fs/8000 in Q16.16)
 229  * this will overflow at approx 4 MHz
 230  */
 231 static inline unsigned get_usb_high_speed_rate(unsigned int rate)
 232 {
 233         return ((rate << 10) + 62) / 125;
 234 }
 235
 236 /* convert our full speed USB rate into sampling rate in Hz */
 237 static inline unsigned get_full_speed_hz(unsigned int usb_rate)
 238 {
 239         return (usb_rate * 125 + (1 << 12)) >> 13;
 240 }
 241
 242 /* convert our high speed USB rate into sampling rate in Hz */
 243 static inline unsigned get_high_speed_hz(unsigned int usb_rate)
 244 {
 245         return (usb_rate * 125 + (1 << 9)) >> 10;
 246 }
 247
 248
 249 /*
 250  * prepare urb for full speed capture sync pipe
 251  *
 252  * fill the length and offset of each urb descriptor.
 253  * the fixed 10.14 frequency is passed through the pipe.
 254  */
 255 static int prepare_capture_sync_urb(struct snd_usb_substream *subs,
 256                                     struct snd_pcm_runtime *runtime,
 257                                     struct urb *urb)
 258 {
 259         unsigned char *cp = urb->transfer_buffer;
 260         struct snd_urb_ctx *ctx = urb->context;
 261
 262         urb->dev = ctx->subs->dev; /* we need to set this at each time */
 263         urb->iso_frame_desc[0].length = 3;
 264         urb->iso_frame_desc[0].offset = 0;
 265         cp[0] = subs->freqn >> 2;
 266         cp[1] = subs->freqn >> 10;
 267         cp[2] = subs->freqn >> 18;
 268         return 0;
 269 }
 270
 271 /*
 272  * prepare urb for high speed capture sync pipe
 273  *
 274  * fill the length and offset of each urb descriptor.
 275  * the fixed 12.13 frequency is passed as 16.16 through the pipe.
 276  */
 277 static int prepare_capture_sync_urb_hs(struct snd_usb_substream *subs,
 278                                        struct snd_pcm_runtime *runtime,
 279                                        struct urb *urb)
 280 {
 281         unsigned char *cp = urb->transfer_buffer;
 282         struct snd_urb_ctx *ctx = urb->context;
 283
 284         urb->dev = ctx->subs->dev; /* we need to set this at each time */
 285         urb->iso_frame_desc[0].length = 4;
 286         urb->iso_frame_desc[0].offset = 0;
 287         cp[0] = subs->freqn;
 288         cp[1] = subs->freqn >> 8;
 289         cp[2] = subs->freqn >> 16;
 290         cp[3] = subs->freqn >> 24;
 291         return 0;
 292 }
 293
 294 /*
 295  * process after capture sync complete
 296  * - nothing to do
 297  */
 298 static int retire_capture_sync_urb(struct snd_usb_substream *subs,
 299                                    struct snd_pcm_runtime *runtime,
 300                                    struct urb *urb)
 301 {
 302         return 0;
 303 }
 304
 305 /*
 306  * prepare urb for capture data pipe
 307  *
 308  * fill the offset and length of each descriptor.
 309  *
 310  * we use a temporary buffer to write the captured data.
 311  * since the length of written data is determined by host, we cannot
 312  * write onto the pcm buffer directly...  the data is thus copied
 313  * later at complete callback to the global buffer.
 314  */
 315 static int prepare_capture_urb(struct snd_usb_substream *subs,
 316                                struct snd_pcm_runtime *runtime,
 317                                struct urb *urb)
 318 {
 319         int i, offs;
 320         struct snd_urb_ctx *ctx = urb->context;
 321
 322         offs = 0;
 323         urb->dev = ctx->subs->dev; /* we need to set this at each time */
 324         for (i = 0; i < ctx->packets; i++) {
 325                 urb->iso_frame_desc[i].offset = offs;
 326                 urb->iso_frame_desc[i].length = subs->curpacksize;
 327                 offs += subs->curpacksize;
 328         }
 329         urb->transfer_buffer_length = offs;
 330         urb->number_of_packets = ctx->packets;
 331         return 0;
 332 }
 333
 334 /*
 335  * process after capture complete
 336  *
 337  * copy the data from each desctiptor to the pcm buffer, and
 338  * update the current position.
 339  */
 340 static int retire_capture_urb(struct snd_usb_substream *subs,
 341                               struct snd_pcm_runtime *runtime,
 342                               struct urb *urb)
 343 {
 344         unsigned long flags;
 345         unsigned char *cp;
 346         int i;
 347         unsigned int stride, len, oldptr;
 348         int period_elapsed = 0;
 349
 350         stride = runtime->frame_bits >> 3;
 351
 352         for (i = 0; i < urb->number_of_packets; i++) {
 353                 cp = (unsigned char *)urb->transfer_buffer + urb->iso_frame_desc[i].offset;
 354                 if (urb->iso_frame_desc[i].status) {
 355                         snd_printd(KERN_ERR "frame %d active: %d\n", i, urb->iso_frame_desc[i].status);
 356                         // continue;
 357                 }
 358                 len = urb->iso_frame_desc[i].actual_length / stride;
 359                 if (! len)
 360                         continue;
 361                 /* update the current pointer */
 362                 spin_lock_irqsave(&subs->lock, flags);
 363                 oldptr = subs->hwptr_done;
 364                 subs->hwptr_done += len;
 365                 if (subs->hwptr_done >= runtime->buffer_size)
 366                         subs->hwptr_done -= runtime->buffer_size;
 367                 subs->transfer_done += len;
 368                 if (subs->transfer_done >= runtime->period_size) {
 369                         subs->transfer_done -= runtime->period_size;
 370                         period_elapsed = 1;
 371                 }
 372                 spin_unlock_irqrestore(&subs->lock, flags);
 373                 /* copy a data chunk */
 374                 if (oldptr + len > runtime->buffer_size) {
 375                         unsigned int cnt = runtime->buffer_size - oldptr;
 376                         unsigned int blen = cnt * stride;
 377                         memcpy(runtime->dma_area + oldptr * stride, cp, blen);
 378                         memcpy(runtime->dma_area, cp + blen, len * stride - blen);
 379                 } else {
 380                         memcpy(runtime->dma_area + oldptr * stride, cp, len * stride);
 381                 }
 382         }
 383         if (period_elapsed)
 384                 snd_pcm_period_elapsed(subs->pcm_substream);
 385         return 0;
 386 }
 387
 388 /*
 389  * Process after capture complete when paused.  Nothing to do.
 390  */
 391 static int retire_paused_capture_urb(struct snd_usb_substream *subs,
 392                                      struct snd_pcm_runtime *runtime,
 393                                      struct urb *urb)
 394 {
 395         return 0;
 396 }
 397
 398
 399 /*
 400  * prepare urb for full speed playback sync pipe
 401  *
 402  * set up the offset and length to receive the current frequency.
 403  */
 404
 405 static int prepare_playback_sync_urb(struct snd_usb_substream *subs,
 406                                      struct snd_pcm_runtime *runtime,
 407                                      struct urb *urb)
 408 {
 409         struct snd_urb_ctx *ctx = urb->context;
 410
 411         urb->dev = ctx->subs->dev; /* we need to set this at each time */
 412         urb->iso_frame_desc[0].length = 3;
 413         urb->iso_frame_desc[0].offset = 0;
 414         return 0;
 415 }
 416
 417 /*
 418  * prepare urb for high speed playback sync pipe
 419  *
 420  * set up the offset and length to receive the current frequency.
 421  */
 422
 423 static int prepare_playback_sync_urb_hs(struct snd_usb_substream *subs,
 424                                         struct snd_pcm_runtime *runtime,
 425                                         struct urb *urb)
 426 {
 427         struct snd_urb_ctx *ctx = urb->context;
 428
 429         urb->dev = ctx->subs->dev; /* we need to set this at each time */
 430         urb->iso_frame_desc[0].length = 4;
 431         urb->iso_frame_desc[0].offset = 0;
 432         return 0;
 433 }
 434
 435 /*
 436  * process after full speed playback sync complete
 437  *
 438  * retrieve the current 10.14 frequency from pipe, and set it.
 439  * the value is referred in prepare_playback_urb().
 440  */
 441 static int retire_playback_sync_urb(struct snd_usb_substream *subs,
 442                                     struct snd_pcm_runtime *runtime,
 443                                     struct urb *urb)
 444 {
 445         unsigned int f;
 446         unsigned long flags;
 447
 448         if (urb->iso_frame_desc[0].status == 0 &&
 449             urb->iso_frame_desc[0].actual_length == 3) {
 450                 f = combine_triple((u8*)urb->transfer_buffer) << 2;
 451                 if (f >= subs->freqn - subs->freqn / 8 && f <= subs->freqmax) {
 452                         spin_lock_irqsave(&subs->lock, flags);
 453                         subs->freqm = f;
 454                         spin_unlock_irqrestore(&subs->lock, flags);
 455                 }
 456         }
 457
 458         return 0;
 459 }
 460
 461 /*
 462  * process after high speed playback sync complete
 463  *
 464  * retrieve the current 12.13 frequency from pipe, and set it.
 465  * the value is referred in prepare_playback_urb().
 466  */
 467 static int retire_playback_sync_urb_hs(struct snd_usb_substream *subs,
 468                                        struct snd_pcm_runtime *runtime,
 469                                        struct urb *urb)
 470 {
 471         unsigned int f;
 472         unsigned long flags;
 473
 474         if (urb->iso_frame_desc[0].status == 0 &&
 475             urb->iso_frame_desc[0].actual_length == 4) {
 476                 f = combine_quad((u8*)urb->transfer_buffer) & 0x0fffffff;
 477                 if (f >= subs->freqn - subs->freqn / 8 && f <= subs->freqmax) {
 478                         spin_lock_irqsave(&subs->lock, flags);
 479                         subs->freqm = f;
 480                         spin_unlock_irqrestore(&subs->lock, flags);
 481                 }
 482         }
 483
 484         return 0;
 485 }
 486
 487 /*
 488  * process after E-Mu 0202/0404/Tracker Pre high speed playback sync complete
 489  *
 490  * These devices return the number of samples per packet instead of the number
 491  * of samples per microframe.
 492  */
 493 static int retire_playback_sync_urb_hs_emu(struct snd_usb_substream *subs,
 494                                            struct snd_pcm_runtime *runtime,
 495                                            struct urb *urb)
 496 {
 497         unsigned int f;
 498         unsigned long flags;
 499
 500         if (urb->iso_frame_desc[0].status == 0 &&
 501             urb->iso_frame_desc[0].actual_length == 4) {
 502                 f = combine_quad((u8*)urb->transfer_buffer) & 0x0fffffff;
 503                 f >>= subs->datainterval;
 504                 if (f >= subs->freqn - subs->freqn / 8 && f <= subs->freqmax) {
 505                         spin_lock_irqsave(&subs->lock, flags);
 506                         subs->freqm = f;
 507                         spin_unlock_irqrestore(&subs->lock, flags);
 508                 }
 509         }
 510
 511         return 0;
 512 }
 513
 514 /* determine the number of frames in the next packet */
 515 static int snd_usb_audio_next_packet_size(struct snd_usb_substream *subs)
 516 {
 517         if (subs->fill_max)
 518                 return subs->maxframesize;
 519         else {
 520                 subs->phase = (subs->phase & 0xffff)
 521                         + (subs->freqm << subs->datainterval);
 522                 return min(subs->phase >> 16, subs->maxframesize);
 523         }
 524 }
 525
 526 /*
 527  * Prepare urb for streaming before playback starts or when paused.
 528  *
 529  * We don't have any data, so we send silence.
 530  */
 531 static int prepare_nodata_playback_urb(struct snd_usb_substream *subs,
 532                                        struct snd_pcm_runtime *runtime,
 533                                        struct urb *urb)
 534 {
 535         unsigned int i, offs, counts;
 536         struct snd_urb_ctx *ctx = urb->context;
 537         int stride = runtime->frame_bits >> 3;
 538
 539         offs = 0;
 540         urb->dev = ctx->subs->dev;
 541         for (i = 0; i < ctx->packets; ++i) {
 542                 counts = snd_usb_audio_next_packet_size(subs);
 543                 urb->iso_frame_desc[i].offset = offs * stride;
 544                 urb->iso_frame_desc[i].length = counts * stride;
 545                 offs += counts;
 546         }
 547         urb->number_of_packets = ctx->packets;
 548         urb->transfer_buffer_length = offs * stride;
 549         memset(urb->transfer_buffer,
 550                subs->cur_audiofmt->format == SNDRV_PCM_FORMAT_U8 ? 0x80 : 0,
 551                offs * stride);
 552         return 0;
 553 }
 554
 555 /*
 556  * prepare urb for playback data pipe
 557  *
 558  * Since a URB can handle only a single linear buffer, we must use double
 559  * buffering when the data to be transferred overflows the buffer boundary.
 560  * To avoid inconsistencies when updating hwptr_done, we use double buffering
 561  * for all URBs.
 562  */
 563 static int prepare_playback_urb(struct snd_usb_substream *subs,
 564                                 struct snd_pcm_runtime *runtime,
 565                                 struct urb *urb)
 566 {
 567         int i, stride, offs;
 568         unsigned int counts;
 569         unsigned long flags;
 570         int period_elapsed = 0;
 571         struct snd_urb_ctx *ctx = urb->context;
 572
 573         stride = runtime->frame_bits >> 3;
 574
 575         offs = 0;
 576         urb->dev = ctx->subs->dev; /* we need to set this at each time */
 577         urb->number_of_packets = 0;
 578         spin_lock_irqsave(&subs->lock, flags);
 579         for (i = 0; i < ctx->packets; i++) {
 580                 counts = snd_usb_audio_next_packet_size(subs);
 581                 /* set up descriptor */
 582                 urb->iso_frame_desc[i].offset = offs * stride;
 583                 urb->iso_frame_desc[i].length = counts * stride;
 584                 offs += counts;
 585                 urb->number_of_packets++;
 586                 subs->transfer_done += counts;
 587                 if (subs->transfer_done >= runtime->period_size) {
 588                         subs->transfer_done -= runtime->period_size;
 589                         period_elapsed = 1;
 590                         if (subs->fmt_type == USB_FORMAT_TYPE_II) {
 591                                 if (subs->transfer_done > 0) {
 592                                         /* FIXME: fill-max mode is not
 593                                          * supported yet */
 594                                         offs -= subs->transfer_done;
 595                                         counts -= subs->transfer_done;
 596                                         urb->iso_frame_desc[i].length =
 597                                                 counts * stride;
 598                                         subs->transfer_done = 0;
 599                                 }
 600                                 i++;
 601                                 if (i < ctx->packets) {
 602                                         /* add a transfer delimiter */
 603                                         urb->iso_frame_desc[i].offset =
 604                                                 offs * stride;
 605                                         urb->iso_frame_desc[i].length = 0;
 606                                         urb->number_of_packets++;
 607                                 }
 608                                 break;
 609                         }
 610                 }
 611                 /* finish at the frame boundary at/after the period boundary */
 612                 if (period_elapsed &&
 613                     (i & (subs->packs_per_ms - 1)) == subs->packs_per_ms - 1)
 614                         break;
 615         }
 616         if (subs->hwptr_done + offs > runtime->buffer_size) {
 617                 /* err, the transferred area goes over buffer boundary. */
 618                 unsigned int len = runtime->buffer_size - subs->hwptr_done;
 619                 memcpy(urb->transfer_buffer,
 620                        runtime->dma_area + subs->hwptr_done * stride,
 621                        len * stride);
 622                 memcpy(urb->transfer_buffer + len * stride,
 623                        runtime->dma_area,
 624                        (offs - len) * stride);
 625         } else {
 626                 memcpy(urb->transfer_buffer,
 627                        runtime->dma_area + subs->hwptr_done * stride,
 628                        offs * stride);
 629         }
 630         subs->hwptr_done += offs;
 631         if (subs->hwptr_done >= runtime->buffer_size)
 632                 subs->hwptr_done -= runtime->buffer_size;
 633         spin_unlock_irqrestore(&subs->lock, flags);
 634         urb->transfer_buffer_length = offs * stride;
 635         if (period_elapsed)
 636                 snd_pcm_period_elapsed(subs->pcm_substream);
 637         return 0;
 638 }
 639
 640 /*
 641  * process after playback data complete
 642  * - nothing to do
 643  */
 644 static int retire_playback_urb(struct snd_usb_substream *subs,
 645                                struct snd_pcm_runtime *runtime,
 646                                struct urb *urb)
 647 {
 648         return 0;
 649 }
 650
 651
 652 /*
 653  */
 654 static struct snd_urb_ops audio_urb_ops[2] = {
 655         {
 656                 .prepare =      prepare_nodata_playback_urb,
 657                 .retire =       retire_playback_urb,
 658                 .prepare_sync = prepare_playback_sync_urb,
 659                 .retire_sync =  retire_playback_sync_urb,
 660         },
 661         {
 662                 .prepare =      prepare_capture_urb,
 663                 .retire =       retire_capture_urb,
 664                 .prepare_sync = prepare_capture_sync_urb,
 665                 .retire_sync =  retire_capture_sync_urb,
 666         },
 667 };
 668
 669 static struct snd_urb_ops audio_urb_ops_high_speed[2] = {
 670         {
 671                 .prepare =      prepare_nodata_playback_urb,
 672                 .retire =       retire_playback_urb,
 673                 .prepare_sync = prepare_playback_sync_urb_hs,
 674                 .retire_sync =  retire_playback_sync_urb_hs,
 675         },
 676         {
 677                 .prepare =      prepare_capture_urb,
 678                 .retire =       retire_capture_urb,
 679                 .prepare_sync = prepare_capture_sync_urb_hs,
 680                 .retire_sync =  retire_capture_sync_urb,
 681         },
 682 };
 683
 684 /*
 685  * complete callback from data urb
 686  */
 687 static void snd_complete_urb(struct urb *urb)
 688 {
 689         struct snd_urb_ctx *ctx = urb->context;
 690         struct snd_usb_substream *subs = ctx->subs;
 691         struct snd_pcm_substream *substream = ctx->subs->pcm_substream;
 692         int err = 0;
 693
 694         if ((subs->running && subs->ops.retire(subs, substream->runtime, urb)) ||
 695             !subs->running || /* can be stopped during retire callback */
 696             (err = subs->ops.prepare(subs, substream->runtime, urb)) < 0 ||
 697             (err = usb_submit_urb(urb, GFP_ATOMIC)) < 0) {
 698                 clear_bit(ctx->index, &subs->active_mask);
 699                 if (err < 0) {
 700                         snd_printd(KERN_ERR "cannot submit urb (err = %d)\n", err);
 701                         snd_pcm_stop(substream, SNDRV_PCM_STATE_XRUN);
 702                 }
 703         }
 704 }
 705
 706
 707 /*
 708  * complete callback from sync urb
 709  */
 710 static void snd_complete_sync_urb(struct urb *urb)
 711 {
 712         struct snd_urb_ctx *ctx = urb->context;
 713         struct snd_usb_substream *subs = ctx->subs;
 714         struct snd_pcm_substream *substream = ctx->subs->pcm_substream;
 715         int err = 0;
 716
 717         if ((subs->running && subs->ops.retire_sync(subs, substream->runtime, urb)) ||
 718             !subs->running || /* can be stopped during retire callback */
 719             (err = subs->ops.prepare_sync(subs, substream->runtime, urb)) < 0 ||
 720             (err = usb_submit_urb(urb, GFP_ATOMIC)) < 0) {
 721                 clear_bit(ctx->index + 16, &subs->active_mask);
 722                 if (err < 0) {
 723                         snd_printd(KERN_ERR "cannot submit sync urb (err = %d)\n", err);
 724                         snd_pcm_stop(substream, SNDRV_PCM_STATE_XRUN);
 725                 }
 726         }
 727 }
 728
 729
 730 /* get the physical page pointer at the given offset */
 731 static struct page *snd_pcm_get_vmalloc_page(struct snd_pcm_substream *subs,
 732                                              unsigned long offset)
 733 {
 734         void *pageptr = subs->runtime->dma_area + offset;
 735         return vmalloc_to_page(pageptr);
 736 }
 737
 738 /* allocate virtual buffer; may be called more than once */
 739 static int snd_pcm_alloc_vmalloc_buffer(struct snd_pcm_substream *subs, size_t size)
 740 {
 741         struct snd_pcm_runtime *runtime = subs->runtime;
 742         if (runtime->dma_area) {
 743                 if (runtime->dma_bytes >= size)
 744                         return 0; /* already large enough */
 745                 vfree(runtime->dma_area);
 746         }
 747         runtime->dma_area = vmalloc(size);
 748         if (!runtime->dma_area)
 749                 return -ENOMEM;
 750         runtime->dma_bytes = size;
 751         return 0;
 752 }
 753
 754 /* free virtual buffer; may be called more than once */
 755 static int snd_pcm_free_vmalloc_buffer(struct snd_pcm_substream *subs)
 756 {
 757         struct snd_pcm_runtime *runtime = subs->runtime;
 758
 759         vfree(runtime->dma_area);
 760         runtime->dma_area = NULL;
 761         return 0;
 762 }
 763
 764
 765 /*
 766  * unlink active urbs.
 767  */
 768 static int deactivate_urbs(struct snd_usb_substream *subs, int force, int can_sleep)
 769 {
 770         unsigned int i;
 771         int async;
 772
 773         subs->running = 0;
 774
 775         if (!force && subs->stream->chip->shutdown) /* to be sure... */
 776                 return -EBADFD;
 777
 778         async = !can_sleep && async_unlink;
 779
 780         if (!async && in_interrupt())
 781                 return 0;
 782
 783         for (i = 0; i < subs->nurbs; i++) {
 784                 if (test_bit(i, &subs->active_mask)) {
 785                         if (!test_and_set_bit(i, &subs->unlink_mask)) {
 786                                 struct urb *u = subs->dataurb[i].urb;
 787                                 if (async)
 788                                         usb_unlink_urb(u);
 789                                 else
 790                                         usb_kill_urb(u);
 791                         }
 792                 }
 793         }
 794         if (subs->syncpipe) {
 795                 for (i = 0; i < SYNC_URBS; i++) {
 796                         if (test_bit(i+16, &subs->active_mask)) {
 797                                 if (!test_and_set_bit(i+16, &subs->unlink_mask)) {
 798                                         struct urb *u = subs->syncurb[i].urb;
 799                                         if (async)
 800                                                 usb_unlink_urb(u);
 801                                         else
 802                                                 usb_kill_urb(u);
 803                                 }
 804                         }
 805                 }
 806         }
 807         return 0;
 808 }
 809
 810
 811 static const char *usb_error_string(int err)
 812 {
 813         switch (err) {
 814         case -ENODEV:
 815                 return "no device";
 816         case -ENOENT:
 817                 return "endpoint not enabled";
 818         case -EPIPE:
 819                 return "endpoint stalled";
 820         case -ENOSPC:
 821                 return "not enough bandwidth";
 822         case -ESHUTDOWN:
 823                 return "device disabled";
 824         case -EHOSTUNREACH:
 825                 return "device suspended";
 826         case -EINVAL:
 827         case -EAGAIN:
 828         case -EFBIG:
 829         case -EMSGSIZE:
 830                 return "internal error";
 831         default:
 832                 return "unknown error";
 833         }
 834 }
 835
 836 /*
 837  * set up and start data/sync urbs
 838  */
 839 static int start_urbs(struct snd_usb_substream *subs, struct snd_pcm_runtime *runtime)
 840 {
 841         unsigned int i;
 842         int err;
 843
 844         if (subs->stream->chip->shutdown)
 845                 return -EBADFD;
 846
 847         for (i = 0; i < subs->nurbs; i++) {
 848                 if (snd_BUG_ON(!subs->dataurb[i].urb))
 849                         return -EINVAL;
 850                 if (subs->ops.prepare(subs, runtime, subs->dataurb[i].urb) < 0) {
 851                         snd_printk(KERN_ERR "cannot prepare datapipe for urb %d\n", i);
 852                         goto __error;
 853                 }
 854         }
 855         if (subs->syncpipe) {
 856                 for (i = 0; i < SYNC_URBS; i++) {
 857                         if (snd_BUG_ON(!subs->syncurb[i].urb))
 858                                 return -EINVAL;
 859                         if (subs->ops.prepare_sync(subs, runtime, subs->syncurb[i].urb) < 0) {
 860                                 snd_printk(KERN_ERR "cannot prepare syncpipe for urb %d\n", i);
 861                                 goto __error;
 862                         }
 863                 }
 864         }
 865
 866         subs->active_mask = 0;
 867         subs->unlink_mask = 0;
 868         subs->running = 1;
 869         for (i = 0; i < subs->nurbs; i++) {
 870                 err = usb_submit_urb(subs->dataurb[i].urb, GFP_ATOMIC);
 871                 if (err < 0) {
 872                         snd_printk(KERN_ERR "cannot submit datapipe "
 873                                    "for urb %d, error %d: %s\n",
 874                                    i, err, usb_error_string(err));
 875                         goto __error;
 876                 }
 877                 set_bit(i, &subs->active_mask);
 878         }
 879         if (subs->syncpipe) {
 880                 for (i = 0; i < SYNC_URBS; i++) {
 881                         err = usb_submit_urb(subs->syncurb[i].urb, GFP_ATOMIC);
 882                         if (err < 0) {
 883                                 snd_printk(KERN_ERR "cannot submit syncpipe "
 884                                            "for urb %d, error %d: %s\n",
 885                                            i, err, usb_error_string(err));
 886                                 goto __error;
 887                         }
 888                         set_bit(i + 16, &subs->active_mask);
 889                 }
 890         }
 891         return 0;
 892
 893  __error:
 894         // snd_pcm_stop(subs->pcm_substream, SNDRV_PCM_STATE_XRUN);
 895         deactivate_urbs(subs, 0, 0);
 896         return -EPIPE;
 897 }
 898
 899
 900 /*
 901  *  wait until all urbs are processed.
 902  */
 903 static int wait_clear_urbs(struct snd_usb_substream *subs)
 904 {
 905         unsigned long end_time = jiffies + msecs_to_jiffies(1000);
 906         unsigned int i;
 907         int alive;
 908
 909         do {
 910                 alive = 0;
 911                 for (i = 0; i < subs->nurbs; i++) {
 912                         if (test_bit(i, &subs->active_mask))
 913                                 alive++;
 914                 }
 915                 if (subs->syncpipe) {
 916                         for (i = 0; i < SYNC_URBS; i++) {
 917                                 if (test_bit(i + 16, &subs->active_mask))
 918                                         alive++;
 919                         }
 920                 }
 921                 if (! alive)
 922                         break;
 923                 schedule_timeout_uninterruptible(1);
 924         } while (time_before(jiffies, end_time));
 925         if (alive)
 926                 snd_printk(KERN_ERR "timeout: still %d active urbs..\n", alive);
 927         return 0;
 928 }
 929
 930
 931 /*
 932  * return the current pcm pointer.  just return the hwptr_done value.
 933  */
 934 static snd_pcm_uframes_t snd_usb_pcm_pointer(struct snd_pcm_substream *substream)
 935 {
 936         struct snd_usb_substream *subs;
 937         snd_pcm_uframes_t hwptr_done;
 938
 939         subs = (struct snd_usb_substream *)substream->runtime->private_data;
 940         spin_lock(&subs->lock);
 941         hwptr_done = subs->hwptr_done;
 942         spin_unlock(&subs->lock);
 943         return hwptr_done;
 944 }
 945
 946
 947 /*
 948  * start/stop playback substream
 949  */
 950 static int snd_usb_pcm_playback_trigger(struct snd_pcm_substream *substream,
 951                                         int cmd)
 952 {
 953         struct snd_usb_substream *subs = substream->runtime->private_data;
 954
 955         switch (cmd) {
 956         case SNDRV_PCM_TRIGGER_START:
 957         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
 958                 subs->ops.prepare = prepare_playback_urb;
 959                 return 0;
 960         case SNDRV_PCM_TRIGGER_STOP:
 961                 return deactivate_urbs(subs, 0, 0);
 962         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
 963                 subs->ops.prepare = prepare_nodata_playback_urb;
 964                 return 0;
 965         default:
 966                 return -EINVAL;
 967         }
 968 }
 969
 970 /*
 971  * start/stop capture substream
 972  */
 973 static int snd_usb_pcm_capture_trigger(struct snd_pcm_substream *substream,
 974                                        int cmd)
 975 {
 976         struct snd_usb_substream *subs = substream->runtime->private_data;
 977
 978         switch (cmd) {
 979         case SNDRV_PCM_TRIGGER_START:
 980                 subs->ops.retire = retire_capture_urb;
 981                 return start_urbs(subs, substream->runtime);
 982         case SNDRV_PCM_TRIGGER_STOP:
 983                 return deactivate_urbs(subs, 0, 0);
 984         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
 985                 subs->ops.retire = retire_paused_capture_urb;
 986                 return 0;
 987         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
 988                 subs->ops.retire = retire_capture_urb;
 989                 return 0;
 990         default:
 991                 return -EINVAL;
 992         }
 993 }
 994
 995
 996 /*
 997  * release a urb data
 998  */
 999 static void release_urb_ctx(struct snd_urb_ctx *u)
1000 {
1001         if (u->urb) {
1002                 if (u->buffer_size)
1003                         usb_buffer_free(u->subs->dev, u->buffer_size,
1004                                         u->urb->transfer_buffer,
1005                                         u->urb->transfer_dma);
1006                 usb_free_urb(u->urb);
1007                 u->urb = NULL;
1008         }
1009 }
1010
1011 /*
1012  * release a substream
1013  */
1014 static void release_substream_urbs(struct snd_usb_substream *subs, int force)
1015 {
1016         int i;
1017
1018         /* stop urbs (to be sure) */
1019         deactivate_urbs(subs, force, 1);
1020         wait_clear_urbs(subs);
1021
1022         for (i = 0; i < MAX_URBS; i++)
1023                 release_urb_ctx(&subs->dataurb[i]);
1024         for (i = 0; i < SYNC_URBS; i++)
1025                 release_urb_ctx(&subs->syncurb[i]);
1026         usb_buffer_free(subs->dev, SYNC_URBS * 4,
1027                         subs->syncbuf, subs->sync_dma);
1028         subs->syncbuf = NULL;
1029         subs->nurbs = 0;
1030 }
1031
1032 /*
1033  * initialize a substream for plaback/capture
1034  */
1035 static int init_substream_urbs(struct snd_usb_substream *subs, unsigned int period_bytes,
1036                                unsigned int rate, unsigned int frame_bits)
1037 {
1038         unsigned int maxsize, n, i;
1039         int is_playback = subs->direction == SNDRV_PCM_STREAM_PLAYBACK;
1040         unsigned int npacks[MAX_URBS], urb_packs, total_packs, packs_per_ms;
1041
1042         /* calculate the frequency in 16.16 format */
1043         if (snd_usb_get_speed(subs->dev) == USB_SPEED_FULL)
1044                 subs->freqn = get_usb_full_speed_rate(rate);
1045         else
1046                 subs->freqn = get_usb_high_speed_rate(rate);
1047         subs->freqm = subs->freqn;
1048         /* calculate max. frequency */
1049         if (subs->maxpacksize) {
1050                 /* whatever fits into a max. size packet */
1051                 maxsize = subs->maxpacksize;
1052                 subs->freqmax = (maxsize / (frame_bits >> 3))
1053                                 << (16 - subs->datainterval);
1054         } else {
1055                 /* no max. packet size: just take 25% higher than nominal */
1056                 subs->freqmax = subs->freqn + (subs->freqn >> 2);
1057                 maxsize = ((subs->freqmax + 0xffff) * (frame_bits >> 3))
1058                                 >> (16 - subs->datainterval);
1059         }
1060         subs->phase = 0;
1061
1062         if (subs->fill_max)
1063                 subs->curpacksize = subs->maxpacksize;
1064         else
1065                 subs->curpacksize = maxsize;
1066
1067         if (snd_usb_get_speed(subs->dev) == USB_SPEED_HIGH)
1068                 packs_per_ms = 8 >> subs->datainterval;
1069         else
1070                 packs_per_ms = 1;
1071         subs->packs_per_ms = packs_per_ms;
1072
1073         if (is_playback) {
1074                 urb_packs = nrpacks;
1075                 urb_packs = max(urb_packs, (unsigned int)MIN_PACKS_URB);
1076                 urb_packs = min(urb_packs, (unsigned int)MAX_PACKS);
1077         } else
1078                 urb_packs = 1;
1079         urb_packs *= packs_per_ms;
1080
1081         /* decide how many packets to be used */
1082         if (is_playback) {
1083                 unsigned int minsize, maxpacks;
1084                 /* determine how small a packet can be */
1085                 minsize = (subs->freqn >> (16 - subs->datainterval))
1086                           * (frame_bits >> 3);
1087                 /* with sync from device, assume it can be 12% lower */
1088                 if (subs->syncpipe)
1089                         minsize -= minsize >> 3;
1090                 minsize = max(minsize, 1u);
1091                 total_packs = (period_bytes + minsize - 1) / minsize;
1092                 /* round up to multiple of packs_per_ms */
1093                 total_packs = (total_packs + packs_per_ms - 1)
1094                                 & ~(packs_per_ms - 1);
1095                 /* we need at least two URBs for queueing */
1096                 if (total_packs < 2 * MIN_PACKS_URB * packs_per_ms)
1097                         total_packs = 2 * MIN_PACKS_URB * packs_per_ms;
1098                 else {
1099                         /* and we don't want too long a queue either */
1100                         maxpacks = max((unsigned int)MAX_QUEUE, urb_packs * 2);
1101                         if (total_packs > maxpacks * packs_per_ms)
1102                                 total_packs = maxpacks * packs_per_ms;
1103                 }
1104         } else {
1105                 total_packs = MAX_URBS * urb_packs;
1106         }
1107         subs->nurbs = (total_packs + urb_packs - 1) / urb_packs;
1108         if (subs->nurbs > MAX_URBS) {
1109                 /* too much... */
1110                 subs->nurbs = MAX_URBS;
1111                 total_packs = MAX_URBS * urb_packs;
1112         }
1113         n = total_packs;
1114         for (i = 0; i < subs->nurbs; i++) {
1115                 npacks[i] = n > urb_packs ? urb_packs : n;
1116                 n -= urb_packs;
1117         }
1118         if (subs->nurbs <= 1) {
1119                 /* too little - we need at least two packets
1120                  * to ensure contiguous playback/capture
1121                  */
1122                 subs->nurbs = 2;
1123                 npacks[0] = (total_packs + 1) / 2;
1124                 npacks[1] = total_packs - npacks[0];
1125         } else if (npacks[subs->nurbs-1] < MIN_PACKS_URB * packs_per_ms) {
1126                 /* the last packet is too small.. */
1127                 if (subs->nurbs > 2) {
1128                         /* merge to the first one */
1129                         npacks[0] += npacks[subs->nurbs - 1];
1130                         subs->nurbs--;
1131                 } else {
1132                         /* divide to two */
1133                         subs->nurbs = 2;
1134                         npacks[0] = (total_packs + 1) / 2;
1135                         npacks[1] = total_packs - npacks[0];
1136                 }
1137         }
1138
1139         /* allocate and initialize data urbs */
1140         for (i = 0; i < subs->nurbs; i++) {
1141                 struct snd_urb_ctx *u = &subs->dataurb[i];
1142                 u->index = i;
1143                 u->subs = subs;
1144                 u->packets = npacks[i];
1145                 u->buffer_size = maxsize * u->packets;
1146                 if (subs->fmt_type == USB_FORMAT_TYPE_II)
1147                         u->packets++; /* for transfer delimiter */
1148                 u->urb = usb_alloc_urb(u->packets, GFP_KERNEL);
1149                 if (!u->urb)
1150                         goto out_of_memory;
1151                 u->urb->transfer_buffer =
1152                         usb_buffer_alloc(subs->dev, u->buffer_size, GFP_KERNEL,
1153                                          &u->urb->transfer_dma);
1154                 if (!u->urb->transfer_buffer)
1155                         goto out_of_memory;
1156                 u->urb->pipe = subs->datapipe;
1157                 u->urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
1158                 u->urb->interval = 1 << subs->datainterval;
1159                 u->urb->context = u;
1160                 u->urb->complete = snd_complete_urb;
1161         }
1162
1163         if (subs->syncpipe) {
1164                 /* allocate and initialize sync urbs */
1165                 subs->syncbuf = usb_buffer_alloc(subs->dev, SYNC_URBS * 4,
1166                                                  GFP_KERNEL, &subs->sync_dma);
1167                 if (!subs->syncbuf)
1168                         goto out_of_memory;
1169                 for (i = 0; i < SYNC_URBS; i++) {
1170                         struct snd_urb_ctx *u = &subs->syncurb[i];
1171                         u->index = i;
1172                         u->subs = subs;
1173                         u->packets = 1;
1174                         u->urb = usb_alloc_urb(1, GFP_KERNEL);
1175                         if (!u->urb)
1176                                 goto out_of_memory;
1177                         u->urb->transfer_buffer = subs->syncbuf + i * 4;
1178                         u->urb->transfer_dma = subs->sync_dma + i * 4;
1179                         u->urb->transfer_buffer_length = 4;
1180                         u->urb->pipe = subs->syncpipe;
1181                         u->urb->transfer_flags = URB_ISO_ASAP |
1182                                                  URB_NO_TRANSFER_DMA_MAP;
1183                         u->urb->number_of_packets = 1;
1184                         u->urb->interval = 1 << subs->syncinterval;
1185                         u->urb->context = u;
1186                         u->urb->complete = snd_complete_sync_urb;
1187                 }
1188         }
1189         return 0;
1190
1191 out_of_memory:
1192         release_substream_urbs(subs, 0);
1193         return -ENOMEM;
1194 }
1195
1196
1197 /*
1198  * find a matching audio format
1199  */
1200 static struct audioformat *find_format(struct snd_usb_substream *subs, unsigned int format,
1201                                        unsigned int rate, unsigned int channels)
1202 {
1203         struct list_head *p;
1204         struct audioformat *found = NULL;
1205         int cur_attr = 0, attr;
1206
1207         list_for_each(p, &subs->fmt_list) {
1208                 struct audioformat *fp;
1209                 fp = list_entry(p, struct audioformat, list);
1210                 if (fp->format != format || fp->channels != channels)
1211                         continue;
1212                 if (rate < fp->rate_min || rate > fp->rate_max)
1213                         continue;
1214                 if (! (fp->rates & SNDRV_PCM_RATE_CONTINUOUS)) {
1215                         unsigned int i;
1216                         for (i = 0; i < fp->nr_rates; i++)
1217                                 if (fp->rate_table[i] == rate)
1218                                         break;
1219                         if (i >= fp->nr_rates)
1220                                 continue;
1221                 }
1222                 attr = fp->ep_attr & EP_ATTR_MASK;
1223                 if (! found) {
1224                         found = fp;
1225                         cur_attr = attr;
1226                         continue;
1227                 }
1228                 /* avoid async out and adaptive in if the other method
1229                  * supports the same format.
1230                  * this is a workaround for the case like
1231                  * M-audio audiophile USB.
1232                  */
1233                 if (attr != cur_attr) {
1234                         if ((attr == EP_ATTR_ASYNC &&
1235                              subs->direction == SNDRV_PCM_STREAM_PLAYBACK) ||
1236                             (attr == EP_ATTR_ADAPTIVE &&
1237                              subs->direction == SNDRV_PCM_STREAM_CAPTURE))
1238                                 continue;
1239                         if ((cur_attr == EP_ATTR_ASYNC &&
1240                              subs->direction == SNDRV_PCM_STREAM_PLAYBACK) ||
1241                             (cur_attr == EP_ATTR_ADAPTIVE &&
1242                              subs->direction == SNDRV_PCM_STREAM_CAPTURE)) {
1243                                 found = fp;
1244                                 cur_attr = attr;
1245                                 continue;
1246                         }
1247                 }
1248                 /* find the format with the largest max. packet size */
1249                 if (fp->maxpacksize > found->maxpacksize) {
1250                         found = fp;
1251                         cur_attr = attr;
1252                 }
1253         }
1254         return found;
1255 }
1256
1257
1258 /*
1259  * initialize the picth control and sample rate
1260  */
1261 static int init_usb_pitch(struct usb_device *dev, int iface,
1262                           struct usb_host_interface *alts,
1263                           struct audioformat *fmt)
1264 {
1265         unsigned int ep;
1266         unsigned char data[1];
1267         int err;
1268
1269         ep = get_endpoint(alts, 0)->bEndpointAddress;
1270         /* if endpoint has pitch control, enable it */
1271         if (fmt->attributes & EP_CS_ATTR_PITCH_CONTROL) {
1272                 data[0] = 1;
1273                 if ((err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR,
1274                                            USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_OUT,
1275                                            PITCH_CONTROL << 8, ep, data, 1, 1000)) < 0) {
1276                         snd_printk(KERN_ERR "%d:%d:%d: cannot set enable PITCH\n",
1277                                    dev->devnum, iface, ep);
1278                         return err;
1279                 }
1280         }
1281         return 0;
1282 }
1283
1284 static int init_usb_sample_rate(struct usb_device *dev, int iface,
1285                                 struct usb_host_interface *alts,
1286                                 struct audioformat *fmt, int rate)
1287 {
1288         unsigned int ep;
1289         unsigned char data[3];
1290         int err;
1291
1292         ep = get_endpoint(alts, 0)->bEndpointAddress;
1293         /* if endpoint has sampling rate control, set it */
1294         if (fmt->attributes & EP_CS_ATTR_SAMPLE_RATE) {
1295                 int crate;
1296                 data[0] = rate;
1297                 data[1] = rate >> 8;
1298                 data[2] = rate >> 16;
1299                 if ((err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR,
1300                                            USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_OUT,
1301                                            SAMPLING_FREQ_CONTROL << 8, ep, data, 3, 1000)) < 0) {
1302                         snd_printk(KERN_ERR "%d:%d:%d: cannot set freq %d to ep 0x%x\n",
1303                                    dev->devnum, iface, fmt->altsetting, rate, ep);
1304                         return err;
1305                 }
1306                 if ((err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), GET_CUR,
1307                                            USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_IN,
1308                                            SAMPLING_FREQ_CONTROL << 8, ep, data, 3, 1000)) < 0) {
1309                         snd_printk(KERN_WARNING "%d:%d:%d: cannot get freq at ep 0x%x\n",
1310                                    dev->devnum, iface, fmt->altsetting, ep);
1311                         return 0; /* some devices don't support reading */
1312                 }
1313                 crate = data[0] | (data[1] << 8) | (data[2] << 16);
1314                 if (crate != rate) {
1315                         snd_printd(KERN_WARNING "current rate %d is different from the runtime rate %d\n", crate, rate);
1316                         // runtime->rate = crate;
1317                 }
1318         }
1319         return 0;
1320 }
1321
1322 /*
1323  * find a matching format and set up the interface
1324  */
1325 static int set_format(struct snd_usb_substream *subs, struct audioformat *fmt)
1326 {
1327         struct usb_device *dev = subs->dev;
1328         struct usb_host_interface *alts;
1329         struct usb_interface_descriptor *altsd;
1330         struct usb_interface *iface;
1331         unsigned int ep, attr;
1332         int is_playback = subs->direction == SNDRV_PCM_STREAM_PLAYBACK;
1333         int err;
1334
1335         iface = usb_ifnum_to_if(dev, fmt->iface);
1336         if (WARN_ON(!iface))
1337                 return -EINVAL;
1338         alts = &iface->altsetting[fmt->altset_idx];
1339         altsd = get_iface_desc(alts);
1340         if (WARN_ON(altsd->bAlternateSetting != fmt->altsetting))
1341                 return -EINVAL;
1342
1343         if (fmt == subs->cur_audiofmt)
1344                 return 0;
1345
1346         /* close the old interface */
1347         if (subs->interface >= 0 && subs->interface != fmt->iface) {
1348                 if (usb_set_interface(subs->dev, subs->interface, 0) < 0) {
1349                         snd_printk(KERN_ERR "%d:%d:%d: return to setting 0 failed\n",
1350                                 dev->devnum, fmt->iface, fmt->altsetting);
1351                         return -EIO;
1352                 }
1353                 subs->interface = -1;
1354                 subs->format = 0;
1355         }
1356
1357         /* set interface */
1358         if (subs->interface != fmt->iface || subs->format != fmt->altset_idx) {
1359                 if (usb_set_interface(dev, fmt->iface, fmt->altsetting) < 0) {
1360                         snd_printk(KERN_ERR "%d:%d:%d: usb_set_interface failed\n",
1361                                    dev->devnum, fmt->iface, fmt->altsetting);
1362                         return -EIO;
1363                 }
1364                 snd_printdd(KERN_INFO "setting usb interface %d:%d\n", fmt->iface, fmt->altsetting);
1365                 subs->interface = fmt->iface;
1366                 subs->format = fmt->altset_idx;
1367         }
1368
1369         /* create a data pipe */
1370         ep = fmt->endpoint & USB_ENDPOINT_NUMBER_MASK;
1371         if (is_playback)
1372                 subs->datapipe = usb_sndisocpipe(dev, ep);
1373         else
1374                 subs->datapipe = usb_rcvisocpipe(dev, ep);
1375         if (snd_usb_get_speed(subs->dev) == USB_SPEED_HIGH &&
1376             get_endpoint(alts, 0)->bInterval >= 1 &&
1377             get_endpoint(alts, 0)->bInterval <= 4)
1378                 subs->datainterval = get_endpoint(alts, 0)->bInterval - 1;
1379         else
1380                 subs->datainterval = 0;
1381         subs->syncpipe = subs->syncinterval = 0;
1382         subs->maxpacksize = fmt->maxpacksize;
1383         subs->fill_max = 0;
1384
1385         /* we need a sync pipe in async OUT or adaptive IN mode */
1386         /* check the number of EP, since some devices have broken
1387          * descriptors which fool us.  if it has only one EP,
1388          * assume it as adaptive-out or sync-in.
1389          */
1390         attr = fmt->ep_attr & EP_ATTR_MASK;
1391         if (((is_playback && attr == EP_ATTR_ASYNC) ||
1392              (! is_playback && attr == EP_ATTR_ADAPTIVE)) &&
1393             altsd->bNumEndpoints >= 2) {
1394                 /* check sync-pipe endpoint */
1395                 /* ... and check descriptor size before accessing bSynchAddress
1396                    because there is a version of the SB Audigy 2 NX firmware lacking
1397                    the audio fields in the endpoint descriptors */
1398                 if ((get_endpoint(alts, 1)->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) != 0x01 ||
1399                     (get_endpoint(alts, 1)->bLength >= USB_DT_ENDPOINT_AUDIO_SIZE &&
1400                      get_endpoint(alts, 1)->bSynchAddress != 0)) {
1401                         snd_printk(KERN_ERR "%d:%d:%d : invalid synch pipe\n",
1402                                    dev->devnum, fmt->iface, fmt->altsetting);
1403                         return -EINVAL;
1404                 }
1405                 ep = get_endpoint(alts, 1)->bEndpointAddress;
1406                 if (get_endpoint(alts, 0)->bLength >= USB_DT_ENDPOINT_AUDIO_SIZE &&
1407                     (( is_playback && ep != (unsigned int)(get_endpoint(alts, 0)->bSynchAddress | USB_DIR_IN)) ||
1408                      (!is_playback && ep != (unsigned int)(get_endpoint(alts, 0)->bSynchAddress & ~USB_DIR_IN)))) {
1409                         snd_printk(KERN_ERR "%d:%d:%d : invalid synch pipe\n",
1410                                    dev->devnum, fmt->iface, fmt->altsetting);
1411                         return -EINVAL;
1412                 }
1413                 ep &= USB_ENDPOINT_NUMBER_MASK;
1414                 if (is_playback)
1415                         subs->syncpipe = usb_rcvisocpipe(dev, ep);
1416                 else
1417                         subs->syncpipe = usb_sndisocpipe(dev, ep);
1418                 if (get_endpoint(alts, 1)->bLength >= USB_DT_ENDPOINT_AUDIO_SIZE &&
1419                     get_endpoint(alts, 1)->bRefresh >= 1 &&
1420                     get_endpoint(alts, 1)->bRefresh <= 9)
1421                         subs->syncinterval = get_endpoint(alts, 1)->bRefresh;
1422                 else if (snd_usb_get_speed(subs->dev) == USB_SPEED_FULL)
1423                         subs->syncinterval = 1;
1424                 else if (get_endpoint(alts, 1)->bInterval >= 1 &&
1425                          get_endpoint(alts, 1)->bInterval <= 16)
1426                         subs->syncinterval = get_endpoint(alts, 1)->bInterval - 1;
1427                 else
1428                         subs->syncinterval = 3;
1429         }
1430
1431         /* always fill max packet size */
1432         if (fmt->attributes & EP_CS_ATTR_FILL_MAX)
1433                 subs->fill_max = 1;
1434
1435         if ((err = init_usb_pitch(dev, subs->interface, alts, fmt)) < 0)
1436                 return err;
1437
1438         subs->cur_audiofmt = fmt;
1439
1440 #if 0
1441         printk("setting done: format = %d, rate = %d..%d, channels = %d\n",
1442                fmt->format, fmt->rate_min, fmt->rate_max, fmt->channels);
1443         printk("  datapipe = 0x%0x, syncpipe = 0x%0x\n",
1444                subs->datapipe, subs->syncpipe);
1445 #endif
1446
1447         return 0;
1448 }
1449
1450 /*
1451  * hw_params callback
1452  *
1453  * allocate a buffer and set the given audio format.
1454  *
1455  * so far we use a physically linear buffer although packetize transfer
1456  * doesn't need a continuous area.
1457  * if sg buffer is supported on the later version of alsa, we'll follow
1458  * that.
1459  */
1460 static int snd_usb_hw_params(struct snd_pcm_substream *substream,
1461                              struct snd_pcm_hw_params *hw_params)
1462 {
1463         struct snd_usb_substream *subs = substream->runtime->private_data;
1464         struct audioformat *fmt;
1465         unsigned int channels, rate, format;
1466         int ret, changed;
1467
1468         ret = snd_pcm_alloc_vmalloc_buffer(substream,
1469                                            params_buffer_bytes(hw_params));
1470         if (ret < 0)
1471                 return ret;
1472
1473         format = params_format(hw_params);
1474         rate = params_rate(hw_params);
1475         channels = params_channels(hw_params);
1476         fmt = find_format(subs, format, rate, channels);
1477         if (!fmt) {
1478                 snd_printd(KERN_DEBUG "cannot set format: format = 0x%x, rate = %d, channels = %d\n",
1479                            format, rate, channels);
1480                 return -EINVAL;
1481         }
1482
1483         changed = subs->cur_audiofmt != fmt ||
1484                 subs->period_bytes != params_period_bytes(hw_params) ||
1485                 subs->cur_rate != rate;
1486         if ((ret = set_format(subs, fmt)) < 0)
1487                 return ret;
1488
1489         if (subs->cur_rate != rate) {
1490                 struct usb_host_interface *alts;
1491                 struct usb_interface *iface;
1492                 iface = usb_ifnum_to_if(subs->dev, fmt->iface);
1493                 alts = &iface->altsetting[fmt->altset_idx];
1494                 ret = init_usb_sample_rate(subs->dev, subs->interface, alts, fmt, rate);
1495                 if (ret < 0)
1496                         return ret;
1497                 subs->cur_rate = rate;
1498         }
1499
1500         if (changed) {
1501                 /* format changed */
1502                 release_substream_urbs(subs, 0);
1503                 /* influenced: period_bytes, channels, rate, format, */
1504                 ret = init_substream_urbs(subs, params_period_bytes(hw_params),
1505                                           params_rate(hw_params),
1506                                           snd_pcm_format_physical_width(params_format(hw_params)) * params_channels(hw_params));
1507         }
1508
1509         return ret;
1510 }
1511
1512 /*
1513  * hw_free callback
1514  *
1515  * reset the audio format and release the buffer
1516  */
1517 static int snd_usb_hw_free(struct snd_pcm_substream *substream)
1518 {
1519         struct snd_usb_substream *subs = substream->runtime->private_data;
1520
1521         subs->cur_audiofmt = NULL;
1522         subs->cur_rate = 0;
1523         subs->period_bytes = 0;
1524         if (!subs->stream->chip->shutdown)
1525                 release_substream_urbs(subs, 0);
1526         return snd_pcm_free_vmalloc_buffer(substream);
1527 }
1528
1529 /*
1530  * prepare callback
1531  *
1532  * only a few subtle things...
1533  */
1534 static int snd_usb_pcm_prepare(struct snd_pcm_substream *substream)
1535 {
1536         struct snd_pcm_runtime *runtime = substream->runtime;
1537         struct snd_usb_substream *subs = runtime->private_data;
1538
1539         if (! subs->cur_audiofmt) {
1540                 snd_printk(KERN_ERR "usbaudio: no format is specified!\n");
1541                 return -ENXIO;
1542         }
1543
1544         /* some unit conversions in runtime */
1545         subs->maxframesize = bytes_to_frames(runtime, subs->maxpacksize);
1546         subs->curframesize = bytes_to_frames(runtime, subs->curpacksize);
1547
1548         /* reset the pointer */
1549         subs->hwptr_done = 0;
1550         subs->transfer_done = 0;
1551         subs->phase = 0;
1552
1553         /* clear urbs (to be sure) */
1554         deactivate_urbs(subs, 0, 1);
1555         wait_clear_urbs(subs);
1556
1557         /* for playback, submit the URBs now; otherwise, the first hwptr_done
1558          * updates for all URBs would happen at the same time when starting */
1559         if (subs->direction == SNDRV_PCM_STREAM_PLAYBACK) {
1560                 subs->ops.prepare = prepare_nodata_playback_urb;
1561                 return start_urbs(subs, runtime);
1562         } else
1563                 return 0;
1564 }
1565
1566 static struct snd_pcm_hardware snd_usb_hardware =
1567 {
1568         .info =                 SNDRV_PCM_INFO_MMAP |
1569                                 SNDRV_PCM_INFO_MMAP_VALID |
1570                                 SNDRV_PCM_INFO_BATCH |
1571                                 SNDRV_PCM_INFO_INTERLEAVED |
1572                                 SNDRV_PCM_INFO_BLOCK_TRANSFER |
1573                                 SNDRV_PCM_INFO_PAUSE,
1574         .buffer_bytes_max =     1024 * 1024,
1575         .period_bytes_min =     64,
1576         .period_bytes_max =     512 * 1024,
1577         .periods_min =          2,
1578         .periods_max =          1024,
1579 };
1580
1581 /*
1582  * h/w constraints
1583  */
1584
1585 #ifdef HW_CONST_DEBUG
1586 #define hwc_debug(fmt, args...) printk(KERN_DEBUG fmt, ##args)
1587 #else
1588 #define hwc_debug(fmt, args...) /**/
1589 #endif
1590
1591 static int hw_check_valid_format(struct snd_pcm_hw_params *params, struct audioformat *fp)
1592 {
1593         struct snd_interval *it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
1594         struct snd_interval *ct = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
1595         struct snd_mask *fmts = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
1596
1597         /* check the format */
1598         if (!snd_mask_test(fmts, fp->format)) {
1599                 hwc_debug("   > check: no supported format %d\n", fp->format);
1600                 return 0;
1601         }
1602         /* check the channels */
1603         if (fp->channels < ct->min || fp->channels > ct->max) {
1604                 hwc_debug("   > check: no valid channels %d (%d/%d)\n", fp->channels, ct->min, ct->max);
1605                 return 0;
1606         }
1607         /* check the rate is within the range */
1608         if (fp->rate_min > it->max || (fp->rate_min == it->max && it->openmax)) {
1609                 hwc_debug("   > check: rate_min %d > max %d\n", fp->rate_min, it->max);
1610                 return 0;
1611         }
1612         if (fp->rate_max < it->min || (fp->rate_max == it->min && it->openmin)) {
1613                 hwc_debug("   > check: rate_max %d < min %d\n", fp->rate_max, it->min);
1614                 return 0;
1615         }
1616         return 1;
1617 }
1618
1619 static int hw_rule_rate(struct snd_pcm_hw_params *params,
1620                         struct snd_pcm_hw_rule *rule)
1621 {
1622         struct snd_usb_substream *subs = rule->private;
1623         struct list_head *p;
1624         struct snd_interval *it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
1625         unsigned int rmin, rmax;
1626         int changed;
1627
1628         hwc_debug("hw_rule_rate: (%d,%d)\n", it->min, it->max);
1629         changed = 0;
1630         rmin = rmax = 0;
1631         list_for_each(p, &subs->fmt_list) {
1632                 struct audioformat *fp;
1633                 fp = list_entry(p, struct audioformat, list);
1634                 if (!hw_check_valid_format(params, fp))
1635                         continue;
1636                 if (changed++) {
1637                         if (rmin > fp->rate_min)
1638                                 rmin = fp->rate_min;
1639                         if (rmax < fp->rate_max)
1640                                 rmax = fp->rate_max;
1641                 } else {
1642                         rmin = fp->rate_min;
1643                         rmax = fp->rate_max;
1644                 }
1645         }
1646
1647         if (!changed) {
1648                 hwc_debug("  --> get empty\n");
1649                 it->empty = 1;
1650                 return -EINVAL;
1651         }
1652
1653         changed = 0;
1654         if (it->min < rmin) {
1655                 it->min = rmin;
1656                 it->openmin = 0;
1657                 changed = 1;
1658         }
1659         if (it->max > rmax) {
1660                 it->max = rmax;
1661                 it->openmax = 0;
1662                 changed = 1;
1663         }
1664         if (snd_interval_checkempty(it)) {
1665                 it->empty = 1;
1666                 return -EINVAL;
1667         }
1668         hwc_debug("  --> (%d, %d) (changed = %d)\n", it->min, it->max, changed);
1669         return changed;
1670 }
1671
1672
1673 static int hw_rule_channels(struct snd_pcm_hw_params *params,
1674                             struct snd_pcm_hw_rule *rule)
1675 {
1676         struct snd_usb_substream *subs = rule->private;
1677         struct list_head *p;
1678         struct snd_interval *it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
1679         unsigned int rmin, rmax;
1680         int changed;
1681
1682         hwc_debug("hw_rule_channels: (%d,%d)\n", it->min, it->max);
1683         changed = 0;
1684         rmin = rmax = 0;
1685         list_for_each(p, &subs->fmt_list) {
1686                 struct audioformat *fp;
1687                 fp = list_entry(p, struct audioformat, list);
1688                 if (!hw_check_valid_format(params, fp))
1689                         continue;
1690                 if (changed++) {
1691                         if (rmin > fp->channels)
1692                                 rmin = fp->channels;
1693                         if (rmax < fp->channels)
1694                                 rmax = fp->channels;
1695                 } else {
1696                         rmin = fp->channels;
1697                         rmax = fp->channels;
1698                 }
1699         }
1700
1701         if (!changed) {
1702                 hwc_debug("  --> get empty\n");
1703                 it->empty = 1;
1704                 return -EINVAL;
1705         }
1706
1707         changed = 0;
1708         if (it->min < rmin) {
1709                 it->min = rmin;
1710                 it->openmin = 0;
1711                 changed = 1;
1712         }
1713         if (it->max > rmax) {
1714                 it->max = rmax;
1715                 it->openmax = 0;
1716                 changed = 1;
1717         }
1718         if (snd_interval_checkempty(it)) {
1719                 it->empty = 1;
1720                 return -EINVAL;
1721         }
1722         hwc_debug("  --> (%d, %d) (changed = %d)\n", it->min, it->max, changed);
1723         return changed;
1724 }
1725
1726 static int hw_rule_format(struct snd_pcm_hw_params *params,
1727                           struct snd_pcm_hw_rule *rule)
1728 {
1729         struct snd_usb_substream *subs = rule->private;
1730         struct list_head *p;
1731         struct snd_mask *fmt = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
1732         u64 fbits;
1733         u32 oldbits[2];
1734         int changed;
1735
1736         hwc_debug("hw_rule_format: %x:%x\n", fmt->bits[0], fmt->bits[1]);
1737         fbits = 0;
1738         list_for_each(p, &subs->fmt_list) {
1739                 struct audioformat *fp;
1740                 fp = list_entry(p, struct audioformat, list);
1741                 if (!hw_check_valid_format(params, fp))
1742                         continue;
1743                 fbits |= (1ULL << fp->format);
1744         }
1745
1746         oldbits[0] = fmt->bits[0];
1747         oldbits[1] = fmt->bits[1];
1748         fmt->bits[0] &= (u32)fbits;
1749         fmt->bits[1] &= (u32)(fbits >> 32);
1750         if (!fmt->bits[0] && !fmt->bits[1]) {
1751                 hwc_debug("  --> get empty\n");
1752                 return -EINVAL;
1753         }
1754         changed = (oldbits[0] != fmt->bits[0] || oldbits[1] != fmt->bits[1]);
1755         hwc_debug("  --> %x:%x (changed = %d)\n", fmt->bits[0], fmt->bits[1], changed);
1756         return changed;
1757 }
1758
1759 #define MAX_MASK        64
1760
1761 /*
1762  * check whether the registered audio formats need special hw-constraints
1763  */
1764 static int check_hw_params_convention(struct snd_usb_substream *subs)
1765 {
1766         int i;
1767         u32 *channels;
1768         u32 *rates;
1769         u32 cmaster, rmaster;
1770         u32 rate_min = 0, rate_max = 0;
1771         struct list_head *p;
1772         int err = 1;
1773
1774         channels = kcalloc(MAX_MASK, sizeof(u32), GFP_KERNEL);
1775         rates = kcalloc(MAX_MASK, sizeof(u32), GFP_KERNEL);
1776         if (!channels || !rates) {
1777                 err = -ENOMEM;
1778                 goto __out;
1779         }
1780
1781         list_for_each(p, &subs->fmt_list) {
1782                 struct audioformat *f;
1783                 f = list_entry(p, struct audioformat, list);
1784                 /* unconventional channels? */
1785                 if (f->channels > 32)
1786                         goto __out;
1787                 /* continuous rate min/max matches? */
1788                 if (f->rates & SNDRV_PCM_RATE_CONTINUOUS) {
1789                         if (rate_min && f->rate_min != rate_min)
1790                                 goto __out;
1791                         if (rate_max && f->rate_max != rate_max)
1792                                 goto __out;
1793                         rate_min = f->rate_min;
1794                         rate_max = f->rate_max;
1795                 }
1796                 /* combination of continuous rates and fixed rates? */
1797                 if (rates[f->format] & SNDRV_PCM_RATE_CONTINUOUS) {
1798                         if (f->rates != rates[f->format])
1799                                 goto __out;
1800                 }
1801                 if (f->rates & SNDRV_PCM_RATE_CONTINUOUS) {
1802                         if (rates[f->format] && rates[f->format] != f->rates)
1803                                 goto __out;
1804                 }
1805                 channels[f->format] |= (1 << f->channels);
1806                 rates[f->format] |= f->rates;
1807                 /* needs knot? */
1808                 if (f->rates & SNDRV_PCM_RATE_KNOT)
1809                         goto __out;
1810         }
1811         /* check whether channels and rates match for all formats */
1812         cmaster = rmaster = 0;
1813         for (i = 0; i < MAX_MASK; i++) {
1814                 if (cmaster != channels[i] && cmaster && channels[i])
1815                         goto __out;
1816                 if (rmaster != rates[i] && rmaster && rates[i])
1817                         goto __out;
1818                 if (channels[i])
1819                         cmaster = channels[i];
1820                 if (rates[i])
1821                         rmaster = rates[i];
1822         }
1823         /* check whether channels match for all distinct rates */
1824         memset(channels, 0, MAX_MASK * sizeof(u32));
1825         list_for_each(p, &subs->fmt_list) {
1826                 struct audioformat *f;
1827                 f = list_entry(p, struct audioformat, list);
1828                 if (f->rates & SNDRV_PCM_RATE_CONTINUOUS)
1829                         continue;
1830                 for (i = 0; i < 32; i++) {
1831                         if (f->rates & (1 << i))
1832                                 channels[i] |= (1 << f->channels);
1833                 }
1834         }
1835         cmaster = 0;
1836         for (i = 0; i < 32; i++) {
1837                 if (cmaster != channels[i] && cmaster && channels[i])
1838                         goto __out;
1839                 if (channels[i])
1840                         cmaster = channels[i];
1841         }
1842         err = 0;
1843
1844  __out:
1845         kfree(channels);
1846         kfree(rates);
1847         return err;
1848 }
1849
1850 /*
1851  *  If the device supports unusual bit rates, does the request meet these?
1852  */
1853 static int snd_usb_pcm_check_knot(struct snd_pcm_runtime *runtime,
1854                                   struct snd_usb_substream *subs)
1855 {
1856         struct audioformat *fp;
1857         int count = 0, needs_knot = 0;
1858         int err;
1859
1860         list_for_each_entry(fp, &subs->fmt_list, list) {
1861                 if (fp->rates & SNDRV_PCM_RATE_CONTINUOUS)
1862                         return 0;
1863                 count += fp->nr_rates;
1864                 if (fp->rates & SNDRV_PCM_RATE_KNOT)
1865                         needs_knot = 1;
1866         }
1867         if (!needs_knot)
1868                 return 0;
1869
1870         subs->rate_list.count = count;
1871         subs->rate_list.list = kmalloc(sizeof(int) * count, GFP_KERNEL);
1872         subs->rate_list.mask = 0;
1873         count = 0;
1874         list_for_each_entry(fp, &subs->fmt_list, list) {
1875                 int i;
1876                 for (i = 0; i < fp->nr_rates; i++)
1877                         subs->rate_list.list[count++] = fp->rate_table[i];
1878         }
1879         err = snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
1880                                          &subs->rate_list);
1881         if (err < 0)
1882                 return err;
1883
1884         return 0;
1885 }
1886
1887
1888 /*
1889  * set up the runtime hardware information.
1890  */
1891
1892 static int setup_hw_info(struct snd_pcm_runtime *runtime, struct snd_usb_substream *subs)
1893 {
1894         struct list_head *p;
1895         int err;
1896
1897         runtime->hw.formats = subs->formats;
1898
1899         runtime->hw.rate_min = 0x7fffffff;
1900         runtime->hw.rate_max = 0;
1901         runtime->hw.channels_min = 256;
1902         runtime->hw.channels_max = 0;
1903         runtime->hw.rates = 0;
1904         /* check min/max rates and channels */
1905         list_for_each(p, &subs->fmt_list) {
1906                 struct audioformat *fp;
1907                 fp = list_entry(p, struct audioformat, list);
1908                 runtime->hw.rates |= fp->rates;
1909                 if (runtime->hw.rate_min > fp->rate_min)
1910                         runtime->hw.rate_min = fp->rate_min;
1911                 if (runtime->hw.rate_max < fp->rate_max)
1912                         runtime->hw.rate_max = fp->rate_max;
1913                 if (runtime->hw.channels_min > fp->channels)
1914                         runtime->hw.channels_min = fp->channels;
1915                 if (runtime->hw.channels_max < fp->channels)
1916                         runtime->hw.channels_max = fp->channels;
1917                 if (fp->fmt_type == USB_FORMAT_TYPE_II && fp->frame_size > 0) {
1918                         /* FIXME: there might be more than one audio formats... */
1919                         runtime->hw.period_bytes_min = runtime->hw.period_bytes_max =
1920                                 fp->frame_size;
1921                 }
1922         }
1923
1924         /* set the period time minimum 1ms */
1925         /* FIXME: high-speed mode allows 125us minimum period, but many parts
1926          * in the current code assume the 1ms period.
1927          */
1928         snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIOD_TIME,
1929                                      1000 * MIN_PACKS_URB,
1930                                      /*(nrpacks * MAX_URBS) * 1000*/ UINT_MAX);
1931
1932         err = check_hw_params_convention(subs);
1933         if (err < 0)
1934                 return err;
1935         else if (err) {
1936                 hwc_debug("setting extra hw constraints...\n");
1937                 if ((err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
1938                                                hw_rule_rate, subs,
1939                                                SNDRV_PCM_HW_PARAM_FORMAT,
1940                                                SNDRV_PCM_HW_PARAM_CHANNELS,
1941                                                -1)) < 0)
1942                         return err;
1943                 if ((err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
1944                                                hw_rule_channels, subs,
1945                                                SNDRV_PCM_HW_PARAM_FORMAT,
1946                                                SNDRV_PCM_HW_PARAM_RATE,
1947                                                -1)) < 0)
1948                         return err;
1949                 if ((err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_FORMAT,
1950                                                hw_rule_format, subs,
1951                                                SNDRV_PCM_HW_PARAM_RATE,
1952                                                SNDRV_PCM_HW_PARAM_CHANNELS,
1953                                                -1)) < 0)
1954                         return err;
1955                 if ((err = snd_usb_pcm_check_knot(runtime, subs)) < 0)
1956                         return err;
1957         }
1958         return 0;
1959 }
1960
1961 static int snd_usb_pcm_open(struct snd_pcm_substream *substream, int direction)
1962 {
1963         struct snd_usb_stream *as = snd_pcm_substream_chip(substream);
1964         struct snd_pcm_runtime *runtime = substream->runtime;
1965         struct snd_usb_substream *subs = &as->substream[direction];
1966
1967         subs->interface = -1;
1968         subs->format = 0;
1969         runtime->hw = snd_usb_hardware;
1970         runtime->private_data = subs;
1971         subs->pcm_substream = substream;
1972         return setup_hw_info(runtime, subs);
1973 }
1974
1975 static int snd_usb_pcm_close(struct snd_pcm_substream *substream, int direction)
1976 {
1977         struct snd_usb_stream *as = snd_pcm_substream_chip(substream);
1978         struct snd_usb_substream *subs = &as->substream[direction];
1979
1980         if (subs->interface >= 0) {
1981                 usb_set_interface(subs->dev, subs->interface, 0);
1982                 subs->interface = -1;
1983         }
1984         subs->pcm_substream = NULL;
1985         return 0;
1986 }
1987
1988 static int snd_usb_playback_open(struct snd_pcm_substream *substream)
1989 {
1990         return snd_usb_pcm_open(substream, SNDRV_PCM_STREAM_PLAYBACK);
1991 }
1992
1993 static int snd_usb_playback_close(struct snd_pcm_substream *substream)
1994 {
1995         return snd_usb_pcm_close(substream, SNDRV_PCM_STREAM_PLAYBACK);
1996 }
1997
1998 static int snd_usb_capture_open(struct snd_pcm_substream *substream)
1999 {
2000         return snd_usb_pcm_open(substream, SNDRV_PCM_STREAM_CAPTURE);
2001 }
2002
2003 static int snd_usb_capture_close(struct snd_pcm_substream *substream)
2004 {
2005         return snd_usb_pcm_close(substream, SNDRV_PCM_STREAM_CAPTURE);
2006 }
2007
2008 static struct snd_pcm_ops snd_usb_playback_ops = {
2009         .open =         snd_usb_playback_open,
2010         .close =        snd_usb_playback_close,
2011         .ioctl =        snd_pcm_lib_ioctl,
2012         .hw_params =    snd_usb_hw_params,
2013         .hw_free =      snd_usb_hw_free,
2014         .prepare =      snd_usb_pcm_prepare,
2015         .trigger =      snd_usb_pcm_playback_trigger,
2016         .pointer =      snd_usb_pcm_pointer,
2017         .page =         snd_pcm_get_vmalloc_page,
2018 };
2019
2020 static struct snd_pcm_ops snd_usb_capture_ops = {
2021         .open =         snd_usb_capture_open,
2022         .close =        snd_usb_capture_close,
2023         .ioctl =        snd_pcm_lib_ioctl,
2024         .hw_params =    snd_usb_hw_params,
2025         .hw_free =      snd_usb_hw_free,
2026         .prepare =      snd_usb_pcm_prepare,
2027         .trigger =      snd_usb_pcm_capture_trigger,
2028         .pointer =      snd_usb_pcm_pointer,
2029         .page =         snd_pcm_get_vmalloc_page,
2030 };
2031
2032
2033
2034 /*
2035  * helper functions
2036  */
2037
2038 /*
2039  * combine bytes and get an integer value
2040  */
2041 unsigned int snd_usb_combine_bytes(unsigned char *bytes, int size)
2042 {
2043         switch (size) {
2044         case 1:  return *bytes;
2045         case 2:  return combine_word(bytes);
2046         case 3:  return combine_triple(bytes);
2047         case 4:  return combine_quad(bytes);
2048         default: return 0;
2049         }
2050 }
2051
2052 /*
2053  * parse descriptor buffer and return the pointer starting the given
2054  * descriptor type.
2055  */
2056 void *snd_usb_find_desc(void *descstart, int desclen, void *after, u8 dtype)
2057 {
2058         u8 *p, *end, *next;
2059
2060         p = descstart;
2061         end = p + desclen;
2062         for (; p < end;) {
2063                 if (p[0] < 2)
2064                         return NULL;
2065                 next = p + p[0];
2066                 if (next > end)
2067                         return NULL;
2068                 if (p[1] == dtype && (!after || (void *)p > after)) {
2069                         return p;
2070                 }
2071                 p = next;
2072         }
2073         return NULL;
2074 }
2075
2076 /*
2077  * find a class-specified interface descriptor with the given subtype.
2078  */
2079 void *snd_usb_find_csint_desc(void *buffer, int buflen, void *after, u8 dsubtype)
2080 {
2081         unsigned char *p = after;
2082
2083         while ((p = snd_usb_find_desc(buffer, buflen, p,
2084                                       USB_DT_CS_INTERFACE)) != NULL) {
2085                 if (p[0] >= 3 && p[2] == dsubtype)
2086                         return p;
2087         }
2088         return NULL;
2089 }
2090
2091 /*
2092  * Wrapper for usb_control_msg().
2093  * Allocates a temp buffer to prevent dmaing from/to the stack.
2094  */
2095 int snd_usb_ctl_msg(struct usb_device *dev, unsigned int pipe, __u8 request,
2096                     __u8 requesttype, __u16 value, __u16 index, void *data,
2097                     __u16 size, int timeout)
2098 {
2099         int err;
2100         void *buf = NULL;
2101
2102         if (size > 0) {
2103                 buf = kmemdup(data, size, GFP_KERNEL);
2104                 if (!buf)
2105                         return -ENOMEM;
2106         }
2107         err = usb_control_msg(dev, pipe, request, requesttype,
2108                               value, index, buf, size, timeout);
2109         if (size > 0) {
2110                 memcpy(data, buf, size);
2111                 kfree(buf);
2112         }
2113         return err;
2114 }
2115
2116
2117 /*
2118  * entry point for linux usb interface
2119  */
2120
2121 static int usb_audio_probe(struct usb_interface *intf,
2122                            const struct usb_device_id *id);
2123 static void usb_audio_disconnect(struct usb_interface *intf);
2124
2125 #ifdef CONFIG_PM
2126 static int usb_audio_suspend(struct usb_interface *intf, pm_message_t message);
2127 static int usb_audio_resume(struct usb_interface *intf);
2128 #else
2129 #define usb_audio_suspend NULL
2130 #define usb_audio_resume NULL
2131 #endif
2132
2133 static struct usb_device_id usb_audio_ids [] = {
2134 #include "usbquirks.h"
2135     { .match_flags = (USB_DEVICE_ID_MATCH_INT_CLASS | USB_DEVICE_ID_MATCH_INT_SUBCLASS),
2136       .bInterfaceClass = USB_CLASS_AUDIO,
2137       .bInterfaceSubClass = USB_SUBCLASS_AUDIO_CONTROL },
2138     { }                                         /* Terminating entry */
2139 };
2140
2141 MODULE_DEVICE_TABLE (usb, usb_audio_ids);
2142
2143 static struct usb_driver usb_audio_driver = {
2144         .name =         "snd-usb-audio",
2145         .probe =        usb_audio_probe,
2146         .disconnect =   usb_audio_disconnect,
2147         .suspend =      usb_audio_suspend,
2148         .resume =       usb_audio_resume,
2149         .id_table =     usb_audio_ids,
2150 };
2151
2152
2153 #if defined(CONFIG_PROC_FS) && defined(CONFIG_SND_VERBOSE_PROCFS)
2154
2155 /*
2156  * proc interface for list the supported pcm formats
2157  */
2158 static void proc_dump_substream_formats(struct snd_usb_substream *subs, struct snd_info_buffer *buffer)
2159 {
2160         struct list_head *p;
2161         static char *sync_types[4] = {
2162                 "NONE", "ASYNC", "ADAPTIVE", "SYNC"
2163         };
2164
2165         list_for_each(p, &subs->fmt_list) {
2166                 struct audioformat *fp;
2167                 fp = list_entry(p, struct audioformat, list);
2168                 snd_iprintf(buffer, "  Interface %d\n", fp->iface);
2169                 snd_iprintf(buffer, "    Altset %d\n", fp->altsetting);
2170                 snd_iprintf(buffer, "    Format: 0x%x\n", fp->format);
2171                 snd_iprintf(buffer, "    Channels: %d\n", fp->channels);
2172                 snd_iprintf(buffer, "    Endpoint: %d %s (%s)\n",
2173                             fp->endpoint & USB_ENDPOINT_NUMBER_MASK,
2174                             fp->endpoint & USB_DIR_IN ? "IN" : "OUT",
2175                             sync_types[(fp->ep_attr & EP_ATTR_MASK) >> 2]);
2176                 if (fp->rates & SNDRV_PCM_RATE_CONTINUOUS) {
2177                         snd_iprintf(buffer, "    Rates: %d - %d (continuous)\n",
2178                                     fp->rate_min, fp->rate_max);
2179                 } else {
2180                         unsigned int i;
2181                         snd_iprintf(buffer, "    Rates: ");
2182                         for (i = 0; i < fp->nr_rates; i++) {
2183                                 if (i > 0)
2184                                         snd_iprintf(buffer, ", ");
2185                                 snd_iprintf(buffer, "%d", fp->rate_table[i]);
2186                         }
2187                         snd_iprintf(buffer, "\n");
2188                 }
2189                 // snd_iprintf(buffer, "    Max Packet Size = %d\n", fp->maxpacksize);
2190                 // snd_iprintf(buffer, "    EP Attribute = 0x%x\n", fp->attributes);
2191         }
2192 }
2193
2194 static void proc_dump_substream_status(struct snd_usb_substream *subs, struct snd_info_buffer *buffer)
2195 {
2196         if (subs->running) {
2197                 unsigned int i;
2198                 snd_iprintf(buffer, "  Status: Running\n");
2199                 snd_iprintf(buffer, "    Interface = %d\n", subs->interface);
2200                 snd_iprintf(buffer, "    Altset = %d\n", subs->format);
2201                 snd_iprintf(buffer, "    URBs = %d [ ", subs->nurbs);
2202                 for (i = 0; i < subs->nurbs; i++)
2203                         snd_iprintf(buffer, "%d ", subs->dataurb[i].packets);
2204                 snd_iprintf(buffer, "]\n");
2205                 snd_iprintf(buffer, "    Packet Size = %d\n", subs->curpacksize);
2206                 snd_iprintf(buffer, "    Momentary freq = %u Hz (%#x.%04x)\n",
2207                             snd_usb_get_speed(subs->dev) == USB_SPEED_FULL
2208                             ? get_full_speed_hz(subs->freqm)
2209                             : get_high_speed_hz(subs->freqm),
2210                             subs->freqm >> 16, subs->freqm & 0xffff);
2211         } else {
2212                 snd_iprintf(buffer, "  Status: Stop\n");
2213         }
2214 }
2215
2216 static void proc_pcm_format_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
2217 {
2218         struct snd_usb_stream *stream = entry->private_data;
2219
2220         snd_iprintf(buffer, "%s : %s\n", stream->chip->card->longname, stream->pcm->name);
2221
2222         if (stream->substream[SNDRV_PCM_STREAM_PLAYBACK].num_formats) {
2223                 snd_iprintf(buffer, "\nPlayback:\n");
2224                 proc_dump_substream_status(&stream->substream[SNDRV_PCM_STREAM_PLAYBACK], buffer);
2225                 proc_dump_substream_formats(&stream->substream[SNDRV_PCM_STREAM_PLAYBACK], buffer);
2226         }
2227         if (stream->substream[SNDRV_PCM_STREAM_CAPTURE].num_formats) {
2228                 snd_iprintf(buffer, "\nCapture:\n");
2229                 proc_dump_substream_status(&stream->substream[SNDRV_PCM_STREAM_CAPTURE], buffer);
2230                 proc_dump_substream_formats(&stream->substream[SNDRV_PCM_STREAM_CAPTURE], buffer);
2231         }
2232 }
2233
2234 static void proc_pcm_format_add(struct snd_usb_stream *stream)
2235 {
2236         struct snd_info_entry *entry;
2237         char name[32];
2238         struct snd_card *card = stream->chip->card;
2239
2240         sprintf(name, "stream%d", stream->pcm_index);
2241         if (!snd_card_proc_new(card, name, &entry))
2242                 snd_info_set_text_ops(entry, stream, proc_pcm_format_read);
2243 }
2244
2245 #else
2246
2247 static inline void proc_pcm_format_add(struct snd_usb_stream *stream)
2248 {
2249 }
2250
2251 #endif
2252
2253 /*
2254  * initialize the substream instance.
2255  */
2256
2257 static void init_substream(struct snd_usb_stream *as, int stream, struct audioformat *fp)
2258 {
2259         struct snd_usb_substream *subs = &as->substream[stream];
2260
2261         INIT_LIST_HEAD(&subs->fmt_list);
2262         spin_lock_init(&subs->lock);
2263
2264         subs->stream = as;
2265         subs->direction = stream;
2266         subs->dev = as->chip->dev;
2267         if (snd_usb_get_speed(subs->dev) == USB_SPEED_FULL) {
2268                 subs->ops = audio_urb_ops[stream];
2269         } else {
2270                 subs->ops = audio_urb_ops_high_speed[stream];
2271                 switch (as->chip->usb_id) {
2272                 case USB_ID(0x041e, 0x3f02): /* E-Mu 0202 USB */
2273                 case USB_ID(0x041e, 0x3f04): /* E-Mu 0404 USB */
2274                 case USB_ID(0x041e, 0x3f0a): /* E-Mu Tracker Pre */
2275                         subs->ops.retire_sync = retire_playback_sync_urb_hs_emu;
2276                         break;
2277                 }
2278         }
2279         snd_pcm_set_ops(as->pcm, stream,
2280                         stream == SNDRV_PCM_STREAM_PLAYBACK ?
2281                         &snd_usb_playback_ops : &snd_usb_capture_ops);
2282
2283         list_add_tail(&fp->list, &subs->fmt_list);
2284         subs->formats |= 1ULL << fp->format;
2285         subs->endpoint = fp->endpoint;
2286         subs->num_formats++;
2287         subs->fmt_type = fp->fmt_type;
2288 }
2289
2290
2291 /*
2292  * free a substream
2293  */
2294 static void free_substream(struct snd_usb_substream *subs)
2295 {
2296         struct list_head *p, *n;
2297
2298         if (!subs->num_formats)
2299                 return; /* not initialized */
2300         list_for_each_safe(p, n, &subs->fmt_list) {
2301                 struct audioformat *fp = list_entry(p, struct audioformat, list);
2302                 kfree(fp->rate_table);
2303                 kfree(fp);
2304         }
2305         kfree(subs->rate_list.list);
2306 }
2307
2308
2309 /*
2310  * free a usb stream instance
2311  */
2312 static void snd_usb_audio_stream_free(struct snd_usb_stream *stream)
2313 {
2314         free_substream(&stream->substream[0]);
2315         free_substream(&stream->substream[1]);
2316         list_del(&stream->list);
2317         kfree(stream);
2318 }
2319
2320 static void snd_usb_audio_pcm_free(struct snd_pcm *pcm)
2321 {
2322         struct snd_usb_stream *stream = pcm->private_data;
2323         if (stream) {
2324                 stream->pcm = NULL;
2325                 snd_usb_audio_stream_free(stream);
2326         }
2327 }
2328
2329
2330 /*
2331  * add this endpoint to the chip instance.
2332  * if a stream with the same endpoint already exists, append to it.
2333  * if not, create a new pcm stream.
2334  */
2335 static int add_audio_endpoint(struct snd_usb_audio *chip, int stream, struct audioformat *fp)
2336 {
2337         struct list_head *p;
2338         struct snd_usb_stream *as;
2339         struct snd_usb_substream *subs;
2340         struct snd_pcm *pcm;
2341         int err;
2342
2343         list_for_each(p, &chip->pcm_list) {
2344                 as = list_entry(p, struct snd_usb_stream, list);
2345                 if (as->fmt_type != fp->fmt_type)
2346                         continue;
2347                 subs = &as->substream[stream];
2348                 if (!subs->endpoint)
2349                         continue;
2350                 if (subs->endpoint == fp->endpoint) {
2351                         list_add_tail(&fp->list, &subs->fmt_list);
2352                         subs->num_formats++;
2353                         subs->formats |= 1ULL << fp->format;
2354                         return 0;
2355                 }
2356         }
2357         /* look for an empty stream */
2358         list_for_each(p, &chip->pcm_list) {
2359                 as = list_entry(p, struct snd_usb_stream, list);
2360                 if (as->fmt_type != fp->fmt_type)
2361                         continue;
2362                 subs = &as->substream[stream];
2363                 if (subs->endpoint)
2364                         continue;
2365                 err = snd_pcm_new_stream(as->pcm, stream, 1);
2366                 if (err < 0)
2367                         return err;
2368                 init_substream(as, stream, fp);
2369                 return 0;
2370         }
2371
2372         /* create a new pcm */
2373         as = kzalloc(sizeof(*as), GFP_KERNEL);
2374         if (!as)
2375                 return -ENOMEM;
2376         as->pcm_index = chip->pcm_devs;
2377         as->chip = chip;
2378         as->fmt_type = fp->fmt_type;
2379         err = snd_pcm_new(chip->card, "USB Audio", chip->pcm_devs,
2380                           stream == SNDRV_PCM_STREAM_PLAYBACK ? 1 : 0,
2381                           stream == SNDRV_PCM_STREAM_PLAYBACK ? 0 : 1,
2382                           &pcm);
2383         if (err < 0) {
2384                 kfree(as);
2385                 return err;
2386         }
2387         as->pcm = pcm;
2388         pcm->private_data = as;
2389         pcm->private_free = snd_usb_audio_pcm_free;
2390         pcm->info_flags = 0;
2391         if (chip->pcm_devs > 0)
2392                 sprintf(pcm->name, "USB Audio #%d", chip->pcm_devs);
2393         else
2394                 strcpy(pcm->name, "USB Audio");
2395
2396         init_substream(as, stream, fp);
2397
2398         list_add(&as->list, &chip->pcm_list);
2399         chip->pcm_devs++;
2400
2401         proc_pcm_format_add(as);
2402
2403         return 0;
2404 }
2405
2406
2407 /*
2408  * check if the device uses big-endian samples
2409  */
2410 static int is_big_endian_format(struct snd_usb_audio *chip, struct audioformat *fp)
2411 {
2412         switch (chip->usb_id) {
2413         case USB_ID(0x0763, 0x2001): /* M-Audio Quattro: captured data only */
2414                 if (fp->endpoint & USB_DIR_IN)
2415                         return 1;
2416                 break;
2417         case USB_ID(0x0763, 0x2003): /* M-Audio Audiophile USB */
2418                 if (device_setup[chip->index] == 0x00 ||
2419                     fp->altsetting==1 || fp->altsetting==2 || fp->altsetting==3)
2420                         return 1;
2421         }
2422         return 0;
2423 }
2424
2425 /*
2426  * parse the audio format type I descriptor
2427  * and returns the corresponding pcm format
2428  *
2429  * @dev: usb device
2430  * @fp: audioformat record
2431  * @format: the format tag (wFormatTag)
2432  * @fmt: the format type descriptor
2433  */
2434 static int parse_audio_format_i_type(struct snd_usb_audio *chip, struct audioformat *fp,
2435                                      int format, unsigned char *fmt)
2436 {
2437         int pcm_format;
2438         int sample_width, sample_bytes;
2439
2440         /* FIXME: correct endianess and sign? */
2441         pcm_format = -1;
2442         sample_width = fmt[6];
2443         sample_bytes = fmt[5];
2444         switch (format) {
2445         case 0: /* some devices don't define this correctly... */
2446                 snd_printdd(KERN_INFO "%d:%u:%d : format type 0 is detected, processed as PCM\n",
2447                             chip->dev->devnum, fp->iface, fp->altsetting);
2448                 /* fall-through */
2449         case USB_AUDIO_FORMAT_PCM:
2450                 if (sample_width > sample_bytes * 8) {
2451                         snd_printk(KERN_INFO "%d:%u:%d : sample bitwidth %d in over sample bytes %d\n",
2452                                    chip->dev->devnum, fp->iface, fp->altsetting,
2453                                    sample_width, sample_bytes);
2454                 }
2455                 /* check the format byte size */
2456                 switch (fmt[5]) {
2457                 case 1:
2458                         pcm_format = SNDRV_PCM_FORMAT_S8;
2459                         break;
2460                 case 2:
2461                         if (is_big_endian_format(chip, fp))
2462                                 pcm_format = SNDRV_PCM_FORMAT_S16_BE; /* grrr, big endian!! */
2463                         else
2464                                 pcm_format = SNDRV_PCM_FORMAT_S16_LE;
2465                         break;
2466                 case 3:
2467                         if (is_big_endian_format(chip, fp))
2468                                 pcm_format = SNDRV_PCM_FORMAT_S24_3BE; /* grrr, big endian!! */
2469                         else
2470                                 pcm_format = SNDRV_PCM_FORMAT_S24_3LE;
2471                         break;
2472                 case 4:
2473                         pcm_format = SNDRV_PCM_FORMAT_S32_LE;
2474                         break;
2475                 default:
2476                         snd_printk(KERN_INFO "%d:%u:%d : unsupported sample bitwidth %d in %d bytes\n",
2477                                    chip->dev->devnum, fp->iface,
2478                                    fp->altsetting, sample_width, sample_bytes);
2479                         break;
2480                 }
2481                 break;
2482         case USB_AUDIO_FORMAT_PCM8:
2483                 pcm_format = SNDRV_PCM_FORMAT_U8;
2484
2485                 /* Dallas DS4201 workaround: it advertises U8 format, but really
2486                    supports S8. */
2487                 if (chip->usb_id == USB_ID(0x04fa, 0x4201))
2488                         pcm_format = SNDRV_PCM_FORMAT_S8;
2489                 break;
2490         case USB_AUDIO_FORMAT_IEEE_FLOAT:
2491                 pcm_format = SNDRV_PCM_FORMAT_FLOAT_LE;
2492                 break;
2493         case USB_AUDIO_FORMAT_ALAW:
2494                 pcm_format = SNDRV_PCM_FORMAT_A_LAW;
2495                 break;
2496         case USB_AUDIO_FORMAT_MU_LAW:
2497                 pcm_format = SNDRV_PCM_FORMAT_MU_LAW;
2498                 break;
2499         default:
2500                 snd_printk(KERN_INFO "%d:%u:%d : unsupported format type %d\n",
2501                            chip->dev->devnum, fp->iface, fp->altsetting, format);
2502                 break;
2503         }
2504         return pcm_format;
2505 }
2506
2507
2508 /*
2509  * parse the format descriptor and stores the possible sample rates
2510  * on the audioformat table.
2511  *
2512  * @dev: usb device
2513  * @fp: audioformat record
2514  * @fmt: the format descriptor
2515  * @offset: the start offset of descriptor pointing the rate type
2516  *          (7 for type I and II, 8 for type II)
2517  */
2518 static int parse_audio_format_rates(struct snd_usb_audio *chip, struct audioformat *fp,
2519                                     unsigned char *fmt, int offset)
2520 {
2521         int nr_rates = fmt[offset];
2522
2523         if (fmt[0] < offset + 1 + 3 * (nr_rates ? nr_rates : 2)) {
2524                 snd_printk(KERN_ERR "%d:%u:%d : invalid FORMAT_TYPE desc\n",
2525                                    chip->dev->devnum, fp->iface, fp->altsetting);
2526                 return -1;
2527         }
2528
2529         if (nr_rates) {
2530                 /*
2531                  * build the rate table and bitmap flags
2532                  */
2533                 int r, idx;
2534                 unsigned int nonzero_rates = 0;
2535
2536                 fp->rate_table = kmalloc(sizeof(int) * nr_rates, GFP_KERNEL);
2537                 if (fp->rate_table == NULL) {
2538                         snd_printk(KERN_ERR "cannot malloc\n");
2539                         return -1;
2540                 }
2541
2542                 fp->nr_rates = nr_rates;
2543                 fp->rate_min = fp->rate_max = combine_triple(&fmt[8]);
2544                 for (r = 0, idx = offset + 1; r < nr_rates; r++, idx += 3) {
2545                         unsigned int rate = combine_triple(&fmt[idx]);
2546                         /* C-Media CM6501 mislabels its 96 kHz altsetting */
2547                         if (rate == 48000 && nr_rates == 1 &&
2548                             chip->usb_id == USB_ID(0x0d8c, 0x0201) &&
2549                             fp->altsetting == 5 && fp->maxpacksize == 392)
2550                                 rate = 96000;
2551                         fp->rate_table[r] = rate;
2552                         nonzero_rates |= rate;
2553                         if (rate < fp->rate_min)
2554                                 fp->rate_min = rate;
2555                         else if (rate > fp->rate_max)
2556                                 fp->rate_max = rate;
2557                         fp->rates |= snd_pcm_rate_to_rate_bit(rate);
2558                 }
2559                 if (!nonzero_rates) {
2560                         hwc_debug("All rates were zero. Skipping format!\n");
2561                         return -1;
2562                 }
2563         } else {
2564                 /* continuous rates */
2565                 fp->rates = SNDRV_PCM_RATE_CONTINUOUS;
2566                 fp->rate_min = combine_triple(&fmt[offset + 1]);
2567                 fp->rate_max = combine_triple(&fmt[offset + 4]);
2568         }
2569         return 0;
2570 }
2571
2572 /*
2573  * parse the format type I and III descriptors
2574  */
2575 static int parse_audio_format_i(struct snd_usb_audio *chip, struct audioformat *fp,
2576                                 int format, unsigned char *fmt)
2577 {
2578         int pcm_format;
2579
2580         if (fmt[3] == USB_FORMAT_TYPE_III) {
2581                 /* FIXME: the format type is really IECxxx
2582                  *        but we give normal PCM format to get the existing
2583                  *        apps working...
2584                  */
2585                 switch (chip->usb_id) {
2586
2587                 case USB_ID(0x0763, 0x2003): /* M-Audio Audiophile USB */
2588                         if (device_setup[chip->index] == 0x00 &&
2589                             fp->altsetting == 6)
2590                                 pcm_format = SNDRV_PCM_FORMAT_S16_BE;
2591                         else
2592                                 pcm_format = SNDRV_PCM_FORMAT_S16_LE;
2593                         break;
2594                 default:
2595                         pcm_format = SNDRV_PCM_FORMAT_S16_LE;
2596                 }
2597         } else {
2598                 pcm_format = parse_audio_format_i_type(chip, fp, format, fmt);
2599                 if (pcm_format < 0)
2600                         return -1;
2601         }
2602         fp->format = pcm_format;
2603         fp->channels = fmt[4];
2604         if (fp->channels < 1) {
2605                 snd_printk(KERN_ERR "%d:%u:%d : invalid channels %d\n",
2606                            chip->dev->devnum, fp->iface, fp->altsetting, fp->channels);
2607                 return -1;
2608         }
2609         return parse_audio_format_rates(chip, fp, fmt, 7);
2610 }
2611
2612 /*
2613  * prase the format type II descriptor
2614  */
2615 static int parse_audio_format_ii(struct snd_usb_audio *chip, struct audioformat *fp,
2616                                  int format, unsigned char *fmt)
2617 {
2618         int brate, framesize;
2619         switch (format) {
2620         case USB_AUDIO_FORMAT_AC3:
2621                 /* FIXME: there is no AC3 format defined yet */
2622                 // fp->format = SNDRV_PCM_FORMAT_AC3;
2623                 fp->format = SNDRV_PCM_FORMAT_U8; /* temporarily hack to receive byte streams */
2624                 break;
2625         case USB_AUDIO_FORMAT_MPEG:
2626                 fp->format = SNDRV_PCM_FORMAT_MPEG;
2627                 break;
2628         default:
2629                 snd_printd(KERN_INFO "%d:%u:%d : unknown format tag 0x%x is detected.  processed as MPEG.\n",
2630                            chip->dev->devnum, fp->iface, fp->altsetting, format);
2631                 fp->format = SNDRV_PCM_FORMAT_MPEG;
2632                 break;
2633         }
2634         fp->channels = 1;
2635         brate = combine_word(&fmt[4]);  /* fmt[4,5] : wMaxBitRate (in kbps) */
2636         framesize = combine_word(&fmt[6]); /* fmt[6,7]: wSamplesPerFrame */
2637         snd_printd(KERN_INFO "found format II with max.bitrate = %d, frame size=%d\n", brate, framesize);
2638         fp->frame_size = framesize;
2639         return parse_audio_format_rates(chip, fp, fmt, 8); /* fmt[8..] sample rates */
2640 }
2641
2642 static int parse_audio_format(struct snd_usb_audio *chip, struct audioformat *fp,
2643                               int format, unsigned char *fmt, int stream)
2644 {
2645         int err;
2646
2647         switch (fmt[3]) {
2648         case USB_FORMAT_TYPE_I:
2649         case USB_FORMAT_TYPE_III:
2650                 err = parse_audio_format_i(chip, fp, format, fmt);
2651                 break;
2652         case USB_FORMAT_TYPE_II:
2653                 err = parse_audio_format_ii(chip, fp, format, fmt);
2654                 break;
2655         default:
2656                 snd_printd(KERN_INFO "%d:%u:%d : format type %d is not supported yet\n",
2657                            chip->dev->devnum, fp->iface, fp->altsetting, fmt[3]);
2658                 return -1;
2659         }
2660         fp->fmt_type = fmt[3];
2661         if (err < 0)
2662                 return err;
2663 #if 1
2664         /* FIXME: temporary hack for extigy/audigy 2 nx/zs */
2665         /* extigy apparently supports sample rates other than 48k
2666          * but not in ordinary way.  so we enable only 48k atm.
2667          */
2668         if (chip->usb_id == USB_ID(0x041e, 0x3000) ||
2669             chip->usb_id == USB_ID(0x041e, 0x3020) ||
2670             chip->usb_id == USB_ID(0x041e, 0x3061)) {
2671                 if (fmt[3] == USB_FORMAT_TYPE_I &&
2672                     fp->rates != SNDRV_PCM_RATE_48000 &&
2673                     fp->rates != SNDRV_PCM_RATE_96000)
2674                         return -1;
2675         }
2676 #endif
2677         return 0;
2678 }
2679
2680 static int audiophile_skip_setting_quirk(struct snd_usb_audio *chip,
2681                                          int iface, int altno);
2682 static int parse_audio_endpoints(struct snd_usb_audio *chip, int iface_no)
2683 {
2684         struct usb_device *dev;
2685         struct usb_interface *iface;
2686         struct usb_host_interface *alts;
2687         struct usb_interface_descriptor *altsd;
2688         int i, altno, err, stream;
2689         int format;
2690         struct audioformat *fp;
2691         unsigned char *fmt, *csep;
2692         int num;
2693
2694         dev = chip->dev;
2695
2696         /* parse the interface's altsettings */
2697         iface = usb_ifnum_to_if(dev, iface_no);
2698
2699         num = iface->num_altsetting;
2700
2701         /*
2702          * Dallas DS4201 workaround: It presents 5 altsettings, but the last
2703          * one misses syncpipe, and does not produce any sound.
2704          */
2705         if (chip->usb_id == USB_ID(0x04fa, 0x4201))
2706                 num = 4;
2707
2708         for (i = 0; i < num; i++) {
2709                 alts = &iface->altsetting[i];
2710                 altsd = get_iface_desc(alts);
2711                 /* skip invalid one */
2712                 if ((altsd->bInterfaceClass != USB_CLASS_AUDIO &&
2713                      altsd->bInterfaceClass != USB_CLASS_VENDOR_SPEC) ||
2714                     (altsd->bInterfaceSubClass != USB_SUBCLASS_AUDIO_STREAMING &&
2715                      altsd->bInterfaceSubClass != USB_SUBCLASS_VENDOR_SPEC) ||
2716                     altsd->bNumEndpoints < 1 ||
2717                     le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize) == 0)
2718                         continue;
2719                 /* must be isochronous */
2720                 if ((get_endpoint(alts, 0)->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) !=
2721                     USB_ENDPOINT_XFER_ISOC)
2722                         continue;
2723                 /* check direction */
2724                 stream = (get_endpoint(alts, 0)->bEndpointAddress & USB_DIR_IN) ?
2725                         SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK;
2726                 altno = altsd->bAlternateSetting;
2727
2728                 /* audiophile usb: skip altsets incompatible with device_setup
2729                  */
2730                 if (chip->usb_id == USB_ID(0x0763, 0x2003) &&
2731                     audiophile_skip_setting_quirk(chip, iface_no, altno))
2732                         continue;
2733
2734                 /* get audio formats */
2735                 fmt = snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL, AS_GENERAL);
2736                 if (!fmt) {
2737                         snd_printk(KERN_ERR "%d:%u:%d : AS_GENERAL descriptor not found\n",
2738                                    dev->devnum, iface_no, altno);
2739                         continue;
2740                 }
2741
2742                 if (fmt[0] < 7) {
2743                         snd_printk(KERN_ERR "%d:%u:%d : invalid AS_GENERAL desc\n",
2744                                    dev->devnum, iface_no, altno);
2745                         continue;
2746                 }
2747
2748                 format = (fmt[6] << 8) | fmt[5]; /* remember the format value */
2749
2750                 /* get format type */
2751                 fmt = snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL, FORMAT_TYPE);
2752                 if (!fmt) {
2753                         snd_printk(KERN_ERR "%d:%u:%d : no FORMAT_TYPE desc\n",
2754                                    dev->devnum, iface_no, altno);
2755                         continue;
2756                 }
2757                 if (fmt[0] < 8) {
2758                         snd_printk(KERN_ERR "%d:%u:%d : invalid FORMAT_TYPE desc\n",
2759                                    dev->devnum, iface_no, altno);
2760                         continue;
2761                 }
2762
2763                 csep = snd_usb_find_desc(alts->endpoint[0].extra, alts->endpoint[0].extralen, NULL, USB_DT_CS_ENDPOINT);
2764                 /* Creamware Noah has this descriptor after the 2nd endpoint */
2765                 if (!csep && altsd->bNumEndpoints >= 2)
2766                         csep = snd_usb_find_desc(alts->endpoint[1].extra, alts->endpoint[1].extralen, NULL, USB_DT_CS_ENDPOINT);
2767                 if (!csep || csep[0] < 7 || csep[2] != EP_GENERAL) {
2768                         snd_printk(KERN_WARNING "%d:%u:%d : no or invalid"
2769                                    " class specific endpoint descriptor\n",
2770                                    dev->devnum, iface_no, altno);
2771                         csep = NULL;
2772                 }
2773
2774                 fp = kzalloc(sizeof(*fp), GFP_KERNEL);
2775                 if (! fp) {
2776                         snd_printk(KERN_ERR "cannot malloc\n");
2777                         return -ENOMEM;
2778                 }
2779
2780                 fp->iface = iface_no;
2781                 fp->altsetting = altno;
2782                 fp->altset_idx = i;
2783                 fp->endpoint = get_endpoint(alts, 0)->bEndpointAddress;
2784                 fp->ep_attr = get_endpoint(alts, 0)->bmAttributes;
2785                 fp->maxpacksize = le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize);
2786                 if (snd_usb_get_speed(dev) == USB_SPEED_HIGH)
2787                         fp->maxpacksize = (((fp->maxpacksize >> 11) & 3) + 1)
2788                                         * (fp->maxpacksize & 0x7ff);
2789                 fp->attributes = csep ? csep[3] : 0;
2790
2791                 /* some quirks for attributes here */
2792
2793                 switch (chip->usb_id) {
2794                 case USB_ID(0x0a92, 0x0053): /* AudioTrak Optoplay */
2795                         /* Optoplay sets the sample rate attribute although
2796                          * it seems not supporting it in fact.
2797                          */
2798                         fp->attributes &= ~EP_CS_ATTR_SAMPLE_RATE;
2799                         break;
2800                 case USB_ID(0x041e, 0x3020): /* Creative SB Audigy 2 NX */
2801                 case USB_ID(0x0763, 0x2003): /* M-Audio Audiophile USB */
2802                         /* doesn't set the sample rate attribute, but supports it */
2803                         fp->attributes |= EP_CS_ATTR_SAMPLE_RATE;
2804                         break;
2805                 case USB_ID(0x047f, 0x0ca1): /* plantronics headset */
2806                 case USB_ID(0x077d, 0x07af): /* Griffin iMic (note that there is
2807                                                 an older model 77d:223) */
2808                 /*
2809                  * plantronics headset and Griffin iMic have set adaptive-in
2810                  * although it's really not...
2811                  */
2812                         fp->ep_attr &= ~EP_ATTR_MASK;
2813                         if (stream == SNDRV_PCM_STREAM_PLAYBACK)
2814                                 fp->ep_attr |= EP_ATTR_ADAPTIVE;
2815                         else
2816                                 fp->ep_attr |= EP_ATTR_SYNC;
2817                         break;
2818                 }
2819
2820                 /* ok, let's parse further... */
2821                 if (parse_audio_format(chip, fp, format, fmt, stream) < 0) {
2822                         kfree(fp->rate_table);
2823                         kfree(fp);
2824                         continue;
2825                 }
2826
2827                 snd_printdd(KERN_INFO "%d:%u:%d: add audio endpoint 0x%x\n", dev->devnum, iface_no, altno, fp->endpoint);
2828                 err = add_audio_endpoint(chip, stream, fp);
2829                 if (err < 0) {
2830                         kfree(fp->rate_table);
2831                         kfree(fp);
2832                         return err;
2833                 }
2834                 /* try to set the interface... */
2835                 usb_set_interface(chip->dev, iface_no, altno);
2836                 init_usb_pitch(chip->dev, iface_no, alts, fp);
2837                 init_usb_sample_rate(chip->dev, iface_no, alts, fp, fp->rate_max);
2838         }
2839         return 0;
2840 }
2841
2842
2843 /*
2844  * disconnect streams
2845  * called from snd_usb_audio_disconnect()
2846  */
2847 static void snd_usb_stream_disconnect(struct list_head *head)
2848 {
2849         int idx;
2850         struct snd_usb_stream *as;
2851         struct snd_usb_substream *subs;
2852
2853         as = list_entry(head, struct snd_usb_stream, list);
2854         for (idx = 0; idx < 2; idx++) {
2855                 subs = &as->substream[idx];
2856                 if (!subs->num_formats)
2857                         return;
2858                 release_substream_urbs(subs, 1);
2859                 subs->interface = -1;
2860         }
2861 }
2862
2863 /*
2864  * parse audio control descriptor and create pcm/midi streams
2865  */
2866 static int snd_usb_create_streams(struct snd_usb_audio *chip, int ctrlif)
2867 {
2868         struct usb_device *dev = chip->dev;
2869         struct usb_host_interface *host_iface;
2870         struct usb_interface *iface;
2871         unsigned char *p1;
2872         int i, j;
2873
2874         /* find audiocontrol interface */
2875         host_iface = &usb_ifnum_to_if(dev, ctrlif)->altsetting[0];
2876         if (!(p1 = snd_usb_find_csint_desc(host_iface->extra, host_iface->extralen, NULL, HEADER))) {
2877                 snd_printk(KERN_ERR "cannot find HEADER\n");
2878                 return -EINVAL;
2879         }
2880         if (! p1[7] || p1[0] < 8 + p1[7]) {
2881                 snd_printk(KERN_ERR "invalid HEADER\n");
2882                 return -EINVAL;
2883         }
2884
2885         /*
2886          * parse all USB audio streaming interfaces
2887          */
2888         for (i = 0; i < p1[7]; i++) {
2889                 struct usb_host_interface *alts;
2890                 struct usb_interface_descriptor *altsd;
2891                 j = p1[8 + i];
2892                 iface = usb_ifnum_to_if(dev, j);
2893                 if (!iface) {
2894                         snd_printk(KERN_ERR "%d:%u:%d : does not exist\n",
2895                                    dev->devnum, ctrlif, j);
2896                         continue;
2897                 }
2898                 if (usb_interface_claimed(iface)) {
2899                         snd_printdd(KERN_INFO "%d:%d:%d: skipping, already claimed\n", dev->devnum, ctrlif, j);
2900                         continue;
2901                 }
2902                 alts = &iface->altsetting[0];
2903                 altsd = get_iface_desc(alts);
2904                 if ((altsd->bInterfaceClass == USB_CLASS_AUDIO ||
2905                      altsd->bInterfaceClass == USB_CLASS_VENDOR_SPEC) &&
2906                     altsd->bInterfaceSubClass == USB_SUBCLASS_MIDI_STREAMING) {
2907                         if (snd_usb_create_midi_interface(chip, iface, NULL) < 0) {
2908                                 snd_printk(KERN_ERR "%d:%u:%d: cannot create sequencer device\n", dev->devnum, ctrlif, j);
2909                                 continue;
2910                         }
2911                         usb_driver_claim_interface(&usb_audio_driver, iface, (void *)-1L);
2912                         continue;
2913                 }
2914                 if ((altsd->bInterfaceClass != USB_CLASS_AUDIO &&
2915                      altsd->bInterfaceClass != USB_CLASS_VENDOR_SPEC) ||
2916                     altsd->bInterfaceSubClass != USB_SUBCLASS_AUDIO_STREAMING) {
2917                         snd_printdd(KERN_ERR "%d:%u:%d: skipping non-supported interface %d\n", dev->devnum, ctrlif, j, altsd->bInterfaceClass);
2918                         /* skip non-supported classes */
2919                         continue;
2920                 }
2921                 if (snd_usb_get_speed(dev) == USB_SPEED_LOW) {
2922                         snd_printk(KERN_ERR "low speed audio streaming not supported\n");
2923                         continue;
2924                 }
2925                 if (! parse_audio_endpoints(chip, j)) {
2926                         usb_set_interface(dev, j, 0); /* reset the current interface */
2927                         usb_driver_claim_interface(&usb_audio_driver, iface, (void *)-1L);
2928                 }
2929         }
2930
2931         return 0;
2932 }
2933
2934 /*
2935  * create a stream for an endpoint/altsetting without proper descriptors
2936  */
2937 static int create_fixed_stream_quirk(struct snd_usb_audio *chip,
2938                                      struct usb_interface *iface,
2939                                      const struct snd_usb_audio_quirk *quirk)
2940 {
2941         struct audioformat *fp;
2942         struct usb_host_interface *alts;
2943         int stream, err;
2944         unsigned *rate_table = NULL;
2945
2946         fp = kmemdup(quirk->data, sizeof(*fp), GFP_KERNEL);
2947         if (! fp) {
2948                 snd_printk(KERN_ERR "cannot memdup\n");
2949                 return -ENOMEM;
2950         }
2951         if (fp->nr_rates > 0) {
2952                 rate_table = kmalloc(sizeof(int) * fp->nr_rates, GFP_KERNEL);
2953                 if (!rate_table) {
2954                         kfree(fp);
2955                         return -ENOMEM;
2956                 }
2957                 memcpy(rate_table, fp->rate_table, sizeof(int) * fp->nr_rates);
2958                 fp->rate_table = rate_table;
2959         }
2960
2961         stream = (fp->endpoint & USB_DIR_IN)
2962                 ? SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK;
2963         err = add_audio_endpoint(chip, stream, fp);
2964         if (err < 0) {
2965                 kfree(fp);
2966                 kfree(rate_table);
2967                 return err;
2968         }
2969         if (fp->iface != get_iface_desc(&iface->altsetting[0])->bInterfaceNumber ||
2970             fp->altset_idx >= iface->num_altsetting) {
2971                 kfree(fp);
2972                 kfree(rate_table);
2973                 return -EINVAL;
2974         }
2975         alts = &iface->altsetting[fp->altset_idx];
2976         usb_set_interface(chip->dev, fp->iface, 0);
2977         init_usb_pitch(chip->dev, fp->iface, alts, fp);
2978         init_usb_sample_rate(chip->dev, fp->iface, alts, fp, fp->rate_max);
2979         return 0;
2980 }
2981
2982 /*
2983  * create a stream for an interface with proper descriptors
2984  */
2985 static int create_standard_audio_quirk(struct snd_usb_audio *chip,
2986                                        struct usb_interface *iface,
2987                                        const struct snd_usb_audio_quirk *quirk)
2988 {
2989         struct usb_host_interface *alts;
2990         struct usb_interface_descriptor *altsd;
2991         int err;
2992
2993         alts = &iface->altsetting[0];
2994         altsd = get_iface_desc(alts);
2995         err = parse_audio_endpoints(chip, altsd->bInterfaceNumber);
2996         if (err < 0) {
2997                 snd_printk(KERN_ERR "cannot setup if %d: error %d\n",
2998                            altsd->bInterfaceNumber, err);
2999                 return err;
3000         }
3001         /* reset the current interface */
3002         usb_set_interface(chip->dev, altsd->bInterfaceNumber, 0);
3003         return 0;
3004 }
3005
3006 /*
3007  * Create a stream for an Edirol UA-700/UA-25/UA-4FX interface.
3008  * The only way to detect the sample rate is by looking at wMaxPacketSize.
3009  */
3010 static int create_uaxx_quirk(struct snd_usb_audio *chip,
3011                               struct usb_interface *iface,
3012                               const struct snd_usb_audio_quirk *quirk)
3013 {
3014         static const struct audioformat ua_format = {
3015                 .format = SNDRV_PCM_FORMAT_S24_3LE,
3016                 .channels = 2,
3017                 .fmt_type = USB_FORMAT_TYPE_I,
3018                 .altsetting = 1,
3019                 .altset_idx = 1,
3020                 .rates = SNDRV_PCM_RATE_CONTINUOUS,
3021         };
3022         struct usb_host_interface *alts;
3023         struct usb_interface_descriptor *altsd;
3024         struct audioformat *fp;
3025         int stream, err;
3026
3027         /* both PCM and MIDI interfaces have 2 or more altsettings */
3028         if (iface->num_altsetting < 2)
3029                 return -ENXIO;
3030         alts = &iface->altsetting[1];
3031         altsd = get_iface_desc(alts);
3032
3033         if (altsd->bNumEndpoints == 2) {
3034                 static const struct snd_usb_midi_endpoint_info ua700_ep = {
3035                         .out_cables = 0x0003,
3036                         .in_cables  = 0x0003
3037                 };
3038                 static const struct snd_usb_audio_quirk ua700_quirk = {
3039                         .type = QUIRK_MIDI_FIXED_ENDPOINT,
3040                         .data = &ua700_ep
3041                 };
3042                 static const struct snd_usb_midi_endpoint_info uaxx_ep = {
3043                         .out_cables = 0x0001,
3044                         .in_cables  = 0x0001
3045                 };
3046                 static const struct snd_usb_audio_quirk uaxx_quirk = {
3047                         .type = QUIRK_MIDI_FIXED_ENDPOINT,
3048                         .data = &uaxx_ep
3049                 };
3050                 if (chip->usb_id == USB_ID(0x0582, 0x002b))
3051                         return snd_usb_create_midi_interface(chip, iface,
3052                                                              &ua700_quirk);
3053                 else
3054                         return snd_usb_create_midi_interface(chip, iface,
3055                                                              &uaxx_quirk);
3056         }
3057
3058         if (altsd->bNumEndpoints != 1)
3059                 return -ENXIO;
3060
3061         fp = kmalloc(sizeof(*fp), GFP_KERNEL);
3062         if (!fp)
3063                 return -ENOMEM;
3064         memcpy(fp, &ua_format, sizeof(*fp));
3065
3066         fp->iface = altsd->bInterfaceNumber;
3067         fp->endpoint = get_endpoint(alts, 0)->bEndpointAddress;
3068         fp->ep_attr = get_endpoint(alts, 0)->bmAttributes;
3069         fp->maxpacksize = le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize);
3070
3071         switch (fp->maxpacksize) {
3072         case 0x120:
3073                 fp->rate_max = fp->rate_min = 44100;
3074                 break;
3075         case 0x138:
3076         case 0x140:
3077                 fp->rate_max = fp->rate_min = 48000;
3078                 break;
3079         case 0x258:
3080         case 0x260:
3081                 fp->rate_max = fp->rate_min = 96000;
3082                 break;
3083         default:
3084                 snd_printk(KERN_ERR "unknown sample rate\n");
3085                 kfree(fp);
3086                 return -ENXIO;
3087         }
3088
3089         stream = (fp->endpoint & USB_DIR_IN)
3090                 ? SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK;
3091         err = add_audio_endpoint(chip, stream, fp);
3092         if (err < 0) {
3093                 kfree(fp);
3094                 return err;
3095         }
3096         usb_set_interface(chip->dev, fp->iface, 0);
3097         return 0;
3098 }
3099
3100 /*
3101  * Create a stream for an Edirol UA-1000 interface.
3102  */
3103 static int create_ua1000_quirk(struct snd_usb_audio *chip,
3104                                struct usb_interface *iface,
3105                                const struct snd_usb_audio_quirk *quirk)
3106 {
3107         static const struct audioformat ua1000_format = {
3108                 .format = SNDRV_PCM_FORMAT_S32_LE,
3109                 .fmt_type = USB_FORMAT_TYPE_I,
3110                 .altsetting = 1,
3111                 .altset_idx = 1,
3112                 .attributes = 0,
3113                 .rates = SNDRV_PCM_RATE_CONTINUOUS,
3114         };
3115         struct usb_host_interface *alts;
3116         struct usb_interface_descriptor *altsd;
3117         struct audioformat *fp;
3118         int stream, err;
3119
3120         if (iface->num_altsetting != 2)
3121                 return -ENXIO;
3122         alts = &iface->altsetting[1];
3123         altsd = get_iface_desc(alts);
3124         if (alts->extralen != 11 || alts->extra[1] != USB_DT_CS_INTERFACE ||
3125             altsd->bNumEndpoints != 1)
3126                 return -ENXIO;
3127
3128         fp = kmemdup(&ua1000_format, sizeof(*fp), GFP_KERNEL);
3129         if (!fp)
3130                 return -ENOMEM;
3131
3132         fp->channels = alts->extra[4];
3133         fp->iface = altsd->bInterfaceNumber;
3134         fp->endpoint = get_endpoint(alts, 0)->bEndpointAddress;
3135         fp->ep_attr = get_endpoint(alts, 0)->bmAttributes;
3136         fp->maxpacksize = le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize);
3137         fp->rate_max = fp->rate_min = combine_triple(&alts->extra[8]);
3138
3139         stream = (fp->endpoint & USB_DIR_IN)
3140                 ? SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK;
3141         err = add_audio_endpoint(chip, stream, fp);
3142         if (err < 0) {
3143                 kfree(fp);
3144                 return err;
3145         }
3146         /* FIXME: playback must be synchronized to capture */
3147         usb_set_interface(chip->dev, fp->iface, 0);
3148         return 0;
3149 }
3150
3151 /*
3152  * Create a stream for an Edirol UA-101 interface.
3153  * Copy, paste and modify from Edirol UA-1000
3154  */
3155 static int create_ua101_quirk(struct snd_usb_audio *chip,
3156                                struct usb_interface *iface,
3157                                const struct snd_usb_audio_quirk *quirk)
3158 {
3159         static const struct audioformat ua101_format = {
3160                 .format = SNDRV_PCM_FORMAT_S32_LE,
3161                 .fmt_type = USB_FORMAT_TYPE_I,
3162                 .altsetting = 1,
3163                 .altset_idx = 1,
3164                 .attributes = 0,
3165                 .rates = SNDRV_PCM_RATE_CONTINUOUS,
3166         };
3167         struct usb_host_interface *alts;
3168         struct usb_interface_descriptor *altsd;
3169         struct audioformat *fp;
3170         int stream, err;
3171
3172         if (iface->num_altsetting != 2)
3173                 return -ENXIO;
3174         alts = &iface->altsetting[1];
3175         altsd = get_iface_desc(alts);
3176         if (alts->extralen != 18 || alts->extra[1] != USB_DT_CS_INTERFACE ||
3177             altsd->bNumEndpoints != 1)
3178                 return -ENXIO;
3179
3180         fp = kmemdup(&ua101_format, sizeof(*fp), GFP_KERNEL);
3181         if (!fp)
3182                 return -ENOMEM;
3183
3184         fp->channels = alts->extra[11];
3185         fp->iface = altsd->bInterfaceNumber;
3186         fp->endpoint = get_endpoint(alts, 0)->bEndpointAddress;
3187         fp->ep_attr = get_endpoint(alts, 0)->bmAttributes;
3188         fp->maxpacksize = le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize);
3189         fp->rate_max = fp->rate_min = combine_triple(&alts->extra[15]);
3190
3191         stream = (fp->endpoint & USB_DIR_IN)
3192                 ? SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK;
3193         err = add_audio_endpoint(chip, stream, fp);
3194         if (err < 0) {
3195                 kfree(fp);
3196                 return err;
3197         }
3198         /* FIXME: playback must be synchronized to capture */
3199         usb_set_interface(chip->dev, fp->iface, 0);
3200         return 0;
3201 }
3202
3203 static int snd_usb_create_quirk(struct snd_usb_audio *chip,
3204                                 struct usb_interface *iface,
3205                                 const struct snd_usb_audio_quirk *quirk);
3206
3207 /*
3208  * handle the quirks for the contained interfaces
3209  */
3210 static int create_composite_quirk(struct snd_usb_audio *chip,
3211                                   struct usb_interface *iface,
3212                                   const struct snd_usb_audio_quirk *quirk)
3213 {
3214         int probed_ifnum = get_iface_desc(iface->altsetting)->bInterfaceNumber;
3215         int err;
3216
3217         for (quirk = quirk->data; quirk->ifnum >= 0; ++quirk) {
3218                 iface = usb_ifnum_to_if(chip->dev, quirk->ifnum);
3219                 if (!iface)
3220                         continue;
3221                 if (quirk->ifnum != probed_ifnum &&
3222                     usb_interface_claimed(iface))
3223                         continue;
3224                 err = snd_usb_create_quirk(chip, iface, quirk);
3225                 if (err < 0)
3226                         return err;
3227                 if (quirk->ifnum != probed_ifnum)
3228                         usb_driver_claim_interface(&usb_audio_driver, iface, (void *)-1L);
3229         }
3230         return 0;
3231 }
3232
3233 static int ignore_interface_quirk(struct snd_usb_audio *chip,
3234                                   struct usb_interface *iface,
3235                                   const struct snd_usb_audio_quirk *quirk)
3236 {
3237         return 0;
3238 }
3239
3240
3241 /*
3242  * boot quirks
3243  */
3244
3245 #define EXTIGY_FIRMWARE_SIZE_OLD 794
3246 #define EXTIGY_FIRMWARE_SIZE_NEW 483
3247
3248 static int snd_usb_extigy_boot_quirk(struct usb_device *dev, struct usb_interface *intf)
3249 {
3250         struct usb_host_config *config = dev->actconfig;
3251         int err;
3252
3253         if (le16_to_cpu(get_cfg_desc(config)->wTotalLength) == EXTIGY_FIRMWARE_SIZE_OLD ||
3254             le16_to_cpu(get_cfg_desc(config)->wTotalLength) == EXTIGY_FIRMWARE_SIZE_NEW) {
3255                 snd_printdd("sending Extigy boot sequence...\n");
3256                 /* Send message to force it to reconnect with full interface. */
3257                 err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev,0),
3258                                       0x10, 0x43, 0x0001, 0x000a, NULL, 0, 1000);
3259                 if (err < 0) snd_printdd("error sending boot message: %d\n", err);
3260                 err = usb_get_descriptor(dev, USB_DT_DEVICE, 0,
3261                                 &dev->descriptor, sizeof(dev->descriptor));
3262                 config = dev->actconfig;
3263                 if (err < 0) snd_printdd("error usb_get_descriptor: %d\n", err);
3264                 err = usb_reset_configuration(dev);
3265                 if (err < 0) snd_printdd("error usb_reset_configuration: %d\n", err);
3266                 snd_printdd("extigy_boot: new boot length = %d\n",
3267                             le16_to_cpu(get_cfg_desc(config)->wTotalLength));
3268                 return -ENODEV; /* quit this anyway */
3269         }
3270         return 0;
3271 }
3272
3273 static int snd_usb_audigy2nx_boot_quirk(struct usb_device *dev)
3274 {
3275         u8 buf = 1;
3276
3277         snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), 0x2a,
3278                         USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_OTHER,
3279                         0, 0, &buf, 1, 1000);
3280         if (buf == 0) {
3281                 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 0x29,
3282                                 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
3283                                 1, 2000, NULL, 0, 1000);
3284                 return -ENODEV;
3285         }
3286         return 0;
3287 }
3288
3289 /*
3290  * C-Media CM106/CM106+ have four 16-bit internal registers that are nicely
3291  * documented in the device's data sheet.
3292  */
3293 static int snd_usb_cm106_write_int_reg(struct usb_device *dev, int reg, u16 value)
3294 {
3295         u8 buf[4];
3296         buf[0] = 0x20;
3297         buf[1] = value & 0xff;
3298         buf[2] = (value >> 8) & 0xff;
3299         buf[3] = reg;
3300         return snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), USB_REQ_SET_CONFIGURATION,
3301                                USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_ENDPOINT,
3302                                0, 0, &buf, 4, 1000);
3303 }
3304
3305 static int snd_usb_cm106_boot_quirk(struct usb_device *dev)
3306 {
3307         /*
3308          * Enable line-out driver mode, set headphone source to front
3309          * channels, enable stereo mic.
3310          */
3311         return snd_usb_cm106_write_int_reg(dev, 2, 0x8004);
3312 }
3313
3314
3315 /*
3316  * Setup quirks
3317  */
3318 #define AUDIOPHILE_SET                  0x01 /* if set, parse device_setup */
3319 #define AUDIOPHILE_SET_DTS              0x02 /* if set, enable DTS Digital Output */
3320 #define AUDIOPHILE_SET_96K              0x04 /* 48-96KHz rate if set, 8-48KHz otherwise */
3321 #define AUDIOPHILE_SET_24B              0x08 /* 24bits sample if set, 16bits otherwise */
3322 #define AUDIOPHILE_SET_DI               0x10 /* if set, enable Digital Input */
3323 #define AUDIOPHILE_SET_MASK             0x1F /* bit mask for setup value */
3324 #define AUDIOPHILE_SET_24B_48K_DI       0x19 /* value for 24bits+48KHz+Digital Input */
3325 #define AUDIOPHILE_SET_24B_48K_NOTDI    0x09 /* value for 24bits+48KHz+No Digital Input */
3326 #define AUDIOPHILE_SET_16B_48K_DI       0x11 /* value for 16bits+48KHz+Digital Input */
3327 #define AUDIOPHILE_SET_16B_48K_NOTDI    0x01 /* value for 16bits+48KHz+No Digital Input */
3328
3329 static int audiophile_skip_setting_quirk(struct snd_usb_audio *chip,
3330                                          int iface, int altno)
3331 {
3332         /* Reset ALL ifaces to 0 altsetting.
3333          * Call it for every possible altsetting of every interface.
3334          */
3335         usb_set_interface(chip->dev, iface, 0);
3336
3337         if (device_setup[chip->index] & AUDIOPHILE_SET) {
3338                 if ((device_setup[chip->index] & AUDIOPHILE_SET_DTS)
3339                     && altno != 6)
3340                         return 1; /* skip this altsetting */
3341                 if ((device_setup[chip->index] & AUDIOPHILE_SET_96K)
3342                     && altno != 1)
3343                         return 1; /* skip this altsetting */
3344                 if ((device_setup[chip->index] & AUDIOPHILE_SET_MASK) ==
3345                     AUDIOPHILE_SET_24B_48K_DI && altno != 2)
3346                         return 1; /* skip this altsetting */
3347                 if ((device_setup[chip->index] & AUDIOPHILE_SET_MASK) ==
3348                     AUDIOPHILE_SET_24B_48K_NOTDI && altno != 3)
3349                         return 1; /* skip this altsetting */
3350                 if ((device_setup[chip->index] & AUDIOPHILE_SET_MASK) ==
3351                     AUDIOPHILE_SET_16B_48K_DI && altno != 4)
3352                         return 1; /* skip this altsetting */
3353                 if ((device_setup[chip->index] & AUDIOPHILE_SET_MASK) ==
3354                     AUDIOPHILE_SET_16B_48K_NOTDI && altno != 5)
3355                         return 1; /* skip this altsetting */
3356         }
3357         return 0; /* keep this altsetting */
3358 }
3359
3360 /*
3361  * audio-interface quirks
3362  *
3363  * returns zero if no standard audio/MIDI parsing is needed.
3364  * returns a postive value if standard audio/midi interfaces are parsed
3365  * after this.
3366  * returns a negative value at error.
3367  */
3368 static int snd_usb_create_quirk(struct snd_usb_audio *chip,
3369                                 struct usb_interface *iface,
3370                                 const struct snd_usb_audio_quirk *quirk)
3371 {
3372         typedef int (*quirk_func_t)(struct snd_usb_audio *, struct usb_interface *,
3373                                     const struct snd_usb_audio_quirk *);
3374         static const quirk_func_t quirk_funcs[] = {
3375                 [QUIRK_IGNORE_INTERFACE] = ignore_interface_quirk,
3376                 [QUIRK_COMPOSITE] = create_composite_quirk,
3377                 [QUIRK_MIDI_STANDARD_INTERFACE] = snd_usb_create_midi_interface,
3378                 [QUIRK_MIDI_FIXED_ENDPOINT] = snd_usb_create_midi_interface,
3379                 [QUIRK_MIDI_YAMAHA] = snd_usb_create_midi_interface,
3380                 [QUIRK_MIDI_MIDIMAN] = snd_usb_create_midi_interface,
3381                 [QUIRK_MIDI_NOVATION] = snd_usb_create_midi_interface,
3382                 [QUIRK_MIDI_RAW] = snd_usb_create_midi_interface,
3383                 [QUIRK_MIDI_EMAGIC] = snd_usb_create_midi_interface,
3384                 [QUIRK_MIDI_CME] = snd_usb_create_midi_interface,
3385                 [QUIRK_AUDIO_STANDARD_INTERFACE] = create_standard_audio_quirk,
3386                 [QUIRK_AUDIO_FIXED_ENDPOINT] = create_fixed_stream_quirk,
3387                 [QUIRK_AUDIO_EDIROL_UA1000] = create_ua1000_quirk,
3388                 [QUIRK_AUDIO_EDIROL_UA101] = create_ua101_quirk,
3389                 [QUIRK_AUDIO_EDIROL_UAXX] = create_uaxx_quirk
3390         };
3391
3392         if (quirk->type < QUIRK_TYPE_COUNT) {
3393                 return quirk_funcs[quirk->type](chip, iface, quirk);
3394         } else {
3395                 snd_printd(KERN_ERR "invalid quirk type %d\n", quirk->type);
3396                 return -ENXIO;
3397         }
3398 }
3399
3400
3401 /*
3402  * common proc files to show the usb device info
3403  */
3404 static void proc_audio_usbbus_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
3405 {
3406         struct snd_usb_audio *chip = entry->private_data;
3407         if (!chip->shutdown)
3408                 snd_iprintf(buffer, "%03d/%03d\n", chip->dev->bus->busnum, chip->dev->devnum);
3409 }
3410
3411 static void proc_audio_usbid_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
3412 {
3413         struct snd_usb_audio *chip = entry->private_data;
3414         if (!chip->shutdown)
3415                 snd_iprintf(buffer, "%04x:%04x\n",
3416                             USB_ID_VENDOR(chip->usb_id),
3417                             USB_ID_PRODUCT(chip->usb_id));
3418 }
3419
3420 static void snd_usb_audio_create_proc(struct snd_usb_audio *chip)
3421 {
3422         struct snd_info_entry *entry;
3423         if (!snd_card_proc_new(chip->card, "usbbus", &entry))
3424                 snd_info_set_text_ops(entry, chip, proc_audio_usbbus_read);
3425         if (!snd_card_proc_new(chip->card, "usbid", &entry))
3426                 snd_info_set_text_ops(entry, chip, proc_audio_usbid_read);
3427 }
3428
3429 /*
3430  * free the chip instance
3431  *
3432  * here we have to do not much, since pcm and controls are already freed
3433  *
3434  */
3435
3436 static int snd_usb_audio_free(struct snd_usb_audio *chip)
3437 {
3438         kfree(chip);
3439         return 0;
3440 }
3441
3442 static int snd_usb_audio_dev_free(struct snd_device *device)
3443 {
3444         struct snd_usb_audio *chip = device->device_data;
3445         return snd_usb_audio_free(chip);
3446 }
3447
3448
3449 /*
3450  * create a chip instance and set its names.
3451  */
3452 static int snd_usb_audio_create(struct usb_device *dev, int idx,
3453                                 const struct snd_usb_audio_quirk *quirk,
3454                                 struct snd_usb_audio **rchip)
3455 {
3456         struct snd_card *card;
3457         struct snd_usb_audio *chip;
3458         int err, len;
3459         char component[14];
3460         static struct snd_device_ops ops = {
3461                 .dev_free =     snd_usb_audio_dev_free,
3462         };
3463
3464         *rchip = NULL;
3465
3466         if (snd_usb_get_speed(dev) != USB_SPEED_LOW &&
3467             snd_usb_get_speed(dev) != USB_SPEED_FULL &&
3468             snd_usb_get_speed(dev) != USB_SPEED_HIGH) {
3469                 snd_printk(KERN_ERR "unknown device speed %d\n", snd_usb_get_speed(dev));
3470                 return -ENXIO;
3471         }
3472
3473         card = snd_card_new(index[idx], id[idx], THIS_MODULE, 0);
3474         if (card == NULL) {
3475                 snd_printk(KERN_ERR "cannot create card instance %d\n", idx);
3476                 return -ENOMEM;
3477         }
3478
3479         chip = kzalloc(sizeof(*chip), GFP_KERNEL);
3480         if (! chip) {
3481                 snd_card_free(card);
3482                 return -ENOMEM;
3483         }
3484
3485         chip->index = idx;
3486         chip->dev = dev;
3487         chip->card = card;
3488         chip->usb_id = USB_ID(le16_to_cpu(dev->descriptor.idVendor),
3489                               le16_to_cpu(dev->descriptor.idProduct));
3490         INIT_LIST_HEAD(&chip->pcm_list);
3491         INIT_LIST_HEAD(&chip->midi_list);
3492         INIT_LIST_HEAD(&chip->mixer_list);
3493
3494         if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) {
3495                 snd_usb_audio_free(chip);
3496                 snd_card_free(card);
3497                 return err;
3498         }
3499
3500         strcpy(card->driver, "USB-Audio");
3501         sprintf(component, "USB%04x:%04x",
3502                 USB_ID_VENDOR(chip->usb_id), USB_ID_PRODUCT(chip->usb_id));
3503         snd_component_add(card, component);
3504
3505         /* retrieve the device string as shortname */
3506         if (quirk && quirk->product_name) {
3507                 strlcpy(card->shortname, quirk->product_name, sizeof(card->shortname));
3508         } else {
3509                 if (!dev->descriptor.iProduct ||
3510                     usb_string(dev, dev->descriptor.iProduct,
3511                                card->shortname, sizeof(card->shortname)) <= 0) {
3512                         /* no name available from anywhere, so use ID */
3513                         sprintf(card->shortname, "USB Device %#04x:%#04x",
3514                                 USB_ID_VENDOR(chip->usb_id),
3515                                 USB_ID_PRODUCT(chip->usb_id));
3516                 }
3517         }
3518
3519         /* retrieve the vendor and device strings as longname */
3520         if (quirk && quirk->vendor_name) {
3521                 len = strlcpy(card->longname, quirk->vendor_name, sizeof(card->longname));
3522         } else {
3523                 if (dev->descriptor.iManufacturer)
3524                         len = usb_string(dev, dev->descriptor.iManufacturer,
3525                                          card->longname, sizeof(card->longname));
3526                 else
3527                         len = 0;
3528                 /* we don't really care if there isn't any vendor string */
3529         }
3530         if (len > 0)
3531                 strlcat(card->longname, " ", sizeof(card->longname));
3532
3533         strlcat(card->longname, card->shortname, sizeof(card->longname));
3534
3535         len = strlcat(card->longname, " at ", sizeof(card->longname));
3536
3537         if (len < sizeof(card->longname))
3538                 usb_make_path(dev, card->longname + len, sizeof(card->longname) - len);
3539
3540         strlcat(card->longname,
3541                 snd_usb_get_speed(dev) == USB_SPEED_LOW ? ", low speed" :
3542                 snd_usb_get_speed(dev) == USB_SPEED_FULL ? ", full speed" :
3543                 ", high speed",
3544                 sizeof(card->longname));
3545
3546         snd_usb_audio_create_proc(chip);
3547
3548         *rchip = chip;
3549         return 0;
3550 }
3551
3552
3553 /*
3554  * probe the active usb device
3555  *
3556  * note that this can be called multiple times per a device, when it
3557  * includes multiple audio control interfaces.
3558  *
3559  * thus we check the usb device pointer and creates the card instance
3560  * only at the first time.  the successive calls of this function will
3561  * append the pcm interface to the corresponding card.
3562  */
3563 static void *snd_usb_audio_probe(struct usb_device *dev,
3564                                  struct usb_interface *intf,
3565                                  const struct usb_device_id *usb_id)
3566 {
3567         const struct snd_usb_audio_quirk *quirk = (const struct snd_usb_audio_quirk *)usb_id->driver_info;
3568         int i, err;
3569         struct snd_usb_audio *chip;
3570         struct usb_host_interface *alts;
3571         int ifnum;
3572         u32 id;
3573
3574         alts = &intf->altsetting[0];
3575         ifnum = get_iface_desc(alts)->bInterfaceNumber;
3576         id = USB_ID(le16_to_cpu(dev->descriptor.idVendor),
3577                     le16_to_cpu(dev->descriptor.idProduct));
3578
3579         if (quirk && quirk->ifnum >= 0 && ifnum != quirk->ifnum)
3580                 goto __err_val;
3581
3582         /* SB Extigy needs special boot-up sequence */
3583         /* if more models come, this will go to the quirk list. */
3584         if (id == USB_ID(0x041e, 0x3000)) {
3585                 if (snd_usb_extigy_boot_quirk(dev, intf) < 0)
3586                         goto __err_val;
3587         }
3588         /* SB Audigy 2 NX needs its own boot-up magic, too */
3589         if (id == USB_ID(0x041e, 0x3020)) {
3590                 if (snd_usb_audigy2nx_boot_quirk(dev) < 0)
3591                         goto __err_val;
3592         }
3593
3594         /* C-Media CM106 / Turtle Beach Audio Advantage Roadie */
3595         if (id == USB_ID(0x10f5, 0x0200)) {
3596                 if (snd_usb_cm106_boot_quirk(dev) < 0)
3597                         goto __err_val;
3598         }
3599
3600         /*
3601          * found a config.  now register to ALSA
3602          */
3603
3604         /* check whether it's already registered */
3605         chip = NULL;
3606         mutex_lock(&register_mutex);
3607         for (i = 0; i < SNDRV_CARDS; i++) {
3608                 if (usb_chip[i] && usb_chip[i]->dev == dev) {
3609                         if (usb_chip[i]->shutdown) {
3610                                 snd_printk(KERN_ERR "USB device is in the shutdown state, cannot create a card instance\n");
3611                                 goto __error;
3612                         }
3613                         chip = usb_chip[i];
3614                         break;
3615                 }
3616         }
3617         if (! chip) {
3618                 /* it's a fresh one.
3619                  * now look for an empty slot and create a new card instance
3620                  */
3621                 for (i = 0; i < SNDRV_CARDS; i++)
3622                         if (enable[i] && ! usb_chip[i] &&
3623                             (vid[i] == -1 || vid[i] == USB_ID_VENDOR(id)) &&
3624                             (pid[i] == -1 || pid[i] == USB_ID_PRODUCT(id))) {
3625                                 if (snd_usb_audio_create(dev, i, quirk, &chip) < 0) {
3626                                         goto __error;
3627                                 }
3628                                 snd_card_set_dev(chip->card, &intf->dev);
3629                                 break;
3630                         }
3631                 if (!chip) {
3632                         printk(KERN_ERR "no available usb audio device\n");
3633                         goto __error;
3634                 }
3635         }
3636
3637         err = 1; /* continue */
3638         if (quirk && quirk->ifnum != QUIRK_NO_INTERFACE) {
3639                 /* need some special handlings */
3640                 if ((err = snd_usb_create_quirk(chip, intf, quirk)) < 0)
3641                         goto __error;
3642         }
3643
3644         if (err > 0) {
3645                 /* create normal USB audio interfaces */
3646                 if (snd_usb_create_streams(chip, ifnum) < 0 ||
3647                     snd_usb_create_mixer(chip, ifnum, ignore_ctl_error) < 0) {
3648                         goto __error;
3649                 }
3650         }
3651
3652         /* we are allowed to call snd_card_register() many times */
3653         if (snd_card_register(chip->card) < 0) {
3654                 goto __error;
3655         }
3656
3657         usb_chip[chip->index] = chip;
3658         chip->num_interfaces++;
3659         mutex_unlock(&register_mutex);
3660         return chip;
3661
3662  __error:
3663         if (chip && !chip->num_interfaces)
3664                 snd_card_free(chip->card);
3665         mutex_unlock(&register_mutex);
3666  __err_val:
3667         return NULL;
3668 }
3669
3670 /*
3671  * we need to take care of counter, since disconnection can be called also
3672  * many times as well as usb_audio_probe().
3673  */
3674 static void snd_usb_audio_disconnect(struct usb_device *dev, void *ptr)
3675 {
3676         struct snd_usb_audio *chip;
3677         struct snd_card *card;
3678         struct list_head *p;
3679
3680         if (ptr == (void *)-1L)
3681                 return;
3682
3683         chip = ptr;
3684         card = chip->card;
3685         mutex_lock(&register_mutex);
3686         chip->shutdown = 1;
3687         chip->num_interfaces--;
3688         if (chip->num_interfaces <= 0) {
3689                 snd_card_disconnect(card);
3690                 /* release the pcm resources */
3691                 list_for_each(p, &chip->pcm_list) {
3692                         snd_usb_stream_disconnect(p);
3693                 }
3694                 /* release the midi resources */
3695                 list_for_each(p, &chip->midi_list) {
3696                         snd_usbmidi_disconnect(p);
3697                 }
3698                 /* release mixer resources */
3699                 list_for_each(p, &chip->mixer_list) {
3700                         snd_usb_mixer_disconnect(p);
3701                 }
3702                 usb_chip[chip->index] = NULL;
3703                 mutex_unlock(&register_mutex);
3704                 snd_card_free_when_closed(card);
3705         } else {
3706                 mutex_unlock(&register_mutex);
3707         }
3708 }
3709
3710 /*
3711  * new 2.5 USB kernel API
3712  */
3713 static int usb_audio_probe(struct usb_interface *intf,
3714                            const struct usb_device_id *id)
3715 {
3716         void *chip;
3717         chip = snd_usb_audio_probe(interface_to_usbdev(intf), intf, id);
3718         if (chip) {
3719                 usb_set_intfdata(intf, chip);
3720                 return 0;
3721         } else
3722                 return -EIO;
3723 }
3724
3725 static void usb_audio_disconnect(struct usb_interface *intf)
3726 {
3727         snd_usb_audio_disconnect(interface_to_usbdev(intf),
3728                                  usb_get_intfdata(intf));
3729 }
3730
3731 #ifdef CONFIG_PM
3732 static int usb_audio_suspend(struct usb_interface *intf, pm_message_t message)
3733 {
3734         struct snd_usb_audio *chip = usb_get_intfdata(intf);
3735         struct list_head *p;
3736         struct snd_usb_stream *as;
3737
3738         if (chip == (void *)-1L)
3739                 return 0;
3740
3741         snd_power_change_state(chip->card, SNDRV_CTL_POWER_D3hot);
3742         if (!chip->num_suspended_intf++) {
3743                 list_for_each(p, &chip->pcm_list) {
3744                         as = list_entry(p, struct snd_usb_stream, list);
3745                         snd_pcm_suspend_all(as->pcm);
3746                 }
3747         }
3748
3749         return 0;
3750 }
3751
3752 static int usb_audio_resume(struct usb_interface *intf)
3753 {
3754         struct snd_usb_audio *chip = usb_get_intfdata(intf);
3755
3756         if (chip == (void *)-1L)
3757                 return 0;
3758         if (--chip->num_suspended_intf)
3759                 return 0;
3760         /*
3761          * ALSA leaves material resumption to user space
3762          * we just notify
3763          */
3764
3765         snd_power_change_state(chip->card, SNDRV_CTL_POWER_D0);
3766
3767         return 0;
3768 }
3769 #endif          /* CONFIG_PM */
3770
3771 static int __init snd_usb_audio_init(void)
3772 {
3773         if (nrpacks < MIN_PACKS_URB || nrpacks > MAX_PACKS) {
3774                 printk(KERN_WARNING "invalid nrpacks value.\n");
3775                 return -EINVAL;
3776         }
3777         return usb_register(&usb_audio_driver);
3778 }
3779
3780
3781 static void __exit snd_usb_audio_cleanup(void)
3782 {
3783         usb_deregister(&usb_audio_driver);
3784 }
3785
3786 module_init(snd_usb_audio_init);
3787 module_exit(snd_usb_audio_cleanup);