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