drivers/usb/audio.c

   1 /*****************************************************************************/
   2
   3 /*
   4  *      audio.c  --  USB Audio Class driver
   5  *
   6  *      Copyright (C) 1999, 2000, 2001
   7  *          Alan Cox (alan@lxorguk.ukuu.org.uk)
   8  *          Thomas Sailer (sailer@ife.ee.ethz.ch)
   9  *
  10  *      This program is free software; you can redistribute it and/or modify
  11  *      it under the terms of the GNU General Public License as published by
  12  *      the Free Software Foundation; either version 2 of the License, or
  13  *      (at your option) any later version.
  14  *
  15  * Debugging:
  16  *      Use the 'lsusb' utility to dump the descriptors.
  17  *
  18  * 1999-09-07:  Alan Cox
  19  *              Parsing Audio descriptor patch
  20  * 1999-09-08:  Thomas Sailer
  21  *              Added OSS compatible data io functions; both parts of the
  22  *              driver remain to be glued together
  23  * 1999-09-10:  Thomas Sailer
  24  *              Beautified the driver. Added sample format conversions.
  25  *              Still not properly glued with the parsing code.
  26  *              The parsing code seems to have its problems btw,
  27  *              Since it parses all available configs but doesn't
  28  *              store which iface/altsetting belongs to which config.
  29  * 1999-09-20:  Thomas Sailer
  30  *              Threw out Alan's parsing code and implemented my own one.
  31  *              You cannot reasonnably linearly parse audio descriptors,
  32  *              especially the AudioClass descriptors have to be considered
  33  *              pointer lists. Mixer parsing untested, due to lack of device.
  34  *              First stab at synch pipe implementation, the Dallas USB DAC
  35  *              wants to use an Asynch out pipe. usb_audio_state now basically
  36  *              only contains lists of mixer and wave devices. We can therefore
  37  *              now have multiple mixer/wave devices per USB device.
  38  * 1999-10-28:  Thomas Sailer
  39  *              Converted to URB API. Fixed a taskstate/wakeup semantics mistake
  40  *              that made the driver consume all available CPU cycles.
  41  *              Now runs stable on UHCI-Acher/Fliegl/Sailer.
  42  * 1999-10-31:  Thomas Sailer
  43  *              Audio can now be unloaded if it is not in use by any mixer
  44  *              or dsp client (formerly you had to disconnect the audio devices
  45  *              from the USB port)
  46  *              Finally, about three months after ordering, my "Maxxtro SPK222"
  47  *              speakers arrived, isn't disdata a great mail order company 8-)
  48  *              Parse class specific endpoint descriptor of the audiostreaming
  49  *              interfaces and take the endpoint attributes from there.
  50  *              Unbelievably, the Philips USB DAC has a sampling rate range
  51  *              of over a decade, yet does not support the sampling rate control!
  52  *              No wonder it sounds so bad, has very audible sampling rate
  53  *              conversion distortion. Don't try to listen to it using
  54  *              decent headphones!
  55  *              "Let's make things better" -> but please Philips start with your
  56  *              own stuff!!!!
  57  * 1999-11-02:  Thomas Sailer
  58  *              It takes the Philips boxes several seconds to acquire synchronisation
  59  *              that means they won't play short sounds. Should probably maintain
  60  *              the ISO datastream even if there's nothing to play.
  61  *              Fix counting the total_bytes counter, RealPlayer G2 depends on it.
  62  * 1999-12-20:  Thomas Sailer
  63  *              Fix bad bug in conversion to per interface probing.
  64  *              disconnect was called multiple times for the audio device,
  65  *              leading to a premature freeing of the audio structures
  66  * 2000-05-13:  Thomas Sailer
  67  *              I don't remember who changed the find_format routine,
  68  *              but the change was completely broken for the Dallas
  69  *              chip. Anyway taking sampling rate into account in find_format
  70  *              is bad and should not be done unless there are devices with
  71  *              completely broken audio descriptors. Unless someone shows
  72  *              me such a descriptor, I will not allow find_format to
  73  *              take the sampling rate into account.
  74  *              Also, the former find_format made:
  75  *              - mpg123 play mono instead of stereo
  76  *              - sox completely fail for wav's with sample rates < 44.1kHz
  77  *                  for the Dallas chip.
  78  *              Also fix a rather long standing problem with applications that
  79  *              use "small" writes producing no sound at all.
  80  * 2000-05-15:  Thomas Sailer
  81  *              My fears came true, the Philips camera indeed has pretty stupid
  82  *              audio descriptors.
  83  * 2000-05-17:  Thomas Sailer
  84  *              Nemsoft spotted my stupid last minute change, thanks
  85  * 2000-05-19:  Thomas Sailer
  86  *              Fixed FEATURE_UNIT thinkos found thanks to the KC Technology
  87  *              Xtend device. Basically the driver treated FEATURE_UNIT's sourced
  88  *              by mono terminals as stereo.
  89  * 2000-05-20:  Thomas Sailer
  90  *              SELECTOR support (and thus selecting record channels from the mixer).
  91  *              Somewhat peculiar due to OSS interface limitations. Only works
  92  *              for channels where a "slider" is already in front of it (i.e.
  93  *              a MIXER unit or a FEATURE unit with volume capability).
  94  * 2000-11-26:  Thomas Sailer
  95  *              Workaround for Dallas DS4201. The DS4201 uses PCM8 as format tag for
  96  *              its 8 bit modes, but expects signed data (and should therefore have used PCM).
  97  * 2001-03-10:  Thomas Sailer
  98  *              provide abs function, prevent picking up a bogus kernel macro
  99  *              for abs. Bug report by Andrew Morton <andrewm@uow.edu.au>
 100  * 2001-06-16:  Bryce Nesbitt <bryce@obviously.com>
 101  *              Fix SNDCTL_DSP_STEREO API violation
 102  * 2002-10-16:  Monty <monty@xiph.org>
 103  *              Expand device support from a maximum of 8/16bit,mono/stereo to
 104  *              8/16/24/32bit,N channels.  Add AFMT_?24_?? and AFMT_?32_?? to OSS
 105  *              functionality. Tested and used in production with the emagic emi 2|6
 106  *              on PPC and Intel. Also fixed a few logic 'crash and burn' corner
 107  *              cases.
 108  * 2003-06-30:  Thomas Sailer
 109  *              Fix SETTRIGGER non OSS API conformity
 110  */
 111
 112 /*
 113  * Strategy:
 114  *
 115  * Alan Cox and Thomas Sailer are starting to dig at opposite ends and
 116  * are hoping to meet in the middle, just like tunnel diggers :)
 117  * Alan tackles the descriptor parsing, Thomas the actual data IO and the
 118  * OSS compatible interface.
 119  *
 120  * Data IO implementation issues
 121  *
 122  * A mmap'able ring buffer per direction is implemented, because
 123  * almost every OSS app expects it. It is however impractical to
 124  * transmit/receive USB data directly into and out of the ring buffer,
 125  * due to alignment and synchronisation issues. Instead, the ring buffer
 126  * feeds a constant time delay line that handles the USB issues.
 127  *
 128  * Now we first try to find an alternate setting that exactly matches
 129  * the sample format requested by the user. If we find one, we do not
 130  * need to perform any sample rate conversions. If there is no matching
 131  * altsetting, we choose the closest one and perform sample format
 132  * conversions. We never do sample rate conversion; these are too
 133  * expensive to be performed in the kernel.
 134  *
 135  * Current status:
 136  * - Pretty stable on UHCI-Acher/Fliegl/Sailer
 137  * - Does not work on OHCI due to lack of OHCI driver supporting URB's
 138  *
 139  * Generally: Due to the brokenness of the Audio Class spec
 140  * it seems generally impossible to write a generic Audio Class driver,
 141  * so a reasonable driver should implement the features that are actually
 142  * used.
 143  *
 144  * Parsing implementation issues
 145  *
 146  * One cannot reasonably parse the AudioClass descriptors linearly.
 147  * Therefore the current implementation features routines to look
 148  * for a specific descriptor in the descriptor list.
 149  *
 150  * How does the parsing work? First, all interfaces are searched
 151  * for an AudioControl class interface. If found, the config descriptor
 152  * that belongs to the current configuration is fetched from the device.
 153  * Then the HEADER descriptor is fetched. It contains a list of
 154  * all AudioStreaming and MIDIStreaming devices. This list is then walked,
 155  * and all AudioStreaming interfaces are classified into input and output
 156  * interfaces (according to the endpoint0 direction in altsetting1) (MIDIStreaming
 157  * is currently not supported). The input & output list is then used
 158  * to group inputs and outputs together and issued pairwise to the
 159  * AudioStreaming class parser. Finally, all OUTPUT_TERMINAL descriptors
 160  * are walked and issued to the mixer construction routine.
 161  *
 162  * The AudioStreaming parser simply enumerates all altsettings belonging
 163  * to the specified interface. It looks for AS_GENERAL and FORMAT_TYPE
 164  * class specific descriptors to extract the sample format/sample rate
 165  * data. Only sample format types PCM and PCM8 are supported right now, and
 166  * only FORMAT_TYPE_I is handled. The isochronous data endpoint needs to
 167  * be the first endpoint of the interface, and the optional synchronisation
 168  * isochronous endpoint the second one.
 169  *
 170  * Mixer construction works as follows: The various TERMINAL and UNIT
 171  * descriptors span a tree from the root (OUTPUT_TERMINAL) through the
 172  * intermediate nodes (UNITs) to the leaves (INPUT_TERMINAL). We walk
 173  * that tree in a depth first manner. FEATURE_UNITs may contribute volume,
 174  * bass and treble sliders to the mixer, MIXER_UNITs volume sliders.
 175  * The terminal type encoded in the INPUT_TERMINALs feeds a heuristic
 176  * to determine "meaningful" OSS slider numbers, however we will see
 177  * how well this works in practice. Other features are not used at the
 178  * moment, they seem less often used. Also, it seems difficult at least
 179  * to construct recording source switches from SELECTOR_UNITs, but
 180  * since there are not many USB ADC's available, we leave that for later.
 181  */
 182
 183 /*****************************************************************************/
 184
 185 #include <linux/version.h>
 186 #include <linux/kernel.h>
 187 #include <linux/slab.h>
 188 #include <linux/string.h>
 189 #include <linux/timer.h>
 190 #include <linux/sched.h>
 191 #include <linux/smp_lock.h>
 192 #include <linux/module.h>
 193 #include <linux/sound.h>
 194 #include <linux/soundcard.h>
 195 #include <linux/list.h>
 196 #include <linux/vmalloc.h>
 197 #include <linux/wrapper.h>
 198 #include <linux/init.h>
 199 #include <linux/poll.h>
 200 #include <linux/bitops.h>
 201 #include <asm/uaccess.h>
 202 #include <asm/io.h>
 203 #include <linux/usb.h>
 204
 205 #include "audio.h"
 206
 207 /*
 208  * Version Information
 209  */
 210 #define DRIVER_VERSION "v1.0.0"
 211 #define DRIVER_AUTHOR "Alan Cox <alan@lxorguk.ukuu.org.uk>, Thomas Sailer (sailer@ife.ee.ethz.ch)"
 212 #define DRIVER_DESC "USB Audio Class driver"
 213
 214 #define AUDIO_DEBUG 1
 215
 216 #define SND_DEV_DSP16   5
 217
 218 #define dprintk(x)
 219
 220 /* --------------------------------------------------------------------- */
 221
 222 /*
 223  * Linked list of all audio devices...
 224  */
 225 static struct list_head audiodevs = LIST_HEAD_INIT(audiodevs);
 226 static DECLARE_MUTEX(open_sem);
 227
 228 /*
 229  * wait queue for processes wanting to open an USB audio device
 230  */
 231 static DECLARE_WAIT_QUEUE_HEAD(open_wait);
 232
 233
 234 #define MAXFORMATS        MAX_ALT
 235 #define DMABUFSHIFT       17  /* 128k worth of DMA buffer */
 236 #define NRSGBUF           (1U<<(DMABUFSHIFT-PAGE_SHIFT))
 237
 238 #define MAXCHANNELS       32
 239 #define MAXWIDTH          4
 240 #define MAXSAMPLEWIDTH    (MAXCHANNELS*MAXWIDTH)
 241 #define TMPCOPYWIDTH      MAXSAMPLEWIDTH /* max (128,MAXSAMPLEWIDTH) */
 242
 243 /*
 244  * This influences:
 245  * - Latency
 246  * - Interrupt rate
 247  * - Synchronisation behaviour
 248  * Don't touch this if you don't understand all of the above.
 249  */
 250 #define DESCFRAMES  5
 251 #define SYNCFRAMES  DESCFRAMES
 252
 253 #define MIXFLG_STEREOIN   1
 254 #define MIXFLG_STEREOOUT  2
 255
 256 struct mixerchannel {
 257         __u16 value;
 258         __u16 osschannel;  /* number of the OSS channel */
 259         __s16 minval, maxval;
 260         __u16 slctunitid;
 261         __u8 unitid;
 262         __u8 selector;
 263         __u8 chnum;
 264         __u8 flags;
 265 };
 266
 267 struct audioformat {
 268         unsigned int format;
 269         unsigned int sratelo;
 270         unsigned int sratehi;
 271         unsigned char altsetting;
 272         unsigned char attributes;
 273 };
 274
 275 struct dmabuf {
 276         /* buffer data format */
 277         unsigned int format;
 278         unsigned int srate;
 279         /* physical buffer */
 280         unsigned char *sgbuf[NRSGBUF];
 281         unsigned int bufsize;
 282         unsigned int numfrag;
 283         unsigned int fragshift;
 284         unsigned int wrptr, rdptr;
 285         unsigned int total_bytes;
 286         int count;
 287         unsigned int error; /* over/underrun */
 288         wait_queue_head_t wait;
 289         /* redundant, but makes calculations easier */
 290         unsigned int fragsize;
 291         unsigned int dmasize;
 292         /* OSS stuff */
 293         unsigned int mapped:1;
 294         unsigned int ready:1;
 295         unsigned int enabled:1;
 296         unsigned int ossfragshift;
 297         int ossmaxfrags;
 298         unsigned int subdivision;
 299 };
 300
 301 struct usb_audio_state;
 302
 303 #define FLG_URB0RUNNING   1
 304 #define FLG_URB1RUNNING   2
 305 #define FLG_SYNC0RUNNING  4
 306 #define FLG_SYNC1RUNNING  8
 307 #define FLG_RUNNING      16
 308 #define FLG_CONNECTED    32
 309
 310 struct my_data_urb {
 311         struct urb urb;
 312         struct iso_packet_descriptor isoframe[DESCFRAMES];
 313 };
 314
 315 struct my_sync_urb {
 316         struct urb urb;
 317         struct iso_packet_descriptor isoframe[SYNCFRAMES];
 318 };
 319
 320
 321 struct usb_audiodev {
 322         struct list_head list;
 323         struct usb_audio_state *state;
 324
 325         /* soundcore stuff */
 326         int dev_audio;
 327
 328         /* wave stuff */
 329         mode_t open_mode;
 330         spinlock_t lock;         /* DMA buffer access spinlock */
 331
 332         struct usbin {
 333                 int interface;           /* Interface number, -1 means not used */
 334                 unsigned int format;     /* USB data format */
 335                 unsigned int datapipe;   /* the data input pipe */
 336                 unsigned int syncpipe;   /* the synchronisation pipe - 0 for anything but adaptive IN mode */
 337                 unsigned int syncinterval;  /* P for adaptive IN mode, 0 otherwise */
 338                 unsigned int freqn;      /* nominal sampling rate in USB format, i.e. fs/1000 in Q10.14 */
 339                 unsigned int freqmax;    /* maximum sampling rate, used for buffer management */
 340                 unsigned int phase;      /* phase accumulator */
 341                 unsigned int flags;      /* see FLG_ defines */
 342
 343                 struct my_data_urb durb[2];  /* ISO descriptors for the data endpoint */
 344                 struct my_sync_urb surb[2];  /* ISO sync pipe descriptor if needed */
 345
 346                 struct dmabuf dma;
 347         } usbin;
 348
 349         struct usbout {
 350                 int interface;           /* Interface number, -1 means not used */
 351                 unsigned int format;     /* USB data format */
 352                 unsigned int datapipe;   /* the data input pipe */
 353                 unsigned int syncpipe;   /* the synchronisation pipe - 0 for anything but asynchronous OUT mode */
 354                 unsigned int syncinterval;  /* P for asynchronous OUT mode, 0 otherwise */
 355                 unsigned int freqn;      /* nominal sampling rate in USB format, i.e. fs/1000 in Q10.14 */
 356                 unsigned int freqm;      /* momentary sampling rate in USB format, i.e. fs/1000 in Q10.14 */
 357                 unsigned int freqmax;    /* maximum sampling rate, used for buffer management */
 358                 unsigned int phase;      /* phase accumulator */
 359                 unsigned int flags;      /* see FLG_ defines */
 360
 361                 struct my_data_urb durb[2];  /* ISO descriptors for the data endpoint */
 362                 struct my_sync_urb surb[2];  /* ISO sync pipe descriptor if needed */
 363
 364                 struct dmabuf dma;
 365         } usbout;
 366
 367
 368         unsigned int numfmtin, numfmtout;
 369         struct audioformat fmtin[MAXFORMATS];
 370         struct audioformat fmtout[MAXFORMATS];
 371 };
 372
 373 struct usb_mixerdev {
 374         struct list_head list;
 375         struct usb_audio_state *state;
 376
 377         /* soundcore stuff */
 378         int dev_mixer;
 379
 380         unsigned char iface;  /* interface number of the AudioControl interface */
 381
 382         /* USB format descriptions */
 383         unsigned int numch, modcnt;
 384
 385         /* mixch is last and gets allocated dynamically */
 386         struct mixerchannel ch[0];
 387 };
 388
 389 struct usb_audio_state {
 390         struct list_head audiodev;
 391
 392         /* USB device */
 393         struct usb_device *usbdev;
 394
 395         struct list_head audiolist;
 396         struct list_head mixerlist;
 397
 398         unsigned count;  /* usage counter; NOTE: the usb stack is also considered a user */
 399 };
 400
 401 /* in the event we don't have the extended soundcard.h, we still need
 402    to compile successfully.  Supply definitions */
 403
 404 #ifndef AFMT_S24_LE
 405 #       define AFMT_S24_LE              0x00000800
 406 #endif
 407 #ifndef AFMT_S24_BE
 408 #       define AFMT_S24_BE              0x00001000
 409 #endif
 410 #ifndef AFMT_U24_LE
 411 #       define AFMT_U24_LE              0x00002000
 412 #endif
 413 #ifndef AFMT_U24_BE
 414 #       define AFMT_U24_BE              0x00004000
 415 #endif
 416 #ifndef AFMT_S32_LE
 417 #       define AFMT_S32_LE              0x00008000
 418 #endif
 419 #ifndef AFMT_S32_BE
 420 #       define AFMT_S32_BE              0x00010000
 421 #endif
 422 #ifndef AFMT_U32_LE
 423 #       define AFMT_U32_LE              0x00020000
 424 #endif
 425 #ifndef AFMT_U32_BE
 426 #       define AFMT_U32_BE              0x00040000
 427 #endif
 428
 429 /* private audio format extensions */
 430 #define AFMT_STEREO         0x01000000
 431 #define AFMT_CHMASK         0xff000000
 432 #define AFMT_8MASK          (AFMT_U8 | AFMT_S8)
 433 #define AFMT_16MASK         (AFMT_U16_LE | AFMT_S16_LE | AFMT_U16_BE | AFMT_S16_BE)
 434 #define AFMT_24MASK         (AFMT_U24_LE | AFMT_S24_LE | AFMT_U24_BE | AFMT_S24_BE)
 435 #define AFMT_32MASK         (AFMT_U32_LE | AFMT_S32_LE | AFMT_U32_BE | AFMT_S32_BE)
 436
 437 #define AFMT_SIGNMASK       (AFMT_S8 | AFMT_S16_LE | AFMT_S16_BE |\
 438                                        AFMT_S24_LE | AFMT_S24_BE |\
 439                                        AFMT_S32_LE | AFMT_S32_BE)
 440
 441 /* a little odd, but the code counts on byte formats being identified as 'big endian' */
 442 #define AFMT_ENDIANMASK     (AFMT_S8 | AFMT_U8 |\
 443                                        AFMT_S16_BE | AFMT_U16_BE |\
 444                                        AFMT_S24_BE | AFMT_U24_BE |\
 445                                        AFMT_S32_BE | AFMT_U32_BE)
 446
 447 #define AFMT_ISSTEREO(x)    (((x) & 0xff000000) == AFMT_STEREO)
 448 #define AFMT_CHANNELS(x)    (((unsigned)(x) >> 24) + 1)
 449 #define AFMT_BYTES(x)       ( (((x)&AFMT_8MASK)!=0)+\
 450                               (((x)&AFMT_16MASK)!=0)*2+\
 451                               (((x)&AFMT_24MASK)!=0)*3+\
 452                               (((x)&AFMT_32MASK)!=0)*4 )
 453 #define AFMT_SAMPLEBYTES(x) (AFMT_BYTES(x)*AFMT_CHANNELS(x))
 454 #define AFMT_SIGN(x)        ((x)&AFMT_SIGNMASK)
 455 #define AFMT_ENDIAN(x)      ((x)&AFMT_ENDIANMASK)
 456
 457
 458 /* --------------------------------------------------------------------- */
 459
 460 /* prevent picking up a bogus abs macro */
 461 #undef my_abs
 462 static inline int my_abs(int x)
 463 {
 464         if (x < 0)
 465                 return -x;
 466         return x;
 467 }
 468
 469 /* --------------------------------------------------------------------- */
 470
 471 static inline unsigned ld2(unsigned int x)
 472 {
 473         unsigned r = 0;
 474
 475         if (x >= 0x10000) {
 476                 x >>= 16;
 477                 r += 16;
 478         }
 479         if (x >= 0x100) {
 480                 x >>= 8;
 481                 r += 8;
 482         }
 483         if (x >= 0x10) {
 484                 x >>= 4;
 485                 r += 4;
 486         }
 487         if (x >= 4) {
 488                 x >>= 2;
 489                 r += 2;
 490         }
 491         if (x >= 2)
 492                 r++;
 493         return r;
 494 }
 495
 496 /* --------------------------------------------------------------------- */
 497
 498 /*
 499  * OSS compatible ring buffer management. The ring buffer may be mmap'ed into
 500  * an application address space.
 501  *
 502  * I first used the rvmalloc stuff copied from bttv. Alan Cox did not like it, so
 503  * we now use an array of pointers to a single page each. This saves us the
 504  * kernel page table manipulations, but we have to do a page table alike mechanism
 505  * (though only one indirection) in software.
 506  */
 507
 508 static void dmabuf_release(struct dmabuf *db)
 509 {
 510         unsigned int nr;
 511         void *p;
 512
 513         for(nr = 0; nr < NRSGBUF; nr++) {
 514                 if (!(p = db->sgbuf[nr]))
 515                         continue;
 516                 mem_map_unreserve(virt_to_page(p));
 517                 free_page((unsigned long)p);
 518                 db->sgbuf[nr] = NULL;
 519         }
 520         db->mapped = db->ready = 0;
 521 }
 522
 523 static int dmabuf_init(struct dmabuf *db)
 524 {
 525         unsigned int nr, bytepersec, bufs;
 526         void *p;
 527
 528         /* initialize some fields */
 529         db->rdptr = db->wrptr = db->total_bytes = db->count = db->error = 0;
 530         /* calculate required buffer size */
 531         bytepersec = db->srate * AFMT_SAMPLEBYTES(db->format);
 532         bufs = 1U << DMABUFSHIFT;
 533         if (db->ossfragshift) {
 534                 if ((1000 << db->ossfragshift) < bytepersec)
 535                         db->fragshift = ld2(bytepersec/1000);
 536                 else
 537                         db->fragshift = db->ossfragshift;
 538         } else {
 539                 db->fragshift = ld2(bytepersec/100/(db->subdivision ? db->subdivision : 1));
 540                 if (db->fragshift < 3)
 541                         db->fragshift = 3;
 542         }
 543         db->numfrag = bufs >> db->fragshift;
 544         while (db->numfrag < 4 && db->fragshift > 3) {
 545                 db->fragshift--;
 546                 db->numfrag = bufs >> db->fragshift;
 547         }
 548         db->fragsize = 1 << db->fragshift;
 549         if (db->ossmaxfrags >= 4 && db->ossmaxfrags < db->numfrag)
 550                 db->numfrag = db->ossmaxfrags;
 551         db->dmasize = db->numfrag << db->fragshift;
 552         for(nr = 0; nr < NRSGBUF; nr++) {
 553                 if (!db->sgbuf[nr]) {
 554                         p = (void *)get_free_page(GFP_KERNEL);
 555                         if (!p)
 556                                 return -ENOMEM;
 557                         db->sgbuf[nr] = p;
 558                         mem_map_reserve(virt_to_page(p));
 559                 }
 560                 memset(db->sgbuf[nr], AFMT_SIGN(db->format) ? 0 : 0x80, PAGE_SIZE);
 561                 if ((nr << PAGE_SHIFT) >= db->dmasize)
 562                         break;
 563         }
 564         db->bufsize = nr << PAGE_SHIFT;
 565         db->enabled = 1;
 566         db->ready = 1;
 567         dprintk((KERN_DEBUG "usbaudio: dmabuf_init bytepersec %d bufs %d ossfragshift %d ossmaxfrags %d "
 568                  "fragshift %d fragsize %d numfrag %d dmasize %d bufsize %d fmt 0x%x srate %d\n",
 569                  bytepersec, bufs, db->ossfragshift, db->ossmaxfrags, db->fragshift, db->fragsize,
 570                  db->numfrag, db->dmasize, db->bufsize, db->format, db->srate));
 571         return 0;
 572 }
 573
 574 static int dmabuf_mmap(struct dmabuf *db, unsigned long start, unsigned long size, pgprot_t prot)
 575 {
 576         unsigned int nr;
 577
 578         if (!db->ready || db->mapped || (start | size) & (PAGE_SIZE-1) || size > db->bufsize)
 579                 return -EINVAL;
 580         size >>= PAGE_SHIFT;
 581         for(nr = 0; nr < size; nr++)
 582                 if (!db->sgbuf[nr])
 583                         return -EINVAL;
 584         db->mapped = 1;
 585         for(nr = 0; nr < size; nr++) {
 586                 if (remap_page_range(start, virt_to_phys(db->sgbuf[nr]), PAGE_SIZE, prot))
 587                         return -EAGAIN;
 588                 start += PAGE_SIZE;
 589         }
 590         return 0;
 591 }
 592
 593 static void dmabuf_copyin(struct dmabuf *db, const void *_buffer, unsigned int size)
 594 {
 595         unsigned int pgrem, rem;
 596         const char *buffer = _buffer;
 597
 598         db->total_bytes += size;
 599         for (;;) {
 600                 if (size <= 0)
 601                         return;
 602                 pgrem = ((~db->wrptr) & (PAGE_SIZE-1)) + 1;
 603                 if (pgrem > size)
 604                         pgrem = size;
 605                 rem = db->dmasize - db->wrptr;
 606                 if (pgrem > rem)
 607                         pgrem = rem;
 608                 memcpy((db->sgbuf[db->wrptr >> PAGE_SHIFT]) + (db->wrptr & (PAGE_SIZE-1)), buffer, pgrem);
 609                 size -= pgrem;
 610                 buffer += pgrem;
 611                 db->wrptr += pgrem;
 612                 if (db->wrptr >= db->dmasize)
 613                         db->wrptr = 0;
 614         }
 615 }
 616
 617 static void dmabuf_copyout(struct dmabuf *db, void *_buffer, unsigned int size)
 618 {
 619         unsigned int pgrem, rem;
 620         char *buffer = _buffer;
 621
 622         db->total_bytes += size;
 623         for (;;) {
 624                 if (size <= 0)
 625                         return;
 626                 pgrem = ((~db->rdptr) & (PAGE_SIZE-1)) + 1;
 627                 if (pgrem > size)
 628                         pgrem = size;
 629                 rem = db->dmasize - db->rdptr;
 630                 if (pgrem > rem)
 631                         pgrem = rem;
 632                 memcpy(buffer, (db->sgbuf[db->rdptr >> PAGE_SHIFT]) + (db->rdptr & (PAGE_SIZE-1)), pgrem);
 633                 size -= pgrem;
 634                 buffer += pgrem;
 635                 db->rdptr += pgrem;
 636                 if (db->rdptr >= db->dmasize)
 637                         db->rdptr = 0;
 638         }
 639 }
 640
 641 static int dmabuf_copyin_user(struct dmabuf *db, unsigned int ptr, const void *_buffer, unsigned int size)
 642 {
 643         unsigned int pgrem, rem;
 644         const char *buffer = _buffer;
 645
 646         if (!db->ready || db->mapped)
 647                 return -EINVAL;
 648         for (;;) {
 649                 if (size <= 0)
 650                         return 0;
 651                 pgrem = ((~ptr) & (PAGE_SIZE-1)) + 1;
 652                 if (pgrem > size)
 653                         pgrem = size;
 654                 rem = db->dmasize - ptr;
 655                 if (pgrem > rem)
 656                         pgrem = rem;
 657                 if (copy_from_user((db->sgbuf[ptr >> PAGE_SHIFT]) + (ptr & (PAGE_SIZE-1)), buffer, pgrem))
 658                         return -EFAULT;
 659                 size -= pgrem;
 660                 buffer += pgrem;
 661                 ptr += pgrem;
 662                 if (ptr >= db->dmasize)
 663                         ptr = 0;
 664         }
 665 }
 666
 667 static int dmabuf_copyout_user(struct dmabuf *db, unsigned int ptr, void *_buffer, unsigned int size)
 668 {
 669         unsigned int pgrem, rem;
 670         char *buffer = _buffer;
 671
 672         if (!db->ready || db->mapped)
 673                 return -EINVAL;
 674         for (;;) {
 675                 if (size <= 0)
 676                         return 0;
 677                 pgrem = ((~ptr) & (PAGE_SIZE-1)) + 1;
 678                 if (pgrem > size)
 679                         pgrem = size;
 680                 rem = db->dmasize - ptr;
 681                 if (pgrem > rem)
 682                         pgrem = rem;
 683                 if (copy_to_user(buffer, (db->sgbuf[ptr >> PAGE_SHIFT]) + (ptr & (PAGE_SIZE-1)), pgrem))
 684                         return -EFAULT;
 685                 size -= pgrem;
 686                 buffer += pgrem;
 687                 ptr += pgrem;
 688                 if (ptr >= db->dmasize)
 689                         ptr = 0;
 690         }
 691 }
 692
 693 /* --------------------------------------------------------------------- */
 694 /*
 695  * USB I/O code. We do sample format conversion if necessary
 696  */
 697
 698 static void usbin_stop(struct usb_audiodev *as)
 699 {
 700         struct usbin *u = &as->usbin;
 701         unsigned long flags;
 702         unsigned int i, notkilled = 1;
 703
 704         spin_lock_irqsave(&as->lock, flags);
 705         u->flags &= ~FLG_RUNNING;
 706         i = u->flags;
 707         spin_unlock_irqrestore(&as->lock, flags);
 708         while (i & (FLG_URB0RUNNING|FLG_URB1RUNNING|FLG_SYNC0RUNNING|FLG_SYNC1RUNNING)) {
 709                 set_current_state(notkilled ? TASK_INTERRUPTIBLE : TASK_UNINTERRUPTIBLE);
 710                 schedule_timeout(1);
 711                 spin_lock_irqsave(&as->lock, flags);
 712                 i = u->flags;
 713                 spin_unlock_irqrestore(&as->lock, flags);
 714                 if (notkilled && signal_pending(current)) {
 715                         if (i & FLG_URB0RUNNING)
 716                                 usb_unlink_urb(&u->durb[0].urb);
 717                         if (i & FLG_URB1RUNNING)
 718                                 usb_unlink_urb(&u->durb[1].urb);
 719                         if (i & FLG_SYNC0RUNNING)
 720                                 usb_unlink_urb(&u->surb[0].urb);
 721                         if (i & FLG_SYNC1RUNNING)
 722                                 usb_unlink_urb(&u->surb[1].urb);
 723                         notkilled = 0;
 724                 }
 725         }
 726         set_current_state(TASK_RUNNING);
 727         if (u->durb[0].urb.transfer_buffer)
 728                 kfree(u->durb[0].urb.transfer_buffer);
 729         if (u->durb[1].urb.transfer_buffer)
 730                 kfree(u->durb[1].urb.transfer_buffer);
 731         if (u->surb[0].urb.transfer_buffer)
 732                 kfree(u->surb[0].urb.transfer_buffer);
 733         if (u->surb[1].urb.transfer_buffer)
 734                 kfree(u->surb[1].urb.transfer_buffer);
 735         u->durb[0].urb.transfer_buffer = u->durb[1].urb.transfer_buffer =
 736                 u->surb[0].urb.transfer_buffer = u->surb[1].urb.transfer_buffer = NULL;
 737 }
 738
 739 static inline void usbin_release(struct usb_audiodev *as)
 740 {
 741         usbin_stop(as);
 742 }
 743
 744 static void usbin_disc(struct usb_audiodev *as)
 745 {
 746         struct usbin *u = &as->usbin;
 747
 748         unsigned long flags;
 749
 750         spin_lock_irqsave(&as->lock, flags);
 751         u->flags &= ~(FLG_RUNNING | FLG_CONNECTED);
 752         spin_unlock_irqrestore(&as->lock, flags);
 753         usbin_stop(as);
 754 }
 755
 756 static inline int iconvert(unsigned char **xx,int jump)
 757 {
 758   int value=0;
 759   unsigned char *x=*xx;
 760
 761   /* conversion fall-through cascade compiles to a jump table */
 762   switch(jump){
 763   case 0:
 764     /* 32 bit BE */
 765     value  = x[3];
 766   case 1:
 767     /* 24 bit BE */
 768     value |= x[2] << 8;
 769   case 2:
 770     /* 16 bit BE */
 771     value |= x[1] << 16;
 772   case 3:
 773     /* 8 bit */
 774     value |= x[0] << 24;
 775     x+=(4-jump);
 776     break;
 777
 778   case 4:
 779     /* 32 bit LE */
 780     value  = *x++;
 781   case 5:
 782     /* 24 bit LE */
 783     value |= *x++ << 8;
 784   case 6:
 785     /* 16 bit LE */
 786     value |= *x++ << 16;
 787     value |= *x++ << 24;
 788     break;
 789   }
 790   *xx=x;
 791   return(value);
 792 }
 793
 794 static inline void oconvert(unsigned char **yy,int jump,int value)
 795 {
 796   unsigned char *y=*yy;
 797
 798   /* conversion fall-through cascade compiles to a jump table */
 799   switch(jump){
 800   case 0:
 801     /* 32 bit BE */
 802     y[3] = value;
 803   case 1:
 804     /* 24 bit BE */
 805     y[2] = value >> 8;
 806   case 2:
 807     /* 16 bit BE */
 808     y[1] = value >> 16;
 809   case 3:
 810     /* 8 bit */
 811     y[0] = value >> 24;
 812     y+=(4-jump);
 813     break;
 814
 815   case 4:
 816     /* 32 bit LE */
 817     *y++ = value;
 818   case 5:
 819     /* 24 bit LE */
 820     *y++ = value >> 8;
 821   case 6:
 822     /* 16 bit LE */
 823     *y++ = value >> 16;
 824     *y++ = value >> 24;
 825     break;
 826   }
 827   *yy=y;
 828 }
 829
 830 /* capable of any-to-any conversion */
 831 static void conversion(const void *ibuf, unsigned int ifmt,
 832                        void *obuf, unsigned int ofmt, unsigned int scnt)
 833 {
 834
 835   /* some conversion is indeed needed */
 836   unsigned int i,j;
 837   unsigned char *x=(unsigned char *)ibuf;
 838   unsigned char *y=(unsigned char *)obuf;
 839
 840   int ichannels = AFMT_CHANNELS(ifmt);
 841   int ochannels = AFMT_CHANNELS(ofmt);
 842   int ibytes    = AFMT_BYTES(ifmt);
 843   int obytes    = AFMT_BYTES(ofmt);
 844   int iendian   = AFMT_ENDIAN(ifmt);
 845   int oendian   = AFMT_ENDIAN(ofmt);
 846   int isign     = AFMT_SIGN(ifmt)?0:0x80000000UL;
 847   int osign     = AFMT_SIGN(ofmt)?0:0x80000000UL;
 848   int sign      = (isign==osign?0:0x80000000UL);
 849
 850   /* build the byte/endian jump table offsets */
 851   int ijump = (iendian ? 4-ibytes : 8-ibytes);
 852   int ojump = (oendian ? 4-obytes : 8-obytes);
 853
 854   if(ichannels == 2 && ochannels == 1){
 855     /* Stereo -> mono is a special case loop; we downmix */
 856     for(i=0;i<scnt;i++){
 857       int valueL = iconvert(&x,ijump) ^ isign; /* side effect; increments x */
 858       int valueR = iconvert(&x,ijump) ^ isign; /* side effect; increments x */
 859       int value  = (valueL>>1) + (valueR>>1);
 860       oconvert(&y,ojump,value^osign);  /* side effect; increments y */
 861                 }
 862     return;
 863                 }
 864   if(ichannels == 1 && ochannels == 2){
 865     /* mono->stereo is a special case loop; we replicate */
 866     for(i=0;i<scnt;i++){
 867       int value = iconvert(&x,ijump) ^ sign; /* side effect; increments x */
 868       oconvert(&y,ojump,value);  /* side effect; increments y */
 869       oconvert(&y,ojump,value);  /* side effect; increments y */
 870         }
 871     return;
 872                 }
 873   if(ichannels<ochannels){
 874     /* zero out extra output channels */
 875     for(i=0;i<scnt;i++){
 876       for(j=0;j<ichannels;j++){
 877         int value = iconvert(&x,ijump) ^ sign; /* side effect; increments x */
 878         oconvert(&y,ojump,value);  /* side effect; increments y */
 879
 880         }
 881       for(;j<ochannels;j++){
 882         oconvert(&y,ojump,osign);  /* side effect; increments y */
 883         }
 884                 }
 885     return;
 886                 }
 887   if(ichannels>=ochannels){
 888     /* discard extra input channels */
 889     int xincrement=ibytes*(ichannels-ochannels);
 890     for(i=0;i<scnt;i++){
 891       for(j=0;j<ichannels;j++){
 892         int value = iconvert(&x,ijump) ^ sign; /* side effect; increments x */
 893         oconvert(&y,ojump,value);  /* side effect; increments y */
 894
 895                 }
 896       x+=xincrement;
 897                 }
 898     return;
 899         }
 900 }
 901
 902 static void usbin_convert(struct usbin *u, unsigned char *buffer, unsigned int samples)
 903 {
 904         unsigned int scnt;
 905         unsigned int ufmtb = AFMT_SAMPLEBYTES(u->format);
 906         unsigned int dfmtb = AFMT_SAMPLEBYTES(u->dma.format);
 907         unsigned char tmp[TMPCOPYWIDTH];
 908         unsigned int maxs  = sizeof(tmp)/dfmtb;
 909
 910         while (samples > 0) {
 911                 scnt = samples;
 912                 if (scnt > maxs)
 913                         scnt = maxs;
 914
 915                 conversion(buffer, u->format, tmp, u->dma.format, scnt);
 916                 dmabuf_copyin(&u->dma, tmp, scnt * dfmtb);
 917                 buffer += scnt * ufmtb;
 918                 samples -= scnt;
 919         }
 920 }
 921
 922 static int usbin_prepare_desc(struct usbin *u, struct urb *urb)
 923 {
 924         unsigned int i, maxsize, offs;
 925
 926         maxsize = ((u->freqmax + 0x3fff) * AFMT_SAMPLEBYTES(u->format)) >> 14;
 927         //printk(KERN_DEBUG "usbin_prepare_desc: maxsize %d freq 0x%x format 0x%x\n", maxsize, u->freqn, u->format);
 928         for (i = offs = 0; i < DESCFRAMES; i++, offs += maxsize) {
 929                 urb->iso_frame_desc[i].length = maxsize;
 930                 urb->iso_frame_desc[i].offset = offs;
 931         }
 932         return 0;
 933 }
 934
 935 /*
 936  * return value: 0 if descriptor should be restarted, -1 otherwise
 937  * convert sample format on the fly if necessary
 938  */
 939 static int usbin_retire_desc(struct usbin *u, struct urb *urb)
 940 {
 941         unsigned int i, ufmtb, dfmtb, err = 0, cnt, scnt, dmafree;
 942         unsigned char *cp;
 943
 944         ufmtb = AFMT_SAMPLEBYTES(u->format);
 945         dfmtb = AFMT_SAMPLEBYTES(u->dma.format);
 946         for (i = 0; i < DESCFRAMES; i++) {
 947                 cp = ((unsigned char *)urb->transfer_buffer) + urb->iso_frame_desc[i].offset;
 948                 if (urb->iso_frame_desc[i].status) {
 949                         dprintk((KERN_DEBUG "usbin_retire_desc: frame %u status %d\n", i, urb->iso_frame_desc[i].status));
 950                         continue;
 951                 }
 952                 scnt = urb->iso_frame_desc[i].actual_length / ufmtb;
 953                 if (!scnt)
 954                         continue;
 955                 cnt = scnt * dfmtb;
 956                 if (!u->dma.mapped) {
 957                         dmafree = u->dma.dmasize - u->dma.count;
 958                         if (cnt > dmafree) {
 959                                 scnt = dmafree / dfmtb;
 960                                 cnt = scnt * dfmtb;
 961                                 err++;
 962                         }
 963                 }
 964                 u->dma.count += cnt;
 965                 if (u->format == u->dma.format) {
 966                         /* we do not need format conversion */
 967                         dprintk((KERN_DEBUG "usbaudio: no sample format conversion\n"));
 968                         dmabuf_copyin(&u->dma, cp, cnt);
 969                 } else {
 970                         /* we need sampling format conversion */
 971                         dprintk((KERN_DEBUG "usbaudio: sample format conversion %x != %x\n", u->format, u->dma.format));
 972                         usbin_convert(u, cp, scnt);
 973                 }
 974         }
 975         if (err)
 976                 u->dma.error++;
 977         if (u->dma.count >= (signed)u->dma.fragsize)
 978                 wake_up(&u->dma.wait);
 979         return err ? -1 : 0;
 980 }
 981
 982 static void usbin_completed(struct urb *urb)
 983 {
 984         struct usb_audiodev *as = (struct usb_audiodev *)urb->context;
 985         struct usbin *u = &as->usbin;
 986         unsigned long flags;
 987         unsigned int mask;
 988         int suret = USB_ST_NOERROR;
 989
 990 #if 0
 991         printk(KERN_DEBUG "usbin_completed: status %d errcnt %d flags 0x%x\n", urb->status, urb->error_count, u->flags);
 992 #endif
 993         if (urb == &u->durb[0].urb)
 994                 mask = FLG_URB0RUNNING;
 995         else if (urb == &u->durb[1].urb)
 996                 mask = FLG_URB1RUNNING;
 997         else {
 998                 mask = 0;
 999                 printk(KERN_ERR "usbin_completed: panic: unknown URB\n");
1000         }
1001         urb->dev = as->state->usbdev;
1002         spin_lock_irqsave(&as->lock, flags);
1003         if (!usbin_retire_desc(u, urb) &&
1004             u->flags & FLG_RUNNING &&
1005             !usbin_prepare_desc(u, urb) &&
1006             (suret = usb_submit_urb(urb)) == USB_ST_NOERROR) {
1007                 u->flags |= mask;
1008         } else {
1009                 u->flags &= ~(mask | FLG_RUNNING);
1010                 wake_up(&u->dma.wait);
1011                 printk(KERN_DEBUG "usbin_completed: descriptor not restarted (usb_submit_urb: %d)\n", suret);
1012         }
1013         spin_unlock_irqrestore(&as->lock, flags);
1014 }
1015
1016 /*
1017  * we output sync data
1018  */
1019 static int usbin_sync_prepare_desc(struct usbin *u, struct urb *urb)
1020 {
1021         unsigned char *cp = urb->transfer_buffer;
1022         unsigned int i, offs;
1023
1024         for (i = offs = 0; i < SYNCFRAMES; i++, offs += 3, cp += 3) {
1025                 urb->iso_frame_desc[i].length = 3;
1026                 urb->iso_frame_desc[i].offset = offs;
1027                 cp[0] = u->freqn;
1028                 cp[1] = u->freqn >> 8;
1029                 cp[2] = u->freqn >> 16;
1030         }
1031         return 0;
1032 }
1033
1034 /*
1035  * return value: 0 if descriptor should be restarted, -1 otherwise
1036  */
1037 static int usbin_sync_retire_desc(struct usbin *u, struct urb *urb)
1038 {
1039         unsigned int i;
1040
1041         for (i = 0; i < SYNCFRAMES; i++)
1042                 if (urb->iso_frame_desc[0].status)
1043                         dprintk((KERN_DEBUG "usbin_sync_retire_desc: frame %u status %d\n", i, urb->iso_frame_desc[i].status));
1044         return 0;
1045 }
1046
1047 static void usbin_sync_completed(struct urb *urb)
1048 {
1049         struct usb_audiodev *as = (struct usb_audiodev *)urb->context;
1050         struct usbin *u = &as->usbin;
1051         unsigned long flags;
1052         unsigned int mask;
1053         int suret = USB_ST_NOERROR;
1054
1055 #if 0
1056         printk(KERN_DEBUG "usbin_sync_completed: status %d errcnt %d flags 0x%x\n", urb->status, urb->error_count, u->flags);
1057 #endif
1058         if (urb == &u->surb[0].urb)
1059                 mask = FLG_SYNC0RUNNING;
1060         else if (urb == &u->surb[1].urb)
1061                 mask = FLG_SYNC1RUNNING;
1062         else {
1063                 mask = 0;
1064                 printk(KERN_ERR "usbin_sync_completed: panic: unknown URB\n");
1065         }
1066         urb->dev = as->state->usbdev;
1067         spin_lock_irqsave(&as->lock, flags);
1068         if (!usbin_sync_retire_desc(u, urb) &&
1069             u->flags & FLG_RUNNING &&
1070             !usbin_sync_prepare_desc(u, urb) &&
1071             (suret = usb_submit_urb(urb)) == USB_ST_NOERROR) {
1072                 u->flags |= mask;
1073         } else {
1074                 u->flags &= ~(mask | FLG_RUNNING);
1075                 wake_up(&u->dma.wait);
1076                 dprintk((KERN_DEBUG "usbin_sync_completed: descriptor not restarted (usb_submit_urb: %d)\n", suret));
1077         }
1078         spin_unlock_irqrestore(&as->lock, flags);
1079 }
1080
1081 static int usbin_start(struct usb_audiodev *as)
1082 {
1083         struct usb_device *dev = as->state->usbdev;
1084         struct usbin *u = &as->usbin;
1085         struct urb *urb;
1086         unsigned long flags;
1087         unsigned int maxsze, bufsz;
1088
1089 #if 0
1090         printk(KERN_DEBUG "usbin_start: device %d ufmt 0x%08x dfmt 0x%08x srate %d\n",
1091                dev->devnum, u->format, u->dma.format, u->dma.srate);
1092 #endif
1093         /* allocate USB storage if not already done */
1094         spin_lock_irqsave(&as->lock, flags);
1095         if (!(u->flags & FLG_CONNECTED)) {
1096                 spin_unlock_irqrestore(&as->lock, flags);
1097                 return -EIO;
1098         }
1099         if (!(u->flags & FLG_RUNNING)) {
1100                 spin_unlock_irqrestore(&as->lock, flags);
1101                 u->freqn = ((u->dma.srate << 11) + 62) / 125; /* this will overflow at approx 2MSPS */
1102                 u->freqmax = u->freqn + (u->freqn >> 2);
1103                 u->phase = 0;
1104                 maxsze = ((u->freqmax + 0x3fff) * AFMT_SAMPLEBYTES(u->format)) >> 14;
1105                 bufsz = DESCFRAMES * maxsze;
1106                 if (u->durb[0].urb.transfer_buffer)
1107                         kfree(u->durb[0].urb.transfer_buffer);
1108                 u->durb[0].urb.transfer_buffer = kmalloc(bufsz, GFP_KERNEL);
1109                 u->durb[0].urb.transfer_buffer_length = bufsz;
1110                 if (u->durb[1].urb.transfer_buffer)
1111                         kfree(u->durb[1].urb.transfer_buffer);
1112                 u->durb[1].urb.transfer_buffer = kmalloc(bufsz, GFP_KERNEL);
1113                 u->durb[1].urb.transfer_buffer_length = bufsz;
1114                 if (u->syncpipe) {
1115                         if (u->surb[0].urb.transfer_buffer)
1116                                 kfree(u->surb[0].urb.transfer_buffer);
1117                         u->surb[0].urb.transfer_buffer = kmalloc(3*SYNCFRAMES, GFP_KERNEL);
1118                         u->surb[0].urb.transfer_buffer_length = 3*SYNCFRAMES;
1119                         if (u->surb[1].urb.transfer_buffer)
1120                                 kfree(u->surb[1].urb.transfer_buffer);
1121                         u->surb[1].urb.transfer_buffer = kmalloc(3*SYNCFRAMES, GFP_KERNEL);
1122                         u->surb[1].urb.transfer_buffer_length = 3*SYNCFRAMES;
1123                 }
1124                 if (!u->durb[0].urb.transfer_buffer || !u->durb[1].urb.transfer_buffer ||
1125                     (u->syncpipe && (!u->surb[0].urb.transfer_buffer || !u->surb[1].urb.transfer_buffer))) {
1126                         printk(KERN_ERR "usbaudio: cannot start playback device %d\n", dev->devnum);
1127                         return 0;
1128                 }
1129                 spin_lock_irqsave(&as->lock, flags);
1130         }
1131         if (u->dma.count >= u->dma.dmasize && !u->dma.mapped) {
1132                 spin_unlock_irqrestore(&as->lock, flags);
1133                 return 0;
1134         }
1135         u->flags |= FLG_RUNNING;
1136         if (!(u->flags & FLG_URB0RUNNING)) {
1137                 urb = &u->durb[0].urb;
1138                 urb->dev = dev;
1139                 urb->pipe = u->datapipe;
1140                 urb->transfer_flags = USB_ISO_ASAP;
1141                 urb->number_of_packets = DESCFRAMES;
1142                 urb->context = as;
1143                 urb->complete = usbin_completed;
1144                 if (!usbin_prepare_desc(u, urb) && !usb_submit_urb(urb))
1145                         u->flags |= FLG_URB0RUNNING;
1146                 else
1147                         u->flags &= ~FLG_RUNNING;
1148         }
1149         if (u->flags & FLG_RUNNING && !(u->flags & FLG_URB1RUNNING)) {
1150                 urb = &u->durb[1].urb;
1151                 urb->dev = dev;
1152                 urb->pipe = u->datapipe;
1153                 urb->transfer_flags = USB_ISO_ASAP;
1154                 urb->number_of_packets = DESCFRAMES;
1155                 urb->context = as;
1156                 urb->complete = usbin_completed;
1157                 if (!usbin_prepare_desc(u, urb) && !usb_submit_urb(urb))
1158                         u->flags |= FLG_URB1RUNNING;
1159                 else
1160                         u->flags &= ~FLG_RUNNING;
1161         }
1162         if (u->syncpipe) {
1163                 if (u->flags & FLG_RUNNING && !(u->flags & FLG_SYNC0RUNNING)) {
1164                         urb = &u->surb[0].urb;
1165                         urb->dev = dev;
1166                         urb->pipe = u->syncpipe;
1167                         urb->transfer_flags = USB_ISO_ASAP;
1168                         urb->number_of_packets = SYNCFRAMES;
1169                         urb->context = as;
1170                         urb->complete = usbin_sync_completed;
1171                         /* stride: u->syncinterval */
1172                         if (!usbin_sync_prepare_desc(u, urb) && !usb_submit_urb(urb))
1173                                 u->flags |= FLG_SYNC0RUNNING;
1174                         else
1175                                 u->flags &= ~FLG_RUNNING;
1176                 }
1177                 if (u->flags & FLG_RUNNING && !(u->flags & FLG_SYNC1RUNNING)) {
1178                         urb = &u->surb[1].urb;
1179                         urb->dev = dev;
1180                         urb->pipe = u->syncpipe;
1181                         urb->transfer_flags = USB_ISO_ASAP;
1182                         urb->number_of_packets = SYNCFRAMES;
1183                         urb->context = as;
1184                         urb->complete = usbin_sync_completed;
1185                         /* stride: u->syncinterval */
1186                         if (!usbin_sync_prepare_desc(u, urb) && !usb_submit_urb(urb))
1187                                 u->flags |= FLG_SYNC1RUNNING;
1188                         else
1189                                 u->flags &= ~FLG_RUNNING;
1190                 }
1191         }
1192         spin_unlock_irqrestore(&as->lock, flags);
1193         return 0;
1194 }
1195
1196 static void usbout_stop(struct usb_audiodev *as)
1197 {
1198         struct usbout *u = &as->usbout;
1199         unsigned long flags;
1200         unsigned int i, notkilled = 1;
1201
1202         spin_lock_irqsave(&as->lock, flags);
1203         u->flags &= ~FLG_RUNNING;
1204         i = u->flags;
1205         spin_unlock_irqrestore(&as->lock, flags);
1206         while (i & (FLG_URB0RUNNING|FLG_URB1RUNNING|FLG_SYNC0RUNNING|FLG_SYNC1RUNNING)) {
1207                 set_current_state(notkilled ? TASK_INTERRUPTIBLE : TASK_UNINTERRUPTIBLE);
1208                 schedule_timeout(1);
1209                 spin_lock_irqsave(&as->lock, flags);
1210                 i = u->flags;
1211                 spin_unlock_irqrestore(&as->lock, flags);
1212                 if (notkilled && signal_pending(current)) {
1213                         if (i & FLG_URB0RUNNING)
1214                                 usb_unlink_urb(&u->durb[0].urb);
1215                         if (i & FLG_URB1RUNNING)
1216                                 usb_unlink_urb(&u->durb[1].urb);
1217                         if (i & FLG_SYNC0RUNNING)
1218                                 usb_unlink_urb(&u->surb[0].urb);
1219                         if (i & FLG_SYNC1RUNNING)
1220                                 usb_unlink_urb(&u->surb[1].urb);
1221                         notkilled = 0;
1222                 }
1223         }
1224         set_current_state(TASK_RUNNING);
1225         if (u->durb[0].urb.transfer_buffer)
1226                 kfree(u->durb[0].urb.transfer_buffer);
1227         if (u->durb[1].urb.transfer_buffer)
1228                 kfree(u->durb[1].urb.transfer_buffer);
1229         if (u->surb[0].urb.transfer_buffer)
1230                 kfree(u->surb[0].urb.transfer_buffer);
1231         if (u->surb[1].urb.transfer_buffer)
1232                 kfree(u->surb[1].urb.transfer_buffer);
1233         u->durb[0].urb.transfer_buffer = u->durb[1].urb.transfer_buffer =
1234                 u->surb[0].urb.transfer_buffer = u->surb[1].urb.transfer_buffer = NULL;
1235 }
1236
1237 static inline void usbout_release(struct usb_audiodev *as)
1238 {
1239         usbout_stop(as);
1240 }
1241
1242 static void usbout_disc(struct usb_audiodev *as)
1243 {
1244         struct usbout *u = &as->usbout;
1245         unsigned long flags;
1246
1247         spin_lock_irqsave(&as->lock, flags);
1248         u->flags &= ~(FLG_RUNNING | FLG_CONNECTED);
1249         spin_unlock_irqrestore(&as->lock, flags);
1250         usbout_stop(as);
1251 }
1252
1253 static void usbout_convert(struct usbout *u, unsigned char *buffer, unsigned int samples)
1254 {
1255         unsigned char tmp[TMPCOPYWIDTH];
1256         unsigned int scnt;
1257         unsigned int ufmtb = AFMT_SAMPLEBYTES(u->format);
1258         unsigned int dfmtb = AFMT_SAMPLEBYTES(u->dma.format);
1259         unsigned int maxs  = sizeof(tmp)/dfmtb;
1260
1261         while (samples > 0) {
1262                 scnt = samples;
1263                 if (scnt > maxs)
1264                         scnt = maxs;
1265
1266                 dmabuf_copyout(&u->dma, tmp, scnt * dfmtb);
1267                 conversion(tmp, u->dma.format, buffer, u->format, scnt);
1268                 buffer += scnt * ufmtb;
1269                 samples -= scnt;
1270         }
1271 }
1272
1273 static int usbout_prepare_desc(struct usbout *u, struct urb *urb)
1274 {
1275         unsigned int i, ufmtb, dfmtb, err = 0, cnt, scnt, offs;
1276         unsigned char *cp = urb->transfer_buffer;
1277
1278         ufmtb = AFMT_SAMPLEBYTES(u->format);
1279         dfmtb = AFMT_SAMPLEBYTES(u->dma.format);
1280         for (i = offs = 0; i < DESCFRAMES; i++) {
1281                 urb->iso_frame_desc[i].offset = offs;
1282                 u->phase = (u->phase & 0x3fff) + u->freqm;
1283                 scnt = u->phase >> 14;
1284                 if (!scnt) {
1285                         urb->iso_frame_desc[i].length = 0;
1286                         continue;
1287                 }
1288                 cnt = scnt * dfmtb;
1289                 if (!u->dma.mapped) {
1290                         if (cnt > u->dma.count) {
1291                                 scnt = u->dma.count / dfmtb;
1292                                 cnt = scnt * dfmtb;
1293                                 err++;
1294                         }
1295                         u->dma.count -= cnt;
1296                 } else
1297                         u->dma.count += cnt;
1298                 if (u->format == u->dma.format) {
1299                         /* we do not need format conversion */
1300                         dmabuf_copyout(&u->dma, cp, cnt);
1301                 } else {
1302                         /* we need sampling format conversion */
1303                         usbout_convert(u, cp, scnt);
1304                 }
1305                 cnt = scnt * ufmtb;
1306                 urb->iso_frame_desc[i].length = cnt;
1307                 offs += cnt;
1308                 cp += cnt;
1309         }
1310         if (err)
1311                 u->dma.error++;
1312         if (u->dma.mapped) {
1313                 if (u->dma.count >= (signed)u->dma.fragsize)
1314                         wake_up(&u->dma.wait);
1315         } else {
1316                 if ((signed)u->dma.dmasize >= u->dma.count + (signed)u->dma.fragsize)
1317                         wake_up(&u->dma.wait);
1318         }
1319         return err ? -1 : 0;
1320 }
1321
1322 /*
1323  * return value: 0 if descriptor should be restarted, -1 otherwise
1324  */
1325 static int usbout_retire_desc(struct usbout *u, struct urb *urb)
1326 {
1327         unsigned int i;
1328
1329         for (i = 0; i < DESCFRAMES; i++) {
1330                 if (urb->iso_frame_desc[i].status) {
1331                         dprintk((KERN_DEBUG "usbout_retire_desc: frame %u status %d\n", i, urb->iso_frame_desc[i].status));
1332                         continue;
1333                 }
1334         }
1335         return 0;
1336 }
1337
1338 static void usbout_completed(struct urb *urb)
1339 {
1340         struct usb_audiodev *as = (struct usb_audiodev *)urb->context;
1341         struct usbout *u = &as->usbout;
1342         unsigned long flags;
1343         unsigned int mask;
1344         int suret = USB_ST_NOERROR;
1345
1346 #if 0
1347         printk(KERN_DEBUG "usbout_completed: status %d errcnt %d flags 0x%x\n", urb->status, urb->error_count, u->flags);
1348 #endif
1349         if (urb == &u->durb[0].urb)
1350                 mask = FLG_URB0RUNNING;
1351         else if (urb == &u->durb[1].urb)
1352                 mask = FLG_URB1RUNNING;
1353         else {
1354                 mask = 0;
1355                 printk(KERN_ERR "usbout_completed: panic: unknown URB\n");
1356         }
1357         urb->dev = as->state->usbdev;
1358         spin_lock_irqsave(&as->lock, flags);
1359         if (!usbout_retire_desc(u, urb) &&
1360             u->flags & FLG_RUNNING &&
1361             !usbout_prepare_desc(u, urb) &&
1362             (suret = usb_submit_urb(urb)) == USB_ST_NOERROR) {
1363                 u->flags |= mask;
1364         } else {
1365                 u->flags &= ~(mask | FLG_RUNNING);
1366                 wake_up(&u->dma.wait);
1367                 dprintk((KERN_DEBUG "usbout_completed: descriptor not restarted (usb_submit_urb: %d)\n", suret));
1368         }
1369         spin_unlock_irqrestore(&as->lock, flags);
1370 }
1371
1372 static int usbout_sync_prepare_desc(struct usbout *u, struct urb *urb)
1373 {
1374         unsigned int i, offs;
1375
1376         for (i = offs = 0; i < SYNCFRAMES; i++, offs += 3) {
1377                 urb->iso_frame_desc[i].length = 3;
1378                 urb->iso_frame_desc[i].offset = offs;
1379         }
1380         return 0;
1381 }
1382
1383 /*
1384  * return value: 0 if descriptor should be restarted, -1 otherwise
1385  */
1386 static int usbout_sync_retire_desc(struct usbout *u, struct urb *urb)
1387 {
1388         unsigned char *cp = urb->transfer_buffer;
1389         unsigned int f, i;
1390
1391         for (i = 0; i < SYNCFRAMES; i++, cp += 3) {
1392                 if (urb->iso_frame_desc[i].status) {
1393                         dprintk((KERN_DEBUG "usbout_sync_retire_desc: frame %u status %d\n", i, urb->iso_frame_desc[i].status));
1394                         continue;
1395                 }
1396                 if (urb->iso_frame_desc[i].actual_length < 3) {
1397                         dprintk((KERN_DEBUG "usbout_sync_retire_desc: frame %u length %d\n", i, urb->iso_frame_desc[i].actual_length));
1398                         continue;
1399                 }
1400                 f = cp[0] | (cp[1] << 8) | (cp[2] << 16);
1401                 if (my_abs(f - u->freqn) > (u->freqn >> 3) || f > u->freqmax) {
1402                         printk(KERN_WARNING "usbout_sync_retire_desc: requested frequency %u (nominal %u) out of range!\n", f, u->freqn);
1403                         continue;
1404                 }
1405                 u->freqm = f;
1406         }
1407         return 0;
1408 }
1409
1410 static void usbout_sync_completed(struct urb *urb)
1411 {
1412         struct usb_audiodev *as = (struct usb_audiodev *)urb->context;
1413         struct usbout *u = &as->usbout;
1414         unsigned long flags;
1415         unsigned int mask;
1416         int suret = USB_ST_NOERROR;
1417
1418 #if 0
1419         printk(KERN_DEBUG "usbout_sync_completed: status %d errcnt %d flags 0x%x\n", urb->status, urb->error_count, u->flags);
1420 #endif
1421         if (urb == &u->surb[0].urb)
1422                 mask = FLG_SYNC0RUNNING;
1423         else if (urb == &u->surb[1].urb)
1424                 mask = FLG_SYNC1RUNNING;
1425         else {
1426                 mask = 0;
1427                 printk(KERN_ERR "usbout_sync_completed: panic: unknown URB\n");
1428         }
1429         urb->dev = as->state->usbdev;
1430         spin_lock_irqsave(&as->lock, flags);
1431         if (!usbout_sync_retire_desc(u, urb) &&
1432             u->flags & FLG_RUNNING &&
1433             !usbout_sync_prepare_desc(u, urb) &&
1434             (suret = usb_submit_urb(urb)) == USB_ST_NOERROR) {
1435                 u->flags |= mask;
1436         } else {
1437                 u->flags &= ~(mask | FLG_RUNNING);
1438                 wake_up(&u->dma.wait);
1439                 dprintk((KERN_DEBUG "usbout_sync_completed: descriptor not restarted (usb_submit_urb: %d)\n", suret));
1440         }
1441         spin_unlock_irqrestore(&as->lock, flags);
1442 }
1443
1444 static int usbout_start(struct usb_audiodev *as)
1445 {
1446         struct usb_device *dev = as->state->usbdev;
1447         struct usbout *u = &as->usbout;
1448         struct urb *urb;
1449         unsigned long flags;
1450         unsigned int maxsze, bufsz;
1451
1452 #if 0
1453         printk(KERN_DEBUG "usbout_start: device %d ufmt 0x%08x dfmt 0x%08x srate %d\n",
1454                dev->devnum, u->format, u->dma.format, u->dma.srate);
1455 #endif
1456         /* allocate USB storage if not already done */
1457         spin_lock_irqsave(&as->lock, flags);
1458         if (!(u->flags & FLG_CONNECTED)) {
1459                 spin_unlock_irqrestore(&as->lock, flags);
1460                 return -EIO;
1461         }
1462         if (!(u->flags & FLG_RUNNING)) {
1463                 spin_unlock_irqrestore(&as->lock, flags);
1464                 u->freqn = u->freqm = ((u->dma.srate << 11) + 62) / 125; /* this will overflow at approx 2MSPS */
1465                 u->freqmax = u->freqn + (u->freqn >> 2);
1466                 u->phase = 0;
1467                 maxsze = ((u->freqmax + 0x3fff) * AFMT_SAMPLEBYTES(u->format)) >>14;
1468
1469                 bufsz = DESCFRAMES * maxsze;
1470                 if (u->durb[0].urb.transfer_buffer)
1471                         kfree(u->durb[0].urb.transfer_buffer);
1472                 u->durb[0].urb.transfer_buffer = kmalloc(bufsz, GFP_KERNEL);
1473                 u->durb[0].urb.transfer_buffer_length = bufsz;
1474                 if (u->durb[1].urb.transfer_buffer)
1475                         kfree(u->durb[1].urb.transfer_buffer);
1476                 u->durb[1].urb.transfer_buffer = kmalloc(bufsz, GFP_KERNEL);
1477                 u->durb[1].urb.transfer_buffer_length = bufsz;
1478                 if (u->syncpipe) {
1479                         if (u->surb[0].urb.transfer_buffer)
1480                                 kfree(u->surb[0].urb.transfer_buffer);
1481                         u->surb[0].urb.transfer_buffer = kmalloc(3*SYNCFRAMES, GFP_KERNEL);
1482                         u->surb[0].urb.transfer_buffer_length = 3*SYNCFRAMES;
1483                         if (u->surb[1].urb.transfer_buffer)
1484                                 kfree(u->surb[1].urb.transfer_buffer);
1485                         u->surb[1].urb.transfer_buffer = kmalloc(3*SYNCFRAMES, GFP_KERNEL);
1486                         u->surb[1].urb.transfer_buffer_length = 3*SYNCFRAMES;
1487                 }
1488                 if (!u->durb[0].urb.transfer_buffer || !u->durb[1].urb.transfer_buffer ||
1489                     (u->syncpipe && (!u->surb[0].urb.transfer_buffer || !u->surb[1].urb.transfer_buffer))) {
1490                         printk(KERN_ERR "usbaudio: cannot start playback device %d\n", dev->devnum);
1491                         return 0;
1492                 }
1493                 spin_lock_irqsave(&as->lock, flags);
1494         }
1495         if (u->dma.count <= 0 && !u->dma.mapped) {
1496                 spin_unlock_irqrestore(&as->lock, flags);
1497                 return 0;
1498         }
1499         u->flags |= FLG_RUNNING;
1500         if (!(u->flags & FLG_URB0RUNNING)) {
1501                 urb = &u->durb[0].urb;
1502                 urb->dev = dev;
1503                 urb->pipe = u->datapipe;
1504                 urb->transfer_flags = USB_ISO_ASAP;
1505                 urb->number_of_packets = DESCFRAMES;
1506                 urb->context = as;
1507                 urb->complete = usbout_completed;
1508                 if (!usbout_prepare_desc(u, urb) && !usb_submit_urb(urb))
1509                         u->flags |= FLG_URB0RUNNING;
1510                 else
1511                         u->flags &= ~FLG_RUNNING;
1512         }
1513         if (u->flags & FLG_RUNNING && !(u->flags & FLG_URB1RUNNING)) {
1514                 urb = &u->durb[1].urb;
1515                 urb->dev = dev;
1516                 urb->pipe = u->datapipe;
1517                 urb->transfer_flags = USB_ISO_ASAP;
1518                 urb->number_of_packets = DESCFRAMES;
1519                 urb->context = as;
1520                 urb->complete = usbout_completed;
1521                 if (!usbout_prepare_desc(u, urb) && !usb_submit_urb(urb))
1522                         u->flags |= FLG_URB1RUNNING;
1523                 else
1524                         u->flags &= ~FLG_RUNNING;
1525         }
1526         if (u->syncpipe) {
1527                 if (u->flags & FLG_RUNNING && !(u->flags & FLG_SYNC0RUNNING)) {
1528                         urb = &u->surb[0].urb;
1529                         urb->dev = dev;
1530                         urb->pipe = u->syncpipe;
1531                         urb->transfer_flags = USB_ISO_ASAP;
1532                         urb->number_of_packets = SYNCFRAMES;
1533                         urb->context = as;
1534                         urb->complete = usbout_sync_completed;
1535                         /* stride: u->syncinterval */
1536                         if (!usbout_sync_prepare_desc(u, urb) && !usb_submit_urb(urb))
1537                                 u->flags |= FLG_SYNC0RUNNING;
1538                         else
1539                                 u->flags &= ~FLG_RUNNING;
1540                 }
1541                 if (u->flags & FLG_RUNNING && !(u->flags & FLG_SYNC1RUNNING)) {
1542                         urb = &u->surb[1].urb;
1543                         urb->dev = dev;
1544                         urb->pipe = u->syncpipe;
1545                         urb->transfer_flags = USB_ISO_ASAP;
1546                         urb->number_of_packets = SYNCFRAMES;
1547                         urb->context = as;
1548                         urb->complete = usbout_sync_completed;
1549                         /* stride: u->syncinterval */
1550                         if (!usbout_sync_prepare_desc(u, urb) && !usb_submit_urb(urb))
1551                                 u->flags |= FLG_SYNC1RUNNING;
1552                         else
1553                                 u->flags &= ~FLG_RUNNING;
1554                 }
1555         }
1556         spin_unlock_irqrestore(&as->lock, flags);
1557         return 0;
1558 }
1559
1560 /* --------------------------------------------------------------------- */
1561 /* allowed conversions (sign, endian, width, channels), and relative
1562    weighting penalties against fuzzy match selection.  For the
1563    purposes of not confusing users, 'lossy' format translation is
1564    disallowed, eg, don't allow a mono 8 bit device to successfully
1565    open as 5.1, 24 bit... Never allow a mode that tries to deliver greater
1566    than the hard capabilities of the device.
1567
1568    device --=> app
1569
1570    signed   => unsigned : 1
1571    unsigned => signed   : 1
1572
1573    le       => be       : 1
1574    be       => le       : 1
1575
1576    8        => 16       : not allowed
1577    8        => 24       : not allowed
1578    8        => 32       : not allowed
1579    16       => 24       : not allowed
1580    16       => 32       : not allowed
1581    24       => 32       : not allowed
1582
1583    16       => 8        : 4
1584    24       => 16       : 4
1585    24       => 8        : 5
1586    32       => 24       : 4
1587    32       => 16       : 5
1588    32       => 8        : 5
1589
1590    mono     => stereo   : not allowed
1591    stereo   => mono     : 32 (downmix to L+R/2)
1592
1593    N        => >N       : not allowed
1594    N        => <N       : 32 */
1595
1596 static unsigned int format_goodness(struct audioformat *afp, unsigned int app,
1597                                     unsigned int srate){
1598         unsigned int g = 0;
1599         unsigned int sratelo=afp->sratelo;
1600         unsigned int sratehi=afp->sratehi;
1601         unsigned int dev=afp->format;
1602
1603         if(AFMT_SIGN(dev) && !AFMT_SIGN(app))     g += 1;
1604         if(!AFMT_SIGN(dev) && AFMT_SIGN(app))     g += 1;
1605         if(AFMT_ENDIAN(dev) && !AFMT_ENDIAN(app)) g += 1;
1606         if(!AFMT_ENDIAN(dev) && AFMT_ENDIAN(app)) g += 1;
1607
1608         switch(AFMT_BYTES(app)+AFMT_BYTES(dev)*10){
1609         case 12: return ~0;
1610         case 13: return ~0;
1611         case 14: return ~0;
1612         case 21: g += 4; break;
1613         case 23: return ~0;
1614         case 24: return ~0;
1615         case 31: g += 5; break;
1616         case 32: g += 4; break;
1617         case 34: return ~0;
1618         case 41: g += 6; break;
1619         case 42: g += 5; break;
1620         case 43: g += 4; break;
1621         }
1622
1623         if(AFMT_CHANNELS(dev) > AFMT_CHANNELS(app)){
1624                 g+=32;
1625         }else if(AFMT_CHANNELS(dev) < AFMT_CHANNELS(app)){
1626                 return ~0;
1627         }
1628
1629         g<<=20;
1630
1631         if (srate < sratelo)
1632                 g += sratelo - srate;
1633         if (srate > sratehi)
1634                 g += srate - sratehi;
1635
1636         return(g);
1637 }
1638
1639 static int find_format(struct audioformat *afp, unsigned int nr,
1640                           unsigned int fmt, unsigned int srate)
1641 {
1642         unsigned int i, g, gb = ~0;
1643         int j = -1; /* default to failure */
1644
1645         /* find "best" format (according to format_goodness) */
1646         for (i = 0; i < nr; i++) {
1647                 g = format_goodness(&afp[i], fmt, srate);
1648                 if (g >= gb) continue;
1649                 j = i;
1650                 gb = g;
1651         }
1652         return j;
1653 }
1654
1655 static int set_format_in(struct usb_audiodev *as)
1656 {
1657         struct usb_device *dev = as->state->usbdev;
1658         struct usb_config_descriptor *config = dev->actconfig;
1659         struct usb_interface_descriptor *alts;
1660         struct usb_interface *iface;
1661         struct usbin *u = &as->usbin;
1662         struct dmabuf *d = &u->dma;
1663         struct audioformat *fmt;
1664         unsigned int ep;
1665         unsigned char data[3];
1666         int fmtnr, ret;
1667
1668         if (u->interface < 0 || u->interface >= config->bNumInterfaces)
1669                 return 0;
1670         iface = &config->interface[u->interface];
1671
1672         fmtnr = find_format(as->fmtin, as->numfmtin, d->format, d->srate);
1673         if (fmtnr < 0) {
1674                 printk(KERN_ERR "usbaudio: set_format_in(): failed to find desired format/speed combination.\n");
1675                 return -1;
1676         }
1677
1678         fmt = as->fmtin + fmtnr;
1679         alts = &iface->altsetting[fmt->altsetting];
1680         u->format = fmt->format;
1681         u->datapipe = usb_rcvisocpipe(dev, alts->endpoint[0].bEndpointAddress & 0xf);
1682         u->syncpipe = u->syncinterval = 0;
1683         if ((alts->endpoint[0].bmAttributes & 0x0c) == 0x08) {
1684                 if (alts->bNumEndpoints < 2 ||
1685                     alts->endpoint[1].bmAttributes != 0x01 ||
1686                     alts->endpoint[1].bSynchAddress != 0 ||
1687                     alts->endpoint[1].bEndpointAddress != (alts->endpoint[0].bSynchAddress & 0x7f)) {
1688                         printk(KERN_WARNING "usbaudio: device %d interface %d altsetting %d claims adaptive in but has invalid synch pipe; treating as asynchronous in\n",
1689                                dev->devnum, u->interface, fmt->altsetting);
1690                 } else {
1691                         u->syncpipe = usb_sndisocpipe(dev, alts->endpoint[1].bEndpointAddress & 0xf);
1692                         u->syncinterval = alts->endpoint[1].bRefresh;
1693                 }
1694         }
1695         if (d->srate < fmt->sratelo)
1696                 d->srate = fmt->sratelo;
1697         if (d->srate > fmt->sratehi)
1698                 d->srate = fmt->sratehi;
1699         dprintk((KERN_DEBUG "usbaudio: set_format_in: usb_set_interface %u %u\n", alts->bInterfaceNumber, fmt->altsetting));
1700         if (usb_set_interface(dev, alts->bInterfaceNumber, fmt->altsetting) < 0) {
1701                 printk(KERN_WARNING "usbaudio: usb_set_interface failed, device %d interface %d altsetting %d\n",
1702                        dev->devnum, u->interface, fmt->altsetting);
1703                 return -1;
1704         }
1705         if (fmt->sratelo == fmt->sratehi)
1706                 return 0;
1707         ep = usb_pipeendpoint(u->datapipe) | (u->datapipe & USB_DIR_IN);
1708         /* if endpoint has pitch control, enable it */
1709         if (fmt->attributes & 0x02) {
1710                 data[0] = 1;
1711                 if ((ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR, USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_OUT,
1712                                            PITCH_CONTROL << 8, ep, data, 1, HZ)) < 0) {
1713                         printk(KERN_ERR "usbaudio: failure (error %d) to set output pitch control device %d interface %u endpoint 0x%x to %u\n",
1714                                ret, dev->devnum, u->interface, ep, d->srate);
1715                         return -1;
1716                 }
1717         }
1718         /* if endpoint has sampling rate control, set it */
1719         if (fmt->attributes & 0x01) {
1720                 data[0] = d->srate;
1721                 data[1] = d->srate >> 8;
1722                 data[2] = d->srate >> 16;
1723                 if ((ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR, USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_OUT,
1724                                            SAMPLING_FREQ_CONTROL << 8, ep, data, 3, HZ)) < 0) {
1725                         printk(KERN_ERR "usbaudio: failure (error %d) to set input sampling frequency device %d interface %u endpoint 0x%x to %u\n",
1726                                ret, dev->devnum, u->interface, ep, d->srate);
1727                         return -1;
1728                 }
1729                 if ((ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), GET_CUR, USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_IN,
1730                                            SAMPLING_FREQ_CONTROL << 8, ep, data, 3, HZ)) < 0) {
1731                         printk(KERN_ERR "usbaudio: failure (error %d) to get input sampling frequency device %d interface %u endpoint 0x%x\n",
1732                                ret, dev->devnum, u->interface, ep);
1733                         return -1;
1734                 }
1735                 dprintk((KERN_DEBUG "usbaudio: set_format_in: device %d interface %d altsetting %d srate req: %u real %u\n",
1736                         dev->devnum, u->interface, fmt->altsetting, d->srate, data[0] | (data[1] << 8) | (data[2] << 16)));
1737                 d->srate = data[0] | (data[1] << 8) | (data[2] << 16);
1738         }
1739         dprintk((KERN_DEBUG "usbaudio: set_format_in: USB format 0x%x, DMA format 0x%x srate %u\n", u->format, d->format, d->srate));
1740         return 0;
1741 }
1742
1743 static int set_format_out(struct usb_audiodev *as)
1744 {
1745         struct usb_device *dev = as->state->usbdev;
1746         struct usb_config_descriptor *config = dev->actconfig;
1747         struct usb_interface_descriptor *alts;
1748         struct usb_interface *iface;
1749         struct usbout *u = &as->usbout;
1750         struct dmabuf *d = &u->dma;
1751         struct audioformat *fmt;
1752         unsigned int ep;
1753         unsigned char data[3];
1754         int fmtnr, ret;
1755
1756         if (u->interface < 0 || u->interface >= config->bNumInterfaces)
1757                 return 0;
1758         iface = &config->interface[u->interface];
1759
1760         fmtnr = find_format(as->fmtout, as->numfmtout, d->format, d->srate);
1761         if (fmtnr < 0) {
1762                 printk(KERN_ERR "usbaudio: set_format_out(): failed to find desired format/speed combination.\n");
1763                 return -1;
1764         }
1765
1766         fmt = as->fmtout + fmtnr;
1767         u->format = fmt->format;
1768         alts = &iface->altsetting[fmt->altsetting];
1769         u->datapipe = usb_sndisocpipe(dev, alts->endpoint[0].bEndpointAddress & 0xf);
1770         u->syncpipe = u->syncinterval = 0;
1771         if ((alts->endpoint[0].bmAttributes & 0x0c) == 0x04) {
1772 #if 0
1773                 printk(KERN_DEBUG "bNumEndpoints 0x%02x endpoint[1].bmAttributes 0x%02x\n"
1774                        KERN_DEBUG "endpoint[1].bSynchAddress 0x%02x endpoint[1].bEndpointAddress 0x%02x\n"
1775                        KERN_DEBUG "endpoint[0].bSynchAddress 0x%02x\n", alts->bNumEndpoints,
1776                        alts->endpoint[1].bmAttributes, alts->endpoint[1].bSynchAddress,
1777                        alts->endpoint[1].bEndpointAddress, alts->endpoint[0].bSynchAddress);
1778 #endif
1779                 if (alts->bNumEndpoints < 2 ||
1780                     alts->endpoint[1].bmAttributes != 0x01 ||
1781                     alts->endpoint[1].bSynchAddress != 0 ||
1782                     alts->endpoint[1].bEndpointAddress != (alts->endpoint[0].bSynchAddress | 0x80)) {
1783                         printk(KERN_WARNING "usbaudio: device %d interface %d altsetting %d claims asynch out but has invalid synch pipe; treating as adaptive out\n",
1784                                dev->devnum, u->interface, fmt->altsetting);
1785                 } else {
1786                         u->syncpipe = usb_rcvisocpipe(dev, alts->endpoint[1].bEndpointAddress & 0xf);
1787                         u->syncinterval = alts->endpoint[1].bRefresh;
1788                 }
1789         }
1790         if (d->srate < fmt->sratelo)
1791                 d->srate = fmt->sratelo;
1792         if (d->srate > fmt->sratehi)
1793                 d->srate = fmt->sratehi;
1794         dprintk((KERN_DEBUG "usbaudio: set_format_out: usb_set_interface %u %u\n", alts->bInterfaceNumber, fmt->altsetting));
1795         if (usb_set_interface(dev, u->interface, fmt->altsetting) < 0) {
1796                 printk(KERN_WARNING "usbaudio: usb_set_interface failed, device %d interface %d altsetting %d\n",
1797                        dev->devnum, u->interface, fmt->altsetting);
1798                 return -1;
1799         }
1800         if (fmt->sratelo == fmt->sratehi)
1801                 return 0;
1802         ep = usb_pipeendpoint(u->datapipe) | (u->datapipe & USB_DIR_IN);
1803         /* if endpoint has pitch control, enable it */
1804         if (fmt->attributes & 0x02) {
1805                 data[0] = 1;
1806                 if ((ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR, USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_OUT,
1807                                            PITCH_CONTROL << 8, ep, data, 1, HZ)) < 0) {
1808                         printk(KERN_ERR "usbaudio: failure (error %d) to set output pitch control device %d interface %u endpoint 0x%x to %u\n",
1809                                ret, dev->devnum, u->interface, ep, d->srate);
1810                         return -1;
1811                 }
1812         }
1813         /* if endpoint has sampling rate control, set it */
1814         if (fmt->attributes & 0x01) {
1815                 data[0] = d->srate;
1816                 data[1] = d->srate >> 8;
1817                 data[2] = d->srate >> 16;
1818                 if ((ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR, USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_OUT,
1819                                            SAMPLING_FREQ_CONTROL << 8, ep, data, 3, HZ)) < 0) {
1820                         printk(KERN_ERR "usbaudio: failure (error %d) to set output sampling frequency device %d interface %u endpoint 0x%x to %u\n",
1821                                ret, dev->devnum, u->interface, ep, d->srate);
1822                         return -1;
1823                 }
1824                 if ((ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), GET_CUR, USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_IN,
1825                                            SAMPLING_FREQ_CONTROL << 8, ep, data, 3, HZ)) < 0) {
1826                         printk(KERN_ERR "usbaudio: failure (error %d) to get output sampling frequency device %d interface %u endpoint 0x%x\n",
1827                                ret, dev->devnum, u->interface, ep);
1828                         return -1;
1829                 }
1830                 dprintk((KERN_DEBUG "usbaudio: set_format_out: device %d interface %d altsetting %d srate req: %u real %u\n",
1831                         dev->devnum, u->interface, fmt->altsetting, d->srate, data[0] | (data[1] << 8) | (data[2] << 16)));
1832                 d->srate = data[0] | (data[1] << 8) | (data[2] << 16);
1833         }
1834         dprintk((KERN_DEBUG "usbaudio: set_format_out: USB format 0x%x, DMA format 0x%x srate %u\n", u->format, d->format, d->srate));
1835         return 0;
1836 }
1837
1838 static int set_format(struct usb_audiodev *s, unsigned int fmode, unsigned int fmt, unsigned int srate)
1839 {
1840         int ret1 = 0, ret2 = 0;
1841
1842         if (!(fmode & (FMODE_READ|FMODE_WRITE)))
1843                 return -EINVAL;
1844         if (fmode & FMODE_READ) {
1845                 usbin_stop(s);
1846                 s->usbin.dma.ready = 0;
1847                 if (fmt == AFMT_QUERY)
1848                         fmt = s->usbin.dma.format;
1849                 else
1850                         s->usbin.dma.format = fmt;
1851                 if (!srate)
1852                         srate = s->usbin.dma.srate;
1853                 else
1854                         s->usbin.dma.srate = srate;
1855         }
1856         if (fmode & FMODE_WRITE) {
1857                 usbout_stop(s);
1858                 s->usbout.dma.ready = 0;
1859                 if (fmt == AFMT_QUERY)
1860                         fmt = s->usbout.dma.format;
1861                 else
1862                         s->usbout.dma.format = fmt;
1863                 if (!srate)
1864                         srate = s->usbout.dma.srate;
1865                 else
1866                         s->usbout.dma.srate = srate;
1867         }
1868         if (fmode & FMODE_READ)
1869                 ret1 = set_format_in(s);
1870         if (fmode & FMODE_WRITE)
1871                 ret2 = set_format_out(s);
1872         return ret1 ? ret1 : ret2;
1873 }
1874
1875 /* --------------------------------------------------------------------- */
1876
1877 static int wrmixer(struct usb_mixerdev *ms, unsigned mixch, unsigned value)
1878 {
1879         struct usb_device *dev = ms->state->usbdev;
1880         unsigned char data[2];
1881         struct mixerchannel *ch;
1882         int v1, v2, v3;
1883
1884         if (mixch >= ms->numch)
1885                 return -1;
1886         ch = &ms->ch[mixch];
1887         v3 = ch->maxval - ch->minval;
1888         v1 = value & 0xff;
1889         v2 = (value >> 8) & 0xff;
1890         if (v1 > 100)
1891                 v1 = 100;
1892         if (v2 > 100)
1893                 v2 = 100;
1894         if (!(ch->flags & (MIXFLG_STEREOIN | MIXFLG_STEREOOUT)))
1895                 v2 = v1;
1896         ch->value = v1 | (v2 << 8);
1897         v1 = (v1 * v3) / 100 + ch->minval;
1898         v2 = (v2 * v3) / 100 + ch->minval;
1899         switch (ch->selector) {
1900         case 0:  /* mixer unit request */
1901                 data[0] = v1;
1902                 data[1] = v1 >> 8;
1903                 if (usb_control_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
1904                                     (ch->chnum << 8) | 1, ms->iface | (ch->unitid << 8), data, 2, HZ) < 0)
1905                         goto err;
1906                 if (!(ch->flags & (MIXFLG_STEREOIN | MIXFLG_STEREOOUT)))
1907                         return 0;
1908                 data[0] = v2;
1909                 data[1] = v2 >> 8;
1910                 if (usb_control_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
1911                                     ((ch->chnum + !!(ch->flags & MIXFLG_STEREOIN)) << 8) | (1 + !!(ch->flags & MIXFLG_STEREOOUT)),
1912                                     ms->iface | (ch->unitid << 8), data, 2, HZ) < 0)
1913                         goto err;
1914                 return 0;
1915
1916                 /* various feature unit controls */
1917         case VOLUME_CONTROL:
1918                 data[0] = v1;
1919                 data[1] = v1 >> 8;
1920                 if (usb_control_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
1921                                     (ch->selector << 8) | ch->chnum, ms->iface | (ch->unitid << 8), data, 2, HZ) < 0)
1922                         goto err;
1923                 if (!(ch->flags & (MIXFLG_STEREOIN | MIXFLG_STEREOOUT)))
1924                         return 0;
1925                 data[0] = v2;
1926                 data[1] = v2 >> 8;
1927                 if (usb_control_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
1928                                     (ch->selector << 8) | (ch->chnum + 1), ms->iface | (ch->unitid << 8), data, 2, HZ) < 0)
1929                         goto err;
1930                 return 0;
1931
1932         case BASS_CONTROL:
1933         case MID_CONTROL:
1934         case TREBLE_CONTROL:
1935                 data[0] = v1 >> 8;
1936                 if (usb_control_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
1937                                     (ch->selector << 8) | ch->chnum, ms->iface | (ch->unitid << 8), data, 1, HZ) < 0)
1938                         goto err;
1939                 if (!(ch->flags & (MIXFLG_STEREOIN | MIXFLG_STEREOOUT)))
1940                         return 0;
1941                 data[0] = v2 >> 8;
1942                 if (usb_control_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
1943                                     (ch->selector << 8) | (ch->chnum + 1), ms->iface | (ch->unitid << 8), data, 1, HZ) < 0)
1944                         goto err;
1945                 return 0;
1946
1947         default:
1948                 return -1;
1949         }
1950         return 0;
1951
1952  err:
1953         printk(KERN_ERR "usbaudio: mixer request device %u if %u unit %u ch %u selector %u failed\n",
1954                 dev->devnum, ms->iface, ch->unitid, ch->chnum, ch->selector);
1955         return -1;
1956 }
1957
1958 static int get_rec_src(struct usb_mixerdev *ms)
1959 {
1960         struct usb_device *dev = ms->state->usbdev;
1961         unsigned int mask = 0, retmask = 0;
1962         unsigned int i, j;
1963         unsigned char buf;
1964         int err = 0;
1965
1966         for (i = 0; i < ms->numch; i++) {
1967                 if (!ms->ch[i].slctunitid || (mask & (1 << i)))
1968                         continue;
1969                 if (usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), GET_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
1970                                     0, ms->iface | (ms->ch[i].slctunitid << 8), &buf, 1, HZ) < 0) {
1971                         err = -EIO;
1972                         printk(KERN_ERR "usbaudio: selector read request device %u if %u unit %u failed\n",
1973                                dev->devnum, ms->iface, ms->ch[i].slctunitid & 0xff);
1974                         continue;
1975                 }
1976                 for (j = i; j < ms->numch; j++) {
1977                         if ((ms->ch[i].slctunitid ^ ms->ch[j].slctunitid) & 0xff)
1978                                 continue;
1979                         mask |= 1 << j;
1980                         if (buf == (ms->ch[j].slctunitid >> 8))
1981                                 retmask |= 1 << ms->ch[j].osschannel;
1982                 }
1983         }
1984         if (err)
1985                 return -EIO;
1986         return retmask;
1987 }
1988
1989 static int set_rec_src(struct usb_mixerdev *ms, int srcmask)
1990 {
1991         struct usb_device *dev = ms->state->usbdev;
1992         unsigned int mask = 0, smask, bmask;
1993         unsigned int i, j;
1994         unsigned char buf;
1995         int err = 0;
1996
1997         for (i = 0; i < ms->numch; i++) {
1998                 if (!ms->ch[i].slctunitid || (mask & (1 << i)))
1999                         continue;
2000                 if (usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), GET_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
2001                                     0, ms->iface | (ms->ch[i].slctunitid << 8), &buf, 1, HZ) < 0) {
2002                         err = -EIO;
2003                         printk(KERN_ERR "usbaudio: selector read request device %u if %u unit %u failed\n",
2004                                dev->devnum, ms->iface, ms->ch[i].slctunitid & 0xff);
2005                         continue;
2006                 }
2007                 /* first generate smask */
2008                 smask = bmask = 0;
2009                 for (j = i; j < ms->numch; j++) {
2010                         if ((ms->ch[i].slctunitid ^ ms->ch[j].slctunitid) & 0xff)
2011                                 continue;
2012                         smask |= 1 << ms->ch[j].osschannel;
2013                         if (buf == (ms->ch[j].slctunitid >> 8))
2014                                 bmask |= 1 << ms->ch[j].osschannel;
2015                         mask |= 1 << j;
2016                 }
2017                 /* check for multiple set sources */
2018                 j = hweight32(srcmask & smask);
2019                 if (j == 0)
2020                         continue;
2021                 if (j > 1)
2022                         srcmask &= ~bmask;
2023                 for (j = i; j < ms->numch; j++) {
2024                         if ((ms->ch[i].slctunitid ^ ms->ch[j].slctunitid) & 0xff)
2025                                 continue;
2026                         if (!(srcmask & (1 << ms->ch[j].osschannel)))
2027                                 continue;
2028                         buf = ms->ch[j].slctunitid >> 8;
2029                         if (usb_control_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
2030                                     0, ms->iface | (ms->ch[j].slctunitid << 8), &buf, 1, HZ) < 0) {
2031                                 err = -EIO;
2032                                 printk(KERN_ERR "usbaudio: selector write request device %u if %u unit %u failed\n",
2033                                        dev->devnum, ms->iface, ms->ch[j].slctunitid & 0xff);
2034                                 continue;
2035                         }
2036                 }
2037         }
2038         return err ? -EIO : 0;
2039 }
2040
2041 /* --------------------------------------------------------------------- */
2042
2043 /*
2044  * should be called with open_sem hold, so that no new processes
2045  * look at the audio device to be destroyed
2046  */
2047
2048 static void release(struct usb_audio_state *s)
2049 {
2050         struct usb_audiodev *as;
2051         struct usb_mixerdev *ms;
2052
2053         s->count--;
2054         if (s->count) {
2055                 up(&open_sem);
2056                 return;
2057         }
2058         up(&open_sem);
2059         wake_up(&open_wait);
2060         while (!list_empty(&s->audiolist)) {
2061                 as = list_entry(s->audiolist.next, struct usb_audiodev, list);
2062                 list_del(&as->list);
2063                 usbin_release(as);
2064                 usbout_release(as);
2065                 dmabuf_release(&as->usbin.dma);
2066                 dmabuf_release(&as->usbout.dma);
2067                 kfree(as);
2068         }
2069         while (!list_empty(&s->mixerlist)) {
2070                 ms = list_entry(s->mixerlist.next, struct usb_mixerdev, list);
2071                 list_del(&ms->list);
2072                 kfree(ms);
2073         }
2074         kfree(s);
2075 }
2076
2077 static inline int prog_dmabuf_in(struct usb_audiodev *as)
2078 {
2079         usbin_stop(as);
2080         return dmabuf_init(&as->usbin.dma);
2081 }
2082
2083 static inline int prog_dmabuf_out(struct usb_audiodev *as)
2084 {
2085         usbout_stop(as);
2086         return dmabuf_init(&as->usbout.dma);
2087 }
2088
2089 /* --------------------------------------------------------------------- */
2090
2091 static int usb_audio_open_mixdev(struct inode *inode, struct file *file)
2092 {
2093         int minor = MINOR(inode->i_rdev);
2094         struct list_head *devs, *mdevs;
2095         struct usb_mixerdev *ms;
2096         struct usb_audio_state *s;
2097
2098         down(&open_sem);
2099         for (devs = audiodevs.next; devs != &audiodevs; devs = devs->next) {
2100                 s = list_entry(devs, struct usb_audio_state, audiodev);
2101                 for (mdevs = s->mixerlist.next; mdevs != &s->mixerlist; mdevs = mdevs->next) {
2102                         ms = list_entry(mdevs, struct usb_mixerdev, list);
2103                         if (ms->dev_mixer == minor)
2104                                 goto mixer_found;
2105                 }
2106         }
2107         up(&open_sem);
2108         return -ENODEV;
2109
2110  mixer_found:
2111         if (!s->usbdev) {
2112                 up(&open_sem);
2113                 return -EIO;
2114         }
2115         file->private_data = ms;
2116         s->count++;
2117
2118         up(&open_sem);
2119         return 0;
2120 }
2121
2122 static int usb_audio_release_mixdev(struct inode *inode, struct file *file)
2123 {
2124         struct usb_mixerdev *ms = (struct usb_mixerdev *)file->private_data;
2125         struct usb_audio_state *s;
2126
2127         lock_kernel();
2128         s = ms->state;
2129         down(&open_sem);
2130         release(s);
2131         unlock_kernel();
2132         return 0;
2133 }
2134
2135 static int usb_audio_ioctl_mixdev(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
2136 {
2137         struct usb_mixerdev *ms = (struct usb_mixerdev *)file->private_data;
2138         int i, j, val;
2139
2140         if (!ms->state->usbdev)
2141                 return -ENODEV;
2142
2143         if (cmd == SOUND_MIXER_INFO) {
2144                 mixer_info info;
2145
2146                 memset(&info, 0, sizeof(info));
2147                 strncpy(info.id, "USB_AUDIO", sizeof(info.id));
2148                 strncpy(info.name, "USB Audio Class Driver", sizeof(info.name));
2149                 info.modify_counter = ms->modcnt;
2150                 if (copy_to_user((void *)arg, &info, sizeof(info)))
2151                         return -EFAULT;
2152                 return 0;
2153         }
2154         if (cmd == SOUND_OLD_MIXER_INFO) {
2155                 _old_mixer_info info;
2156
2157                 memset(&info, 0, sizeof(info));
2158                 strncpy(info.id, "USB_AUDIO", sizeof(info.id));
2159                 strncpy(info.name, "USB Audio Class Driver", sizeof(info.name));
2160                 if (copy_to_user((void *)arg, &info, sizeof(info)))
2161                         return -EFAULT;
2162                 return 0;
2163         }
2164         if (cmd == OSS_GETVERSION)
2165                 return put_user(SOUND_VERSION, (int *)arg);
2166         if (_IOC_TYPE(cmd) != 'M' || _IOC_SIZE(cmd) != sizeof(int))
2167                 return -EINVAL;
2168         if (_IOC_DIR(cmd) == _IOC_READ) {
2169                 switch (_IOC_NR(cmd)) {
2170                 case SOUND_MIXER_RECSRC: /* Arg contains a bit for each recording source */
2171                         val = get_rec_src(ms);
2172                         if (val < 0)
2173                                 return val;
2174                         return put_user(val, (int *)arg);
2175
2176                 case SOUND_MIXER_DEVMASK: /* Arg contains a bit for each supported device */
2177                         for (val = i = 0; i < ms->numch; i++)
2178                                 val |= 1 << ms->ch[i].osschannel;
2179                         return put_user(val, (int *)arg);
2180
2181                 case SOUND_MIXER_RECMASK: /* Arg contains a bit for each supported recording source */
2182                         for (val = i = 0; i < ms->numch; i++)
2183                                 if (ms->ch[i].slctunitid)
2184                                         val |= 1 << ms->ch[i].osschannel;
2185                         return put_user(val, (int *)arg);
2186
2187                 case SOUND_MIXER_STEREODEVS: /* Mixer channels supporting stereo */
2188                         for (val = i = 0; i < ms->numch; i++)
2189                                 if (ms->ch[i].flags & (MIXFLG_STEREOIN | MIXFLG_STEREOOUT))
2190                                         val |= 1 << ms->ch[i].osschannel;
2191                         return put_user(val, (int *)arg);
2192
2193                 case SOUND_MIXER_CAPS:
2194                         return put_user(SOUND_CAP_EXCL_INPUT, (int *)arg);
2195
2196                 default:
2197                         i = _IOC_NR(cmd);
2198                         if (i >= SOUND_MIXER_NRDEVICES)
2199                                 return -EINVAL;
2200                         for (j = 0; j < ms->numch; j++) {
2201                                 if (ms->ch[j].osschannel == i) {
2202                                         return put_user(ms->ch[j].value, (int *)arg);
2203                                 }
2204                         }
2205                         return -EINVAL;
2206                 }
2207         }
2208         if (_IOC_DIR(cmd) != (_IOC_READ|_IOC_WRITE))
2209                 return -EINVAL;
2210         ms->modcnt++;
2211         switch (_IOC_NR(cmd)) {
2212         case SOUND_MIXER_RECSRC: /* Arg contains a bit for each recording source */
2213                 if (get_user(val, (int *)arg))
2214                         return -EFAULT;
2215                 return set_rec_src(ms, val);
2216
2217         default:
2218                 i = _IOC_NR(cmd);
2219                 if (i >= SOUND_MIXER_NRDEVICES)
2220                         return -EINVAL;
2221                 for (j = 0; j < ms->numch && ms->ch[j].osschannel != i; j++);
2222                 if (j >= ms->numch)
2223                         return -EINVAL;
2224                 if (get_user(val, (int *)arg))
2225                         return -EFAULT;
2226                 if (wrmixer(ms, j, val))
2227                         return -EIO;
2228                 return put_user(ms->ch[j].value, (int *)arg);
2229         }
2230 }
2231
2232 static /*const*/ struct file_operations usb_mixer_fops = {
2233         owner:          THIS_MODULE,
2234         llseek:         no_llseek,
2235         ioctl:          usb_audio_ioctl_mixdev,
2236         open:           usb_audio_open_mixdev,
2237         release:        usb_audio_release_mixdev,
2238 };
2239
2240 /* --------------------------------------------------------------------- */
2241
2242 static int drain_out(struct usb_audiodev *as, int nonblock)
2243 {
2244         DECLARE_WAITQUEUE(wait, current);
2245         unsigned long flags;
2246         int count, tmo;
2247
2248         if (as->usbout.dma.mapped || !as->usbout.dma.ready)
2249                 return 0;
2250         usbout_start(as);
2251         add_wait_queue(&as->usbout.dma.wait, &wait);
2252         for (;;) {
2253                 __set_current_state(TASK_INTERRUPTIBLE);
2254                 spin_lock_irqsave(&as->lock, flags);
2255                 count = as->usbout.dma.count;
2256                 spin_unlock_irqrestore(&as->lock, flags);
2257                 if (count <= 0)
2258                         break;
2259                 if (signal_pending(current))
2260                         break;
2261                 if (nonblock) {
2262                         remove_wait_queue(&as->usbout.dma.wait, &wait);
2263                         set_current_state(TASK_RUNNING);
2264                         return -EBUSY;
2265                 }
2266                 tmo = 3 * HZ * count / (as->usbout.dma.srate *
2267                                         AFMT_SAMPLEBYTES(as->usbout.dma.format));
2268                 if (!schedule_timeout(tmo + 1)) {
2269                         printk(KERN_DEBUG "usbaudio: dma timed out??\n");
2270                         break;
2271                 }
2272         }
2273         remove_wait_queue(&as->usbout.dma.wait, &wait);
2274         set_current_state(TASK_RUNNING);
2275         if (signal_pending(current))
2276                 return -ERESTARTSYS;
2277         return 0;
2278 }
2279
2280 /* --------------------------------------------------------------------- */
2281
2282 static ssize_t usb_audio_read(struct file *file, char *buffer, size_t count, loff_t *ppos)
2283 {
2284         struct usb_audiodev *as = (struct usb_audiodev *)file->private_data;
2285         DECLARE_WAITQUEUE(wait, current);
2286         ssize_t ret = 0;
2287         unsigned long flags;
2288         unsigned int ptr;
2289         int cnt, err;
2290
2291         if (ppos != &file->f_pos)
2292                 return -ESPIPE;
2293         if (as->usbin.dma.mapped)
2294                 return -ENXIO;
2295         if (!as->usbin.dma.ready && (ret = prog_dmabuf_in(as)))
2296                 return ret;
2297         if (!access_ok(VERIFY_WRITE, buffer, count))
2298                 return -EFAULT;
2299         add_wait_queue(&as->usbin.dma.wait, &wait);
2300         while (count > 0) {
2301                 spin_lock_irqsave(&as->lock, flags);
2302                 ptr = as->usbin.dma.rdptr;
2303                 cnt = as->usbin.dma.count;
2304                 /* set task state early to avoid wakeup races */
2305                 if (cnt <= 0)
2306                         __set_current_state(TASK_INTERRUPTIBLE);
2307                 spin_unlock_irqrestore(&as->lock, flags);
2308                 if (cnt > count)
2309                         cnt = count;
2310                 if (cnt <= 0) {
2311                         if (as->usbin.dma.enabled && usbin_start(as)) {
2312                                 if (!ret)
2313                                         ret = -ENODEV;
2314                                 break;
2315                         }
2316                         if (file->f_flags & O_NONBLOCK) {
2317                                 if (!ret)
2318                                         ret = -EAGAIN;
2319                                 break;
2320                         }
2321                         schedule();
2322                         if (signal_pending(current)) {
2323                                 if (!ret)
2324                                         ret = -ERESTARTSYS;
2325                                 break;
2326                         }
2327                         continue;
2328                 }
2329                 if ((err = dmabuf_copyout_user(&as->usbin.dma, ptr, buffer, cnt))) {
2330                         if (!ret)
2331                                 ret = err;
2332                         break;
2333                 }
2334                 ptr += cnt;
2335                 if (ptr >= as->usbin.dma.dmasize)
2336                         ptr -= as->usbin.dma.dmasize;
2337                 spin_lock_irqsave(&as->lock, flags);
2338                 as->usbin.dma.rdptr = ptr;
2339                 as->usbin.dma.count -= cnt;
2340                 spin_unlock_irqrestore(&as->lock, flags);
2341                 count -= cnt;
2342                 buffer += cnt;
2343                 ret += cnt;
2344                 if (as->usbin.dma.enabled && usbin_start(as)) {
2345                         if (!ret)
2346                                 ret = -ENODEV;
2347                         break;
2348                 }
2349         }
2350         __set_current_state(TASK_RUNNING);
2351         remove_wait_queue(&as->usbin.dma.wait, &wait);
2352         return ret;
2353 }
2354
2355 static ssize_t usb_audio_write(struct file *file, const char *buffer, size_t count, loff_t *ppos)
2356 {
2357         struct usb_audiodev *as = (struct usb_audiodev *)file->private_data;
2358         DECLARE_WAITQUEUE(wait, current);
2359         ssize_t ret = 0;
2360         unsigned long flags;
2361         unsigned int ptr;
2362         unsigned int start_thr;
2363         int cnt, err;
2364
2365         if (ppos != &file->f_pos)
2366                 return -ESPIPE;
2367         if (as->usbout.dma.mapped)
2368                 return -ENXIO;
2369         if (!as->usbout.dma.ready && (ret = prog_dmabuf_out(as)))
2370                 return ret;
2371         if (!access_ok(VERIFY_READ, buffer, count))
2372                 return -EFAULT;
2373         start_thr = (as->usbout.dma.srate * AFMT_SAMPLEBYTES(as->usbout.dma.format)) / (1000 / (3 * DESCFRAMES));
2374         add_wait_queue(&as->usbout.dma.wait, &wait);
2375         while (count > 0) {
2376 #if 0
2377                 printk(KERN_DEBUG "usb_audio_write: count %u dma: count %u rdptr %u wrptr %u dmasize %u fragsize %u flags 0x%02x taskst 0x%lx\n",
2378                        count, as->usbout.dma.count, as->usbout.dma.rdptr, as->usbout.dma.wrptr, as->usbout.dma.dmasize, as->usbout.dma.fragsize,
2379                        as->usbout.flags, current->state);
2380 #endif
2381                 spin_lock_irqsave(&as->lock, flags);
2382                 if (as->usbout.dma.count < 0) {
2383                         as->usbout.dma.count = 0;
2384                         as->usbout.dma.rdptr = as->usbout.dma.wrptr;
2385                 }
2386                 ptr = as->usbout.dma.wrptr;
2387                 cnt = as->usbout.dma.dmasize - as->usbout.dma.count;
2388                 /* set task state early to avoid wakeup races */
2389                 if (cnt <= 0)
2390                         __set_current_state(TASK_INTERRUPTIBLE);
2391                 spin_unlock_irqrestore(&as->lock, flags);
2392                 if (cnt > count)
2393                         cnt = count;
2394                 if (cnt <= 0) {
2395                         if (as->usbout.dma.enabled && usbout_start(as)) {
2396                                 if (!ret)
2397                                         ret = -ENODEV;
2398                                 break;
2399                         }
2400                         if (file->f_flags & O_NONBLOCK) {
2401                                 if (!ret)
2402                                         ret = -EAGAIN;
2403                                 break;
2404                         }
2405                         schedule();
2406                         if (signal_pending(current)) {
2407                                 if (!ret)
2408                                         ret = -ERESTARTSYS;
2409                                 break;
2410                         }
2411                         continue;
2412                 }
2413                 if ((err = dmabuf_copyin_user(&as->usbout.dma, ptr, buffer, cnt))) {
2414                         if (!ret)
2415                                 ret = err;
2416                         break;
2417                 }
2418                 ptr += cnt;
2419                 if (ptr >= as->usbout.dma.dmasize)
2420                         ptr -= as->usbout.dma.dmasize;
2421                 spin_lock_irqsave(&as->lock, flags);
2422                 as->usbout.dma.wrptr = ptr;
2423                 as->usbout.dma.count += cnt;
2424                 spin_unlock_irqrestore(&as->lock, flags);
2425                 count -= cnt;
2426                 buffer += cnt;
2427                 ret += cnt;
2428                 if (as->usbout.dma.enabled && as->usbout.dma.count >= start_thr && usbout_start(as)) {
2429                         if (!ret)
2430                                 ret = -ENODEV;
2431                         break;
2432                 }
2433         }
2434         __set_current_state(TASK_RUNNING);
2435         remove_wait_queue(&as->usbout.dma.wait, &wait);
2436         return ret;
2437 }
2438
2439 /* Called without the kernel lock - fine */
2440 static unsigned int usb_audio_poll(struct file *file, struct poll_table_struct *wait)
2441 {
2442         struct usb_audiodev *as = (struct usb_audiodev *)file->private_data;
2443         unsigned long flags;
2444         unsigned int mask = 0;
2445
2446         if (file->f_mode & FMODE_WRITE) {
2447                 if (!as->usbout.dma.ready)
2448                         prog_dmabuf_out(as);
2449                 poll_wait(file, &as->usbout.dma.wait, wait);
2450         }
2451         if (file->f_mode & FMODE_READ) {
2452                 if (!as->usbin.dma.ready)
2453                         prog_dmabuf_in(as);
2454                 poll_wait(file, &as->usbin.dma.wait, wait);
2455         }
2456         spin_lock_irqsave(&as->lock, flags);
2457         if (file->f_mode & FMODE_READ) {
2458                 if (as->usbin.dma.count >= (signed)as->usbin.dma.fragsize)
2459                         mask |= POLLIN | POLLRDNORM;
2460         }
2461         if (file->f_mode & FMODE_WRITE) {
2462                 if (as->usbout.dma.mapped) {
2463                         if (as->usbout.dma.count >= (signed)as->usbout.dma.fragsize)
2464                                 mask |= POLLOUT | POLLWRNORM;
2465                 } else {
2466                         if ((signed)as->usbout.dma.dmasize >= as->usbout.dma.count + (signed)as->usbout.dma.fragsize)
2467                                 mask |= POLLOUT | POLLWRNORM;
2468                 }
2469         }
2470         spin_unlock_irqrestore(&as->lock, flags);
2471         return mask;
2472 }
2473
2474 static int usb_audio_mmap(struct file *file, struct vm_area_struct *vma)
2475 {
2476         struct usb_audiodev *as = (struct usb_audiodev *)file->private_data;
2477         struct dmabuf *db;
2478         int ret = -EINVAL;
2479
2480         lock_kernel();
2481         if (vma->vm_flags & VM_WRITE) {
2482                 if ((ret = prog_dmabuf_out(as)) != 0)
2483                         goto out;
2484                 db = &as->usbout.dma;
2485         } else if (vma->vm_flags & VM_READ) {
2486                 if ((ret = prog_dmabuf_in(as)) != 0)
2487                         goto out;
2488                 db = &as->usbin.dma;
2489         } else
2490                 goto out;
2491
2492         ret = -EINVAL;
2493         if (vma->vm_pgoff != 0)
2494                 goto out;
2495
2496         ret = dmabuf_mmap(db,  vma->vm_start, vma->vm_end - vma->vm_start, vma->vm_page_prot);
2497 out:
2498         unlock_kernel();
2499         return ret;
2500 }
2501
2502 static int usb_audio_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
2503 {
2504         struct usb_audiodev *as = (struct usb_audiodev *)file->private_data;
2505         struct usb_audio_state *s = as->state;
2506         unsigned long flags;
2507         audio_buf_info abinfo;
2508         count_info cinfo;
2509         int val = 0;
2510         int val2, mapped, ret;
2511
2512         if (!s->usbdev)
2513                 return -EIO;
2514         mapped = ((file->f_mode & FMODE_WRITE) && as->usbout.dma.mapped) ||
2515                 ((file->f_mode & FMODE_READ) && as->usbin.dma.mapped);
2516 #if 0
2517         if (arg)
2518                 get_user(val, (int *)arg);
2519         printk(KERN_DEBUG "usbaudio: usb_audio_ioctl cmd=%x arg=%lx *arg=%d\n", cmd, arg, val)
2520 #endif
2521         switch (cmd) {
2522         case OSS_GETVERSION:
2523                 return put_user(SOUND_VERSION, (int *)arg);
2524
2525         case SNDCTL_DSP_SYNC:
2526                 if (file->f_mode & FMODE_WRITE)
2527                         return drain_out(as, 0/*file->f_flags & O_NONBLOCK*/);
2528                 return 0;
2529
2530         case SNDCTL_DSP_SETDUPLEX:
2531                 return 0;
2532
2533         case SNDCTL_DSP_GETCAPS:
2534                 return put_user(DSP_CAP_DUPLEX | DSP_CAP_REALTIME | DSP_CAP_TRIGGER |
2535                                 DSP_CAP_MMAP | DSP_CAP_BATCH, (int *)arg);
2536
2537         case SNDCTL_DSP_RESET:
2538                 if (file->f_mode & FMODE_WRITE) {
2539                         usbout_stop(as);
2540                         as->usbout.dma.rdptr = as->usbout.dma.wrptr = as->usbout.dma.count = as->usbout.dma.total_bytes = 0;
2541                 }
2542                 if (file->f_mode & FMODE_READ) {
2543                         usbin_stop(as);
2544                         as->usbin.dma.rdptr = as->usbin.dma.wrptr = as->usbin.dma.count = as->usbin.dma.total_bytes = 0;
2545                 }
2546                 return 0;
2547
2548         case SNDCTL_DSP_SPEED:
2549                 if (get_user(val, (int *)arg))
2550                         return -EFAULT;
2551                 if (val >= 0) {
2552                         if (val < 4000)
2553                                 val = 4000;
2554                         if (val > 100000)
2555                                 val = 100000;
2556                         if (set_format(as, file->f_mode, AFMT_QUERY, val))
2557                                 return -EIO;
2558                 }
2559                 return put_user((file->f_mode & FMODE_READ) ? as->usbin.dma.srate : as->usbout.dma.srate, (int *)arg);
2560
2561         case SNDCTL_DSP_STEREO:
2562                 if (get_user(val, (int *)arg))
2563                         return -EFAULT;
2564                 val2 = (file->f_mode & FMODE_READ) ? as->usbin.dma.format : as->usbout.dma.format;
2565                 val2 &= 0x00ffffff;
2566                 if (val)
2567                         val2 |= AFMT_STEREO;
2568                 else
2569                         val2 &= ~AFMT_STEREO;
2570                 if (set_format(as, file->f_mode, val2, 0))
2571                         return -EIO;
2572                 return 0;
2573
2574         case SNDCTL_DSP_CHANNELS:
2575                 if (get_user(val, (int *)arg))
2576                         return -EFAULT;
2577                 if (val != 0) {
2578                         val2 = (file->f_mode & FMODE_READ) ? as->usbin.dma.format : as->usbout.dma.format;
2579
2580                         val2 &= 0x00ffffff;
2581                         val2 |= (val-1)<<24;
2582
2583                         if (set_format(as, file->f_mode, val2, 0))
2584                                 return -EIO;
2585                 }
2586                 val2 = (file->f_mode & FMODE_READ) ? as->usbin.dma.format : as->usbout.dma.format;
2587                 return put_user(AFMT_CHANNELS(val2), (int *)arg);
2588
2589         case SNDCTL_DSP_GETFMTS: /* Returns a mask */
2590                 return put_user(AFMT_U8 | AFMT_U16_LE | AFMT_U16_BE |
2591                                 AFMT_S8 | AFMT_S16_LE | AFMT_S16_BE |
2592                                 AFMT_U24_LE | AFMT_U24_BE | AFMT_S24_LE | AFMT_S24_BE |
2593                                 AFMT_U32_LE | AFMT_U32_BE | AFMT_S32_LE | AFMT_S32_BE,
2594                                 (int *)arg);
2595
2596         case SNDCTL_DSP_SETFMT: /* Selects ONE fmt*/
2597                 if (get_user(val, (int *)arg))
2598                         return -EFAULT;
2599                 if (val != AFMT_QUERY) {
2600                         if (hweight32(val) != 1)
2601                                 return -EINVAL;
2602                         if (!(val & (AFMT_U8 | AFMT_U16_LE | AFMT_U16_BE |
2603                                      AFMT_S8 | AFMT_S16_LE | AFMT_S16_BE |
2604                                      AFMT_U24_LE | AFMT_U24_BE | AFMT_S24_LE | AFMT_S24_BE |
2605                                      AFMT_U32_LE | AFMT_U32_BE | AFMT_S32_LE | AFMT_S32_BE)))
2606                                 return -EINVAL;
2607                         val2 = (file->f_mode & FMODE_READ) ? as->usbin.dma.format : as->usbout.dma.format;
2608                         val |= val2 & AFMT_CHMASK;
2609                         if (set_format(as, file->f_mode, val, 0))
2610                                 return -EIO;
2611                 }
2612                 val2 = (file->f_mode & FMODE_READ) ? as->usbin.dma.format : as->usbout.dma.format;
2613                 return put_user(val2 & ~AFMT_CHMASK, (int *)arg);
2614
2615         case SNDCTL_DSP_POST:
2616                 return 0;
2617
2618         case SNDCTL_DSP_GETTRIGGER:
2619                 val = 0;
2620                 if (file->f_mode & FMODE_READ && as->usbin.flags & FLG_RUNNING)
2621                         val |= PCM_ENABLE_INPUT;
2622                 if (file->f_mode & FMODE_WRITE && as->usbout.flags & FLG_RUNNING)
2623                         val |= PCM_ENABLE_OUTPUT;
2624                 return put_user(val, (int *)arg);
2625
2626         case SNDCTL_DSP_SETTRIGGER:
2627                 if (get_user(val, (int *)arg))
2628                         return -EFAULT;
2629                 if (file->f_mode & FMODE_READ) {
2630                         if (val & PCM_ENABLE_INPUT) {
2631                                 if (!as->usbin.dma.ready && (ret = prog_dmabuf_in(as)))
2632                                         return ret;
2633                                 as->usbin.dma.enabled = 1;
2634                                 if (usbin_start(as))
2635                                         return -ENODEV;
2636                         } else {
2637                                 as->usbin.dma.enabled = 0;
2638                                 usbin_stop(as);
2639                         }
2640                 }
2641                 if (file->f_mode & FMODE_WRITE) {
2642                         if (val & PCM_ENABLE_OUTPUT) {
2643                                 if (!as->usbout.dma.ready && (ret = prog_dmabuf_out(as)))
2644                                         return ret;
2645                                 as->usbout.dma.enabled = 1;
2646                                 if (usbout_start(as))
2647                                         return -ENODEV;
2648                         } else {
2649                                 as->usbout.dma.enabled = 0;
2650                                 usbout_stop(as);
2651                         }
2652                 }
2653                 return 0;
2654
2655         case SNDCTL_DSP_GETOSPACE:
2656                 if (!(file->f_mode & FMODE_WRITE))
2657                         return -EINVAL;
2658
2659                 /*if (!(as->usbout.flags & FLG_RUNNING) && (val = prog_dmabuf_out(as)) != 0)
2660
2661                 The above is potentially disasterous; if the
2662                 userspace app calls the GETOSPACE ioctl() before a
2663                 data write on the device (as can happen in a
2664                 sensible client that's tracking the write buffer
2665                 low watermark), the kernel driver will never
2666                 recover from momentary starvation (recall that
2667                 FLG_RUNNING will be cleared by usbout_completed)
2668                 because the ioctl will keep resetting the DMA
2669                 buffer before each write, potentially never
2670                 allowing us to fill the buffer back to the DMA
2671                 restart threshhold.
2672
2673                 Can you tell this was actually biting me? :-) */
2674
2675                 if ((!as->usbout.dma.ready) && (val = prog_dmabuf_out(as)) != 0)
2676                         return val;
2677                 spin_lock_irqsave(&as->lock, flags);
2678                 abinfo.fragsize = as->usbout.dma.fragsize;
2679                 abinfo.bytes = as->usbout.dma.dmasize - as->usbout.dma.count;
2680                 abinfo.fragstotal = as->usbout.dma.numfrag;
2681                 abinfo.fragments = abinfo.bytes >> as->usbout.dma.fragshift;
2682                 spin_unlock_irqrestore(&as->lock, flags);
2683                 return copy_to_user((void *)arg, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
2684
2685         case SNDCTL_DSP_GETISPACE:
2686                 if (!(file->f_mode & FMODE_READ))
2687                         return -EINVAL;
2688
2689                 /*if (!(as->usbin.flags & FLG_RUNNING) && (val = prog_dmabuf_in(as)) != 0)*/
2690                 if ((!as->usbin.dma.ready) && (val = prog_dmabuf_in(as)) != 0)
2691                         return val;
2692                 spin_lock_irqsave(&as->lock, flags);
2693                 abinfo.fragsize = as->usbin.dma.fragsize;
2694                 abinfo.bytes = as->usbin.dma.count;
2695                 abinfo.fragstotal = as->usbin.dma.numfrag;
2696                 abinfo.fragments = abinfo.bytes >> as->usbin.dma.fragshift;
2697                 spin_unlock_irqrestore(&as->lock, flags);
2698                 return copy_to_user((void *)arg, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
2699
2700         case SNDCTL_DSP_NONBLOCK:
2701                 file->f_flags |= O_NONBLOCK;
2702                 return 0;
2703
2704         case SNDCTL_DSP_GETODELAY:
2705                 if (!(file->f_mode & FMODE_WRITE))
2706                         return -EINVAL;
2707                 spin_lock_irqsave(&as->lock, flags);
2708                 val = as->usbout.dma.count;
2709                 spin_unlock_irqrestore(&as->lock, flags);
2710                 return put_user(val, (int *)arg);
2711
2712         case SNDCTL_DSP_GETIPTR:
2713                 if (!(file->f_mode & FMODE_READ))
2714                         return -EINVAL;
2715                 spin_lock_irqsave(&as->lock, flags);
2716                 cinfo.bytes = as->usbin.dma.total_bytes;
2717                 cinfo.blocks = as->usbin.dma.count >> as->usbin.dma.fragshift;
2718                 cinfo.ptr = as->usbin.dma.wrptr;
2719                 if (as->usbin.dma.mapped)
2720                         as->usbin.dma.count &= as->usbin.dma.fragsize-1;
2721                 spin_unlock_irqrestore(&as->lock, flags);
2722                 return copy_to_user((void *)arg, &cinfo, sizeof(cinfo)) ? -EFAULT : 0;
2723
2724         case SNDCTL_DSP_GETOPTR:
2725                 if (!(file->f_mode & FMODE_WRITE))
2726                         return -EINVAL;
2727                 spin_lock_irqsave(&as->lock, flags);
2728                 cinfo.bytes = as->usbout.dma.total_bytes;
2729                 cinfo.blocks = as->usbout.dma.count >> as->usbout.dma.fragshift;
2730                 cinfo.ptr = as->usbout.dma.rdptr;
2731                 if (as->usbout.dma.mapped)
2732                         as->usbout.dma.count &= as->usbout.dma.fragsize-1;
2733                 spin_unlock_irqrestore(&as->lock, flags);
2734                 return copy_to_user((void *)arg, &cinfo, sizeof(cinfo)) ? -EFAULT : 0;
2735
2736        case SNDCTL_DSP_GETBLKSIZE:
2737                 if (file->f_mode & FMODE_WRITE) {
2738
2739                   /* do not clobber devices that are already running! */
2740                   if ((!as->usbout.dma.ready) && (val = prog_dmabuf_out(as)) != 0)
2741                                 return val;
2742                         return put_user(as->usbout.dma.fragsize, (int *)arg);
2743                 }
2744                 /* do not clobber devices that are already running! */
2745                 if ((!as->usbin.dma.ready) && (val = prog_dmabuf_in(as)) != 0)
2746                         return val;
2747                 return put_user(as->usbin.dma.fragsize, (int *)arg);
2748
2749         case SNDCTL_DSP_SETFRAGMENT:
2750                 if (get_user(val, (int *)arg))
2751                         return -EFAULT;
2752                 if (file->f_mode & FMODE_READ) {
2753                         as->usbin.dma.ossfragshift = val & 0xffff;
2754                         as->usbin.dma.ossmaxfrags = (val >> 16) & 0xffff;
2755                         if (as->usbin.dma.ossfragshift < 4)
2756                                 as->usbin.dma.ossfragshift = 4;
2757                         if (as->usbin.dma.ossfragshift > 15)
2758                                 as->usbin.dma.ossfragshift = 15;
2759                         if (as->usbin.dma.ossmaxfrags < 4)
2760                                 as->usbin.dma.ossmaxfrags = 4;
2761                 }
2762                 if (file->f_mode & FMODE_WRITE) {
2763                         as->usbout.dma.ossfragshift = val & 0xffff;
2764                         as->usbout.dma.ossmaxfrags = (val >> 16) & 0xffff;
2765                         if (as->usbout.dma.ossfragshift < 4)
2766                                 as->usbout.dma.ossfragshift = 4;
2767                         if (as->usbout.dma.ossfragshift > 15)
2768                                 as->usbout.dma.ossfragshift = 15;
2769                         if (as->usbout.dma.ossmaxfrags < 4)
2770                                 as->usbout.dma.ossmaxfrags = 4;
2771                 }
2772                 return 0;
2773
2774         case SNDCTL_DSP_SUBDIVIDE:
2775                 if ((file->f_mode & FMODE_READ && as->usbin.dma.subdivision) ||
2776                     (file->f_mode & FMODE_WRITE && as->usbout.dma.subdivision))
2777                         return -EINVAL;
2778                 if (get_user(val, (int *)arg))
2779                         return -EFAULT;
2780                 if (val != 1 && val != 2 && val != 4)
2781                         return -EINVAL;
2782                 if (file->f_mode & FMODE_READ)
2783                         as->usbin.dma.subdivision = val;
2784                 if (file->f_mode & FMODE_WRITE)
2785                         as->usbout.dma.subdivision = val;
2786                 return 0;
2787
2788         case SOUND_PCM_READ_RATE:
2789                 return put_user((file->f_mode & FMODE_READ) ? as->usbin.dma.srate : as->usbout.dma.srate, (int *)arg);
2790
2791         case SOUND_PCM_READ_CHANNELS:
2792                 val2 = (file->f_mode & FMODE_READ) ? as->usbin.dma.format : as->usbout.dma.format;
2793                 return put_user(AFMT_CHANNELS(val2), (int *)arg);
2794
2795         case SOUND_PCM_READ_BITS:
2796                 val2 = (file->f_mode & FMODE_READ) ? as->usbin.dma.format : as->usbout.dma.format;
2797                 return put_user(AFMT_BYTES(val2) * 8, (int *)arg);
2798
2799         case SOUND_PCM_WRITE_FILTER:
2800         case SNDCTL_DSP_SETSYNCRO:
2801         case SOUND_PCM_READ_FILTER:
2802                 return -EINVAL;
2803         }
2804         dprintk((KERN_DEBUG "usbaudio: usb_audio_ioctl - no command found\n"));
2805         return -ENOIOCTLCMD;
2806 }
2807
2808 static int usb_audio_open(struct inode *inode, struct file *file)
2809 {
2810         int minor = MINOR(inode->i_rdev);
2811         DECLARE_WAITQUEUE(wait, current);
2812         struct list_head *devs, *adevs;
2813         struct usb_audiodev *as;
2814         struct usb_audio_state *s;
2815
2816         for (;;) {
2817                 down(&open_sem);
2818                 for (devs = audiodevs.next; devs != &audiodevs; devs = devs->next) {
2819                         s = list_entry(devs, struct usb_audio_state, audiodev);
2820                         for (adevs = s->audiolist.next; adevs != &s->audiolist; adevs = adevs->next) {
2821                                 as = list_entry(adevs, struct usb_audiodev, list);
2822                                 if (!((as->dev_audio ^ minor) & ~0xf))
2823                                         goto device_found;
2824                         }
2825                 }
2826                 up(&open_sem);
2827                 return -ENODEV;
2828
2829         device_found:
2830                 if (!s->usbdev) {
2831                         up(&open_sem);
2832                         return -EIO;
2833                 }
2834                 /* wait for device to become free */
2835                 if (!(as->open_mode & file->f_mode))
2836                         break;
2837                 if (file->f_flags & O_NONBLOCK) {
2838                         up(&open_sem);
2839                         return -EBUSY;
2840                 }
2841                 __set_current_state(TASK_INTERRUPTIBLE);
2842                 add_wait_queue(&open_wait, &wait);
2843                 up(&open_sem);
2844                 schedule();
2845                 __set_current_state(TASK_RUNNING);
2846                 remove_wait_queue(&open_wait, &wait);
2847                 if (signal_pending(current))
2848                         return -ERESTARTSYS;
2849         }
2850         if (file->f_mode & FMODE_READ) {
2851                 as->usbin.dma.ossfragshift = as->usbin.dma.ossmaxfrags = as->usbin.dma.subdivision = 0;
2852                 as->usbin.dma.enabled = 1;
2853         }
2854         if (file->f_mode & FMODE_WRITE) {
2855                 as->usbout.dma.ossfragshift = as->usbout.dma.ossmaxfrags = as->usbout.dma.subdivision = 0;
2856                 as->usbout.dma.enabled = 1;
2857         }
2858         if (set_format(as, file->f_mode, ((minor & 0xf) == SND_DEV_DSP16) ? AFMT_S16_LE : AFMT_U8 /* AFMT_ULAW */, 8000)) {
2859                 up(&open_sem);
2860                 return -EIO;
2861         }
2862         file->private_data = as;
2863         as->open_mode |= file->f_mode & (FMODE_READ | FMODE_WRITE);
2864         s->count++;
2865         up(&open_sem);
2866         return 0;
2867 }
2868
2869 static int usb_audio_release(struct inode *inode, struct file *file)
2870 {
2871         struct usb_audiodev *as = (struct usb_audiodev *)file->private_data;
2872         struct usb_audio_state *s;
2873         struct usb_device *dev;
2874         struct usb_interface *iface;
2875
2876         lock_kernel();
2877         s = as->state;
2878         dev = s->usbdev;
2879         if (file->f_mode & FMODE_WRITE)
2880                 drain_out(as, file->f_flags & O_NONBLOCK);
2881         down(&open_sem);
2882         if (file->f_mode & FMODE_WRITE) {
2883                 usbout_stop(as);
2884                 if (dev && as->usbout.interface >= 0) {
2885                         iface = &dev->actconfig->interface[as->usbout.interface];
2886                         usb_set_interface(dev, iface->altsetting->bInterfaceNumber, 0);
2887                 }
2888                 dmabuf_release(&as->usbout.dma);
2889                 usbout_release(as);
2890         }
2891         if (file->f_mode & FMODE_READ) {
2892                 usbin_stop(as);
2893                 if (dev && as->usbin.interface >= 0) {
2894                         iface = &dev->actconfig->interface[as->usbin.interface];
2895                         usb_set_interface(dev, iface->altsetting->bInterfaceNumber, 0);
2896                 }
2897                 dmabuf_release(&as->usbin.dma);
2898                 usbin_release(as);
2899         }
2900         as->open_mode &= (~file->f_mode) & (FMODE_READ|FMODE_WRITE);
2901         release(s);
2902         wake_up(&open_wait);
2903         unlock_kernel();
2904         return 0;
2905 }
2906
2907 static /*const*/ struct file_operations usb_audio_fops = {
2908         owner:          THIS_MODULE,
2909         llseek:         no_llseek,
2910         read:           usb_audio_read,
2911         write:          usb_audio_write,
2912         poll:           usb_audio_poll,
2913         ioctl:          usb_audio_ioctl,
2914         mmap:           usb_audio_mmap,
2915         open:           usb_audio_open,
2916         release:        usb_audio_release,
2917 };
2918
2919 /* --------------------------------------------------------------------- */
2920
2921 static void * usb_audio_probe(struct usb_device *dev, unsigned int ifnum,
2922                               const struct usb_device_id *id);
2923 static void usb_audio_disconnect(struct usb_device *dev, void *ptr);
2924
2925 static struct usb_device_id usb_audio_ids [] = {
2926     { match_flags: (USB_DEVICE_ID_MATCH_INT_CLASS | USB_DEVICE_ID_MATCH_INT_SUBCLASS),
2927       bInterfaceClass: USB_CLASS_AUDIO, bInterfaceSubClass: 1},
2928     { }                                         /* Terminating entry */
2929 };
2930
2931 MODULE_DEVICE_TABLE (usb, usb_audio_ids);
2932
2933 static struct usb_driver usb_audio_driver = {
2934         name:           "audio",
2935         probe:          usb_audio_probe,
2936         disconnect:     usb_audio_disconnect,
2937         driver_list:    LIST_HEAD_INIT(usb_audio_driver.driver_list),
2938         id_table:       usb_audio_ids,
2939 };
2940
2941 static void *find_descriptor(void *descstart, unsigned int desclen, void *after,
2942                              u8 dtype, int iface, int altsetting)
2943 {
2944         u8 *p, *end, *next;
2945         int ifc = -1, as = -1;
2946
2947         p = descstart;
2948         end = p + desclen;
2949         for (; p < end;) {
2950                 if (p[0] < 2)
2951                         return NULL;
2952                 next = p + p[0];
2953                 if (next > end)
2954                         return NULL;
2955                 if (p[1] == USB_DT_INTERFACE) {
2956                         /* minimum length of interface descriptor */
2957                         if (p[0] < 9)
2958                                 return NULL;
2959                         ifc = p[2];
2960                         as = p[3];
2961                 }
2962                 if (p[1] == dtype && (!after || (void *)p > after) &&
2963                     (iface == -1 || iface == ifc) && (altsetting == -1 || altsetting == as)) {
2964                         return p;
2965                 }
2966                 p = next;
2967         }
2968         return NULL;
2969 }
2970
2971 static void *find_csinterface_descriptor(void *descstart, unsigned int desclen, void *after, u8 dsubtype, int iface, int altsetting)
2972 {
2973         unsigned char *p;
2974
2975         p = find_descriptor(descstart, desclen, after, USB_DT_CS_INTERFACE, iface, altsetting);
2976         while (p) {
2977                 if (p[0] >= 3 && p[2] == dsubtype)
2978                         return p;
2979                 p = find_descriptor(descstart, desclen, p, USB_DT_CS_INTERFACE, iface, altsetting);
2980         }
2981         return NULL;
2982 }
2983
2984 static void *find_audiocontrol_unit(void *descstart, unsigned int desclen, void *after, u8 unit, int iface)
2985 {
2986         unsigned char *p;
2987
2988         p = find_descriptor(descstart, desclen, after, USB_DT_CS_INTERFACE, iface, -1);
2989         while (p) {
2990                 if (p[0] >= 4 && p[2] >= INPUT_TERMINAL && p[2] <= EXTENSION_UNIT && p[3] == unit)
2991                         return p;
2992                 p = find_descriptor(descstart, desclen, p, USB_DT_CS_INTERFACE, iface, -1);
2993         }
2994         return NULL;
2995 }
2996
2997 static void usb_audio_parsestreaming(struct usb_audio_state *s, unsigned char *buffer, unsigned int buflen, int asifin, int asifout)
2998 {
2999         struct usb_device *dev = s->usbdev;
3000         struct usb_audiodev *as;
3001         struct usb_config_descriptor *config = dev->actconfig;
3002         struct usb_interface_descriptor *alts;
3003         struct usb_interface *iface;
3004         struct audioformat *fp;
3005         unsigned char *fmt, *csep;
3006         unsigned int i, j, k, format;
3007
3008         if (!(as = kmalloc(sizeof(struct usb_audiodev), GFP_KERNEL)))
3009                 return;
3010         memset(as, 0, sizeof(struct usb_audiodev));
3011         init_waitqueue_head(&as->usbin.dma.wait);
3012         init_waitqueue_head(&as->usbout.dma.wait);
3013         spin_lock_init(&as->lock);
3014         spin_lock_init(&as->usbin.durb[0].urb.lock);
3015         spin_lock_init(&as->usbin.durb[1].urb.lock);
3016         spin_lock_init(&as->usbin.surb[0].urb.lock);
3017         spin_lock_init(&as->usbin.surb[1].urb.lock);
3018         spin_lock_init(&as->usbout.durb[0].urb.lock);
3019         spin_lock_init(&as->usbout.durb[1].urb.lock);
3020         spin_lock_init(&as->usbout.surb[0].urb.lock);
3021         spin_lock_init(&as->usbout.surb[1].urb.lock);
3022         as->state = s;
3023         as->usbin.interface = asifin;
3024         as->usbout.interface = asifout;
3025         /* search for input formats */
3026         if (asifin >= 0) {
3027                 as->usbin.flags = FLG_CONNECTED;
3028                 iface = &config->interface[asifin];
3029                 for (i = 0; i < iface->num_altsetting; i++) {
3030                         alts = &iface->altsetting[i];
3031                         if (alts->bInterfaceClass != USB_CLASS_AUDIO || alts->bInterfaceSubClass != 2)
3032                                 continue;
3033                         if (alts->bNumEndpoints < 1) {
3034                                 if (i != 0) {  /* altsetting 0 has no endpoints (Section B.3.4.1) */
3035                                         printk(KERN_ERR "usbaudio: device %u interface %u altsetting %u does not have an endpoint\n",
3036                                                dev->devnum, asifin, i);
3037                                 }
3038                                 continue;
3039                         }
3040                         if ((alts->endpoint[0].bmAttributes & 0x03) != 0x01 ||
3041                             !(alts->endpoint[0].bEndpointAddress & 0x80)) {
3042                                 printk(KERN_ERR "usbaudio: device %u interface %u altsetting %u first endpoint not isochronous in\n",
3043                                        dev->devnum, asifin, i);
3044                                 continue;
3045                         }
3046                         fmt = find_csinterface_descriptor(buffer, buflen, NULL, AS_GENERAL, asifin, i);
3047                         if (!fmt) {
3048                                 printk(KERN_ERR "usbaudio: device %u interface %u altsetting %u FORMAT_TYPE descriptor not found\n",
3049                                        dev->devnum, asifin, i);
3050                                 continue;
3051                         }
3052                         if (fmt[0] < 7 || fmt[6] != 0 || (fmt[5] != 1 && fmt[5] != 2)) {
3053                                 printk(KERN_ERR "usbaudio: device %u interface %u altsetting %u format not supported\n",
3054                                        dev->devnum, asifin, i);
3055                                 continue;
3056                         }
3057                         format = (fmt[5] == 2) ?
3058                           (AFMT_U32_LE | AFMT_U24_LE | AFMT_U16_LE | AFMT_U8) :
3059                           (AFMT_S32_LE | AFMT_S24_LE | AFMT_S16_LE | AFMT_S8);
3060                         fmt = find_csinterface_descriptor(buffer, buflen, NULL, FORMAT_TYPE, asifin, i);
3061                         if (!fmt) {
3062                                 printk(KERN_ERR "usbaudio: device %u interface %u altsetting %u FORMAT_TYPE descriptor not found\n",
3063                                        dev->devnum, asifin, i);
3064                                 continue;
3065                         }
3066                         if (fmt[0] < 8+3*(fmt[7] ? fmt[7] : 2) || fmt[3] != 1) {
3067                                 printk(KERN_ERR "usbaudio: device %u interface %u altsetting %u FORMAT_TYPE descriptor not supported\n",
3068                                        dev->devnum, asifin, i);
3069                                 continue;
3070                         }
3071                         if (fmt[4] < 1 || fmt[4] > MAXCHANNELS || fmt[5] < 1 || fmt[5] > 4) {
3072                                 printk(KERN_ERR "usbaudio: device %u interface %u altsetting %u unsupported channels %u framesize %u\n",
3073                                        dev->devnum, asifin, i, fmt[4], fmt[5]);
3074                                 continue;
3075                         }
3076                         csep = find_descriptor(buffer, buflen, NULL, USB_DT_CS_ENDPOINT, asifin, i);
3077                         if (!csep || csep[0] < 7 || csep[2] != EP_GENERAL) {
3078                                 printk(KERN_ERR "usbaudio: device %u interface %u altsetting %u no or invalid class specific endpoint descriptor\n",
3079                                        dev->devnum, asifin, i);
3080                                 continue;
3081                         }
3082                         if (as->numfmtin >= MAXFORMATS)
3083                                 continue;
3084                         printk(KERN_ERR "usbaudio: device %u interface %u altsetting %u channels %u framesize %u configured\n",
3085                                        dev->devnum, asifin, i, fmt[4], fmt[5]);
3086                         fp = &as->fmtin[as->numfmtin++];
3087                         switch (fmt[5]) {
3088                         case 1:
3089                                 format &= (AFMT_U8 | AFMT_S8);
3090                                 break;
3091                         case 2:
3092                                 format &= (AFMT_U16_LE | AFMT_S16_LE);
3093                                 break;
3094                         case 3:
3095                                 format &= (AFMT_U24_LE | AFMT_S24_LE);
3096                                 break;
3097                         case 4:
3098                                 format &= (AFMT_U32_LE | AFMT_S32_LE);
3099                                 break;
3100                         }
3101
3102                         format |= (fmt[4]-1) << 24;
3103
3104                         fp->format = format;
3105                         fp->altsetting = i;
3106                         fp->sratelo = fp->sratehi = fmt[8] | (fmt[9] << 8) | (fmt[10] << 16);
3107                         printk(KERN_INFO "usbaudio: valid input sample rate %u\n", fp->sratelo);
3108                         for (j = fmt[7] ? (fmt[7]-1) : 1; j > 0; j--) {
3109                                 k = fmt[8+3*j] | (fmt[9+3*j] << 8) | (fmt[10+3*j] << 16);
3110                                 printk(KERN_INFO "usbaudio: valid input sample rate %u\n", k);
3111                                 if (k > fp->sratehi)
3112                                         fp->sratehi = k;
3113                                 if (k < fp->sratelo)
3114                                         fp->sratelo = k;
3115                         }
3116                         fp->attributes = csep[3];
3117                         printk(KERN_INFO "usbaudio: device %u interface %u altsetting %u: format 0x%08x sratelo %u sratehi %u attributes 0x%02x\n",
3118                                dev->devnum, asifin, i, fp->format, fp->sratelo, fp->sratehi, fp->attributes);
3119                 }
3120         }
3121         /* search for output formats */
3122         if (asifout >= 0) {
3123                 as->usbout.flags = FLG_CONNECTED;
3124                 iface = &config->interface[asifout];
3125                 for (i = 0; i < iface->num_altsetting; i++) {
3126                         alts = &iface->altsetting[i];
3127                         if (alts->bInterfaceClass != USB_CLASS_AUDIO || alts->bInterfaceSubClass != 2)
3128                                 continue;
3129                         if (alts->bNumEndpoints < 1) {
3130                                 printk(KERN_ERR "usbaudio: device %u interface %u altsetting %u does not have an endpoint\n",
3131                                        dev->devnum, asifout, i);
3132                                 continue;
3133                         }
3134                         if ((alts->endpoint[0].bmAttributes & 0x03) != 0x01 ||
3135                             (alts->endpoint[0].bEndpointAddress & 0x80)) {
3136                                 printk(KERN_ERR "usbaudio: device %u interface %u altsetting %u first endpoint not isochronous out\n",
3137                                        dev->devnum, asifout, i);
3138                                 continue;
3139                         }
3140                         /* See USB audio formats manual, section 2 */
3141                         fmt = find_csinterface_descriptor(buffer, buflen, NULL, AS_GENERAL, asifout, i);
3142                         if (!fmt) {
3143                                 printk(KERN_ERR "usbaudio: device %u interface %u altsetting %u FORMAT_TYPE descriptor not found\n",
3144                                        dev->devnum, asifout, i);
3145                                 continue;
3146                         }
3147                         if (fmt[0] < 7 || fmt[6] != 0 || (fmt[5] != 1 && fmt[5] != 2)) {
3148                                 printk(KERN_ERR "usbaudio: device %u interface %u altsetting %u format not supported\n",
3149                                        dev->devnum, asifout, i);
3150                                 continue;
3151                         }
3152                         format = (fmt[5] == 2) ?
3153                           (AFMT_U32_LE | AFMT_U24_LE | AFMT_U16_LE | AFMT_U8) :
3154                           (AFMT_S32_LE | AFMT_S24_LE | AFMT_S16_LE | AFMT_S8);
3155
3156                         /* Dallas DS4201 workaround */
3157                         if (dev->descriptor.idVendor == 0x04fa && dev->descriptor.idProduct == 0x4201)
3158                                 format = (AFMT_S16_LE | AFMT_S8);
3159                         fmt = find_csinterface_descriptor(buffer, buflen, NULL, FORMAT_TYPE, asifout, i);
3160                         if (!fmt) {
3161                                 printk(KERN_ERR "usbaudio: device %u interface %u altsetting %u FORMAT_TYPE descriptor not found\n",
3162                                        dev->devnum, asifout, i);
3163                                 continue;
3164                         }
3165                         if (fmt[0] < 8+3*(fmt[7] ? fmt[7] : 2) || fmt[3] != 1) {
3166                                 printk(KERN_ERR "usbaudio: device %u interface %u altsetting %u FORMAT_TYPE descriptor not supported\n",
3167                                        dev->devnum, asifout, i);
3168                                 continue;
3169                         }
3170                         if (fmt[4] < 1 || fmt[4] > MAXCHANNELS || fmt[5] < 1 || fmt[5] > 4) {
3171                                 printk(KERN_ERR "usbaudio: device %u interface %u altsetting %u unsupported channels %u framesize %u\n",
3172                                        dev->devnum, asifout, i, fmt[4], fmt[5]);
3173                                 continue;
3174                         }
3175                         csep = find_descriptor(buffer, buflen, NULL, USB_DT_CS_ENDPOINT, asifout, i);
3176                         if (!csep || csep[0] < 7 || csep[2] != EP_GENERAL) {
3177                                 printk(KERN_ERR "usbaudio: device %u interface %u altsetting %u no or invalid class specific endpoint descriptor\n",
3178                                        dev->devnum, asifout, i);
3179                                 continue;
3180                         }
3181                         if (as->numfmtout >= MAXFORMATS)
3182                                 continue;
3183                         printk(KERN_ERR "usbaudio: device %u interface %u altsetting %u channels %u framesize %u configured\n",
3184                                dev->devnum, asifout, i, fmt[4], fmt[5]);
3185                         fp = &as->fmtout[as->numfmtout++];
3186
3187                         switch (fmt[5]) {
3188                         case 1:
3189                                 format &= (AFMT_U8 | AFMT_S8);
3190                                 break;
3191                         case 2:
3192                                 format &= (AFMT_U16_LE | AFMT_S16_LE);
3193                                 break;
3194                         case 3:
3195                                 format &= (AFMT_U24_LE | AFMT_S24_LE);
3196                                 break;
3197                         case 4:
3198                                 format &= (AFMT_U32_LE | AFMT_S32_LE);
3199                                 break;
3200                         }
3201
3202                         format |= (fmt[4]-1) << 24;
3203
3204                         fp->format = format;
3205                         fp->altsetting = i;
3206                         fp->sratelo = fp->sratehi = fmt[8] | (fmt[9] << 8) | (fmt[10] << 16);
3207                         printk(KERN_INFO "usbaudio: valid output sample rate %u\n", fp->sratelo);
3208                         for (j = fmt[7] ? (fmt[7]-1) : 1; j > 0; j--) {
3209                                 k = fmt[8+3*j] | (fmt[9+3*j] << 8) | (fmt[10+3*j] << 16);
3210                                 printk(KERN_INFO "usbaudio: valid output sample rate %u\n", k);
3211                                 if (k > fp->sratehi)
3212                                         fp->sratehi = k;
3213                                 if (k < fp->sratelo)
3214                                         fp->sratelo = k;
3215                         }
3216                         fp->attributes = csep[3];
3217                         printk(KERN_INFO "usbaudio: device %u interface %u altsetting %u: format 0x%08x sratelo %u sratehi %u attributes 0x%02x\n",
3218                                dev->devnum, asifout, i, fp->format, fp->sratelo, fp->sratehi, fp->attributes);
3219                 }
3220         }
3221         if (as->numfmtin == 0 && as->numfmtout == 0) {
3222                 kfree(as);
3223                 return;
3224         }
3225         if ((as->dev_audio = register_sound_dsp(&usb_audio_fops, -1)) < 0) {
3226                 printk(KERN_ERR "usbaudio: cannot register dsp\n");
3227                 kfree(as);
3228                 return;
3229         }
3230         printk(KERN_INFO "usbaudio: registered dsp 14,%d\n", as->dev_audio);
3231         /* everything successful */
3232         list_add_tail(&as->list, &s->audiolist);
3233 }
3234
3235 struct consmixstate {
3236         struct usb_audio_state *s;
3237         unsigned char *buffer;
3238         unsigned int buflen;
3239         unsigned int ctrlif;
3240         struct mixerchannel mixch[SOUND_MIXER_NRDEVICES];
3241         unsigned int nrmixch;
3242         unsigned int mixchmask;
3243         unsigned long unitbitmap[32/sizeof(unsigned long)];
3244         /* return values */
3245         unsigned int nrchannels;
3246         unsigned int termtype;
3247         unsigned int chconfig;
3248 };
3249
3250 static struct mixerchannel *getmixchannel(struct consmixstate *state, unsigned int nr)
3251 {
3252         struct mixerchannel *c;
3253
3254         if (nr >= SOUND_MIXER_NRDEVICES) {
3255                 printk(KERN_ERR "usbaudio: invalid OSS mixer channel %u\n", nr);
3256                 return NULL;
3257         }
3258         if (!(state->mixchmask & (1 << nr))) {
3259                 printk(KERN_WARNING "usbaudio: OSS mixer channel %u already in use\n", nr);
3260                 return NULL;
3261         }
3262         c = &state->mixch[state->nrmixch++];
3263         c->osschannel = nr;
3264         state->mixchmask &= ~(1 << nr);
3265         return c;
3266 }
3267
3268 static unsigned int getvolchannel(struct consmixstate *state)
3269 {
3270         unsigned int u;
3271
3272         if ((state->termtype & 0xff00) == 0x0000 && (state->mixchmask & SOUND_MASK_VOLUME))
3273                 return SOUND_MIXER_VOLUME;
3274         if ((state->termtype & 0xff00) == 0x0100) {
3275                 if (state->mixchmask & SOUND_MASK_PCM)
3276                         return SOUND_MIXER_PCM;
3277                 if (state->mixchmask & SOUND_MASK_ALTPCM)
3278                         return SOUND_MIXER_ALTPCM;
3279         }
3280         if ((state->termtype & 0xff00) == 0x0200 && (state->mixchmask & SOUND_MASK_MIC))
3281                 return SOUND_MIXER_MIC;
3282         if ((state->termtype & 0xff00) == 0x0300 && (state->mixchmask & SOUND_MASK_SPEAKER))
3283                 return SOUND_MIXER_SPEAKER;
3284         if ((state->termtype & 0xff00) == 0x0500) {
3285                 if (state->mixchmask & SOUND_MASK_PHONEIN)
3286                         return SOUND_MIXER_PHONEIN;
3287                 if (state->mixchmask & SOUND_MASK_PHONEOUT)
3288                         return SOUND_MIXER_PHONEOUT;
3289         }
3290         if (state->termtype >= 0x710 && state->termtype <= 0x711 && (state->mixchmask & SOUND_MASK_RADIO))
3291                 return SOUND_MIXER_RADIO;
3292         if (state->termtype >= 0x709 && state->termtype <= 0x70f && (state->mixchmask & SOUND_MASK_VIDEO))
3293                 return SOUND_MIXER_VIDEO;
3294         u = ffs(state->mixchmask & (SOUND_MASK_LINE | SOUND_MASK_CD | SOUND_MASK_LINE1 | SOUND_MASK_LINE2 | SOUND_MASK_LINE3 |
3295                                     SOUND_MASK_DIGITAL1 | SOUND_MASK_DIGITAL2 | SOUND_MASK_DIGITAL3));
3296         return u-1;
3297 }
3298
3299 static void prepmixch(struct consmixstate *state)
3300 {
3301         struct usb_device *dev = state->s->usbdev;
3302         struct mixerchannel *ch;
3303         unsigned char buf[2];
3304         __s16 v1;
3305         unsigned int v2, v3;
3306
3307         if (!state->nrmixch || state->nrmixch > SOUND_MIXER_NRDEVICES)
3308                 return;
3309         ch = &state->mixch[state->nrmixch-1];
3310         switch (ch->selector) {
3311         case 0:  /* mixer unit request */
3312                 if (usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), GET_MIN, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
3313                                     (ch->chnum << 8) | 1, state->ctrlif | (ch->unitid << 8), buf, 2, HZ) < 0)
3314                         goto err;
3315                 ch->minval = buf[0] | (buf[1] << 8);
3316                 if (usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), GET_MAX, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
3317                                     (ch->chnum << 8) | 1, state->ctrlif | (ch->unitid << 8), buf, 2, HZ) < 0)
3318                         goto err;
3319                 ch->maxval = buf[0] | (buf[1] << 8);
3320                 v2 = ch->maxval - ch->minval;
3321                 if (!v2)
3322                         v2 = 1;
3323                 if (usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), GET_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
3324                                     (ch->chnum << 8) | 1, state->ctrlif | (ch->unitid << 8), buf, 2, HZ) < 0)
3325                         goto err;
3326                 v1 = buf[0] | (buf[1] << 8);
3327                 v3 = v1 - ch->minval;
3328                 v3 = 100 * v3 / v2;
3329                 if (v3 > 100)
3330                         v3 = 100;
3331                 ch->value = v3;
3332                 if (ch->flags & (MIXFLG_STEREOIN | MIXFLG_STEREOOUT)) {
3333                         if (usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), GET_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
3334                                             ((ch->chnum + !!(ch->flags & MIXFLG_STEREOIN)) << 8) | (1 + !!(ch->flags & MIXFLG_STEREOOUT)),
3335                                             state->ctrlif | (ch->unitid << 8), buf, 2, HZ) < 0)
3336                         goto err;
3337                         v1 = buf[0] | (buf[1] << 8);
3338                         v3 = v1 - ch->minval;
3339                         v3 = 100 * v3 / v2;
3340                         if (v3 > 100)
3341                                 v3 = 100;
3342                 }
3343                 ch->value |= v3 << 8;
3344                 break;
3345
3346                 /* various feature unit controls */
3347         case VOLUME_CONTROL:
3348                 if (usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), GET_MIN, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
3349                                     (ch->selector << 8) | ch->chnum, state->ctrlif | (ch->unitid << 8), buf, 2, HZ) < 0)
3350                         goto err;
3351                 ch->minval = buf[0] | (buf[1] << 8);
3352                 if (usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), GET_MAX, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
3353                                     (ch->selector << 8) | ch->chnum, state->ctrlif | (ch->unitid << 8), buf, 2, HZ) < 0)
3354                         goto err;
3355                 ch->maxval = buf[0] | (buf[1] << 8);
3356                 if (usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), GET_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
3357                                     (ch->selector << 8) | ch->chnum, state->ctrlif | (ch->unitid << 8), buf, 2, HZ) < 0)
3358                         goto err;
3359                 v1 = buf[0] | (buf[1] << 8);
3360                 v2 = ch->maxval - ch->minval;
3361                 v3 = v1 - ch->minval;
3362                 if (!v2)
3363                         v2 = 1;
3364                 v3 = 100 * v3 / v2;
3365                 if (v3 > 100)
3366                         v3 = 100;
3367                 ch->value = v3;
3368                 if (ch->flags & (MIXFLG_STEREOIN | MIXFLG_STEREOOUT)) {
3369                         if (usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), GET_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
3370                                             (ch->selector << 8) | (ch->chnum + 1), state->ctrlif | (ch->unitid << 8), buf, 2, HZ) < 0)
3371                                 goto err;
3372                         v1 = buf[0] | (buf[1] << 8);
3373                         v3 = v1 - ch->minval;
3374                         v3 = 100 * v3 / v2;
3375                         if (v3 > 100)
3376                                 v3 = 100;
3377                 }
3378                 ch->value |= v3 << 8;
3379                 break;
3380
3381         case BASS_CONTROL:
3382         case MID_CONTROL:
3383         case TREBLE_CONTROL:
3384                 if (usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), GET_MIN, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
3385                                     (ch->selector << 8) | ch->chnum, state->ctrlif | (ch->unitid << 8), buf, 1, HZ) < 0)
3386                         goto err;
3387                 ch->minval = buf[0] << 8;
3388                 if (usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), GET_MAX, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
3389                                     (ch->selector << 8) | ch->chnum, state->ctrlif | (ch->unitid << 8), buf, 1, HZ) < 0)
3390                         goto err;
3391                 ch->maxval = buf[0] << 8;
3392                 if (usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), GET_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
3393                                     (ch->selector << 8) | ch->chnum, state->ctrlif | (ch->unitid << 8), buf, 1, HZ) < 0)
3394                         goto err;
3395                 v1 = buf[0] << 8;
3396                 v2 = ch->maxval - ch->minval;
3397                 v3 = v1 - ch->minval;
3398                 if (!v2)
3399                         v2 = 1;
3400                 v3 = 100 * v3 / v2;
3401                 if (v3 > 100)
3402                         v3 = 100;
3403                 ch->value = v3;
3404                 if (ch->flags & (MIXFLG_STEREOIN | MIXFLG_STEREOOUT)) {
3405                         if (usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), GET_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
3406                                             (ch->selector << 8) | (ch->chnum + 1), state->ctrlif | (ch->unitid << 8), buf, 1, HZ) < 0)
3407                                 goto err;
3408                         v1 = buf[0] << 8;
3409                         v3 = v1 - ch->minval;
3410                         v3 = 100 * v3 / v2;
3411                         if (v3 > 100)
3412                                 v3 = 100;
3413                 }
3414                 ch->value |= v3 << 8;
3415                 break;
3416
3417         default:
3418                 goto err;
3419         }
3420         return;
3421
3422  err:
3423         printk(KERN_ERR "usbaudio: mixer request device %u if %u unit %u ch %u selector %u failed\n",
3424                dev->devnum, state->ctrlif, ch->unitid, ch->chnum, ch->selector);
3425         if (state->nrmixch)
3426                 state->nrmixch--;
3427 }
3428
3429
3430 static void usb_audio_recurseunit(struct consmixstate *state, unsigned char unitid);
3431
3432 static inline int checkmixbmap(unsigned char *bmap, unsigned char flg, unsigned int inidx, unsigned int numoch)
3433 {
3434         unsigned int idx;
3435
3436         idx = inidx*numoch;
3437         if (!(bmap[-(idx >> 3)] & (0x80 >> (idx & 7))))
3438                 return 0;
3439         if (!(flg & (MIXFLG_STEREOIN | MIXFLG_STEREOOUT)))
3440                 return 1;
3441         idx = (inidx+!!(flg & MIXFLG_STEREOIN))*numoch+!!(flg & MIXFLG_STEREOOUT);
3442         if (!(bmap[-(idx >> 3)] & (0x80 >> (idx & 7))))
3443                 return 0;
3444         return 1;
3445 }
3446
3447 static void usb_audio_mixerunit(struct consmixstate *state, unsigned char *mixer)
3448 {
3449         unsigned int nroutch = mixer[5+mixer[4]];
3450         unsigned int chidx[SOUND_MIXER_NRDEVICES+1];
3451         unsigned int termt[SOUND_MIXER_NRDEVICES];
3452         unsigned char flg = (nroutch >= 2) ? MIXFLG_STEREOOUT : 0;
3453         unsigned char *bmap = &mixer[9+mixer[4]];
3454         unsigned int bmapsize;
3455         struct mixerchannel *ch;
3456         unsigned int i;
3457
3458         if (!mixer[4]) {
3459                 printk(KERN_ERR "usbaudio: unit %u invalid MIXER_UNIT descriptor\n", mixer[3]);
3460                 return;
3461         }
3462         if (mixer[4] > SOUND_MIXER_NRDEVICES) {
3463                 printk(KERN_ERR "usbaudio: mixer unit %u: too many input pins\n", mixer[3]);
3464                 return;
3465         }
3466         chidx[0] = 0;
3467         for (i = 0; i < mixer[4]; i++) {
3468                 usb_audio_recurseunit(state, mixer[5+i]);
3469                 chidx[i+1] = chidx[i] + state->nrchannels;
3470                 termt[i] = state->termtype;
3471         }
3472         state->termtype = 0;
3473         state->chconfig = mixer[6+mixer[4]] | (mixer[7+mixer[4]] << 8);
3474         bmapsize = (nroutch * chidx[mixer[4]] + 7) >> 3;
3475         bmap += bmapsize - 1;
3476         if (mixer[0] < 10+mixer[4]+bmapsize) {
3477                 printk(KERN_ERR "usbaudio: unit %u invalid MIXER_UNIT descriptor (bitmap too small)\n", mixer[3]);
3478                 return;
3479         }
3480         for (i = 0; i < mixer[4]; i++) {
3481                 state->termtype = termt[i];
3482                 if (chidx[i+1]-chidx[i] >= 2) {
3483                         flg |= MIXFLG_STEREOIN;
3484                         if (checkmixbmap(bmap, flg, chidx[i], nroutch)) {
3485                                 ch = getmixchannel(state, getvolchannel(state));
3486                                 if (ch) {
3487                                         ch->unitid = mixer[3];
3488                                         ch->selector = 0;
3489                                         ch->chnum = chidx[i]+1;
3490                                         ch->flags = flg;
3491                                         prepmixch(state);
3492                                 }
3493                                 continue;
3494                         }
3495                 }
3496                 flg &= ~MIXFLG_STEREOIN;
3497                 if (checkmixbmap(bmap, flg, chidx[i], nroutch)) {
3498                         ch = getmixchannel(state, getvolchannel(state));
3499                         if (ch) {
3500                                 ch->unitid = mixer[3];
3501                                 ch->selector = 0;
3502                                 ch->chnum = chidx[i]+1;
3503                                 ch->flags = flg;
3504                                 prepmixch(state);
3505                         }
3506                 }
3507         }
3508         state->termtype = 0;
3509 }
3510
3511 static struct mixerchannel *slctsrc_findunit(struct consmixstate *state, __u8 unitid)
3512 {
3513         unsigned int i;
3514
3515         for (i = 0; i < state->nrmixch; i++)
3516                 if (state->mixch[i].unitid == unitid)
3517                         return &state->mixch[i];
3518         return NULL;
3519 }
3520
3521 static void usb_audio_selectorunit(struct consmixstate *state, unsigned char *selector)
3522 {
3523         unsigned int chnum, i, mixch;
3524         struct mixerchannel *mch;
3525
3526         if (!selector[4]) {
3527                 printk(KERN_ERR "usbaudio: unit %u invalid SELECTOR_UNIT descriptor\n", selector[3]);
3528                 return;
3529         }
3530         mixch = state->nrmixch;
3531         usb_audio_recurseunit(state, selector[5]);
3532         if (state->nrmixch != mixch) {
3533                 mch = &state->mixch[state->nrmixch-1];
3534                 mch->slctunitid = selector[3] | (1 << 8);
3535         } else if ((mch = slctsrc_findunit(state, selector[5]))) {
3536                 mch->slctunitid = selector[3] | (1 << 8);
3537         } else {
3538                 printk(KERN_INFO "usbaudio: selector unit %u: ignoring channel 1\n", selector[3]);
3539         }
3540         chnum = state->nrchannels;
3541         for (i = 1; i < selector[4]; i++) {
3542                 mixch = state->nrmixch;
3543                 usb_audio_recurseunit(state, selector[5+i]);
3544                 if (chnum != state->nrchannels) {
3545                         printk(KERN_ERR "usbaudio: selector unit %u: input pins with varying channel numbers\n", selector[3]);
3546                         state->termtype = 0;
3547                         state->chconfig = 0;
3548                         state->nrchannels = 0;
3549                         return;
3550                 }
3551                 if (state->nrmixch != mixch) {
3552                         mch = &state->mixch[state->nrmixch-1];
3553                         mch->slctunitid = selector[3] | ((i + 1) << 8);
3554                 } else if ((mch = slctsrc_findunit(state, selector[5+i]))) {
3555                         mch->slctunitid = selector[3] | ((i + 1) << 8);
3556                 } else {
3557                         printk(KERN_INFO "usbaudio: selector unit %u: ignoring channel %u\n", selector[3], i+1);
3558                 }
3559         }
3560         state->termtype = 0;
3561         state->chconfig = 0;
3562 }
3563
3564 /* in the future we might try to handle 3D etc. effect units */
3565
3566 static void usb_audio_processingunit(struct consmixstate *state, unsigned char *proc)
3567 {
3568         unsigned int i;
3569
3570         for (i = 0; i < proc[6]; i++)
3571                 usb_audio_recurseunit(state, proc[7+i]);
3572         state->nrchannels = proc[7+proc[6]];
3573         state->termtype = 0;
3574         state->chconfig = proc[8+proc[6]] | (proc[9+proc[6]] << 8);
3575 }
3576
3577
3578 /* See Audio Class Spec, section 4.3.2.5 */
3579 static void usb_audio_featureunit(struct consmixstate *state, unsigned char *ftr)
3580 {
3581         struct mixerchannel *ch;
3582         unsigned short chftr, mchftr;
3583 #if 0
3584         struct usb_device *dev = state->s->usbdev;
3585         unsigned char data[1];
3586 #endif
3587         unsigned char nr_logical_channels, i;
3588
3589         usb_audio_recurseunit(state, ftr[4]);
3590
3591         if (ftr[5] == 0 ) {
3592                 printk(KERN_ERR "usbaudio: wrong controls size in feature unit %u\n",ftr[3]);
3593                 return;
3594         }
3595
3596         if (state->nrchannels == 0) {
3597                 printk(KERN_ERR "usbaudio: feature unit %u source has no channels\n", ftr[3]);
3598                 return;
3599         }
3600         if (state->nrchannels > 2)
3601                 printk(KERN_WARNING "usbaudio: feature unit %u: OSS mixer interface does not support more than 2 channels\n", ftr[3]);
3602
3603         nr_logical_channels=(ftr[0]-7)/ftr[5]-1;
3604
3605         if (nr_logical_channels != state->nrchannels) {
3606                 printk(KERN_WARNING "usbaudio: warning: found %d of %d logical channels.\n", state->nrchannels,nr_logical_channels);
3607
3608                 if (state->nrchannels == 1 && nr_logical_channels==0) {
3609                         printk(KERN_INFO "usbaudio: assuming the channel found is the master channel (got a Philips camera?). Should be fine.\n");
3610                 } else if (state->nrchannels == 1 && nr_logical_channels==2) {
3611                         printk(KERN_INFO "usbaudio: assuming that a stereo channel connected directly to a mixer is missing in search (got Labtec headset?). Should be fine.\n");
3612                         state->nrchannels=nr_logical_channels;
3613                 } else {
3614                         printk(KERN_WARNING "usbaudio: no idea what's going on..., contact linux-usb-devel@lists.sourceforge.net\n");
3615                 }
3616         }
3617
3618         /* There is always a master channel */
3619         mchftr = ftr[6];
3620         /* Binary AND over logical channels if they exist */
3621         if (nr_logical_channels) {
3622                 chftr = ftr[6+ftr[5]];
3623                 for (i = 2; i <= nr_logical_channels; i++)
3624                         chftr &= ftr[6+i*ftr[5]];
3625         } else {
3626                 chftr = 0;
3627         }
3628
3629         /* volume control */
3630         if (chftr & 2) {
3631                 ch = getmixchannel(state, getvolchannel(state));
3632                 if (ch) {
3633                         ch->unitid = ftr[3];
3634                         ch->selector = VOLUME_CONTROL;
3635                         ch->chnum = 1;
3636                         ch->flags = (state->nrchannels > 1) ? (MIXFLG_STEREOIN | MIXFLG_STEREOOUT) : 0;
3637                         prepmixch(state);
3638                 }
3639         } else if (mchftr & 2) {
3640                 ch = getmixchannel(state, getvolchannel(state));
3641                 if (ch) {
3642                         ch->unitid = ftr[3];
3643                         ch->selector = VOLUME_CONTROL;
3644                         ch->chnum = 0;
3645                         ch->flags = 0;
3646                         prepmixch(state);
3647                 }
3648         }
3649         /* bass control */
3650         if (chftr & 4) {
3651                 ch = getmixchannel(state, SOUND_MIXER_BASS);
3652                 if (ch) {
3653                         ch->unitid = ftr[3];
3654                         ch->selector = BASS_CONTROL;
3655                         ch->chnum = 1;
3656                         ch->flags = (state->nrchannels > 1) ? (MIXFLG_STEREOIN | MIXFLG_STEREOOUT) : 0;
3657                         prepmixch(state);
3658                 }
3659         } else if (mchftr & 4) {
3660                 ch = getmixchannel(state, SOUND_MIXER_BASS);
3661                 if (ch) {
3662                         ch->unitid = ftr[3];
3663                         ch->selector = BASS_CONTROL;
3664                         ch->chnum = 0;
3665                         ch->flags = 0;
3666                         prepmixch(state);
3667                 }
3668         }
3669         /* treble control */
3670         if (chftr & 16) {
3671                 ch = getmixchannel(state, SOUND_MIXER_TREBLE);
3672                 if (ch) {
3673                         ch->unitid = ftr[3];
3674                         ch->selector = TREBLE_CONTROL;
3675                         ch->chnum = 1;
3676                         ch->flags = (state->nrchannels > 1) ? (MIXFLG_STEREOIN | MIXFLG_STEREOOUT) : 0;
3677                         prepmixch(state);
3678                 }
3679         } else if (mchftr & 16) {
3680                 ch = getmixchannel(state, SOUND_MIXER_TREBLE);
3681                 if (ch) {
3682                         ch->unitid = ftr[3];
3683                         ch->selector = TREBLE_CONTROL;
3684                         ch->chnum = 0;
3685                         ch->flags = 0;
3686                         prepmixch(state);
3687                 }
3688         }
3689 #if 0
3690         /* if there are mute controls, unmute them */
3691         /* does not seem to be necessary, and the Dallas chip does not seem to support the "all" channel (255) */
3692         if ((chftr & 1) || (mchftr & 1)) {
3693                 printk(KERN_DEBUG "usbaudio: unmuting feature unit %u interface %u\n", ftr[3], state->ctrlif);
3694                 data[0] = 0;
3695                 if (usb_control_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
3696                                     (MUTE_CONTROL << 8) | 0xff, state->ctrlif | (ftr[3] << 8), data, 1, HZ) < 0)
3697                         printk(KERN_WARNING "usbaudio: failure to unmute feature unit %u interface %u\n", ftr[3], state->ctrlif);
3698         }
3699 #endif
3700 }
3701
3702 static void usb_audio_recurseunit(struct consmixstate *state, unsigned char unitid)
3703 {
3704         unsigned char *p1;
3705         unsigned int i, j;
3706
3707         if (test_and_set_bit(unitid, &state->unitbitmap)) {
3708                 printk(KERN_INFO "usbaudio: mixer path revisits unit %d\n", unitid);
3709                 return;
3710         }
3711         p1 = find_audiocontrol_unit(state->buffer, state->buflen, NULL, unitid, state->ctrlif);
3712         if (!p1) {
3713                 printk(KERN_ERR "usbaudio: unit %d not found!\n", unitid);
3714                 return;
3715         }
3716         state->nrchannels = 0;
3717         state->termtype = 0;
3718         state->chconfig = 0;
3719         switch (p1[2]) {
3720         case INPUT_TERMINAL:
3721                 if (p1[0] < 12) {
3722                         printk(KERN_ERR "usbaudio: unit %u: invalid INPUT_TERMINAL descriptor\n", unitid);
3723                         return;
3724                 }
3725                 state->nrchannels = p1[7];
3726                 state->termtype = p1[4] | (p1[5] << 8);
3727                 state->chconfig = p1[8] | (p1[9] << 8);
3728                 return;
3729
3730         case MIXER_UNIT:
3731                 if (p1[0] < 10 || p1[0] < 10+p1[4]) {
3732                         printk(KERN_ERR "usbaudio: unit %u: invalid MIXER_UNIT descriptor\n", unitid);
3733                         return;
3734                 }
3735                 usb_audio_mixerunit(state, p1);
3736                 return;
3737
3738         case SELECTOR_UNIT:
3739                 if (p1[0] < 6 || p1[0] < 6+p1[4]) {
3740                         printk(KERN_ERR "usbaudio: unit %u: invalid SELECTOR_UNIT descriptor\n", unitid);
3741                         return;
3742                 }
3743                 usb_audio_selectorunit(state, p1);
3744                 return;
3745
3746         case FEATURE_UNIT: /* See USB Audio Class Spec 4.3.2.5 */
3747                 if (p1[0] < 7 || p1[0] < 7+p1[5]) {
3748                         printk(KERN_ERR "usbaudio: unit %u: invalid FEATURE_UNIT descriptor\n", unitid);
3749                         return;
3750                 }
3751                 usb_audio_featureunit(state, p1);
3752                 return;
3753
3754         case PROCESSING_UNIT:
3755                 if (p1[0] < 13 || p1[0] < 13+p1[6] || p1[0] < 13+p1[6]+p1[11+p1[6]] || p1[0] < 13+p1[6]+p1[11+p1[6]]+p1[13+p1[6]+p1[11+p1[6]]]) {
3756                         printk(KERN_ERR "usbaudio: unit %u: invalid PROCESSING_UNIT descriptor\n", unitid);
3757                         return;
3758                 }
3759                 usb_audio_processingunit(state, p1);
3760                 return;
3761
3762         case EXTENSION_UNIT:
3763                 if (p1[0] < 13 || p1[0] < 13+p1[6] || p1[0] < 13+p1[6]+p1[11+p1[6]]) {
3764                         printk(KERN_ERR "usbaudio: unit %u: invalid EXTENSION_UNIT descriptor\n", unitid);
3765                         return;
3766                 }
3767                 for (j = i = 0; i < p1[6]; i++) {
3768                         usb_audio_recurseunit(state, p1[7+i]);
3769                         if (!i)
3770                                 j = state->termtype;
3771                         else if (j != state->termtype)
3772                                 j = 0;
3773                 }
3774                 state->nrchannels = p1[7+p1[6]];
3775                 state->chconfig = p1[8+p1[6]] | (p1[9+p1[6]] << 8);
3776                 state->termtype = j;
3777                 return;
3778
3779         default:
3780                 printk(KERN_ERR "usbaudio: unit %u: unexpected type 0x%02x\n", unitid, p1[2]);
3781                 return;
3782         }
3783 }
3784
3785 static void usb_audio_constructmixer(struct usb_audio_state *s, unsigned char *buffer, unsigned int buflen, unsigned int ctrlif, unsigned char *oterm)
3786 {
3787         struct usb_mixerdev *ms;
3788         struct consmixstate state;
3789
3790         memset(&state, 0, sizeof(state));
3791         state.s = s;
3792         state.nrmixch = 0;
3793         state.mixchmask = ~0;
3794         state.buffer = buffer;
3795         state.buflen = buflen;
3796         state.ctrlif = ctrlif;
3797         set_bit(oterm[3], &state.unitbitmap);  /* mark terminal ID as visited */
3798         printk(KERN_DEBUG "usbaudio: constructing mixer for Terminal %u type 0x%04x\n",
3799                oterm[3], oterm[4] | (oterm[5] << 8));
3800         usb_audio_recurseunit(&state, oterm[7]);
3801         if (!state.nrmixch) {
3802                 printk(KERN_INFO "usbaudio: no mixer controls found for Terminal %u\n", oterm[3]);
3803                 return;
3804         }
3805         if (!(ms = kmalloc(sizeof(struct usb_mixerdev)+state.nrmixch*sizeof(struct mixerchannel), GFP_KERNEL)))
3806                 return;
3807         memset(ms, 0, sizeof(struct usb_mixerdev));
3808         memcpy(&ms->ch, &state.mixch, state.nrmixch*sizeof(struct mixerchannel));
3809         ms->state = s;
3810         ms->iface = ctrlif;
3811         ms->numch = state.nrmixch;
3812         if ((ms->dev_mixer = register_sound_mixer(&usb_mixer_fops, -1)) < 0) {
3813                 printk(KERN_ERR "usbaudio: cannot register mixer\n");
3814                 kfree(ms);
3815                 return;
3816         }
3817         printk(KERN_INFO "usbaudio: registered mixer 14,%d\n", ms->dev_mixer);
3818         list_add_tail(&ms->list, &s->mixerlist);
3819 }
3820
3821 static void *usb_audio_parsecontrol(struct usb_device *dev, unsigned char *buffer, unsigned int buflen, unsigned int ctrlif)
3822 {
3823         struct usb_audio_state *s;
3824         struct usb_config_descriptor *config = dev->actconfig;
3825         struct usb_interface *iface;
3826         unsigned char ifin[USB_MAXINTERFACES], ifout[USB_MAXINTERFACES];
3827         unsigned char *p1;
3828         unsigned int i, j, k, numifin = 0, numifout = 0;
3829
3830         if (!(s = kmalloc(sizeof(struct usb_audio_state), GFP_KERNEL)))
3831                 return NULL;
3832         memset(s, 0, sizeof(struct usb_audio_state));
3833         INIT_LIST_HEAD(&s->audiolist);
3834         INIT_LIST_HEAD(&s->mixerlist);
3835         s->usbdev = dev;
3836         s->count = 1;
3837
3838         /* find audiocontrol interface */
3839         if (!(p1 = find_csinterface_descriptor(buffer, buflen, NULL, HEADER, ctrlif, -1))) {
3840                 printk(KERN_ERR "usbaudio: device %d audiocontrol interface %u no HEADER found\n",
3841                        dev->devnum, ctrlif);
3842                 goto ret;
3843         }
3844         if (p1[0] < 8 + p1[7]) {
3845                 printk(KERN_ERR "usbaudio: device %d audiocontrol interface %u HEADER error\n",
3846                        dev->devnum, ctrlif);
3847                 goto ret;
3848         }
3849         if (!p1[7])
3850                 printk(KERN_INFO "usbaudio: device %d audiocontrol interface %u has no AudioStreaming and MidiStreaming interfaces\n",
3851                        dev->devnum, ctrlif);
3852         for (i = 0; i < p1[7]; i++) {
3853                 j = p1[8+i];
3854                 if (j >= config->bNumInterfaces) {
3855                         printk(KERN_ERR "usbaudio: device %d audiocontrol interface %u interface %u does not exist\n",
3856                                dev->devnum, ctrlif, j);
3857                         continue;
3858                 }
3859                 iface = &config->interface[j];
3860                 if (iface->altsetting[0].bInterfaceClass != USB_CLASS_AUDIO) {
3861                         printk(KERN_ERR "usbaudio: device %d audiocontrol interface %u interface %u is not an AudioClass interface\n",
3862                                dev->devnum, ctrlif, j);
3863                         continue;
3864                 }
3865                 if (iface->altsetting[0].bInterfaceSubClass == 3) {
3866                         printk(KERN_INFO "usbaudio: device %d audiocontrol interface %u interface %u MIDIStreaming not supported\n",
3867                                dev->devnum, ctrlif, j);
3868                         continue;
3869                 }
3870                 if (iface->altsetting[0].bInterfaceSubClass != 2) {
3871                         printk(KERN_ERR "usbaudio: device %d audiocontrol interface %u interface %u invalid AudioClass subtype\n",
3872                                dev->devnum, ctrlif, j);
3873                         continue;
3874                 }
3875                 if (iface->num_altsetting == 0) {
3876                         printk(KERN_ERR "usbaudio: device %d audiocontrol interface %u has no working interface.\n", dev->devnum, ctrlif);
3877                         continue;
3878                 }
3879                 if (iface->num_altsetting == 1) {
3880                         printk(KERN_ERR "usbaudio: device %d audiocontrol interface %u has only 1 altsetting.\n", dev->devnum, ctrlif);
3881                         continue;
3882                 }
3883                 if (iface->altsetting[0].bNumEndpoints > 0) {
3884                         /* Check all endpoints; should they all have a bandwidth of 0 ? */
3885                         for (k = 0; k < iface->altsetting[0].bNumEndpoints; k++) {
3886                                 if (iface->altsetting[0].endpoint[k].wMaxPacketSize > 0) {
3887                                         printk(KERN_ERR "usbaudio: device %d audiocontrol interface %u endpoint %d does not have 0 bandwidth at alt[0]\n", dev->devnum, ctrlif, k);
3888                                         break;
3889                                 }
3890                         }
3891                         if (k < iface->altsetting[0].bNumEndpoints)
3892                                 continue;
3893                 }
3894                 if (iface->altsetting[1].bNumEndpoints < 1) {
3895                         printk(KERN_ERR "usbaudio: device %d audiocontrol interface %u interface %u has no endpoint\n",
3896                                dev->devnum, ctrlif, j);
3897                         continue;
3898                 }
3899                 /* note: this requires the data endpoint to be ep0 and the optional sync
3900                    ep to be ep1, which seems to be the case */
3901                 if (iface->altsetting[1].endpoint[0].bEndpointAddress & USB_DIR_IN) {
3902                         if (numifin < USB_MAXINTERFACES) {
3903                                 ifin[numifin++] = j;
3904                                 usb_driver_claim_interface(&usb_audio_driver, iface, (void *)-1);
3905                         }
3906                 } else {
3907                         if (numifout < USB_MAXINTERFACES) {
3908                                 ifout[numifout++] = j;
3909                                 usb_driver_claim_interface(&usb_audio_driver, iface, (void *)-1);
3910                         }
3911                 }
3912         }
3913         printk(KERN_INFO "usbaudio: device %d audiocontrol interface %u has %u input and %u output AudioStreaming interfaces\n",
3914                dev->devnum, ctrlif, numifin, numifout);
3915         for (i = 0; i < numifin && i < numifout; i++)
3916                 usb_audio_parsestreaming(s, buffer, buflen, ifin[i], ifout[i]);
3917         for (j = i; j < numifin; j++)
3918                 usb_audio_parsestreaming(s, buffer, buflen, ifin[i], -1);
3919         for (j = i; j < numifout; j++)
3920                 usb_audio_parsestreaming(s, buffer, buflen, -1, ifout[i]);
3921         /* now walk through all OUTPUT_TERMINAL descriptors to search for mixers */
3922         p1 = find_csinterface_descriptor(buffer, buflen, NULL, OUTPUT_TERMINAL, ctrlif, -1);
3923         while (p1) {
3924                 if (p1[0] >= 9)
3925                         usb_audio_constructmixer(s, buffer, buflen, ctrlif, p1);
3926                 p1 = find_csinterface_descriptor(buffer, buflen, p1, OUTPUT_TERMINAL, ctrlif, -1);
3927         }
3928
3929 ret:
3930         if (list_empty(&s->audiolist) && list_empty(&s->mixerlist)) {
3931                 kfree(s);
3932                 return NULL;
3933         }
3934         /* everything successful */
3935         down(&open_sem);
3936         list_add_tail(&s->audiodev, &audiodevs);
3937         up(&open_sem);
3938         printk(KERN_DEBUG "usb_audio_parsecontrol: usb_audio_state at %p\n", s);
3939         return s;
3940 }
3941
3942 /* we only care for the currently active configuration */
3943
3944 static void *usb_audio_probe(struct usb_device *dev, unsigned int ifnum,
3945                              const struct usb_device_id *id)
3946 {
3947         struct usb_config_descriptor *config = dev->actconfig;
3948         unsigned char *buffer;
3949         unsigned char buf[8];
3950         unsigned int i, buflen;
3951         int ret;
3952
3953 #if 0
3954         printk(KERN_DEBUG "usbaudio: Probing if %i: IC %x, ISC %x\n", ifnum,
3955                config->interface[ifnum].altsetting[0].bInterfaceClass,
3956                config->interface[ifnum].altsetting[0].bInterfaceSubClass);
3957 #endif
3958
3959         /*
3960          * audiocontrol interface found
3961          * find which configuration number is active
3962          */
3963         i = dev->actconfig - config;
3964
3965         if (usb_set_configuration(dev, config->bConfigurationValue) < 0) {
3966                 printk(KERN_ERR "usbaudio: set_configuration failed (ConfigValue 0x%x)\n", config->bConfigurationValue);
3967                 return NULL;
3968         }
3969         ret = usb_get_descriptor(dev, USB_DT_CONFIG, i, buf, 8);
3970         if (ret < 0) {
3971                 printk(KERN_ERR "usbaudio: cannot get first 8 bytes of config descriptor %d of device %d (error %d)\n", i, dev->devnum, ret);
3972                 return NULL;
3973         }
3974         if (buf[1] != USB_DT_CONFIG || buf[0] < 9) {
3975                 printk(KERN_ERR "usbaudio: invalid config descriptor %d of device %d\n", i, dev->devnum);
3976                 return NULL;
3977         }
3978         buflen = buf[2] | (buf[3] << 8);
3979         if (!(buffer = kmalloc(buflen, GFP_KERNEL)))
3980                 return NULL;
3981         ret = usb_get_descriptor(dev, USB_DT_CONFIG, i, buffer, buflen);
3982         if (ret < 0) {
3983                 kfree(buffer);
3984                 printk(KERN_ERR "usbaudio: cannot get config descriptor %d of device %d (error %d)\n", i, dev->devnum, ret);
3985                 return NULL;
3986         }
3987         return usb_audio_parsecontrol(dev, buffer, buflen, ifnum);
3988 }
3989
3990
3991 /* a revoke facility would make things simpler */
3992
3993 static void usb_audio_disconnect(struct usb_device *dev, void *ptr)
3994 {
3995         struct usb_audio_state *s = (struct usb_audio_state *)ptr;
3996         struct list_head *list;
3997         struct usb_audiodev *as;
3998         struct usb_mixerdev *ms;
3999
4000         /* we get called with -1 for every audiostreaming interface registered */
4001         if (s == (struct usb_audio_state *)-1) {
4002                 dprintk((KERN_DEBUG "usbaudio: note, usb_audio_disconnect called with -1\n"));
4003                 return;
4004         }
4005         if (!s->usbdev) {
4006                 dprintk((KERN_DEBUG "usbaudio: error,  usb_audio_disconnect already called for %p!\n", s));
4007                 return;
4008         }
4009         down(&open_sem);
4010         list_del(&s->audiodev);
4011         INIT_LIST_HEAD(&s->audiodev);
4012         s->usbdev = NULL;
4013         /* deregister all audio and mixer devices, so no new processes can open this device */
4014         for(list = s->audiolist.next; list != &s->audiolist; list = list->next) {
4015                 as = list_entry(list, struct usb_audiodev, list);
4016                 usbin_disc(as);
4017                 usbout_disc(as);
4018                 wake_up(&as->usbin.dma.wait);
4019                 wake_up(&as->usbout.dma.wait);
4020                 if (as->dev_audio >= 0) {
4021                         unregister_sound_dsp(as->dev_audio);
4022                         printk(KERN_INFO "usbaudio: unregister dsp 14,%d\n", as->dev_audio);
4023                 }
4024                 as->dev_audio = -1;
4025         }
4026         for(list = s->mixerlist.next; list != &s->mixerlist; list = list->next) {
4027                 ms = list_entry(list, struct usb_mixerdev, list);
4028                 if (ms->dev_mixer >= 0) {
4029                         unregister_sound_mixer(ms->dev_mixer);
4030                         printk(KERN_INFO "usbaudio: unregister mixer 14,%d\n", ms->dev_mixer);
4031                 }
4032                 ms->dev_mixer = -1;
4033         }
4034         release(s);
4035         wake_up(&open_wait);
4036 }
4037
4038 static int __init usb_audio_init(void)
4039 {
4040         usb_register(&usb_audio_driver);
4041         info(DRIVER_VERSION ":" DRIVER_DESC);
4042         return 0;
4043 }
4044
4045
4046 static void __exit usb_audio_cleanup(void)
4047 {
4048         usb_deregister(&usb_audio_driver);
4049 }
4050
4051 module_init(usb_audio_init);
4052 module_exit(usb_audio_cleanup);
4053
4054 MODULE_AUTHOR( DRIVER_AUTHOR );
4055 MODULE_DESCRIPTION( DRIVER_DESC );
4056 MODULE_LICENSE("GPL");
4057