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