SAFE public projects git trees. - safe/jmp/linux-2.6/blob - 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, i;
1039         int is_playback = subs->direction == SNDRV_PCM_STREAM_PLAYBACK;
1040         unsigned int 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         } else if (subs->nurbs < 2) {
1113                 /* too little - we need at least two packets
1114                  * to ensure contiguous playback/capture
1115                  */
1116                 subs->nurbs = 2;
1117         }
1118
1119         /* allocate and initialize data urbs */
1120         for (i = 0; i < subs->nurbs; i++) {
1121                 struct snd_urb_ctx *u = &subs->dataurb[i];
1122                 u->index = i;
1123                 u->subs = subs;
1124                 u->packets = (i + 1) * total_packs / subs->nurbs
1125                         - i * total_packs / subs->nurbs;
1126                 u->buffer_size = maxsize * u->packets;
1127                 if (subs->fmt_type == USB_FORMAT_TYPE_II)
1128                         u->packets++; /* for transfer delimiter */
1129                 u->urb = usb_alloc_urb(u->packets, GFP_KERNEL);
1130                 if (!u->urb)
1131                         goto out_of_memory;
1132                 u->urb->transfer_buffer =
1133                         usb_buffer_alloc(subs->dev, u->buffer_size, GFP_KERNEL,
1134                                          &u->urb->transfer_dma);
1135                 if (!u->urb->transfer_buffer)
1136                         goto out_of_memory;
1137                 u->urb->pipe = subs->datapipe;
1138                 u->urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
1139                 u->urb->interval = 1 << subs->datainterval;
1140                 u->urb->context = u;
1141                 u->urb->complete = snd_complete_urb;
1142         }
1143
1144         if (subs->syncpipe) {
1145                 /* allocate and initialize sync urbs */
1146                 subs->syncbuf = usb_buffer_alloc(subs->dev, SYNC_URBS * 4,
1147                                                  GFP_KERNEL, &subs->sync_dma);
1148                 if (!subs->syncbuf)
1149                         goto out_of_memory;
1150                 for (i = 0; i < SYNC_URBS; i++) {
1151                         struct snd_urb_ctx *u = &subs->syncurb[i];
1152                         u->index = i;
1153                         u->subs = subs;
1154                         u->packets = 1;
1155                         u->urb = usb_alloc_urb(1, GFP_KERNEL);
1156                         if (!u->urb)
1157                                 goto out_of_memory;
1158                         u->urb->transfer_buffer = subs->syncbuf + i * 4;
1159                         u->urb->transfer_dma = subs->sync_dma + i * 4;
1160                         u->urb->transfer_buffer_length = 4;
1161                         u->urb->pipe = subs->syncpipe;
1162                         u->urb->transfer_flags = URB_ISO_ASAP |
1163                                                  URB_NO_TRANSFER_DMA_MAP;
1164                         u->urb->number_of_packets = 1;
1165                         u->urb->interval = 1 << subs->syncinterval;
1166                         u->urb->context = u;
1167                         u->urb->complete = snd_complete_sync_urb;
1168                 }
1169         }
1170         return 0;
1171
1172 out_of_memory:
1173         release_substream_urbs(subs, 0);
1174         return -ENOMEM;
1175 }
1176
1177
1178 /*
1179  * find a matching audio format
1180  */
1181 static struct audioformat *find_format(struct snd_usb_substream *subs, unsigned int format,
1182                                        unsigned int rate, unsigned int channels)
1183 {
1184         struct list_head *p;
1185         struct audioformat *found = NULL;
1186         int cur_attr = 0, attr;
1187
1188         list_for_each(p, &subs->fmt_list) {
1189                 struct audioformat *fp;
1190                 fp = list_entry(p, struct audioformat, list);
1191                 if (fp->format != format || fp->channels != channels)
1192                         continue;
1193                 if (rate < fp->rate_min || rate > fp->rate_max)
1194                         continue;
1195                 if (! (fp->rates & SNDRV_PCM_RATE_CONTINUOUS)) {
1196                         unsigned int i;
1197                         for (i = 0; i < fp->nr_rates; i++)
1198                                 if (fp->rate_table[i] == rate)
1199                                         break;
1200                         if (i >= fp->nr_rates)
1201                                 continue;
1202                 }
1203                 attr = fp->ep_attr & EP_ATTR_MASK;
1204                 if (! found) {
1205                         found = fp;
1206                         cur_attr = attr;
1207                         continue;
1208                 }
1209                 /* avoid async out and adaptive in if the other method
1210                  * supports the same format.
1211                  * this is a workaround for the case like
1212                  * M-audio audiophile USB.
1213                  */
1214                 if (attr != cur_attr) {
1215                         if ((attr == EP_ATTR_ASYNC &&
1216                              subs->direction == SNDRV_PCM_STREAM_PLAYBACK) ||
1217                             (attr == EP_ATTR_ADAPTIVE &&
1218                              subs->direction == SNDRV_PCM_STREAM_CAPTURE))
1219                                 continue;
1220                         if ((cur_attr == EP_ATTR_ASYNC &&
1221                              subs->direction == SNDRV_PCM_STREAM_PLAYBACK) ||
1222                             (cur_attr == EP_ATTR_ADAPTIVE &&
1223                              subs->direction == SNDRV_PCM_STREAM_CAPTURE)) {
1224                                 found = fp;
1225                                 cur_attr = attr;
1226                                 continue;
1227                         }
1228                 }
1229                 /* find the format with the largest max. packet size */
1230                 if (fp->maxpacksize > found->maxpacksize) {
1231                         found = fp;
1232                         cur_attr = attr;
1233                 }
1234         }
1235         return found;
1236 }
1237
1238
1239 /*
1240  * initialize the picth control and sample rate
1241  */
1242 static int init_usb_pitch(struct usb_device *dev, int iface,
1243                           struct usb_host_interface *alts,
1244                           struct audioformat *fmt)
1245 {
1246         unsigned int ep;
1247         unsigned char data[1];
1248         int err;
1249
1250         ep = get_endpoint(alts, 0)->bEndpointAddress;
1251         /* if endpoint has pitch control, enable it */
1252         if (fmt->attributes & EP_CS_ATTR_PITCH_CONTROL) {
1253                 data[0] = 1;
1254                 if ((err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR,
1255                                            USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_OUT,
1256                                            PITCH_CONTROL << 8, ep, data, 1, 1000)) < 0) {
1257                         snd_printk(KERN_ERR "%d:%d:%d: cannot set enable PITCH\n",
1258                                    dev->devnum, iface, ep);
1259                         return err;
1260                 }
1261         }
1262         return 0;
1263 }
1264
1265 static int init_usb_sample_rate(struct usb_device *dev, int iface,
1266                                 struct usb_host_interface *alts,
1267                                 struct audioformat *fmt, int rate)
1268 {
1269         unsigned int ep;
1270         unsigned char data[3];
1271         int err;
1272
1273         ep = get_endpoint(alts, 0)->bEndpointAddress;
1274         /* if endpoint has sampling rate control, set it */
1275         if (fmt->attributes & EP_CS_ATTR_SAMPLE_RATE) {
1276                 int crate;
1277                 data[0] = rate;
1278                 data[1] = rate >> 8;
1279                 data[2] = rate >> 16;
1280                 if ((err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR,
1281                                            USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_OUT,
1282                                            SAMPLING_FREQ_CONTROL << 8, ep, data, 3, 1000)) < 0) {
1283                         snd_printk(KERN_ERR "%d:%d:%d: cannot set freq %d to ep 0x%x\n",
1284                                    dev->devnum, iface, fmt->altsetting, rate, ep);
1285                         return err;
1286                 }
1287                 if ((err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), GET_CUR,
1288                                            USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_IN,
1289                                            SAMPLING_FREQ_CONTROL << 8, ep, data, 3, 1000)) < 0) {
1290                         snd_printk(KERN_WARNING "%d:%d:%d: cannot get freq at ep 0x%x\n",
1291                                    dev->devnum, iface, fmt->altsetting, ep);
1292                         return 0; /* some devices don't support reading */
1293                 }
1294                 crate = data[0] | (data[1] << 8) | (data[2] << 16);
1295                 if (crate != rate) {
1296                         snd_printd(KERN_WARNING "current rate %d is different from the runtime rate %d\n", crate, rate);
1297                         // runtime->rate = crate;
1298                 }
1299         }
1300         return 0;
1301 }
1302
1303 /*
1304  * find a matching format and set up the interface
1305  */
1306 static int set_format(struct snd_usb_substream *subs, struct audioformat *fmt)
1307 {
1308         struct usb_device *dev = subs->dev;
1309         struct usb_host_interface *alts;
1310         struct usb_interface_descriptor *altsd;
1311         struct usb_interface *iface;
1312         unsigned int ep, attr;
1313         int is_playback = subs->direction == SNDRV_PCM_STREAM_PLAYBACK;
1314         int err;
1315
1316         iface = usb_ifnum_to_if(dev, fmt->iface);
1317         if (WARN_ON(!iface))
1318                 return -EINVAL;
1319         alts = &iface->altsetting[fmt->altset_idx];
1320         altsd = get_iface_desc(alts);
1321         if (WARN_ON(altsd->bAlternateSetting != fmt->altsetting))
1322                 return -EINVAL;
1323
1324         if (fmt == subs->cur_audiofmt)
1325                 return 0;
1326
1327         /* close the old interface */
1328         if (subs->interface >= 0 && subs->interface != fmt->iface) {
1329                 if (usb_set_interface(subs->dev, subs->interface, 0) < 0) {
1330                         snd_printk(KERN_ERR "%d:%d:%d: return to setting 0 failed\n",
1331                                 dev->devnum, fmt->iface, fmt->altsetting);
1332                         return -EIO;
1333                 }
1334                 subs->interface = -1;
1335                 subs->format = 0;
1336         }
1337
1338         /* set interface */
1339         if (subs->interface != fmt->iface || subs->format != fmt->altset_idx) {
1340                 if (usb_set_interface(dev, fmt->iface, fmt->altsetting) < 0) {
1341                         snd_printk(KERN_ERR "%d:%d:%d: usb_set_interface failed\n",
1342                                    dev->devnum, fmt->iface, fmt->altsetting);
1343                         return -EIO;
1344                 }
1345                 snd_printdd(KERN_INFO "setting usb interface %d:%d\n", fmt->iface, fmt->altsetting);
1346                 subs->interface = fmt->iface;
1347                 subs->format = fmt->altset_idx;
1348         }
1349
1350         /* create a data pipe */
1351         ep = fmt->endpoint & USB_ENDPOINT_NUMBER_MASK;
1352         if (is_playback)
1353                 subs->datapipe = usb_sndisocpipe(dev, ep);
1354         else
1355                 subs->datapipe = usb_rcvisocpipe(dev, ep);
1356         if (snd_usb_get_speed(subs->dev) == USB_SPEED_HIGH &&
1357             get_endpoint(alts, 0)->bInterval >= 1 &&
1358             get_endpoint(alts, 0)->bInterval <= 4)
1359                 subs->datainterval = get_endpoint(alts, 0)->bInterval - 1;
1360         else
1361                 subs->datainterval = 0;
1362         subs->syncpipe = subs->syncinterval = 0;
1363         subs->maxpacksize = fmt->maxpacksize;
1364         subs->fill_max = 0;
1365
1366         /* we need a sync pipe in async OUT or adaptive IN mode */
1367         /* check the number of EP, since some devices have broken
1368          * descriptors which fool us.  if it has only one EP,
1369          * assume it as adaptive-out or sync-in.
1370          */
1371         attr = fmt->ep_attr & EP_ATTR_MASK;
1372         if (((is_playback && attr == EP_ATTR_ASYNC) ||
1373              (! is_playback && attr == EP_ATTR_ADAPTIVE)) &&
1374             altsd->bNumEndpoints >= 2) {
1375                 /* check sync-pipe endpoint */
1376                 /* ... and check descriptor size before accessing bSynchAddress
1377                    because there is a version of the SB Audigy 2 NX firmware lacking
1378                    the audio fields in the endpoint descriptors */
1379                 if ((get_endpoint(alts, 1)->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) != 0x01 ||
1380                     (get_endpoint(alts, 1)->bLength >= USB_DT_ENDPOINT_AUDIO_SIZE &&
1381                      get_endpoint(alts, 1)->bSynchAddress != 0)) {
1382                         snd_printk(KERN_ERR "%d:%d:%d : invalid synch pipe\n",
1383                                    dev->devnum, fmt->iface, fmt->altsetting);
1384                         return -EINVAL;
1385                 }
1386                 ep = get_endpoint(alts, 1)->bEndpointAddress;
1387                 if (get_endpoint(alts, 0)->bLength >= USB_DT_ENDPOINT_AUDIO_SIZE &&
1388                     (( is_playback && ep != (unsigned int)(get_endpoint(alts, 0)->bSynchAddress | USB_DIR_IN)) ||
1389                      (!is_playback && ep != (unsigned int)(get_endpoint(alts, 0)->bSynchAddress & ~USB_DIR_IN)))) {
1390                         snd_printk(KERN_ERR "%d:%d:%d : invalid synch pipe\n",
1391                                    dev->devnum, fmt->iface, fmt->altsetting);
1392                         return -EINVAL;
1393                 }
1394                 ep &= USB_ENDPOINT_NUMBER_MASK;
1395                 if (is_playback)
1396                         subs->syncpipe = usb_rcvisocpipe(dev, ep);
1397                 else
1398                         subs->syncpipe = usb_sndisocpipe(dev, ep);
1399                 if (get_endpoint(alts, 1)->bLength >= USB_DT_ENDPOINT_AUDIO_SIZE &&
1400                     get_endpoint(alts, 1)->bRefresh >= 1 &&
1401                     get_endpoint(alts, 1)->bRefresh <= 9)
1402                         subs->syncinterval = get_endpoint(alts, 1)->bRefresh;
1403                 else if (snd_usb_get_speed(subs->dev) == USB_SPEED_FULL)
1404                         subs->syncinterval = 1;
1405                 else if (get_endpoint(alts, 1)->bInterval >= 1 &&
1406                          get_endpoint(alts, 1)->bInterval <= 16)
1407                         subs->syncinterval = get_endpoint(alts, 1)->bInterval - 1;
1408                 else
1409                         subs->syncinterval = 3;
1410         }
1411
1412         /* always fill max packet size */
1413         if (fmt->attributes & EP_CS_ATTR_FILL_MAX)
1414                 subs->fill_max = 1;
1415
1416         if ((err = init_usb_pitch(dev, subs->interface, alts, fmt)) < 0)
1417                 return err;
1418
1419         subs->cur_audiofmt = fmt;
1420
1421 #if 0
1422         printk("setting done: format = %d, rate = %d..%d, channels = %d\n",
1423                fmt->format, fmt->rate_min, fmt->rate_max, fmt->channels);
1424         printk("  datapipe = 0x%0x, syncpipe = 0x%0x\n",
1425                subs->datapipe, subs->syncpipe);
1426 #endif
1427
1428         return 0;
1429 }
1430
1431 /*
1432  * hw_params callback
1433  *
1434  * allocate a buffer and set the given audio format.
1435  *
1436  * so far we use a physically linear buffer although packetize transfer
1437  * doesn't need a continuous area.
1438  * if sg buffer is supported on the later version of alsa, we'll follow
1439  * that.
1440  */
1441 static int snd_usb_hw_params(struct snd_pcm_substream *substream,
1442                              struct snd_pcm_hw_params *hw_params)
1443 {
1444         struct snd_usb_substream *subs = substream->runtime->private_data;
1445         struct audioformat *fmt;
1446         unsigned int channels, rate, format;
1447         int ret, changed;
1448
1449         ret = snd_pcm_alloc_vmalloc_buffer(substream,
1450                                            params_buffer_bytes(hw_params));
1451         if (ret < 0)
1452                 return ret;
1453
1454         format = params_format(hw_params);
1455         rate = params_rate(hw_params);
1456         channels = params_channels(hw_params);
1457         fmt = find_format(subs, format, rate, channels);
1458         if (!fmt) {
1459                 snd_printd(KERN_DEBUG "cannot set format: format = 0x%x, rate = %d, channels = %d\n",
1460                            format, rate, channels);
1461                 return -EINVAL;
1462         }
1463
1464         changed = subs->cur_audiofmt != fmt ||
1465                 subs->period_bytes != params_period_bytes(hw_params) ||
1466                 subs->cur_rate != rate;
1467         if ((ret = set_format(subs, fmt)) < 0)
1468                 return ret;
1469
1470         if (subs->cur_rate != rate) {
1471                 struct usb_host_interface *alts;
1472                 struct usb_interface *iface;
1473                 iface = usb_ifnum_to_if(subs->dev, fmt->iface);
1474                 alts = &iface->altsetting[fmt->altset_idx];
1475                 ret = init_usb_sample_rate(subs->dev, subs->interface, alts, fmt, rate);
1476                 if (ret < 0)
1477                         return ret;
1478                 subs->cur_rate = rate;
1479         }
1480
1481         if (changed) {
1482                 /* format changed */
1483                 release_substream_urbs(subs, 0);
1484                 /* influenced: period_bytes, channels, rate, format, */
1485                 ret = init_substream_urbs(subs, params_period_bytes(hw_params),
1486                                           params_rate(hw_params),
1487                                           snd_pcm_format_physical_width(params_format(hw_params)) * params_channels(hw_params));
1488         }
1489
1490         return ret;
1491 }
1492
1493 /*
1494  * hw_free callback
1495  *
1496  * reset the audio format and release the buffer
1497  */
1498 static int snd_usb_hw_free(struct snd_pcm_substream *substream)
1499 {
1500         struct snd_usb_substream *subs = substream->runtime->private_data;
1501
1502         subs->cur_audiofmt = NULL;
1503         subs->cur_rate = 0;
1504         subs->period_bytes = 0;
1505         if (!subs->stream->chip->shutdown)
1506                 release_substream_urbs(subs, 0);
1507         return snd_pcm_free_vmalloc_buffer(substream);
1508 }
1509
1510 /*
1511  * prepare callback
1512  *
1513  * only a few subtle things...
1514  */
1515 static int snd_usb_pcm_prepare(struct snd_pcm_substream *substream)
1516 {
1517         struct snd_pcm_runtime *runtime = substream->runtime;
1518         struct snd_usb_substream *subs = runtime->private_data;
1519
1520         if (! subs->cur_audiofmt) {
1521                 snd_printk(KERN_ERR "usbaudio: no format is specified!\n");
1522                 return -ENXIO;
1523         }
1524
1525         /* some unit conversions in runtime */
1526         subs->maxframesize = bytes_to_frames(runtime, subs->maxpacksize);
1527         subs->curframesize = bytes_to_frames(runtime, subs->curpacksize);
1528
1529         /* reset the pointer */
1530         subs->hwptr_done = 0;
1531         subs->transfer_done = 0;
1532         subs->phase = 0;
1533
1534         /* clear urbs (to be sure) */
1535         deactivate_urbs(subs, 0, 1);
1536         wait_clear_urbs(subs);
1537
1538         /* for playback, submit the URBs now; otherwise, the first hwptr_done
1539          * updates for all URBs would happen at the same time when starting */
1540         if (subs->direction == SNDRV_PCM_STREAM_PLAYBACK) {
1541                 subs->ops.prepare = prepare_nodata_playback_urb;
1542                 return start_urbs(subs, runtime);
1543         } else
1544                 return 0;
1545 }
1546
1547 static struct snd_pcm_hardware snd_usb_hardware =
1548 {
1549         .info =                 SNDRV_PCM_INFO_MMAP |
1550                                 SNDRV_PCM_INFO_MMAP_VALID |
1551                                 SNDRV_PCM_INFO_BATCH |
1552                                 SNDRV_PCM_INFO_INTERLEAVED |
1553                                 SNDRV_PCM_INFO_BLOCK_TRANSFER |
1554                                 SNDRV_PCM_INFO_PAUSE,
1555         .buffer_bytes_max =     1024 * 1024,
1556         .period_bytes_min =     64,
1557         .period_bytes_max =     512 * 1024,
1558         .periods_min =          2,
1559         .periods_max =          1024,
1560 };
1561
1562 /*
1563  * h/w constraints
1564  */
1565
1566 #ifdef HW_CONST_DEBUG
1567 #define hwc_debug(fmt, args...) printk(KERN_DEBUG fmt, ##args)
1568 #else
1569 #define hwc_debug(fmt, args...) /**/
1570 #endif
1571
1572 static int hw_check_valid_format(struct snd_pcm_hw_params *params, struct audioformat *fp)
1573 {
1574         struct snd_interval *it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
1575         struct snd_interval *ct = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
1576         struct snd_mask *fmts = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
1577
1578         /* check the format */
1579         if (!snd_mask_test(fmts, fp->format)) {
1580                 hwc_debug("   > check: no supported format %d\n", fp->format);
1581                 return 0;
1582         }
1583         /* check the channels */
1584         if (fp->channels < ct->min || fp->channels > ct->max) {
1585                 hwc_debug("   > check: no valid channels %d (%d/%d)\n", fp->channels, ct->min, ct->max);
1586                 return 0;
1587         }
1588         /* check the rate is within the range */
1589         if (fp->rate_min > it->max || (fp->rate_min == it->max && it->openmax)) {
1590                 hwc_debug("   > check: rate_min %d > max %d\n", fp->rate_min, it->max);
1591                 return 0;
1592         }
1593         if (fp->rate_max < it->min || (fp->rate_max == it->min && it->openmin)) {
1594                 hwc_debug("   > check: rate_max %d < min %d\n", fp->rate_max, it->min);
1595                 return 0;
1596         }
1597         return 1;
1598 }
1599
1600 static int hw_rule_rate(struct snd_pcm_hw_params *params,
1601                         struct snd_pcm_hw_rule *rule)
1602 {
1603         struct snd_usb_substream *subs = rule->private;
1604         struct list_head *p;
1605         struct snd_interval *it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
1606         unsigned int rmin, rmax;
1607         int changed;
1608
1609         hwc_debug("hw_rule_rate: (%d,%d)\n", it->min, it->max);
1610         changed = 0;
1611         rmin = rmax = 0;
1612         list_for_each(p, &subs->fmt_list) {
1613                 struct audioformat *fp;
1614                 fp = list_entry(p, struct audioformat, list);
1615                 if (!hw_check_valid_format(params, fp))
1616                         continue;
1617                 if (changed++) {
1618                         if (rmin > fp->rate_min)
1619                                 rmin = fp->rate_min;
1620                         if (rmax < fp->rate_max)
1621                                 rmax = fp->rate_max;
1622                 } else {
1623                         rmin = fp->rate_min;
1624                         rmax = fp->rate_max;
1625                 }
1626         }
1627
1628         if (!changed) {
1629                 hwc_debug("  --> get empty\n");
1630                 it->empty = 1;
1631                 return -EINVAL;
1632         }
1633
1634         changed = 0;
1635         if (it->min < rmin) {
1636                 it->min = rmin;
1637                 it->openmin = 0;
1638                 changed = 1;
1639         }
1640         if (it->max > rmax) {
1641                 it->max = rmax;
1642                 it->openmax = 0;
1643                 changed = 1;
1644         }
1645         if (snd_interval_checkempty(it)) {
1646                 it->empty = 1;
1647                 return -EINVAL;
1648         }
1649         hwc_debug("  --> (%d, %d) (changed = %d)\n", it->min, it->max, changed);
1650         return changed;
1651 }
1652
1653
1654 static int hw_rule_channels(struct snd_pcm_hw_params *params,
1655                             struct snd_pcm_hw_rule *rule)
1656 {
1657         struct snd_usb_substream *subs = rule->private;
1658         struct list_head *p;
1659         struct snd_interval *it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
1660         unsigned int rmin, rmax;
1661         int changed;
1662
1663         hwc_debug("hw_rule_channels: (%d,%d)\n", it->min, it->max);
1664         changed = 0;
1665         rmin = rmax = 0;
1666         list_for_each(p, &subs->fmt_list) {
1667                 struct audioformat *fp;
1668                 fp = list_entry(p, struct audioformat, list);
1669                 if (!hw_check_valid_format(params, fp))
1670                         continue;
1671                 if (changed++) {
1672                         if (rmin > fp->channels)
1673                                 rmin = fp->channels;
1674                         if (rmax < fp->channels)
1675                                 rmax = fp->channels;
1676                 } else {
1677                         rmin = fp->channels;
1678                         rmax = fp->channels;
1679                 }
1680         }
1681
1682         if (!changed) {
1683                 hwc_debug("  --> get empty\n");
1684                 it->empty = 1;
1685                 return -EINVAL;
1686         }
1687
1688         changed = 0;
1689         if (it->min < rmin) {
1690                 it->min = rmin;
1691                 it->openmin = 0;
1692                 changed = 1;
1693         }
1694         if (it->max > rmax) {
1695                 it->max = rmax;
1696                 it->openmax = 0;
1697                 changed = 1;
1698         }
1699         if (snd_interval_checkempty(it)) {
1700                 it->empty = 1;
1701                 return -EINVAL;
1702         }
1703         hwc_debug("  --> (%d, %d) (changed = %d)\n", it->min, it->max, changed);
1704         return changed;
1705 }
1706
1707 static int hw_rule_format(struct snd_pcm_hw_params *params,
1708                           struct snd_pcm_hw_rule *rule)
1709 {
1710         struct snd_usb_substream *subs = rule->private;
1711         struct list_head *p;
1712         struct snd_mask *fmt = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
1713         u64 fbits;
1714         u32 oldbits[2];
1715         int changed;
1716
1717         hwc_debug("hw_rule_format: %x:%x\n", fmt->bits[0], fmt->bits[1]);
1718         fbits = 0;
1719         list_for_each(p, &subs->fmt_list) {
1720                 struct audioformat *fp;
1721                 fp = list_entry(p, struct audioformat, list);
1722                 if (!hw_check_valid_format(params, fp))
1723                         continue;
1724                 fbits |= (1ULL << fp->format);
1725         }
1726
1727         oldbits[0] = fmt->bits[0];
1728         oldbits[1] = fmt->bits[1];
1729         fmt->bits[0] &= (u32)fbits;
1730         fmt->bits[1] &= (u32)(fbits >> 32);
1731         if (!fmt->bits[0] && !fmt->bits[1]) {
1732                 hwc_debug("  --> get empty\n");
1733                 return -EINVAL;
1734         }
1735         changed = (oldbits[0] != fmt->bits[0] || oldbits[1] != fmt->bits[1]);
1736         hwc_debug("  --> %x:%x (changed = %d)\n", fmt->bits[0], fmt->bits[1], changed);
1737         return changed;
1738 }
1739
1740 #define MAX_MASK        64
1741
1742 /*
1743  * check whether the registered audio formats need special hw-constraints
1744  */
1745 static int check_hw_params_convention(struct snd_usb_substream *subs)
1746 {
1747         int i;
1748         u32 *channels;
1749         u32 *rates;
1750         u32 cmaster, rmaster;
1751         u32 rate_min = 0, rate_max = 0;
1752         struct list_head *p;
1753         int err = 1;
1754
1755         channels = kcalloc(MAX_MASK, sizeof(u32), GFP_KERNEL);
1756         rates = kcalloc(MAX_MASK, sizeof(u32), GFP_KERNEL);
1757         if (!channels || !rates) {
1758                 err = -ENOMEM;
1759                 goto __out;
1760         }
1761
1762         list_for_each(p, &subs->fmt_list) {
1763                 struct audioformat *f;
1764                 f = list_entry(p, struct audioformat, list);
1765                 /* unconventional channels? */
1766                 if (f->channels > 32)
1767                         goto __out;
1768                 /* continuous rate min/max matches? */
1769                 if (f->rates & SNDRV_PCM_RATE_CONTINUOUS) {
1770                         if (rate_min && f->rate_min != rate_min)
1771                                 goto __out;
1772                         if (rate_max && f->rate_max != rate_max)
1773                                 goto __out;
1774                         rate_min = f->rate_min;
1775                         rate_max = f->rate_max;
1776                 }
1777                 /* combination of continuous rates and fixed rates? */
1778                 if (rates[f->format] & SNDRV_PCM_RATE_CONTINUOUS) {
1779                         if (f->rates != rates[f->format])
1780                                 goto __out;
1781                 }
1782                 if (f->rates & SNDRV_PCM_RATE_CONTINUOUS) {
1783                         if (rates[f->format] && rates[f->format] != f->rates)
1784                                 goto __out;
1785                 }
1786                 channels[f->format] |= (1 << f->channels);
1787                 rates[f->format] |= f->rates;
1788                 /* needs knot? */
1789                 if (f->rates & SNDRV_PCM_RATE_KNOT)
1790                         goto __out;
1791         }
1792         /* check whether channels and rates match for all formats */
1793         cmaster = rmaster = 0;
1794         for (i = 0; i < MAX_MASK; i++) {
1795                 if (cmaster != channels[i] && cmaster && channels[i])
1796                         goto __out;
1797                 if (rmaster != rates[i] && rmaster && rates[i])
1798                         goto __out;
1799                 if (channels[i])
1800                         cmaster = channels[i];
1801                 if (rates[i])
1802                         rmaster = rates[i];
1803         }
1804         /* check whether channels match for all distinct rates */
1805         memset(channels, 0, MAX_MASK * sizeof(u32));
1806         list_for_each(p, &subs->fmt_list) {
1807                 struct audioformat *f;
1808                 f = list_entry(p, struct audioformat, list);
1809                 if (f->rates & SNDRV_PCM_RATE_CONTINUOUS)
1810                         continue;
1811                 for (i = 0; i < 32; i++) {
1812                         if (f->rates & (1 << i))
1813                                 channels[i] |= (1 << f->channels);
1814                 }
1815         }
1816         cmaster = 0;
1817         for (i = 0; i < 32; i++) {
1818                 if (cmaster != channels[i] && cmaster && channels[i])
1819                         goto __out;
1820                 if (channels[i])
1821                         cmaster = channels[i];
1822         }
1823         err = 0;
1824
1825  __out:
1826         kfree(channels);
1827         kfree(rates);
1828         return err;
1829 }
1830
1831 /*
1832  *  If the device supports unusual bit rates, does the request meet these?
1833  */
1834 static int snd_usb_pcm_check_knot(struct snd_pcm_runtime *runtime,
1835                                   struct snd_usb_substream *subs)
1836 {
1837         struct audioformat *fp;
1838         int count = 0, needs_knot = 0;
1839         int err;
1840
1841         list_for_each_entry(fp, &subs->fmt_list, list) {
1842                 if (fp->rates & SNDRV_PCM_RATE_CONTINUOUS)
1843                         return 0;
1844                 count += fp->nr_rates;
1845                 if (fp->rates & SNDRV_PCM_RATE_KNOT)
1846                         needs_knot = 1;
1847         }
1848         if (!needs_knot)
1849                 return 0;
1850
1851         subs->rate_list.count = count;
1852         subs->rate_list.list = kmalloc(sizeof(int) * count, GFP_KERNEL);
1853         subs->rate_list.mask = 0;
1854         count = 0;
1855         list_for_each_entry(fp, &subs->fmt_list, list) {
1856                 int i;
1857                 for (i = 0; i < fp->nr_rates; i++)
1858                         subs->rate_list.list[count++] = fp->rate_table[i];
1859         }
1860         err = snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
1861                                          &subs->rate_list);
1862         if (err < 0)
1863                 return err;
1864
1865         return 0;
1866 }
1867
1868
1869 /*
1870  * set up the runtime hardware information.
1871  */
1872
1873 static int setup_hw_info(struct snd_pcm_runtime *runtime, struct snd_usb_substream *subs)
1874 {
1875         struct list_head *p;
1876         int err;
1877
1878         runtime->hw.formats = subs->formats;
1879
1880         runtime->hw.rate_min = 0x7fffffff;
1881         runtime->hw.rate_max = 0;
1882         runtime->hw.channels_min = 256;
1883         runtime->hw.channels_max = 0;
1884         runtime->hw.rates = 0;
1885         /* check min/max rates and channels */
1886         list_for_each(p, &subs->fmt_list) {
1887                 struct audioformat *fp;
1888                 fp = list_entry(p, struct audioformat, list);
1889                 runtime->hw.rates |= fp->rates;
1890                 if (runtime->hw.rate_min > fp->rate_min)
1891                         runtime->hw.rate_min = fp->rate_min;
1892                 if (runtime->hw.rate_max < fp->rate_max)
1893                         runtime->hw.rate_max = fp->rate_max;
1894                 if (runtime->hw.channels_min > fp->channels)
1895                         runtime->hw.channels_min = fp->channels;
1896                 if (runtime->hw.channels_max < fp->channels)
1897                         runtime->hw.channels_max = fp->channels;
1898                 if (fp->fmt_type == USB_FORMAT_TYPE_II && fp->frame_size > 0) {
1899                         /* FIXME: there might be more than one audio formats... */
1900                         runtime->hw.period_bytes_min = runtime->hw.period_bytes_max =
1901                                 fp->frame_size;
1902                 }
1903         }
1904
1905         /* set the period time minimum 1ms */
1906         /* FIXME: high-speed mode allows 125us minimum period, but many parts
1907          * in the current code assume the 1ms period.
1908          */
1909         snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIOD_TIME,
1910                                      1000 * MIN_PACKS_URB,
1911                                      /*(nrpacks * MAX_URBS) * 1000*/ UINT_MAX);
1912
1913         err = check_hw_params_convention(subs);
1914         if (err < 0)
1915                 return err;
1916         else if (err) {
1917                 hwc_debug("setting extra hw constraints...\n");
1918                 if ((err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
1919                                                hw_rule_rate, subs,
1920                                                SNDRV_PCM_HW_PARAM_FORMAT,
1921                                                SNDRV_PCM_HW_PARAM_CHANNELS,
1922                                                -1)) < 0)
1923                         return err;
1924                 if ((err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
1925                                                hw_rule_channels, subs,
1926                                                SNDRV_PCM_HW_PARAM_FORMAT,
1927                                                SNDRV_PCM_HW_PARAM_RATE,
1928                                                -1)) < 0)
1929                         return err;
1930                 if ((err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_FORMAT,
1931                                                hw_rule_format, subs,
1932                                                SNDRV_PCM_HW_PARAM_RATE,
1933                                                SNDRV_PCM_HW_PARAM_CHANNELS,
1934                                                -1)) < 0)
1935                         return err;
1936                 if ((err = snd_usb_pcm_check_knot(runtime, subs)) < 0)
1937                         return err;
1938         }
1939         return 0;
1940 }
1941
1942 static int snd_usb_pcm_open(struct snd_pcm_substream *substream, int direction)
1943 {
1944         struct snd_usb_stream *as = snd_pcm_substream_chip(substream);
1945         struct snd_pcm_runtime *runtime = substream->runtime;
1946         struct snd_usb_substream *subs = &as->substream[direction];
1947
1948         subs->interface = -1;
1949         subs->format = 0;
1950         runtime->hw = snd_usb_hardware;
1951         runtime->private_data = subs;
1952         subs->pcm_substream = substream;
1953         return setup_hw_info(runtime, subs);
1954 }
1955
1956 static int snd_usb_pcm_close(struct snd_pcm_substream *substream, int direction)
1957 {
1958         struct snd_usb_stream *as = snd_pcm_substream_chip(substream);
1959         struct snd_usb_substream *subs = &as->substream[direction];
1960
1961         if (subs->interface >= 0) {
1962                 usb_set_interface(subs->dev, subs->interface, 0);
1963                 subs->interface = -1;
1964         }
1965         subs->pcm_substream = NULL;
1966         return 0;
1967 }
1968
1969 static int snd_usb_playback_open(struct snd_pcm_substream *substream)
1970 {
1971         return snd_usb_pcm_open(substream, SNDRV_PCM_STREAM_PLAYBACK);
1972 }
1973
1974 static int snd_usb_playback_close(struct snd_pcm_substream *substream)
1975 {
1976         return snd_usb_pcm_close(substream, SNDRV_PCM_STREAM_PLAYBACK);
1977 }
1978
1979 static int snd_usb_capture_open(struct snd_pcm_substream *substream)
1980 {
1981         return snd_usb_pcm_open(substream, SNDRV_PCM_STREAM_CAPTURE);
1982 }
1983
1984 static int snd_usb_capture_close(struct snd_pcm_substream *substream)
1985 {
1986         return snd_usb_pcm_close(substream, SNDRV_PCM_STREAM_CAPTURE);
1987 }
1988
1989 static struct snd_pcm_ops snd_usb_playback_ops = {
1990         .open =         snd_usb_playback_open,
1991         .close =        snd_usb_playback_close,
1992         .ioctl =        snd_pcm_lib_ioctl,
1993         .hw_params =    snd_usb_hw_params,
1994         .hw_free =      snd_usb_hw_free,
1995         .prepare =      snd_usb_pcm_prepare,
1996         .trigger =      snd_usb_pcm_playback_trigger,
1997         .pointer =      snd_usb_pcm_pointer,
1998         .page =         snd_pcm_get_vmalloc_page,
1999 };
2000
2001 static struct snd_pcm_ops snd_usb_capture_ops = {
2002         .open =         snd_usb_capture_open,
2003         .close =        snd_usb_capture_close,
2004         .ioctl =        snd_pcm_lib_ioctl,
2005         .hw_params =    snd_usb_hw_params,
2006         .hw_free =      snd_usb_hw_free,
2007         .prepare =      snd_usb_pcm_prepare,
2008         .trigger =      snd_usb_pcm_capture_trigger,
2009         .pointer =      snd_usb_pcm_pointer,
2010         .page =         snd_pcm_get_vmalloc_page,
2011 };
2012
2013
2014
2015 /*
2016  * helper functions
2017  */
2018
2019 /*
2020  * combine bytes and get an integer value
2021  */
2022 unsigned int snd_usb_combine_bytes(unsigned char *bytes, int size)
2023 {
2024         switch (size) {
2025         case 1:  return *bytes;
2026         case 2:  return combine_word(bytes);
2027         case 3:  return combine_triple(bytes);
2028         case 4:  return combine_quad(bytes);
2029         default: return 0;
2030         }
2031 }
2032
2033 /*
2034  * parse descriptor buffer and return the pointer starting the given
2035  * descriptor type.
2036  */
2037 void *snd_usb_find_desc(void *descstart, int desclen, void *after, u8 dtype)
2038 {
2039         u8 *p, *end, *next;
2040
2041         p = descstart;
2042         end = p + desclen;
2043         for (; p < end;) {
2044                 if (p[0] < 2)
2045                         return NULL;
2046                 next = p + p[0];
2047                 if (next > end)
2048                         return NULL;
2049                 if (p[1] == dtype && (!after || (void *)p > after)) {
2050                         return p;
2051                 }
2052                 p = next;
2053         }
2054         return NULL;
2055 }
2056
2057 /*
2058  * find a class-specified interface descriptor with the given subtype.
2059  */
2060 void *snd_usb_find_csint_desc(void *buffer, int buflen, void *after, u8 dsubtype)
2061 {
2062         unsigned char *p = after;
2063
2064         while ((p = snd_usb_find_desc(buffer, buflen, p,
2065                                       USB_DT_CS_INTERFACE)) != NULL) {
2066                 if (p[0] >= 3 && p[2] == dsubtype)
2067                         return p;
2068         }
2069         return NULL;
2070 }
2071
2072 /*
2073  * Wrapper for usb_control_msg().
2074  * Allocates a temp buffer to prevent dmaing from/to the stack.
2075  */
2076 int snd_usb_ctl_msg(struct usb_device *dev, unsigned int pipe, __u8 request,
2077                     __u8 requesttype, __u16 value, __u16 index, void *data,
2078                     __u16 size, int timeout)
2079 {
2080         int err;
2081         void *buf = NULL;
2082
2083         if (size > 0) {
2084                 buf = kmemdup(data, size, GFP_KERNEL);
2085                 if (!buf)
2086                         return -ENOMEM;
2087         }
2088         err = usb_control_msg(dev, pipe, request, requesttype,
2089                               value, index, buf, size, timeout);
2090         if (size > 0) {
2091                 memcpy(data, buf, size);
2092                 kfree(buf);
2093         }
2094         return err;
2095 }
2096
2097
2098 /*
2099  * entry point for linux usb interface
2100  */
2101
2102 static int usb_audio_probe(struct usb_interface *intf,
2103                            const struct usb_device_id *id);
2104 static void usb_audio_disconnect(struct usb_interface *intf);
2105
2106 #ifdef CONFIG_PM
2107 static int usb_audio_suspend(struct usb_interface *intf, pm_message_t message);
2108 static int usb_audio_resume(struct usb_interface *intf);
2109 #else
2110 #define usb_audio_suspend NULL
2111 #define usb_audio_resume NULL
2112 #endif
2113
2114 static struct usb_device_id usb_audio_ids [] = {
2115 #include "usbquirks.h"
2116     { .match_flags = (USB_DEVICE_ID_MATCH_INT_CLASS | USB_DEVICE_ID_MATCH_INT_SUBCLASS),
2117       .bInterfaceClass = USB_CLASS_AUDIO,
2118       .bInterfaceSubClass = USB_SUBCLASS_AUDIO_CONTROL },
2119     { }                                         /* Terminating entry */
2120 };
2121
2122 MODULE_DEVICE_TABLE (usb, usb_audio_ids);
2123
2124 static struct usb_driver usb_audio_driver = {
2125         .name =         "snd-usb-audio",
2126         .probe =        usb_audio_probe,
2127         .disconnect =   usb_audio_disconnect,
2128         .suspend =      usb_audio_suspend,
2129         .resume =       usb_audio_resume,
2130         .id_table =     usb_audio_ids,
2131 };
2132
2133
2134 #if defined(CONFIG_PROC_FS) && defined(CONFIG_SND_VERBOSE_PROCFS)
2135
2136 /*
2137  * proc interface for list the supported pcm formats
2138  */
2139 static void proc_dump_substream_formats(struct snd_usb_substream *subs, struct snd_info_buffer *buffer)
2140 {
2141         struct list_head *p;
2142         static char *sync_types[4] = {
2143                 "NONE", "ASYNC", "ADAPTIVE", "SYNC"
2144         };
2145
2146         list_for_each(p, &subs->fmt_list) {
2147                 struct audioformat *fp;
2148                 fp = list_entry(p, struct audioformat, list);
2149                 snd_iprintf(buffer, "  Interface %d\n", fp->iface);
2150                 snd_iprintf(buffer, "    Altset %d\n", fp->altsetting);
2151                 snd_iprintf(buffer, "    Format: 0x%x\n", fp->format);
2152                 snd_iprintf(buffer, "    Channels: %d\n", fp->channels);
2153                 snd_iprintf(buffer, "    Endpoint: %d %s (%s)\n",
2154                             fp->endpoint & USB_ENDPOINT_NUMBER_MASK,
2155                             fp->endpoint & USB_DIR_IN ? "IN" : "OUT",
2156                             sync_types[(fp->ep_attr & EP_ATTR_MASK) >> 2]);
2157                 if (fp->rates & SNDRV_PCM_RATE_CONTINUOUS) {
2158                         snd_iprintf(buffer, "    Rates: %d - %d (continuous)\n",
2159                                     fp->rate_min, fp->rate_max);
2160                 } else {
2161                         unsigned int i;
2162                         snd_iprintf(buffer, "    Rates: ");
2163                         for (i = 0; i < fp->nr_rates; i++) {
2164                                 if (i > 0)
2165                                         snd_iprintf(buffer, ", ");
2166                                 snd_iprintf(buffer, "%d", fp->rate_table[i]);
2167                         }
2168                         snd_iprintf(buffer, "\n");
2169                 }
2170                 // snd_iprintf(buffer, "    Max Packet Size = %d\n", fp->maxpacksize);
2171                 // snd_iprintf(buffer, "    EP Attribute = 0x%x\n", fp->attributes);
2172         }
2173 }
2174
2175 static void proc_dump_substream_status(struct snd_usb_substream *subs, struct snd_info_buffer *buffer)
2176 {
2177         if (subs->running) {
2178                 unsigned int i;
2179                 snd_iprintf(buffer, "  Status: Running\n");
2180                 snd_iprintf(buffer, "    Interface = %d\n", subs->interface);
2181                 snd_iprintf(buffer, "    Altset = %d\n", subs->format);
2182                 snd_iprintf(buffer, "    URBs = %d [ ", subs->nurbs);
2183                 for (i = 0; i < subs->nurbs; i++)
2184                         snd_iprintf(buffer, "%d ", subs->dataurb[i].packets);
2185                 snd_iprintf(buffer, "]\n");
2186                 snd_iprintf(buffer, "    Packet Size = %d\n", subs->curpacksize);
2187                 snd_iprintf(buffer, "    Momentary freq = %u Hz (%#x.%04x)\n",
2188                             snd_usb_get_speed(subs->dev) == USB_SPEED_FULL
2189                             ? get_full_speed_hz(subs->freqm)
2190                             : get_high_speed_hz(subs->freqm),
2191                             subs->freqm >> 16, subs->freqm & 0xffff);
2192         } else {
2193                 snd_iprintf(buffer, "  Status: Stop\n");
2194         }
2195 }
2196
2197 static void proc_pcm_format_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
2198 {
2199         struct snd_usb_stream *stream = entry->private_data;
2200
2201         snd_iprintf(buffer, "%s : %s\n", stream->chip->card->longname, stream->pcm->name);
2202
2203         if (stream->substream[SNDRV_PCM_STREAM_PLAYBACK].num_formats) {
2204                 snd_iprintf(buffer, "\nPlayback:\n");
2205                 proc_dump_substream_status(&stream->substream[SNDRV_PCM_STREAM_PLAYBACK], buffer);
2206                 proc_dump_substream_formats(&stream->substream[SNDRV_PCM_STREAM_PLAYBACK], buffer);
2207         }
2208         if (stream->substream[SNDRV_PCM_STREAM_CAPTURE].num_formats) {
2209                 snd_iprintf(buffer, "\nCapture:\n");
2210                 proc_dump_substream_status(&stream->substream[SNDRV_PCM_STREAM_CAPTURE], buffer);
2211                 proc_dump_substream_formats(&stream->substream[SNDRV_PCM_STREAM_CAPTURE], buffer);
2212         }
2213 }
2214
2215 static void proc_pcm_format_add(struct snd_usb_stream *stream)
2216 {
2217         struct snd_info_entry *entry;
2218         char name[32];
2219         struct snd_card *card = stream->chip->card;
2220
2221         sprintf(name, "stream%d", stream->pcm_index);
2222         if (!snd_card_proc_new(card, name, &entry))
2223                 snd_info_set_text_ops(entry, stream, proc_pcm_format_read);
2224 }
2225
2226 #else
2227
2228 static inline void proc_pcm_format_add(struct snd_usb_stream *stream)
2229 {
2230 }
2231
2232 #endif
2233
2234 /*
2235  * initialize the substream instance.
2236  */
2237
2238 static void init_substream(struct snd_usb_stream *as, int stream, struct audioformat *fp)
2239 {
2240         struct snd_usb_substream *subs = &as->substream[stream];
2241
2242         INIT_LIST_HEAD(&subs->fmt_list);
2243         spin_lock_init(&subs->lock);
2244
2245         subs->stream = as;
2246         subs->direction = stream;
2247         subs->dev = as->chip->dev;
2248         if (snd_usb_get_speed(subs->dev) == USB_SPEED_FULL) {
2249                 subs->ops = audio_urb_ops[stream];
2250         } else {
2251                 subs->ops = audio_urb_ops_high_speed[stream];
2252                 switch (as->chip->usb_id) {
2253                 case USB_ID(0x041e, 0x3f02): /* E-Mu 0202 USB */
2254                 case USB_ID(0x041e, 0x3f04): /* E-Mu 0404 USB */
2255                 case USB_ID(0x041e, 0x3f0a): /* E-Mu Tracker Pre */
2256                         subs->ops.retire_sync = retire_playback_sync_urb_hs_emu;
2257                         break;
2258                 }
2259         }
2260         snd_pcm_set_ops(as->pcm, stream,
2261                         stream == SNDRV_PCM_STREAM_PLAYBACK ?
2262                         &snd_usb_playback_ops : &snd_usb_capture_ops);
2263
2264         list_add_tail(&fp->list, &subs->fmt_list);
2265         subs->formats |= 1ULL << fp->format;
2266         subs->endpoint = fp->endpoint;
2267         subs->num_formats++;
2268         subs->fmt_type = fp->fmt_type;
2269 }
2270
2271
2272 /*
2273  * free a substream
2274  */
2275 static void free_substream(struct snd_usb_substream *subs)
2276 {
2277         struct list_head *p, *n;
2278
2279         if (!subs->num_formats)
2280                 return; /* not initialized */
2281         list_for_each_safe(p, n, &subs->fmt_list) {
2282                 struct audioformat *fp = list_entry(p, struct audioformat, list);
2283                 kfree(fp->rate_table);
2284                 kfree(fp);
2285         }
2286         kfree(subs->rate_list.list);
2287 }
2288
2289
2290 /*
2291  * free a usb stream instance
2292  */
2293 static void snd_usb_audio_stream_free(struct snd_usb_stream *stream)
2294 {
2295         free_substream(&stream->substream[0]);
2296         free_substream(&stream->substream[1]);
2297         list_del(&stream->list);
2298         kfree(stream);
2299 }
2300
2301 static void snd_usb_audio_pcm_free(struct snd_pcm *pcm)
2302 {
2303         struct snd_usb_stream *stream = pcm->private_data;
2304         if (stream) {
2305                 stream->pcm = NULL;
2306                 snd_usb_audio_stream_free(stream);
2307         }
2308 }
2309
2310
2311 /*
2312  * add this endpoint to the chip instance.
2313  * if a stream with the same endpoint already exists, append to it.
2314  * if not, create a new pcm stream.
2315  */
2316 static int add_audio_endpoint(struct snd_usb_audio *chip, int stream, struct audioformat *fp)
2317 {
2318         struct list_head *p;
2319         struct snd_usb_stream *as;
2320         struct snd_usb_substream *subs;
2321         struct snd_pcm *pcm;
2322         int err;
2323
2324         list_for_each(p, &chip->pcm_list) {
2325                 as = list_entry(p, struct snd_usb_stream, list);
2326                 if (as->fmt_type != fp->fmt_type)
2327                         continue;
2328                 subs = &as->substream[stream];
2329                 if (!subs->endpoint)
2330                         continue;
2331                 if (subs->endpoint == fp->endpoint) {
2332                         list_add_tail(&fp->list, &subs->fmt_list);
2333                         subs->num_formats++;
2334                         subs->formats |= 1ULL << fp->format;
2335                         return 0;
2336                 }
2337         }
2338         /* look for an empty stream */
2339         list_for_each(p, &chip->pcm_list) {
2340                 as = list_entry(p, struct snd_usb_stream, list);
2341                 if (as->fmt_type != fp->fmt_type)
2342                         continue;
2343                 subs = &as->substream[stream];
2344                 if (subs->endpoint)
2345                         continue;
2346                 err = snd_pcm_new_stream(as->pcm, stream, 1);
2347                 if (err < 0)
2348                         return err;
2349                 init_substream(as, stream, fp);
2350                 return 0;
2351         }
2352
2353         /* create a new pcm */
2354         as = kzalloc(sizeof(*as), GFP_KERNEL);
2355         if (!as)
2356                 return -ENOMEM;
2357         as->pcm_index = chip->pcm_devs;
2358         as->chip = chip;
2359         as->fmt_type = fp->fmt_type;
2360         err = snd_pcm_new(chip->card, "USB Audio", chip->pcm_devs,
2361                           stream == SNDRV_PCM_STREAM_PLAYBACK ? 1 : 0,
2362                           stream == SNDRV_PCM_STREAM_PLAYBACK ? 0 : 1,
2363                           &pcm);
2364         if (err < 0) {
2365                 kfree(as);
2366                 return err;
2367         }
2368         as->pcm = pcm;
2369         pcm->private_data = as;
2370         pcm->private_free = snd_usb_audio_pcm_free;
2371         pcm->info_flags = 0;
2372         if (chip->pcm_devs > 0)
2373                 sprintf(pcm->name, "USB Audio #%d", chip->pcm_devs);
2374         else
2375                 strcpy(pcm->name, "USB Audio");
2376
2377         init_substream(as, stream, fp);
2378
2379         list_add(&as->list, &chip->pcm_list);
2380         chip->pcm_devs++;
2381
2382         proc_pcm_format_add(as);
2383
2384         return 0;
2385 }
2386
2387
2388 /*
2389  * check if the device uses big-endian samples
2390  */
2391 static int is_big_endian_format(struct snd_usb_audio *chip, struct audioformat *fp)
2392 {
2393         switch (chip->usb_id) {
2394         case USB_ID(0x0763, 0x2001): /* M-Audio Quattro: captured data only */
2395                 if (fp->endpoint & USB_DIR_IN)
2396                         return 1;
2397                 break;
2398         case USB_ID(0x0763, 0x2003): /* M-Audio Audiophile USB */
2399                 if (device_setup[chip->index] == 0x00 ||
2400                     fp->altsetting==1 || fp->altsetting==2 || fp->altsetting==3)
2401                         return 1;
2402         }
2403         return 0;
2404 }
2405
2406 /*
2407  * parse the audio format type I descriptor
2408  * and returns the corresponding pcm format
2409  *
2410  * @dev: usb device
2411  * @fp: audioformat record
2412  * @format: the format tag (wFormatTag)
2413  * @fmt: the format type descriptor
2414  */
2415 static int parse_audio_format_i_type(struct snd_usb_audio *chip, struct audioformat *fp,
2416                                      int format, unsigned char *fmt)
2417 {
2418         int pcm_format;
2419         int sample_width, sample_bytes;
2420
2421         /* FIXME: correct endianess and sign? */
2422         pcm_format = -1;
2423         sample_width = fmt[6];
2424         sample_bytes = fmt[5];
2425         switch (format) {
2426         case 0: /* some devices don't define this correctly... */
2427                 snd_printdd(KERN_INFO "%d:%u:%d : format type 0 is detected, processed as PCM\n",
2428                             chip->dev->devnum, fp->iface, fp->altsetting);
2429                 /* fall-through */
2430         case USB_AUDIO_FORMAT_PCM:
2431                 if (sample_width > sample_bytes * 8) {
2432                         snd_printk(KERN_INFO "%d:%u:%d : sample bitwidth %d in over sample bytes %d\n",
2433                                    chip->dev->devnum, fp->iface, fp->altsetting,
2434                                    sample_width, sample_bytes);
2435                 }
2436                 /* check the format byte size */
2437                 switch (fmt[5]) {
2438                 case 1:
2439                         pcm_format = SNDRV_PCM_FORMAT_S8;
2440                         break;
2441                 case 2:
2442                         if (is_big_endian_format(chip, fp))
2443                                 pcm_format = SNDRV_PCM_FORMAT_S16_BE; /* grrr, big endian!! */
2444                         else
2445                                 pcm_format = SNDRV_PCM_FORMAT_S16_LE;
2446                         break;
2447                 case 3:
2448                         if (is_big_endian_format(chip, fp))
2449                                 pcm_format = SNDRV_PCM_FORMAT_S24_3BE; /* grrr, big endian!! */
2450                         else
2451                                 pcm_format = SNDRV_PCM_FORMAT_S24_3LE;
2452                         break;
2453                 case 4:
2454                         pcm_format = SNDRV_PCM_FORMAT_S32_LE;
2455                         break;
2456                 default:
2457                         snd_printk(KERN_INFO "%d:%u:%d : unsupported sample bitwidth %d in %d bytes\n",
2458                                    chip->dev->devnum, fp->iface,
2459                                    fp->altsetting, sample_width, sample_bytes);
2460                         break;
2461                 }
2462                 break;
2463         case USB_AUDIO_FORMAT_PCM8:
2464                 pcm_format = SNDRV_PCM_FORMAT_U8;
2465
2466                 /* Dallas DS4201 workaround: it advertises U8 format, but really
2467                    supports S8. */
2468                 if (chip->usb_id == USB_ID(0x04fa, 0x4201))
2469                         pcm_format = SNDRV_PCM_FORMAT_S8;
2470                 break;
2471         case USB_AUDIO_FORMAT_IEEE_FLOAT:
2472                 pcm_format = SNDRV_PCM_FORMAT_FLOAT_LE;
2473                 break;
2474         case USB_AUDIO_FORMAT_ALAW:
2475                 pcm_format = SNDRV_PCM_FORMAT_A_LAW;
2476                 break;
2477         case USB_AUDIO_FORMAT_MU_LAW:
2478                 pcm_format = SNDRV_PCM_FORMAT_MU_LAW;
2479                 break;
2480         default:
2481                 snd_printk(KERN_INFO "%d:%u:%d : unsupported format type %d\n",
2482                            chip->dev->devnum, fp->iface, fp->altsetting, format);
2483                 break;
2484         }
2485         return pcm_format;
2486 }
2487
2488
2489 /*
2490  * parse the format descriptor and stores the possible sample rates
2491  * on the audioformat table.
2492  *
2493  * @dev: usb device
2494  * @fp: audioformat record
2495  * @fmt: the format descriptor
2496  * @offset: the start offset of descriptor pointing the rate type
2497  *          (7 for type I and II, 8 for type II)
2498  */
2499 static int parse_audio_format_rates(struct snd_usb_audio *chip, struct audioformat *fp,
2500                                     unsigned char *fmt, int offset)
2501 {
2502         int nr_rates = fmt[offset];
2503
2504         if (fmt[0] < offset + 1 + 3 * (nr_rates ? nr_rates : 2)) {
2505                 snd_printk(KERN_ERR "%d:%u:%d : invalid FORMAT_TYPE desc\n",
2506                                    chip->dev->devnum, fp->iface, fp->altsetting);
2507                 return -1;
2508         }
2509
2510         if (nr_rates) {
2511                 /*
2512                  * build the rate table and bitmap flags
2513                  */
2514                 int r, idx;
2515                 unsigned int nonzero_rates = 0;
2516
2517                 fp->rate_table = kmalloc(sizeof(int) * nr_rates, GFP_KERNEL);
2518                 if (fp->rate_table == NULL) {
2519                         snd_printk(KERN_ERR "cannot malloc\n");
2520                         return -1;
2521                 }
2522
2523                 fp->nr_rates = nr_rates;
2524                 fp->rate_min = fp->rate_max = combine_triple(&fmt[8]);
2525                 for (r = 0, idx = offset + 1; r < nr_rates; r++, idx += 3) {
2526                         unsigned int rate = combine_triple(&fmt[idx]);
2527                         /* C-Media CM6501 mislabels its 96 kHz altsetting */
2528                         if (rate == 48000 && nr_rates == 1 &&
2529                             chip->usb_id == USB_ID(0x0d8c, 0x0201) &&
2530                             fp->altsetting == 5 && fp->maxpacksize == 392)
2531                                 rate = 96000;
2532                         fp->rate_table[r] = rate;
2533                         nonzero_rates |= rate;
2534                         if (rate < fp->rate_min)
2535                                 fp->rate_min = rate;
2536                         else if (rate > fp->rate_max)
2537                                 fp->rate_max = rate;
2538                         fp->rates |= snd_pcm_rate_to_rate_bit(rate);
2539                 }
2540                 if (!nonzero_rates) {
2541                         hwc_debug("All rates were zero. Skipping format!\n");
2542                         return -1;
2543                 }
2544         } else {
2545                 /* continuous rates */
2546                 fp->rates = SNDRV_PCM_RATE_CONTINUOUS;
2547                 fp->rate_min = combine_triple(&fmt[offset + 1]);
2548                 fp->rate_max = combine_triple(&fmt[offset + 4]);
2549         }
2550         return 0;
2551 }
2552
2553 /*
2554  * parse the format type I and III descriptors
2555  */
2556 static int parse_audio_format_i(struct snd_usb_audio *chip, struct audioformat *fp,
2557                                 int format, unsigned char *fmt)
2558 {
2559         int pcm_format;
2560
2561         if (fmt[3] == USB_FORMAT_TYPE_III) {
2562                 /* FIXME: the format type is really IECxxx
2563                  *        but we give normal PCM format to get the existing
2564                  *        apps working...
2565                  */
2566                 switch (chip->usb_id) {
2567
2568                 case USB_ID(0x0763, 0x2003): /* M-Audio Audiophile USB */
2569                         if (device_setup[chip->index] == 0x00 &&
2570                             fp->altsetting == 6)
2571                                 pcm_format = SNDRV_PCM_FORMAT_S16_BE;
2572                         else
2573                                 pcm_format = SNDRV_PCM_FORMAT_S16_LE;
2574                         break;
2575                 default:
2576                         pcm_format = SNDRV_PCM_FORMAT_S16_LE;
2577                 }
2578         } else {
2579                 pcm_format = parse_audio_format_i_type(chip, fp, format, fmt);
2580                 if (pcm_format < 0)
2581                         return -1;
2582         }
2583         fp->format = pcm_format;
2584         fp->channels = fmt[4];
2585         if (fp->channels < 1) {
2586                 snd_printk(KERN_ERR "%d:%u:%d : invalid channels %d\n",
2587                            chip->dev->devnum, fp->iface, fp->altsetting, fp->channels);
2588                 return -1;
2589         }
2590         return parse_audio_format_rates(chip, fp, fmt, 7);
2591 }
2592
2593 /*
2594  * prase the format type II descriptor
2595  */
2596 static int parse_audio_format_ii(struct snd_usb_audio *chip, struct audioformat *fp,
2597                                  int format, unsigned char *fmt)
2598 {
2599         int brate, framesize;
2600         switch (format) {
2601         case USB_AUDIO_FORMAT_AC3:
2602                 /* FIXME: there is no AC3 format defined yet */
2603                 // fp->format = SNDRV_PCM_FORMAT_AC3;
2604                 fp->format = SNDRV_PCM_FORMAT_U8; /* temporarily hack to receive byte streams */
2605                 break;
2606         case USB_AUDIO_FORMAT_MPEG:
2607                 fp->format = SNDRV_PCM_FORMAT_MPEG;
2608                 break;
2609         default:
2610                 snd_printd(KERN_INFO "%d:%u:%d : unknown format tag 0x%x is detected.  processed as MPEG.\n",
2611                            chip->dev->devnum, fp->iface, fp->altsetting, format);
2612                 fp->format = SNDRV_PCM_FORMAT_MPEG;
2613                 break;
2614         }
2615         fp->channels = 1;
2616         brate = combine_word(&fmt[4]);  /* fmt[4,5] : wMaxBitRate (in kbps) */
2617         framesize = combine_word(&fmt[6]); /* fmt[6,7]: wSamplesPerFrame */
2618         snd_printd(KERN_INFO "found format II with max.bitrate = %d, frame size=%d\n", brate, framesize);
2619         fp->frame_size = framesize;
2620         return parse_audio_format_rates(chip, fp, fmt, 8); /* fmt[8..] sample rates */
2621 }
2622
2623 static int parse_audio_format(struct snd_usb_audio *chip, struct audioformat *fp,
2624                               int format, unsigned char *fmt, int stream)
2625 {
2626         int err;
2627
2628         switch (fmt[3]) {
2629         case USB_FORMAT_TYPE_I:
2630         case USB_FORMAT_TYPE_III:
2631                 err = parse_audio_format_i(chip, fp, format, fmt);
2632                 break;
2633         case USB_FORMAT_TYPE_II:
2634                 err = parse_audio_format_ii(chip, fp, format, fmt);
2635                 break;
2636         default:
2637                 snd_printd(KERN_INFO "%d:%u:%d : format type %d is not supported yet\n",
2638                            chip->dev->devnum, fp->iface, fp->altsetting, fmt[3]);
2639                 return -1;
2640         }
2641         fp->fmt_type = fmt[3];
2642         if (err < 0)
2643                 return err;
2644 #if 1
2645         /* FIXME: temporary hack for extigy/audigy 2 nx/zs */
2646         /* extigy apparently supports sample rates other than 48k
2647          * but not in ordinary way.  so we enable only 48k atm.
2648          */
2649         if (chip->usb_id == USB_ID(0x041e, 0x3000) ||
2650             chip->usb_id == USB_ID(0x041e, 0x3020) ||
2651             chip->usb_id == USB_ID(0x041e, 0x3061)) {
2652                 if (fmt[3] == USB_FORMAT_TYPE_I &&
2653                     fp->rates != SNDRV_PCM_RATE_48000 &&
2654                     fp->rates != SNDRV_PCM_RATE_96000)
2655                         return -1;
2656         }
2657 #endif
2658         return 0;
2659 }
2660
2661 static int audiophile_skip_setting_quirk(struct snd_usb_audio *chip,
2662                                          int iface, int altno);
2663 static int parse_audio_endpoints(struct snd_usb_audio *chip, int iface_no)
2664 {
2665         struct usb_device *dev;
2666         struct usb_interface *iface;
2667         struct usb_host_interface *alts;
2668         struct usb_interface_descriptor *altsd;
2669         int i, altno, err, stream;
2670         int format;
2671         struct audioformat *fp;
2672         unsigned char *fmt, *csep;
2673         int num;
2674
2675         dev = chip->dev;
2676
2677         /* parse the interface's altsettings */
2678         iface = usb_ifnum_to_if(dev, iface_no);
2679
2680         num = iface->num_altsetting;
2681
2682         /*
2683          * Dallas DS4201 workaround: It presents 5 altsettings, but the last
2684          * one misses syncpipe, and does not produce any sound.
2685          */
2686         if (chip->usb_id == USB_ID(0x04fa, 0x4201))
2687                 num = 4;
2688
2689         for (i = 0; i < num; i++) {
2690                 alts = &iface->altsetting[i];
2691                 altsd = get_iface_desc(alts);
2692                 /* skip invalid one */
2693                 if ((altsd->bInterfaceClass != USB_CLASS_AUDIO &&
2694                      altsd->bInterfaceClass != USB_CLASS_VENDOR_SPEC) ||
2695                     (altsd->bInterfaceSubClass != USB_SUBCLASS_AUDIO_STREAMING &&
2696                      altsd->bInterfaceSubClass != USB_SUBCLASS_VENDOR_SPEC) ||
2697                     altsd->bNumEndpoints < 1 ||
2698                     le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize) == 0)
2699                         continue;
2700                 /* must be isochronous */
2701                 if ((get_endpoint(alts, 0)->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) !=
2702                     USB_ENDPOINT_XFER_ISOC)
2703                         continue;
2704                 /* check direction */
2705                 stream = (get_endpoint(alts, 0)->bEndpointAddress & USB_DIR_IN) ?
2706                         SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK;
2707                 altno = altsd->bAlternateSetting;
2708
2709                 /* audiophile usb: skip altsets incompatible with device_setup
2710                  */
2711                 if (chip->usb_id == USB_ID(0x0763, 0x2003) &&
2712                     audiophile_skip_setting_quirk(chip, iface_no, altno))
2713                         continue;
2714
2715                 /* get audio formats */
2716                 fmt = snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL, AS_GENERAL);
2717                 if (!fmt) {
2718                         snd_printk(KERN_ERR "%d:%u:%d : AS_GENERAL descriptor not found\n",
2719                                    dev->devnum, iface_no, altno);
2720                         continue;
2721                 }
2722
2723                 if (fmt[0] < 7) {
2724                         snd_printk(KERN_ERR "%d:%u:%d : invalid AS_GENERAL desc\n",
2725                                    dev->devnum, iface_no, altno);
2726                         continue;
2727                 }
2728
2729                 format = (fmt[6] << 8) | fmt[5]; /* remember the format value */
2730
2731                 /* get format type */
2732                 fmt = snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL, FORMAT_TYPE);
2733                 if (!fmt) {
2734                         snd_printk(KERN_ERR "%d:%u:%d : no FORMAT_TYPE desc\n",
2735                                    dev->devnum, iface_no, altno);
2736                         continue;
2737                 }
2738                 if (fmt[0] < 8) {
2739                         snd_printk(KERN_ERR "%d:%u:%d : invalid FORMAT_TYPE desc\n",
2740                                    dev->devnum, iface_no, altno);
2741                         continue;
2742                 }
2743
2744                 csep = snd_usb_find_desc(alts->endpoint[0].extra, alts->endpoint[0].extralen, NULL, USB_DT_CS_ENDPOINT);
2745                 /* Creamware Noah has this descriptor after the 2nd endpoint */
2746                 if (!csep && altsd->bNumEndpoints >= 2)
2747                         csep = snd_usb_find_desc(alts->endpoint[1].extra, alts->endpoint[1].extralen, NULL, USB_DT_CS_ENDPOINT);
2748                 if (!csep || csep[0] < 7 || csep[2] != EP_GENERAL) {
2749                         snd_printk(KERN_WARNING "%d:%u:%d : no or invalid"
2750                                    " class specific endpoint descriptor\n",
2751                                    dev->devnum, iface_no, altno);
2752                         csep = NULL;
2753                 }
2754
2755                 fp = kzalloc(sizeof(*fp), GFP_KERNEL);
2756                 if (! fp) {
2757                         snd_printk(KERN_ERR "cannot malloc\n");
2758                         return -ENOMEM;
2759                 }
2760
2761                 fp->iface = iface_no;
2762                 fp->altsetting = altno;
2763                 fp->altset_idx = i;
2764                 fp->endpoint = get_endpoint(alts, 0)->bEndpointAddress;
2765                 fp->ep_attr = get_endpoint(alts, 0)->bmAttributes;
2766                 fp->maxpacksize = le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize);
2767                 if (snd_usb_get_speed(dev) == USB_SPEED_HIGH)
2768                         fp->maxpacksize = (((fp->maxpacksize >> 11) & 3) + 1)
2769                                         * (fp->maxpacksize & 0x7ff);
2770                 fp->attributes = csep ? csep[3] : 0;
2771
2772                 /* some quirks for attributes here */
2773
2774                 switch (chip->usb_id) {
2775                 case USB_ID(0x0a92, 0x0053): /* AudioTrak Optoplay */
2776                         /* Optoplay sets the sample rate attribute although
2777                          * it seems not supporting it in fact.
2778                          */
2779                         fp->attributes &= ~EP_CS_ATTR_SAMPLE_RATE;
2780                         break;
2781                 case USB_ID(0x041e, 0x3020): /* Creative SB Audigy 2 NX */
2782                 case USB_ID(0x0763, 0x2003): /* M-Audio Audiophile USB */
2783                         /* doesn't set the sample rate attribute, but supports it */
2784                         fp->attributes |= EP_CS_ATTR_SAMPLE_RATE;
2785                         break;
2786                 case USB_ID(0x047f, 0x0ca1): /* plantronics headset */
2787                 case USB_ID(0x077d, 0x07af): /* Griffin iMic (note that there is
2788                                                 an older model 77d:223) */
2789                 /*
2790                  * plantronics headset and Griffin iMic have set adaptive-in
2791                  * although it's really not...
2792                  */
2793                         fp->ep_attr &= ~EP_ATTR_MASK;
2794                         if (stream == SNDRV_PCM_STREAM_PLAYBACK)
2795                                 fp->ep_attr |= EP_ATTR_ADAPTIVE;
2796                         else
2797                                 fp->ep_attr |= EP_ATTR_SYNC;
2798                         break;
2799                 }
2800
2801                 /* ok, let's parse further... */
2802                 if (parse_audio_format(chip, fp, format, fmt, stream) < 0) {
2803                         kfree(fp->rate_table);
2804                         kfree(fp);
2805                         continue;
2806                 }
2807
2808                 snd_printdd(KERN_INFO "%d:%u:%d: add audio endpoint 0x%x\n", dev->devnum, iface_no, altno, fp->endpoint);
2809                 err = add_audio_endpoint(chip, stream, fp);
2810                 if (err < 0) {
2811                         kfree(fp->rate_table);
2812                         kfree(fp);
2813                         return err;
2814                 }
2815                 /* try to set the interface... */
2816                 usb_set_interface(chip->dev, iface_no, altno);
2817                 init_usb_pitch(chip->dev, iface_no, alts, fp);
2818                 init_usb_sample_rate(chip->dev, iface_no, alts, fp, fp->rate_max);
2819         }
2820         return 0;
2821 }
2822
2823
2824 /*
2825  * disconnect streams
2826  * called from snd_usb_audio_disconnect()
2827  */
2828 static void snd_usb_stream_disconnect(struct list_head *head)
2829 {
2830         int idx;
2831         struct snd_usb_stream *as;
2832         struct snd_usb_substream *subs;
2833
2834         as = list_entry(head, struct snd_usb_stream, list);
2835         for (idx = 0; idx < 2; idx++) {
2836                 subs = &as->substream[idx];
2837                 if (!subs->num_formats)
2838                         return;
2839                 release_substream_urbs(subs, 1);
2840                 subs->interface = -1;
2841         }
2842 }
2843
2844 /*
2845  * parse audio control descriptor and create pcm/midi streams
2846  */
2847 static int snd_usb_create_streams(struct snd_usb_audio *chip, int ctrlif)
2848 {
2849         struct usb_device *dev = chip->dev;
2850         struct usb_host_interface *host_iface;
2851         struct usb_interface *iface;
2852         unsigned char *p1;
2853         int i, j;
2854
2855         /* find audiocontrol interface */
2856         host_iface = &usb_ifnum_to_if(dev, ctrlif)->altsetting[0];
2857         if (!(p1 = snd_usb_find_csint_desc(host_iface->extra, host_iface->extralen, NULL, HEADER))) {
2858                 snd_printk(KERN_ERR "cannot find HEADER\n");
2859                 return -EINVAL;
2860         }
2861         if (! p1[7] || p1[0] < 8 + p1[7]) {
2862                 snd_printk(KERN_ERR "invalid HEADER\n");
2863                 return -EINVAL;
2864         }
2865
2866         /*
2867          * parse all USB audio streaming interfaces
2868          */
2869         for (i = 0; i < p1[7]; i++) {
2870                 struct usb_host_interface *alts;
2871                 struct usb_interface_descriptor *altsd;
2872                 j = p1[8 + i];
2873                 iface = usb_ifnum_to_if(dev, j);
2874                 if (!iface) {
2875                         snd_printk(KERN_ERR "%d:%u:%d : does not exist\n",
2876                                    dev->devnum, ctrlif, j);
2877                         continue;
2878                 }
2879                 if (usb_interface_claimed(iface)) {
2880                         snd_printdd(KERN_INFO "%d:%d:%d: skipping, already claimed\n", dev->devnum, ctrlif, j);
2881                         continue;
2882                 }
2883                 alts = &iface->altsetting[0];
2884                 altsd = get_iface_desc(alts);
2885                 if ((altsd->bInterfaceClass == USB_CLASS_AUDIO ||
2886                      altsd->bInterfaceClass == USB_CLASS_VENDOR_SPEC) &&
2887                     altsd->bInterfaceSubClass == USB_SUBCLASS_MIDI_STREAMING) {
2888                         if (snd_usb_create_midi_interface(chip, iface, NULL) < 0) {
2889                                 snd_printk(KERN_ERR "%d:%u:%d: cannot create sequencer device\n", dev->devnum, ctrlif, j);
2890                                 continue;
2891                         }
2892                         usb_driver_claim_interface(&usb_audio_driver, iface, (void *)-1L);
2893                         continue;
2894                 }
2895                 if ((altsd->bInterfaceClass != USB_CLASS_AUDIO &&
2896                      altsd->bInterfaceClass != USB_CLASS_VENDOR_SPEC) ||
2897                     altsd->bInterfaceSubClass != USB_SUBCLASS_AUDIO_STREAMING) {
2898                         snd_printdd(KERN_ERR "%d:%u:%d: skipping non-supported interface %d\n", dev->devnum, ctrlif, j, altsd->bInterfaceClass);
2899                         /* skip non-supported classes */
2900                         continue;
2901                 }
2902                 if (snd_usb_get_speed(dev) == USB_SPEED_LOW) {
2903                         snd_printk(KERN_ERR "low speed audio streaming not supported\n");
2904                         continue;
2905                 }
2906                 if (! parse_audio_endpoints(chip, j)) {
2907                         usb_set_interface(dev, j, 0); /* reset the current interface */
2908                         usb_driver_claim_interface(&usb_audio_driver, iface, (void *)-1L);
2909                 }
2910         }
2911
2912         return 0;
2913 }
2914
2915 /*
2916  * create a stream for an endpoint/altsetting without proper descriptors
2917  */
2918 static int create_fixed_stream_quirk(struct snd_usb_audio *chip,
2919                                      struct usb_interface *iface,
2920                                      const struct snd_usb_audio_quirk *quirk)
2921 {
2922         struct audioformat *fp;
2923         struct usb_host_interface *alts;
2924         int stream, err;
2925         unsigned *rate_table = NULL;
2926
2927         fp = kmemdup(quirk->data, sizeof(*fp), GFP_KERNEL);
2928         if (! fp) {
2929                 snd_printk(KERN_ERR "cannot memdup\n");
2930                 return -ENOMEM;
2931         }
2932         if (fp->nr_rates > 0) {
2933                 rate_table = kmalloc(sizeof(int) * fp->nr_rates, GFP_KERNEL);
2934                 if (!rate_table) {
2935                         kfree(fp);
2936                         return -ENOMEM;
2937                 }
2938                 memcpy(rate_table, fp->rate_table, sizeof(int) * fp->nr_rates);
2939                 fp->rate_table = rate_table;
2940         }
2941
2942         stream = (fp->endpoint & USB_DIR_IN)
2943                 ? SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK;
2944         err = add_audio_endpoint(chip, stream, fp);
2945         if (err < 0) {
2946                 kfree(fp);
2947                 kfree(rate_table);
2948                 return err;
2949         }
2950         if (fp->iface != get_iface_desc(&iface->altsetting[0])->bInterfaceNumber ||
2951             fp->altset_idx >= iface->num_altsetting) {
2952                 kfree(fp);
2953                 kfree(rate_table);
2954                 return -EINVAL;
2955         }
2956         alts = &iface->altsetting[fp->altset_idx];
2957         usb_set_interface(chip->dev, fp->iface, 0);
2958         init_usb_pitch(chip->dev, fp->iface, alts, fp);
2959         init_usb_sample_rate(chip->dev, fp->iface, alts, fp, fp->rate_max);
2960         return 0;
2961 }
2962
2963 /*
2964  * create a stream for an interface with proper descriptors
2965  */
2966 static int create_standard_audio_quirk(struct snd_usb_audio *chip,
2967                                        struct usb_interface *iface,
2968                                        const struct snd_usb_audio_quirk *quirk)
2969 {
2970         struct usb_host_interface *alts;
2971         struct usb_interface_descriptor *altsd;
2972         int err;
2973
2974         alts = &iface->altsetting[0];
2975         altsd = get_iface_desc(alts);
2976         err = parse_audio_endpoints(chip, altsd->bInterfaceNumber);
2977         if (err < 0) {
2978                 snd_printk(KERN_ERR "cannot setup if %d: error %d\n",
2979                            altsd->bInterfaceNumber, err);
2980                 return err;
2981         }
2982         /* reset the current interface */
2983         usb_set_interface(chip->dev, altsd->bInterfaceNumber, 0);
2984         return 0;
2985 }
2986
2987 /*
2988  * Create a stream for an Edirol UA-700/UA-25/UA-4FX interface.
2989  * The only way to detect the sample rate is by looking at wMaxPacketSize.
2990  */
2991 static int create_uaxx_quirk(struct snd_usb_audio *chip,
2992                               struct usb_interface *iface,
2993                               const struct snd_usb_audio_quirk *quirk)
2994 {
2995         static const struct audioformat ua_format = {
2996                 .format = SNDRV_PCM_FORMAT_S24_3LE,
2997                 .channels = 2,
2998                 .fmt_type = USB_FORMAT_TYPE_I,
2999                 .altsetting = 1,
3000                 .altset_idx = 1,
3001                 .rates = SNDRV_PCM_RATE_CONTINUOUS,
3002         };
3003         struct usb_host_interface *alts;
3004         struct usb_interface_descriptor *altsd;
3005         struct audioformat *fp;
3006         int stream, err;
3007
3008         /* both PCM and MIDI interfaces have 2 or more altsettings */
3009         if (iface->num_altsetting < 2)
3010                 return -ENXIO;
3011         alts = &iface->altsetting[1];
3012         altsd = get_iface_desc(alts);
3013
3014         if (altsd->bNumEndpoints == 2) {
3015                 static const struct snd_usb_midi_endpoint_info ua700_ep = {
3016                         .out_cables = 0x0003,
3017                         .in_cables  = 0x0003
3018                 };
3019                 static const struct snd_usb_audio_quirk ua700_quirk = {
3020                         .type = QUIRK_MIDI_FIXED_ENDPOINT,
3021                         .data = &ua700_ep
3022                 };
3023                 static const struct snd_usb_midi_endpoint_info uaxx_ep = {
3024                         .out_cables = 0x0001,
3025                         .in_cables  = 0x0001
3026                 };
3027                 static const struct snd_usb_audio_quirk uaxx_quirk = {
3028                         .type = QUIRK_MIDI_FIXED_ENDPOINT,
3029                         .data = &uaxx_ep
3030                 };
3031                 if (chip->usb_id == USB_ID(0x0582, 0x002b))
3032                         return snd_usb_create_midi_interface(chip, iface,
3033                                                              &ua700_quirk);
3034                 else
3035                         return snd_usb_create_midi_interface(chip, iface,
3036                                                              &uaxx_quirk);
3037         }
3038
3039         if (altsd->bNumEndpoints != 1)
3040                 return -ENXIO;
3041
3042         fp = kmalloc(sizeof(*fp), GFP_KERNEL);
3043         if (!fp)
3044                 return -ENOMEM;
3045         memcpy(fp, &ua_format, sizeof(*fp));
3046
3047         fp->iface = altsd->bInterfaceNumber;
3048         fp->endpoint = get_endpoint(alts, 0)->bEndpointAddress;
3049         fp->ep_attr = get_endpoint(alts, 0)->bmAttributes;
3050         fp->maxpacksize = le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize);
3051
3052         switch (fp->maxpacksize) {
3053         case 0x120:
3054                 fp->rate_max = fp->rate_min = 44100;
3055                 break;
3056         case 0x138:
3057         case 0x140:
3058                 fp->rate_max = fp->rate_min = 48000;
3059                 break;
3060         case 0x258:
3061         case 0x260:
3062                 fp->rate_max = fp->rate_min = 96000;
3063                 break;
3064         default:
3065                 snd_printk(KERN_ERR "unknown sample rate\n");
3066                 kfree(fp);
3067                 return -ENXIO;
3068         }
3069
3070         stream = (fp->endpoint & USB_DIR_IN)
3071                 ? SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK;
3072         err = add_audio_endpoint(chip, stream, fp);
3073         if (err < 0) {
3074                 kfree(fp);
3075                 return err;
3076         }
3077         usb_set_interface(chip->dev, fp->iface, 0);
3078         return 0;
3079 }
3080
3081 /*
3082  * Create a stream for an Edirol UA-1000 interface.
3083  */
3084 static int create_ua1000_quirk(struct snd_usb_audio *chip,
3085                                struct usb_interface *iface,
3086                                const struct snd_usb_audio_quirk *quirk)
3087 {
3088         static const struct audioformat ua1000_format = {
3089                 .format = SNDRV_PCM_FORMAT_S32_LE,
3090                 .fmt_type = USB_FORMAT_TYPE_I,
3091                 .altsetting = 1,
3092                 .altset_idx = 1,
3093                 .attributes = 0,
3094                 .rates = SNDRV_PCM_RATE_CONTINUOUS,
3095         };
3096         struct usb_host_interface *alts;
3097         struct usb_interface_descriptor *altsd;
3098         struct audioformat *fp;
3099         int stream, err;
3100
3101         if (iface->num_altsetting != 2)
3102                 return -ENXIO;
3103         alts = &iface->altsetting[1];
3104         altsd = get_iface_desc(alts);
3105         if (alts->extralen != 11 || alts->extra[1] != USB_DT_CS_INTERFACE ||
3106             altsd->bNumEndpoints != 1)
3107                 return -ENXIO;
3108
3109         fp = kmemdup(&ua1000_format, sizeof(*fp), GFP_KERNEL);
3110         if (!fp)
3111                 return -ENOMEM;
3112
3113         fp->channels = alts->extra[4];
3114         fp->iface = altsd->bInterfaceNumber;
3115         fp->endpoint = get_endpoint(alts, 0)->bEndpointAddress;
3116         fp->ep_attr = get_endpoint(alts, 0)->bmAttributes;
3117         fp->maxpacksize = le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize);
3118         fp->rate_max = fp->rate_min = combine_triple(&alts->extra[8]);
3119
3120         stream = (fp->endpoint & USB_DIR_IN)
3121                 ? SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK;
3122         err = add_audio_endpoint(chip, stream, fp);
3123         if (err < 0) {
3124                 kfree(fp);
3125                 return err;
3126         }
3127         /* FIXME: playback must be synchronized to capture */
3128         usb_set_interface(chip->dev, fp->iface, 0);
3129         return 0;
3130 }
3131
3132 /*
3133  * Create a stream for an Edirol UA-101 interface.
3134  * Copy, paste and modify from Edirol UA-1000
3135  */
3136 static int create_ua101_quirk(struct snd_usb_audio *chip,
3137                                struct usb_interface *iface,
3138                                const struct snd_usb_audio_quirk *quirk)
3139 {
3140         static const struct audioformat ua101_format = {
3141                 .format = SNDRV_PCM_FORMAT_S32_LE,
3142                 .fmt_type = USB_FORMAT_TYPE_I,
3143                 .altsetting = 1,
3144                 .altset_idx = 1,
3145                 .attributes = 0,
3146                 .rates = SNDRV_PCM_RATE_CONTINUOUS,
3147         };
3148         struct usb_host_interface *alts;
3149         struct usb_interface_descriptor *altsd;
3150         struct audioformat *fp;
3151         int stream, err;
3152
3153         if (iface->num_altsetting != 2)
3154                 return -ENXIO;
3155         alts = &iface->altsetting[1];
3156         altsd = get_iface_desc(alts);
3157         if (alts->extralen != 18 || alts->extra[1] != USB_DT_CS_INTERFACE ||
3158             altsd->bNumEndpoints != 1)
3159                 return -ENXIO;
3160
3161         fp = kmemdup(&ua101_format, sizeof(*fp), GFP_KERNEL);
3162         if (!fp)
3163                 return -ENOMEM;
3164
3165         fp->channels = alts->extra[11];
3166         fp->iface = altsd->bInterfaceNumber;
3167         fp->endpoint = get_endpoint(alts, 0)->bEndpointAddress;
3168         fp->ep_attr = get_endpoint(alts, 0)->bmAttributes;
3169         fp->maxpacksize = le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize);
3170         fp->rate_max = fp->rate_min = combine_triple(&alts->extra[15]);
3171
3172         stream = (fp->endpoint & USB_DIR_IN)
3173                 ? SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK;
3174         err = add_audio_endpoint(chip, stream, fp);
3175         if (err < 0) {
3176                 kfree(fp);
3177                 return err;
3178         }
3179         /* FIXME: playback must be synchronized to capture */
3180         usb_set_interface(chip->dev, fp->iface, 0);
3181         return 0;
3182 }
3183
3184 static int snd_usb_create_quirk(struct snd_usb_audio *chip,
3185                                 struct usb_interface *iface,
3186                                 const struct snd_usb_audio_quirk *quirk);
3187
3188 /*
3189  * handle the quirks for the contained interfaces
3190  */
3191 static int create_composite_quirk(struct snd_usb_audio *chip,
3192                                   struct usb_interface *iface,
3193                                   const struct snd_usb_audio_quirk *quirk)
3194 {
3195         int probed_ifnum = get_iface_desc(iface->altsetting)->bInterfaceNumber;
3196         int err;
3197
3198         for (quirk = quirk->data; quirk->ifnum >= 0; ++quirk) {
3199                 iface = usb_ifnum_to_if(chip->dev, quirk->ifnum);
3200                 if (!iface)
3201                         continue;
3202                 if (quirk->ifnum != probed_ifnum &&
3203                     usb_interface_claimed(iface))
3204                         continue;
3205                 err = snd_usb_create_quirk(chip, iface, quirk);
3206                 if (err < 0)
3207                         return err;
3208                 if (quirk->ifnum != probed_ifnum)
3209                         usb_driver_claim_interface(&usb_audio_driver, iface, (void *)-1L);
3210         }
3211         return 0;
3212 }
3213
3214 static int ignore_interface_quirk(struct snd_usb_audio *chip,
3215                                   struct usb_interface *iface,
3216                                   const struct snd_usb_audio_quirk *quirk)
3217 {
3218         return 0;
3219 }
3220
3221
3222 /*
3223  * boot quirks
3224  */
3225
3226 #define EXTIGY_FIRMWARE_SIZE_OLD 794
3227 #define EXTIGY_FIRMWARE_SIZE_NEW 483
3228
3229 static int snd_usb_extigy_boot_quirk(struct usb_device *dev, struct usb_interface *intf)
3230 {
3231         struct usb_host_config *config = dev->actconfig;
3232         int err;
3233
3234         if (le16_to_cpu(get_cfg_desc(config)->wTotalLength) == EXTIGY_FIRMWARE_SIZE_OLD ||
3235             le16_to_cpu(get_cfg_desc(config)->wTotalLength) == EXTIGY_FIRMWARE_SIZE_NEW) {
3236                 snd_printdd("sending Extigy boot sequence...\n");
3237                 /* Send message to force it to reconnect with full interface. */
3238                 err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev,0),
3239                                       0x10, 0x43, 0x0001, 0x000a, NULL, 0, 1000);
3240                 if (err < 0) snd_printdd("error sending boot message: %d\n", err);
3241                 err = usb_get_descriptor(dev, USB_DT_DEVICE, 0,
3242                                 &dev->descriptor, sizeof(dev->descriptor));
3243                 config = dev->actconfig;
3244                 if (err < 0) snd_printdd("error usb_get_descriptor: %d\n", err);
3245                 err = usb_reset_configuration(dev);
3246                 if (err < 0) snd_printdd("error usb_reset_configuration: %d\n", err);
3247                 snd_printdd("extigy_boot: new boot length = %d\n",
3248                             le16_to_cpu(get_cfg_desc(config)->wTotalLength));
3249                 return -ENODEV; /* quit this anyway */
3250         }
3251         return 0;
3252 }
3253
3254 static int snd_usb_audigy2nx_boot_quirk(struct usb_device *dev)
3255 {
3256         u8 buf = 1;
3257
3258         snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), 0x2a,
3259                         USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_OTHER,
3260                         0, 0, &buf, 1, 1000);
3261         if (buf == 0) {
3262                 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 0x29,
3263                                 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
3264                                 1, 2000, NULL, 0, 1000);
3265                 return -ENODEV;
3266         }
3267         return 0;
3268 }
3269
3270 /*
3271  * C-Media CM106/CM106+ have four 16-bit internal registers that are nicely
3272  * documented in the device's data sheet.
3273  */
3274 static int snd_usb_cm106_write_int_reg(struct usb_device *dev, int reg, u16 value)
3275 {
3276         u8 buf[4];
3277         buf[0] = 0x20;
3278         buf[1] = value & 0xff;
3279         buf[2] = (value >> 8) & 0xff;
3280         buf[3] = reg;
3281         return snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), USB_REQ_SET_CONFIGURATION,
3282                                USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_ENDPOINT,
3283                                0, 0, &buf, 4, 1000);
3284 }
3285
3286 static int snd_usb_cm106_boot_quirk(struct usb_device *dev)
3287 {
3288         /*
3289          * Enable line-out driver mode, set headphone source to front
3290          * channels, enable stereo mic.
3291          */
3292         return snd_usb_cm106_write_int_reg(dev, 2, 0x8004);
3293 }
3294
3295
3296 /*
3297  * Setup quirks
3298  */
3299 #define AUDIOPHILE_SET                  0x01 /* if set, parse device_setup */
3300 #define AUDIOPHILE_SET_DTS              0x02 /* if set, enable DTS Digital Output */
3301 #define AUDIOPHILE_SET_96K              0x04 /* 48-96KHz rate if set, 8-48KHz otherwise */
3302 #define AUDIOPHILE_SET_24B              0x08 /* 24bits sample if set, 16bits otherwise */
3303 #define AUDIOPHILE_SET_DI               0x10 /* if set, enable Digital Input */
3304 #define AUDIOPHILE_SET_MASK             0x1F /* bit mask for setup value */
3305 #define AUDIOPHILE_SET_24B_48K_DI       0x19 /* value for 24bits+48KHz+Digital Input */
3306 #define AUDIOPHILE_SET_24B_48K_NOTDI    0x09 /* value for 24bits+48KHz+No Digital Input */
3307 #define AUDIOPHILE_SET_16B_48K_DI       0x11 /* value for 16bits+48KHz+Digital Input */
3308 #define AUDIOPHILE_SET_16B_48K_NOTDI    0x01 /* value for 16bits+48KHz+No Digital Input */
3309
3310 static int audiophile_skip_setting_quirk(struct snd_usb_audio *chip,
3311                                          int iface, int altno)
3312 {
3313         /* Reset ALL ifaces to 0 altsetting.
3314          * Call it for every possible altsetting of every interface.
3315          */
3316         usb_set_interface(chip->dev, iface, 0);
3317
3318         if (device_setup[chip->index] & AUDIOPHILE_SET) {
3319                 if ((device_setup[chip->index] & AUDIOPHILE_SET_DTS)
3320                     && altno != 6)
3321                         return 1; /* skip this altsetting */
3322                 if ((device_setup[chip->index] & AUDIOPHILE_SET_96K)
3323                     && altno != 1)
3324                         return 1; /* skip this altsetting */
3325                 if ((device_setup[chip->index] & AUDIOPHILE_SET_MASK) ==
3326                     AUDIOPHILE_SET_24B_48K_DI && altno != 2)
3327                         return 1; /* skip this altsetting */
3328                 if ((device_setup[chip->index] & AUDIOPHILE_SET_MASK) ==
3329                     AUDIOPHILE_SET_24B_48K_NOTDI && altno != 3)
3330                         return 1; /* skip this altsetting */
3331                 if ((device_setup[chip->index] & AUDIOPHILE_SET_MASK) ==
3332                     AUDIOPHILE_SET_16B_48K_DI && altno != 4)
3333                         return 1; /* skip this altsetting */
3334                 if ((device_setup[chip->index] & AUDIOPHILE_SET_MASK) ==
3335                     AUDIOPHILE_SET_16B_48K_NOTDI && altno != 5)
3336                         return 1; /* skip this altsetting */
3337         }
3338         return 0; /* keep this altsetting */
3339 }
3340
3341 /*
3342  * audio-interface quirks
3343  *
3344  * returns zero if no standard audio/MIDI parsing is needed.
3345  * returns a postive value if standard audio/midi interfaces are parsed
3346  * after this.
3347  * returns a negative value at error.
3348  */
3349 static int snd_usb_create_quirk(struct snd_usb_audio *chip,
3350                                 struct usb_interface *iface,
3351                                 const struct snd_usb_audio_quirk *quirk)
3352 {
3353         typedef int (*quirk_func_t)(struct snd_usb_audio *, struct usb_interface *,
3354                                     const struct snd_usb_audio_quirk *);
3355         static const quirk_func_t quirk_funcs[] = {
3356                 [QUIRK_IGNORE_INTERFACE] = ignore_interface_quirk,
3357                 [QUIRK_COMPOSITE] = create_composite_quirk,
3358                 [QUIRK_MIDI_STANDARD_INTERFACE] = snd_usb_create_midi_interface,
3359                 [QUIRK_MIDI_FIXED_ENDPOINT] = snd_usb_create_midi_interface,
3360                 [QUIRK_MIDI_YAMAHA] = snd_usb_create_midi_interface,
3361                 [QUIRK_MIDI_MIDIMAN] = snd_usb_create_midi_interface,
3362                 [QUIRK_MIDI_NOVATION] = snd_usb_create_midi_interface,
3363                 [QUIRK_MIDI_RAW] = snd_usb_create_midi_interface,
3364                 [QUIRK_MIDI_EMAGIC] = snd_usb_create_midi_interface,
3365                 [QUIRK_MIDI_CME] = snd_usb_create_midi_interface,
3366                 [QUIRK_AUDIO_STANDARD_INTERFACE] = create_standard_audio_quirk,
3367                 [QUIRK_AUDIO_FIXED_ENDPOINT] = create_fixed_stream_quirk,
3368                 [QUIRK_AUDIO_EDIROL_UA1000] = create_ua1000_quirk,
3369                 [QUIRK_AUDIO_EDIROL_UA101] = create_ua101_quirk,
3370                 [QUIRK_AUDIO_EDIROL_UAXX] = create_uaxx_quirk
3371         };
3372
3373         if (quirk->type < QUIRK_TYPE_COUNT) {
3374                 return quirk_funcs[quirk->type](chip, iface, quirk);
3375         } else {
3376                 snd_printd(KERN_ERR "invalid quirk type %d\n", quirk->type);
3377                 return -ENXIO;
3378         }
3379 }
3380
3381
3382 /*
3383  * common proc files to show the usb device info
3384  */
3385 static void proc_audio_usbbus_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
3386 {
3387         struct snd_usb_audio *chip = entry->private_data;
3388         if (!chip->shutdown)
3389                 snd_iprintf(buffer, "%03d/%03d\n", chip->dev->bus->busnum, chip->dev->devnum);
3390 }
3391
3392 static void proc_audio_usbid_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
3393 {
3394         struct snd_usb_audio *chip = entry->private_data;
3395         if (!chip->shutdown)
3396                 snd_iprintf(buffer, "%04x:%04x\n",
3397                             USB_ID_VENDOR(chip->usb_id),
3398                             USB_ID_PRODUCT(chip->usb_id));
3399 }
3400
3401 static void snd_usb_audio_create_proc(struct snd_usb_audio *chip)
3402 {
3403         struct snd_info_entry *entry;
3404         if (!snd_card_proc_new(chip->card, "usbbus", &entry))
3405                 snd_info_set_text_ops(entry, chip, proc_audio_usbbus_read);
3406         if (!snd_card_proc_new(chip->card, "usbid", &entry))
3407                 snd_info_set_text_ops(entry, chip, proc_audio_usbid_read);
3408 }
3409
3410 /*
3411  * free the chip instance
3412  *
3413  * here we have to do not much, since pcm and controls are already freed
3414  *
3415  */
3416
3417 static int snd_usb_audio_free(struct snd_usb_audio *chip)
3418 {
3419         kfree(chip);
3420         return 0;
3421 }
3422
3423 static int snd_usb_audio_dev_free(struct snd_device *device)
3424 {
3425         struct snd_usb_audio *chip = device->device_data;
3426         return snd_usb_audio_free(chip);
3427 }
3428
3429
3430 /*
3431  * create a chip instance and set its names.
3432  */
3433 static int snd_usb_audio_create(struct usb_device *dev, int idx,
3434                                 const struct snd_usb_audio_quirk *quirk,
3435                                 struct snd_usb_audio **rchip)
3436 {
3437         struct snd_card *card;
3438         struct snd_usb_audio *chip;
3439         int err, len;
3440         char component[14];
3441         static struct snd_device_ops ops = {
3442                 .dev_free =     snd_usb_audio_dev_free,
3443         };
3444
3445         *rchip = NULL;
3446
3447         if (snd_usb_get_speed(dev) != USB_SPEED_LOW &&
3448             snd_usb_get_speed(dev) != USB_SPEED_FULL &&
3449             snd_usb_get_speed(dev) != USB_SPEED_HIGH) {
3450                 snd_printk(KERN_ERR "unknown device speed %d\n", snd_usb_get_speed(dev));
3451                 return -ENXIO;
3452         }
3453
3454         card = snd_card_new(index[idx], id[idx], THIS_MODULE, 0);
3455         if (card == NULL) {
3456                 snd_printk(KERN_ERR "cannot create card instance %d\n", idx);
3457                 return -ENOMEM;
3458         }
3459
3460         chip = kzalloc(sizeof(*chip), GFP_KERNEL);
3461         if (! chip) {
3462                 snd_card_free(card);
3463                 return -ENOMEM;
3464         }
3465
3466         chip->index = idx;
3467         chip->dev = dev;
3468         chip->card = card;
3469         chip->usb_id = USB_ID(le16_to_cpu(dev->descriptor.idVendor),
3470                               le16_to_cpu(dev->descriptor.idProduct));
3471         INIT_LIST_HEAD(&chip->pcm_list);
3472         INIT_LIST_HEAD(&chip->midi_list);
3473         INIT_LIST_HEAD(&chip->mixer_list);
3474
3475         if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) {
3476                 snd_usb_audio_free(chip);
3477                 snd_card_free(card);
3478                 return err;
3479         }
3480
3481         strcpy(card->driver, "USB-Audio");
3482         sprintf(component, "USB%04x:%04x",
3483                 USB_ID_VENDOR(chip->usb_id), USB_ID_PRODUCT(chip->usb_id));
3484         snd_component_add(card, component);
3485
3486         /* retrieve the device string as shortname */
3487         if (quirk && quirk->product_name) {
3488                 strlcpy(card->shortname, quirk->product_name, sizeof(card->shortname));
3489         } else {
3490                 if (!dev->descriptor.iProduct ||
3491                     usb_string(dev, dev->descriptor.iProduct,
3492                                card->shortname, sizeof(card->shortname)) <= 0) {
3493                         /* no name available from anywhere, so use ID */
3494                         sprintf(card->shortname, "USB Device %#04x:%#04x",
3495                                 USB_ID_VENDOR(chip->usb_id),
3496                                 USB_ID_PRODUCT(chip->usb_id));
3497                 }
3498         }
3499
3500         /* retrieve the vendor and device strings as longname */
3501         if (quirk && quirk->vendor_name) {
3502                 len = strlcpy(card->longname, quirk->vendor_name, sizeof(card->longname));
3503         } else {
3504                 if (dev->descriptor.iManufacturer)
3505                         len = usb_string(dev, dev->descriptor.iManufacturer,
3506                                          card->longname, sizeof(card->longname));
3507                 else
3508                         len = 0;
3509                 /* we don't really care if there isn't any vendor string */
3510         }
3511         if (len > 0)
3512                 strlcat(card->longname, " ", sizeof(card->longname));
3513
3514         strlcat(card->longname, card->shortname, sizeof(card->longname));
3515
3516         len = strlcat(card->longname, " at ", sizeof(card->longname));
3517
3518         if (len < sizeof(card->longname))
3519                 usb_make_path(dev, card->longname + len, sizeof(card->longname) - len);
3520
3521         strlcat(card->longname,
3522                 snd_usb_get_speed(dev) == USB_SPEED_LOW ? ", low speed" :
3523                 snd_usb_get_speed(dev) == USB_SPEED_FULL ? ", full speed" :
3524                 ", high speed",
3525                 sizeof(card->longname));
3526
3527         snd_usb_audio_create_proc(chip);
3528
3529         *rchip = chip;
3530         return 0;
3531 }
3532
3533
3534 /*
3535  * probe the active usb device
3536  *
3537  * note that this can be called multiple times per a device, when it
3538  * includes multiple audio control interfaces.
3539  *
3540  * thus we check the usb device pointer and creates the card instance
3541  * only at the first time.  the successive calls of this function will
3542  * append the pcm interface to the corresponding card.
3543  */
3544 static void *snd_usb_audio_probe(struct usb_device *dev,
3545                                  struct usb_interface *intf,
3546                                  const struct usb_device_id *usb_id)
3547 {
3548         const struct snd_usb_audio_quirk *quirk = (const struct snd_usb_audio_quirk *)usb_id->driver_info;
3549         int i, err;
3550         struct snd_usb_audio *chip;
3551         struct usb_host_interface *alts;
3552         int ifnum;
3553         u32 id;
3554
3555         alts = &intf->altsetting[0];
3556         ifnum = get_iface_desc(alts)->bInterfaceNumber;
3557         id = USB_ID(le16_to_cpu(dev->descriptor.idVendor),
3558                     le16_to_cpu(dev->descriptor.idProduct));
3559
3560         if (quirk && quirk->ifnum >= 0 && ifnum != quirk->ifnum)
3561                 goto __err_val;
3562
3563         /* SB Extigy needs special boot-up sequence */
3564         /* if more models come, this will go to the quirk list. */
3565         if (id == USB_ID(0x041e, 0x3000)) {
3566                 if (snd_usb_extigy_boot_quirk(dev, intf) < 0)
3567                         goto __err_val;
3568         }
3569         /* SB Audigy 2 NX needs its own boot-up magic, too */
3570         if (id == USB_ID(0x041e, 0x3020)) {
3571                 if (snd_usb_audigy2nx_boot_quirk(dev) < 0)
3572                         goto __err_val;
3573         }
3574
3575         /* C-Media CM106 / Turtle Beach Audio Advantage Roadie */
3576         if (id == USB_ID(0x10f5, 0x0200)) {
3577                 if (snd_usb_cm106_boot_quirk(dev) < 0)
3578                         goto __err_val;
3579         }
3580
3581         /*
3582          * found a config.  now register to ALSA
3583          */
3584
3585         /* check whether it's already registered */
3586         chip = NULL;
3587         mutex_lock(&register_mutex);
3588         for (i = 0; i < SNDRV_CARDS; i++) {
3589                 if (usb_chip[i] && usb_chip[i]->dev == dev) {
3590                         if (usb_chip[i]->shutdown) {
3591                                 snd_printk(KERN_ERR "USB device is in the shutdown state, cannot create a card instance\n");
3592                                 goto __error;
3593                         }
3594                         chip = usb_chip[i];
3595                         break;
3596                 }
3597         }
3598         if (! chip) {
3599                 /* it's a fresh one.
3600                  * now look for an empty slot and create a new card instance
3601                  */
3602                 for (i = 0; i < SNDRV_CARDS; i++)
3603                         if (enable[i] && ! usb_chip[i] &&
3604                             (vid[i] == -1 || vid[i] == USB_ID_VENDOR(id)) &&
3605                             (pid[i] == -1 || pid[i] == USB_ID_PRODUCT(id))) {
3606                                 if (snd_usb_audio_create(dev, i, quirk, &chip) < 0) {
3607                                         goto __error;
3608                                 }
3609                                 snd_card_set_dev(chip->card, &intf->dev);
3610                                 break;
3611                         }
3612                 if (!chip) {
3613                         printk(KERN_ERR "no available usb audio device\n");
3614                         goto __error;
3615                 }
3616         }
3617
3618         err = 1; /* continue */
3619         if (quirk && quirk->ifnum != QUIRK_NO_INTERFACE) {
3620                 /* need some special handlings */
3621                 if ((err = snd_usb_create_quirk(chip, intf, quirk)) < 0)
3622                         goto __error;
3623         }
3624
3625         if (err > 0) {
3626                 /* create normal USB audio interfaces */
3627                 if (snd_usb_create_streams(chip, ifnum) < 0 ||
3628                     snd_usb_create_mixer(chip, ifnum, ignore_ctl_error) < 0) {
3629                         goto __error;
3630                 }
3631         }
3632
3633         /* we are allowed to call snd_card_register() many times */
3634         if (snd_card_register(chip->card) < 0) {
3635                 goto __error;
3636         }
3637
3638         usb_chip[chip->index] = chip;
3639         chip->num_interfaces++;
3640         mutex_unlock(&register_mutex);
3641         return chip;
3642
3643  __error:
3644         if (chip && !chip->num_interfaces)
3645                 snd_card_free(chip->card);
3646         mutex_unlock(&register_mutex);
3647  __err_val:
3648         return NULL;
3649 }
3650
3651 /*
3652  * we need to take care of counter, since disconnection can be called also
3653  * many times as well as usb_audio_probe().
3654  */
3655 static void snd_usb_audio_disconnect(struct usb_device *dev, void *ptr)
3656 {
3657         struct snd_usb_audio *chip;
3658         struct snd_card *card;
3659         struct list_head *p;
3660
3661         if (ptr == (void *)-1L)
3662                 return;
3663
3664         chip = ptr;
3665         card = chip->card;
3666         mutex_lock(&register_mutex);
3667         chip->shutdown = 1;
3668         chip->num_interfaces--;
3669         if (chip->num_interfaces <= 0) {
3670                 snd_card_disconnect(card);
3671                 /* release the pcm resources */
3672                 list_for_each(p, &chip->pcm_list) {
3673                         snd_usb_stream_disconnect(p);
3674                 }
3675                 /* release the midi resources */
3676                 list_for_each(p, &chip->midi_list) {
3677                         snd_usbmidi_disconnect(p);
3678                 }
3679                 /* release mixer resources */
3680                 list_for_each(p, &chip->mixer_list) {
3681                         snd_usb_mixer_disconnect(p);
3682                 }
3683                 usb_chip[chip->index] = NULL;
3684                 mutex_unlock(&register_mutex);
3685                 snd_card_free_when_closed(card);
3686         } else {
3687                 mutex_unlock(&register_mutex);
3688         }
3689 }
3690
3691 /*
3692  * new 2.5 USB kernel API
3693  */
3694 static int usb_audio_probe(struct usb_interface *intf,
3695                            const struct usb_device_id *id)
3696 {
3697         void *chip;
3698         chip = snd_usb_audio_probe(interface_to_usbdev(intf), intf, id);
3699         if (chip) {
3700                 usb_set_intfdata(intf, chip);
3701                 return 0;
3702         } else
3703                 return -EIO;
3704 }
3705
3706 static void usb_audio_disconnect(struct usb_interface *intf)
3707 {
3708         snd_usb_audio_disconnect(interface_to_usbdev(intf),
3709                                  usb_get_intfdata(intf));
3710 }
3711
3712 #ifdef CONFIG_PM
3713 static int usb_audio_suspend(struct usb_interface *intf, pm_message_t message)
3714 {
3715         struct snd_usb_audio *chip = usb_get_intfdata(intf);
3716         struct list_head *p;
3717         struct snd_usb_stream *as;
3718
3719         if (chip == (void *)-1L)
3720                 return 0;
3721
3722         snd_power_change_state(chip->card, SNDRV_CTL_POWER_D3hot);
3723         if (!chip->num_suspended_intf++) {
3724                 list_for_each(p, &chip->pcm_list) {
3725                         as = list_entry(p, struct snd_usb_stream, list);
3726                         snd_pcm_suspend_all(as->pcm);
3727                 }
3728         }
3729
3730         return 0;
3731 }
3732
3733 static int usb_audio_resume(struct usb_interface *intf)
3734 {
3735         struct snd_usb_audio *chip = usb_get_intfdata(intf);
3736
3737         if (chip == (void *)-1L)
3738                 return 0;
3739         if (--chip->num_suspended_intf)
3740                 return 0;
3741         /*
3742          * ALSA leaves material resumption to user space
3743          * we just notify
3744          */
3745
3746         snd_power_change_state(chip->card, SNDRV_CTL_POWER_D0);
3747
3748         return 0;
3749 }
3750 #endif          /* CONFIG_PM */
3751
3752 static int __init snd_usb_audio_init(void)
3753 {
3754         if (nrpacks < MIN_PACKS_URB || nrpacks > MAX_PACKS) {
3755                 printk(KERN_WARNING "invalid nrpacks value.\n");
3756                 return -EINVAL;
3757         }
3758         return usb_register(&usb_audio_driver);
3759 }
3760
3761
3762 static void __exit snd_usb_audio_cleanup(void)
3763 {
3764         usb_deregister(&usb_audio_driver);
3765 }
3766
3767 module_init(snd_usb_audio_init);
3768 module_exit(snd_usb_audio_cleanup);