drivers/usb/class/audio.c

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