Nuke USB_DECLARE_DRIVER and USB_DECLARE_DRIVER_INIT macros.
[dragonfly.git] / sys / dev / sound / usb / uaudio.c
1 /*      $NetBSD: uaudio.c,v 1.91 2004/11/05 17:46:14 kent Exp $ */
2 /*      $FreeBSD: src/sys/dev/sound/usb/uaudio.c,v 1.14.2.2 2006/04/04 17:34:10 ariff Exp $ */
3 /*      $DragonFly: src/sys/dev/sound/usb/uaudio.c,v 1.16 2007/07/02 23:52:05 hasso Exp $: */
4
5 /*-
6  * Copyright (c) 1999 The NetBSD Foundation, Inc.
7  * All rights reserved.
8  *
9  * This code is derived from software contributed to The NetBSD Foundation
10  * by Lennart Augustsson (lennart@augustsson.net) at
11  * Carlstedt Research & Technology.
12  *
13  * Redistribution and use in source and binary forms, with or without
14  * modification, are permitted provided that the following conditions
15  * are met:
16  * 1. Redistributions of source code must retain the above copyright
17  *    notice, this list of conditions and the following disclaimer.
18  * 2. Redistributions in binary form must reproduce the above copyright
19  *    notice, this list of conditions and the following disclaimer in the
20  *    documentation and/or other materials provided with the distribution.
21  * 3. All advertising materials mentioning features or use of this software
22  *    must display the following acknowledgement:
23  *        This product includes software developed by the NetBSD
24  *        Foundation, Inc. and its contributors.
25  * 4. Neither the name of The NetBSD Foundation nor the names of its
26  *    contributors may be used to endorse or promote products derived
27  *    from this software without specific prior written permission.
28  *
29  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
30  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
31  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
32  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
33  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
34  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
35  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
36  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
37  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
38  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
39  * POSSIBILITY OF SUCH DAMAGE.
40  */
41
42 /*
43  * USB audio specs: http://www.usb.org/developers/devclass_docs/audio10.pdf
44  *                  http://www.usb.org/developers/devclass_docs/frmts10.pdf
45  *                  http://www.usb.org/developers/devclass_docs/termt10.pdf
46  */
47
48 #include <sys/cdefs.h>
49 #if defined(__NetBSD__) || defined(__OpenBSD__)
50 __KERNEL_RCSID(0, "$NetBSD: uaudio.c,v 1.91 2004/11/05 17:46:14 kent Exp $");
51 #endif
52
53 /*
54  * Also merged:
55  *  $NetBSD: uaudio.c,v 1.94 2005/01/15 15:19:53 kent Exp $
56  *  $NetBSD: uaudio.c,v 1.95 2005/01/16 06:02:19 dsainty Exp $
57  *  $NetBSD: uaudio.c,v 1.96 2005/01/16 12:46:00 kent Exp $
58  *  $NetBSD: uaudio.c,v 1.97 2005/02/24 08:19:38 martin Exp $
59  */
60
61 #include <sys/param.h>
62 #include <sys/systm.h>
63 #include <sys/kernel.h>
64 #include <sys/malloc.h>
65 #if defined(__NetBSD__) || defined(__OpenBSD__)
66 #include <sys/device.h>
67 #include <sys/ioctl.h>
68 #endif
69 #include <sys/tty.h>
70 #include <sys/file.h>
71 #include <sys/reboot.h>         /* for bootverbose */
72 #include <sys/select.h>
73 #include <sys/proc.h>
74 #if defined(__NetBSD__) || defined(__OpenBSD__)
75 #include <sys/device.h>
76 #elif defined(__FreeBSD__) || defined(__DragonFly__)
77 #include <sys/module.h>
78 #include <sys/bus.h>
79 #include <sys/conf.h>
80 #endif
81 #include <sys/poll.h>
82 #if defined(__FreeBSD__)
83 #include <sys/sysctl.h>
84 #include <sys/sbuf.h>
85 #elif defined(__DragonFly__)
86 #include <sys/sysctl.h>
87 #include <sys/thread2.h>
88 #endif
89
90 #if defined(__NetBSD__) || defined(__OpenBSD__)
91 #include <sys/audioio.h>
92 #include <dev/audio_if.h>
93 #include <dev/audiovar.h>
94 #include <dev/mulaw.h>
95 #include <dev/auconv.h>
96 #elif defined(__FreeBSD__) || defined(__DragonFly__)
97 #include <dev/sound/pcm/sound.h>        /* XXXXX */
98 #include <dev/sound/chip.h>
99 #include "feeder_if.h"
100 #endif
101
102 #include <bus/usb/usb.h>
103 #include <bus/usb/usbdi.h>
104 #include <bus/usb/usbdi_util.h>
105 #include <bus/usb/usb_quirks.h>
106
107 #if defined(__NetBSD__) || defined(__OpenBSD__)
108 #include <dev/usb/uaudioreg.h>
109 #elif defined(__FreeBSD__) || defined(__DragonFly__)
110 #include <dev/sound/usb/uaudioreg.h>
111 #include <dev/sound/usb/uaudio.h>
112 #endif
113
114 #if defined(__NetBSD__) || defined(__OpenBSD__)
115 /* #define UAUDIO_DEBUG */
116 #else
117 /* #define USB_DEBUG */
118 #endif
119 /* #define UAUDIO_MULTIPLE_ENDPOINTS */
120 #ifdef USB_DEBUG
121 #define DPRINTF(x)      do { if (uaudiodebug) kprintf x; } while (0)
122 #define DPRINTFN(n,x)   do { if (uaudiodebug>(n)) kprintf x; } while (0)
123 int     uaudiodebug = 0;
124 #if defined(__FreeBSD__) || defined(__DragonFly__)
125 SYSCTL_NODE(_hw_usb, OID_AUTO, uaudio, CTLFLAG_RW, 0, "USB uaudio");
126 SYSCTL_INT(_hw_usb_uaudio, OID_AUTO, debug, CTLFLAG_RW,
127            &uaudiodebug, 0, "uaudio debug level");
128 #endif
129 #else
130 #define DPRINTF(x)
131 #define DPRINTFN(n,x)
132 #endif
133
134 #define UAUDIO_NCHANBUFS 6      /* number of outstanding request */
135 #if defined(__NetBSD__) || defined(__OpenBSD__)
136 #define UAUDIO_NFRAMES   10     /* ms of sound in each request */
137 #elif defined(__FreeBSD__) || defined(__DragonFly__)
138 #define UAUDIO_NFRAMES   20     /* ms of sound in each request */
139 #endif
140
141
142 #define MIX_MAX_CHAN 8
143 struct mixerctl {
144         uint16_t        wValue[MIX_MAX_CHAN]; /* using nchan */
145         uint16_t        wIndex;
146         uint8_t         nchan;
147         uint8_t         type;
148 #define MIX_ON_OFF      1
149 #define MIX_SIGNED_16   2
150 #define MIX_UNSIGNED_16 3
151 #define MIX_SIGNED_8    4
152 #define MIX_SELECTOR    5
153 #define MIX_SIZE(n) ((n) == MIX_SIGNED_16 || (n) == MIX_UNSIGNED_16 ? 2 : 1)
154 #define MIX_UNSIGNED(n) ((n) == MIX_UNSIGNED_16)
155         int             minval, maxval;
156         u_int           delta;
157         u_int           mul;
158 #if defined(__FreeBSD__) || defined(__DragonFly__) /* XXXXX */
159         unsigned        ctl;
160 #define MAX_SELECTOR_INPUT_PIN 256
161         uint8_t         slctrtype[MAX_SELECTOR_INPUT_PIN];
162 #endif
163         uint8_t         class;
164 #if !defined(__FreeBSD__) && !defined(__DragonFly__)
165         char            ctlname[MAX_AUDIO_DEV_LEN];
166         char            *ctlunit;
167 #endif
168 };
169 #define MAKE(h,l) (((h) << 8) | (l))
170
171 struct as_info {
172         uint8_t         alt;
173         uint8_t         encoding;
174         uint8_t         attributes; /* Copy of bmAttributes of
175                                      * usb_audio_streaming_endpoint_descriptor
176                                      */
177         usbd_interface_handle   ifaceh;
178         const usb_interface_descriptor_t *idesc;
179         const usb_endpoint_descriptor_audio_t *edesc;
180         const usb_endpoint_descriptor_audio_t *edesc1;
181         const struct usb_audio_streaming_type1_descriptor *asf1desc;
182         int             sc_busy;        /* currently used */
183 };
184
185 struct chan {
186 #if defined(__NetBSD__) || defined(__OpenBSD__)
187         void    (*intr)(void *);        /* DMA completion intr handler */
188         void    *arg;           /* arg for intr() */
189 #else
190         struct pcm_channel *pcm_ch;
191 #endif
192         usbd_pipe_handle pipe;
193         usbd_pipe_handle sync_pipe;
194
195         u_int   sample_size;
196         u_int   sample_rate;
197         u_int   bytes_per_frame;
198         u_int   fraction;       /* fraction/1000 is the extra samples/frame */
199         u_int   residue;        /* accumulates the fractional samples */
200
201         u_char  *start;         /* upper layer buffer start */
202         u_char  *end;           /* upper layer buffer end */
203         u_char  *cur;           /* current position in upper layer buffer */
204         int     blksize;        /* chunk size to report up */
205         int     transferred;    /* transferred bytes not reported up */
206
207         int     altidx;         /* currently used altidx */
208
209         int     curchanbuf;
210         struct chanbuf {
211                 struct chan     *chan;
212                 usbd_xfer_handle xfer;
213                 u_char          *buffer;
214                 u_int16_t       sizes[UAUDIO_NFRAMES];
215                 u_int16_t       offsets[UAUDIO_NFRAMES];
216                 u_int16_t       size;
217         } chanbufs[UAUDIO_NCHANBUFS];
218
219         struct uaudio_softc *sc; /* our softc */
220 #if defined(__FreeBSD__) || defined(__DragonFly__)
221         u_int32_t format;
222         int     precision;
223         int     channels;
224 #endif
225 };
226
227 struct uaudio_softc {
228         device_t        sc_dev;         /* base device */
229         usbd_device_handle sc_udev;     /* USB device */
230         int             sc_ac_iface;    /* Audio Control interface */
231         usbd_interface_handle   sc_ac_ifaceh;
232         struct chan     sc_playchan;    /* play channel */
233         struct chan     sc_recchan;     /* record channel */
234         int             sc_nullalt;
235         int             sc_audio_rev;
236         struct as_info  *sc_alts;       /* alternate settings */
237         int             sc_nalts;       /* # of alternate settings */
238         int             sc_altflags;
239 #define HAS_8           0x01
240 #define HAS_16          0x02
241 #define HAS_8U          0x04
242 #define HAS_ALAW        0x08
243 #define HAS_MULAW       0x10
244 #define UA_NOFRAC       0x20            /* don't do sample rate adjustment */
245 #define HAS_24          0x40
246 #define HAS_32          0x80
247         int             sc_mode;        /* play/record capability */
248         struct mixerctl *sc_ctls;       /* mixer controls */
249         int             sc_nctls;       /* # of mixer controls */
250         device_t        sc_audiodev;
251         char            sc_dying;
252 #if defined(__FreeBSD__) || defined(__DragonFly__)
253         struct sbuf     uaudio_sndstat;
254         int             uaudio_sndstat_flag;
255 #endif
256 };
257
258 struct terminal_list {
259         int size;
260         uint16_t terminals[1];
261 };
262 #define TERMINAL_LIST_SIZE(N)   (offsetof(struct terminal_list, terminals) \
263                                 + sizeof(uint16_t) * (N))
264
265 struct io_terminal {
266         union {
267                 const usb_descriptor_t *desc;
268                 const struct usb_audio_input_terminal *it;
269                 const struct usb_audio_output_terminal *ot;
270                 const struct usb_audio_mixer_unit *mu;
271                 const struct usb_audio_selector_unit *su;
272                 const struct usb_audio_feature_unit *fu;
273                 const struct usb_audio_processing_unit *pu;
274                 const struct usb_audio_extension_unit *eu;
275         } d;
276         int inputs_size;
277         struct terminal_list **inputs; /* list of source input terminals */
278         struct terminal_list *output; /* list of destination output terminals */
279         int direct;             /* directly connected to an output terminal */
280 };
281
282 #define UAC_OUTPUT      0
283 #define UAC_INPUT       1
284 #define UAC_EQUAL       2
285 #define UAC_RECORD      3
286 #define UAC_NCLASSES    4
287 #ifdef USB_DEBUG
288 #if defined(__FreeBSD__) || defined(__DragonFly__)
289 #define AudioCinputs    "inputs"
290 #define AudioCoutputs   "outputs"
291 #define AudioCrecord    "record"
292 #define AudioCequalization      "equalization"
293 #endif
294 static const char *uac_names[] = {
295         AudioCoutputs, AudioCinputs, AudioCequalization, AudioCrecord,
296 };
297 #endif
298
299 static usbd_status uaudio_identify_ac
300         (struct uaudio_softc *, const usb_config_descriptor_t *);
301 static usbd_status uaudio_identify_as
302         (struct uaudio_softc *, const usb_config_descriptor_t *);
303 static usbd_status uaudio_process_as
304         (struct uaudio_softc *, const char *, int *, int,
305          const usb_interface_descriptor_t *);
306
307 static void     uaudio_add_alt(struct uaudio_softc *, const struct as_info *);
308
309 static const usb_interface_descriptor_t *uaudio_find_iface
310         (const char *, int, int *, int);
311
312 static void     uaudio_mixer_add_ctl(struct uaudio_softc *, struct mixerctl *);
313
314 #if defined(__NetBSD__) || defined(__OpenBSD__)
315 static char     *uaudio_id_name
316         (struct uaudio_softc *, const struct io_terminal *, int);
317 #endif
318
319 #ifdef USB_DEBUG
320 static void     uaudio_dump_cluster(const struct usb_audio_cluster *);
321 #endif
322 static struct usb_audio_cluster uaudio_get_cluster
323         (int, const struct io_terminal *);
324 static void     uaudio_add_input
325         (struct uaudio_softc *, const struct io_terminal *, int);
326 static void     uaudio_add_output
327         (struct uaudio_softc *, const struct io_terminal *, int);
328 static void     uaudio_add_mixer
329         (struct uaudio_softc *, const struct io_terminal *, int);
330 static void     uaudio_add_selector
331         (struct uaudio_softc *, const struct io_terminal *, int);
332 #ifdef USB_DEBUG
333 static const char *uaudio_get_terminal_name(int);
334 #endif
335 static int      uaudio_determine_class
336         (const struct io_terminal *, struct mixerctl *);
337 #if defined(__FreeBSD__) || defined(__DragonFly__)
338 static const int uaudio_feature_name(const struct io_terminal *,
339                     struct mixerctl *);
340 #else
341 static const char *uaudio_feature_name
342         (const struct io_terminal *, struct mixerctl *);
343 #endif
344 static void     uaudio_add_feature
345         (struct uaudio_softc *, const struct io_terminal *, int);
346 static void     uaudio_add_processing_updown
347         (struct uaudio_softc *, const struct io_terminal *, int);
348 static void     uaudio_add_processing
349         (struct uaudio_softc *, const struct io_terminal *, int);
350 static void     uaudio_add_extension
351         (struct uaudio_softc *, const struct io_terminal *, int);
352 static struct terminal_list *uaudio_merge_terminal_list
353         (const struct io_terminal *);
354 static struct terminal_list *uaudio_io_terminaltype
355         (int, struct io_terminal *, int);
356 static usbd_status uaudio_identify
357         (struct uaudio_softc *, const usb_config_descriptor_t *);
358
359 static int      uaudio_signext(int, int);
360 #if defined(__NetBSD__) || defined(__OpenBSD__)
361 static int      uaudio_value2bsd(struct mixerctl *, int);
362 #endif
363 static int      uaudio_bsd2value(struct mixerctl *, int);
364 static int      uaudio_get(struct uaudio_softc *, int, int, int, int, int);
365 #if defined(__NetBSD__) || defined(__OpenBSD__)
366 static int      uaudio_ctl_get
367         (struct uaudio_softc *, int, struct mixerctl *, int);
368 #endif
369 static void     uaudio_set
370         (struct uaudio_softc *, int, int, int, int, int, int);
371 static void     uaudio_ctl_set
372         (struct uaudio_softc *, int, struct mixerctl *, int, int);
373
374 static usbd_status uaudio_set_speed(struct uaudio_softc *, int, u_int);
375
376 static usbd_status uaudio_chan_open(struct uaudio_softc *, struct chan *);
377 static void     uaudio_chan_close(struct uaudio_softc *, struct chan *);
378 static usbd_status uaudio_chan_alloc_buffers
379         (struct uaudio_softc *, struct chan *);
380 static void     uaudio_chan_free_buffers(struct uaudio_softc *, struct chan *);
381
382 #if defined(__NetBSD__) || defined(__OpenBSD__)
383 static void     uaudio_chan_init
384         (struct chan *, int, const struct audio_params *, int);
385 static void     uaudio_chan_set_param(struct chan *, u_char *, u_char *, int);
386 #endif
387
388 static void     uaudio_chan_ptransfer(struct chan *);
389 static void     uaudio_chan_pintr
390         (usbd_xfer_handle, usbd_private_handle, usbd_status);
391
392 static void     uaudio_chan_rtransfer(struct chan *);
393 static void     uaudio_chan_rintr
394         (usbd_xfer_handle, usbd_private_handle, usbd_status);
395
396 #if defined(__NetBSD__) || defined(__OpenBSD__)
397 static int      uaudio_open(void *, int);
398 static void     uaudio_close(void *);
399 static int      uaudio_drain(void *);
400 static int      uaudio_query_encoding(void *, struct audio_encoding *);
401 static void     uaudio_get_minmax_rates
402         (int, const struct as_info *, const struct audio_params *,
403          int, u_long *, u_long *);
404 static int      uaudio_match_alt_sub
405         (int, const struct as_info *, const struct audio_params *, int, u_long);
406 static int      uaudio_match_alt_chan
407         (int, const struct as_info *, struct audio_params *, int);
408 static int      uaudio_match_alt
409         (int, const struct as_info *, struct audio_params *, int);
410 static int      uaudio_set_params
411         (void *, int, int, struct audio_params *, struct audio_params *);
412 static int      uaudio_round_blocksize(void *, int);
413 static int      uaudio_trigger_output
414         (void *, void *, void *, int, void (*)(void *), void *,
415          struct audio_params *);
416 static int      uaudio_trigger_input
417         (void *, void *, void *, int, void (*)(void *), void *,
418          struct audio_params *);
419 static int      uaudio_halt_in_dma(void *);
420 static int      uaudio_halt_out_dma(void *);
421 static int      uaudio_getdev(void *, struct audio_device *);
422 static int      uaudio_mixer_set_port(void *, mixer_ctrl_t *);
423 static int      uaudio_mixer_get_port(void *, mixer_ctrl_t *);
424 static int      uaudio_query_devinfo(void *, mixer_devinfo_t *);
425 static int      uaudio_get_props(void *);
426
427 static const struct audio_hw_if uaudio_hw_if = {
428         uaudio_open,
429         uaudio_close,
430         uaudio_drain,
431         uaudio_query_encoding,
432         uaudio_set_params,
433         uaudio_round_blocksize,
434         NULL,
435         NULL,
436         NULL,
437         NULL,
438         NULL,
439         uaudio_halt_out_dma,
440         uaudio_halt_in_dma,
441         NULL,
442         uaudio_getdev,
443         NULL,
444         uaudio_mixer_set_port,
445         uaudio_mixer_get_port,
446         uaudio_query_devinfo,
447         NULL,
448         NULL,
449         NULL,
450         NULL,
451         uaudio_get_props,
452         uaudio_trigger_output,
453         uaudio_trigger_input,
454         NULL,
455 };
456
457 static struct audio_device uaudio_device = {
458         "USB audio",
459         "",
460         "uaudio"
461 };
462
463 #elif defined(__FreeBSD__) || defined(__DragonFly__)
464 static int      audio_attach_mi(device_t);
465 static int      uaudio_init_params(struct uaudio_softc * sc, struct chan *ch, int mode);
466 static int      uaudio_sndstat_prepare_pcm(struct sbuf *s, device_t dev, int verbose);
467
468 /* for NetBSD compatibirity */
469 #define AUMODE_PLAY     0x01
470 #define AUMODE_RECORD   0x02
471
472 #define AUDIO_PROP_FULLDUPLEX   0x01
473
474 #define AUDIO_ENCODING_ULAW             1
475 #define AUDIO_ENCODING_ALAW             2
476 #define AUDIO_ENCODING_SLINEAR_LE       6
477 #define AUDIO_ENCODING_SLINEAR_BE       7
478 #define AUDIO_ENCODING_ULINEAR_LE       8
479 #define AUDIO_ENCODING_ULINEAR_BE       9
480
481 #endif  /* FreeBSD || DragonFly */
482
483
484 #if defined(__NetBSD__) || defined(__OpenBSD__)
485
486 USB_DECLARE_DRIVER(uaudio);
487
488 #elif defined(__FreeBSD__) || defined(__DragonFly__)
489
490 static device_probe_t uaudio_match;
491 static device_attach_t uaudio_attach;
492 static device_detach_t uaudio_detach;
493
494 static devclass_t uaudio_devclass;
495
496 static kobj_method_t uaudio_methods[] = {
497         DEVMETHOD(device_probe, uaudio_match),
498         DEVMETHOD(device_attach, uaudio_attach),
499         DEVMETHOD(device_detach, uaudio_detach),
500         DEVMETHOD(device_suspend, bus_generic_suspend),
501         DEVMETHOD(device_resume, bus_generic_resume),
502         DEVMETHOD(device_shutdown, bus_generic_shutdown),
503         DEVMETHOD(bus_print_child, bus_generic_print_child),
504         {0,0}
505 };
506
507 static driver_t uaudio_driver = {
508         "uaudio",
509         uaudio_methods,
510         sizeof(struct uaudio_softc)
511 };
512
513 MODULE_DEPEND(uaudio, usb, 1, 1, 1);
514 #endif
515
516
517 static int
518 uaudio_match(device_t self)
519 {
520         struct usb_attach_arg *uaa = device_get_ivars(self);
521         usb_interface_descriptor_t *id;
522
523         if (uaa->iface == NULL)
524                 return UMATCH_NONE;
525
526         id = usbd_get_interface_descriptor(uaa->iface);
527         /* Trigger on the control interface. */
528         if (id == NULL ||
529             id->bInterfaceClass != UICLASS_AUDIO ||
530             id->bInterfaceSubClass != UISUBCLASS_AUDIOCONTROL ||
531             (usbd_get_quirks(uaa->device)->uq_flags & UQ_BAD_AUDIO))
532                 return UMATCH_NONE;
533
534         return UMATCH_IFACECLASS_IFACESUBCLASS;
535 }
536
537 static int
538 uaudio_attach(device_t self)
539 {
540         struct uaudio_softc *sc = device_get_softc(self);
541         struct usb_attach_arg *uaa = device_get_ivars(self);
542         usb_interface_descriptor_t *id;
543         usb_config_descriptor_t *cdesc;
544         char devinfo[1024];
545         usbd_status err;
546         int i, j, found;
547
548 #if defined(__FreeBSD__) || defined(__DragonFly__)
549         usbd_devinfo(uaa->device, 0, devinfo);
550         sc->sc_dev = self;
551         device_set_desc_copy(self, devinfo);
552 #else
553         usbd_devinfo(uaa->device, 0, devinfo, sizeof(devinfo));
554         kprintf(": %s\n", devinfo);
555 #endif
556
557         sc->sc_udev = uaa->device;
558
559         cdesc = usbd_get_config_descriptor(sc->sc_udev);
560         if (cdesc == NULL) {
561                 kprintf("%s: failed to get configuration descriptor\n",
562                        device_get_nameunit(sc->sc_dev));
563                 return ENXIO;
564         }
565
566         err = uaudio_identify(sc, cdesc);
567         if (err) {
568                 kprintf("%s: audio descriptors make no sense, error=%d\n",
569                        device_get_nameunit(sc->sc_dev), err);
570                 return ENXIO;
571         }
572
573         sc->sc_ac_ifaceh = uaa->iface;
574         /* Pick up the AS interface. */
575         for (i = 0; i < uaa->nifaces; i++) {
576                 if (uaa->ifaces[i] == NULL)
577                         continue;
578                 id = usbd_get_interface_descriptor(uaa->ifaces[i]);
579                 if (id == NULL)
580                         continue;
581                 found = 0;
582                 for (j = 0; j < sc->sc_nalts; j++) {
583                         if (id->bInterfaceNumber ==
584                             sc->sc_alts[j].idesc->bInterfaceNumber) {
585                                 sc->sc_alts[j].ifaceh = uaa->ifaces[i];
586                                 found = 1;
587                         }
588                 }
589                 if (found)
590                         uaa->ifaces[i] = NULL;
591         }
592
593         for (j = 0; j < sc->sc_nalts; j++) {
594                 if (sc->sc_alts[j].ifaceh == NULL) {
595                         kprintf("%s: alt %d missing AS interface(s)\n",
596                             device_get_nameunit(sc->sc_dev), j);
597                         return ENXIO;
598                 }
599         }
600
601         kprintf("%s: audio rev %d.%02x\n", device_get_nameunit(sc->sc_dev),
602                sc->sc_audio_rev >> 8, sc->sc_audio_rev & 0xff);
603
604         sc->sc_playchan.sc = sc->sc_recchan.sc = sc;
605         sc->sc_playchan.altidx = -1;
606         sc->sc_recchan.altidx = -1;
607
608         if (usbd_get_quirks(sc->sc_udev)->uq_flags & UQ_AU_NO_FRAC)
609                 sc->sc_altflags |= UA_NOFRAC;
610
611 #ifndef USB_DEBUG
612         if (bootverbose)
613 #endif
614                 kprintf("%s: %d mixer controls\n", device_get_nameunit(sc->sc_dev),
615                     sc->sc_nctls);
616
617 #if !defined(__FreeBSD__) && !defined(__DragonFly__)
618         usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev,
619                            sc->sc_dev);
620 #endif
621
622         DPRINTF(("uaudio_attach: doing audio_attach_mi\n"));
623 #if defined(__OpenBSD__)
624         audio_attach_mi(&uaudio_hw_if, sc, &sc->sc_dev);
625 #elif defined(__NetBSD__)
626         sc->sc_audiodev = audio_attach_mi(&uaudio_hw_if, sc, &sc->sc_dev);
627 #elif defined(__FreeBSD__) || defined(__DragonFly__)
628         sc->sc_dying = 0;
629         if (audio_attach_mi(sc->sc_dev)) {
630                 kprintf("audio_attach_mi failed\n");
631                 return ENXIO;
632         }
633 #endif
634
635         return 0;
636 }
637
638 #if defined(__NetBSD__) || defined(__OpenBSD__)
639 int
640 uaudio_activate(device_t self, enum devact act)
641 {
642         struct uaudio_softc *sc;
643         int rv;
644
645         sc = (struct uaudio_softc *)self;
646         rv = 0;
647         switch (act) {
648         case DVACT_ACTIVATE:
649                 return EOPNOTSUPP;
650
651         case DVACT_DEACTIVATE:
652                 if (sc->sc_audiodev != NULL)
653                         rv = config_deactivate(sc->sc_audiodev);
654                 sc->sc_dying = 1;
655                 break;
656         }
657         return rv;
658 }
659 #endif
660
661 #if defined(__NetBSD__) || defined(__OpenBSD__)
662 int
663 uaudio_detach(device_t self, int flags)
664 {
665         struct uaudio_softc *sc;
666         int rv;
667
668         sc = (struct uaudio_softc *)self;
669         rv = 0;
670         /* Wait for outstanding requests to complete. */
671         usbd_delay_ms(sc->sc_udev, UAUDIO_NCHANBUFS * UAUDIO_NFRAMES);
672
673         if (sc->sc_audiodev != NULL)
674                 rv = config_detach(sc->sc_audiodev, flags);
675
676         usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev,
677                            sc->sc_dev);
678
679         return rv;
680 }
681 #elif defined(__FreeBSD__) || defined(__DragonFly__)
682
683 static int
684 uaudio_detach(device_t self)
685 {
686         struct uaudio_softc *sc = device_get_softc(self);
687
688         sbuf_delete(&(sc->uaudio_sndstat));
689         sc->uaudio_sndstat_flag = 0;
690
691         sc->sc_dying = 1;
692
693 #if 0 /* XXX */
694         /* Wait for outstanding requests to complete. */
695         usbd_delay_ms(sc->sc_udev, UAUDIO_NCHANBUFS * UAUDIO_NFRAMES);
696 #endif
697
698         /* do nothing ? */
699         return bus_generic_detach(sc->sc_dev);
700 }
701 #endif
702
703 #if defined(__NetBSD__) || defined(__OpenBSD__)
704 static int
705 uaudio_query_encoding(void *addr, struct audio_encoding *fp)
706 {
707         struct uaudio_softc *sc;
708         int flags;
709         int idx;
710
711         sc = addr;
712         flags = sc->sc_altflags;
713         if (sc->sc_dying)
714                 return EIO;
715
716         if (sc->sc_nalts == 0 || flags == 0)
717                 return ENXIO;
718
719         idx = fp->index;
720         switch (idx) {
721         case 0:
722                 strlcpy(fp->name, AudioEulinear, sizeof(fp->name));
723                 fp->encoding = AUDIO_ENCODING_ULINEAR;
724                 fp->precision = 8;
725                 fp->flags = flags&HAS_8U ? 0 : AUDIO_ENCODINGFLAG_EMULATED;
726                 return (0);
727         case 1:
728                 strlcpy(fp->name, AudioEmulaw, sizeof(fp->name));
729                 fp->encoding = AUDIO_ENCODING_ULAW;
730                 fp->precision = 8;
731                 fp->flags = flags&HAS_MULAW ? 0 : AUDIO_ENCODINGFLAG_EMULATED;
732                 return (0);
733         case 2:
734                 strlcpy(fp->name, AudioEalaw, sizeof(fp->name));
735                 fp->encoding = AUDIO_ENCODING_ALAW;
736                 fp->precision = 8;
737                 fp->flags = flags&HAS_ALAW ? 0 : AUDIO_ENCODINGFLAG_EMULATED;
738                 return (0);
739         case 3:
740                 strlcpy(fp->name, AudioEslinear, sizeof(fp->name));
741                 fp->encoding = AUDIO_ENCODING_SLINEAR;
742                 fp->precision = 8;
743                 fp->flags = flags&HAS_8 ? 0 : AUDIO_ENCODINGFLAG_EMULATED;
744                 return (0);
745         case 4:
746                 strlcpy(fp->name, AudioEslinear_le, sizeof(fp->name));
747                 fp->encoding = AUDIO_ENCODING_SLINEAR_LE;
748                 fp->precision = 16;
749                 fp->flags = 0;
750                 return (0);
751         case 5:
752                 strlcpy(fp->name, AudioEulinear_le, sizeof(fp->name));
753                 fp->encoding = AUDIO_ENCODING_ULINEAR_LE;
754                 fp->precision = 16;
755                 fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
756                 return (0);
757         case 6:
758                 strlcpy(fp->name, AudioEslinear_be, sizeof(fp->name));
759                 fp->encoding = AUDIO_ENCODING_SLINEAR_BE;
760                 fp->precision = 16;
761                 fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
762                 return (0);
763         case 7:
764                 strlcpy(fp->name, AudioEulinear_be, sizeof(fp->name));
765                 fp->encoding = AUDIO_ENCODING_ULINEAR_BE;
766                 fp->precision = 16;
767                 fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
768                 return (0);
769         default:
770                 return (EINVAL);
771         }
772 }
773 #endif
774
775 static const usb_interface_descriptor_t *
776 uaudio_find_iface(const char *buf, int size, int *offsp, int subtype)
777 {
778         const usb_interface_descriptor_t *d;
779
780         while (*offsp < size) {
781                 d = (const void *)(buf + *offsp);
782                 *offsp += d->bLength;
783                 if (d->bDescriptorType == UDESC_INTERFACE &&
784                     d->bInterfaceClass == UICLASS_AUDIO &&
785                     d->bInterfaceSubClass == subtype)
786                         return d;
787         }
788         return NULL;
789 }
790
791 static void
792 uaudio_mixer_add_ctl(struct uaudio_softc *sc, struct mixerctl *mc)
793 {
794         int res;
795         size_t len;
796         struct mixerctl *nmc;
797
798 #if defined(__FreeBSD__) || defined(__DragonFly__)
799         if (mc->class < UAC_NCLASSES) {
800                 DPRINTF(("%s: adding %s.%d\n",
801                          __func__, uac_names[mc->class], mc->ctl));
802         } else {
803                 DPRINTF(("%s: adding %d\n", __func__, mc->ctl));
804         }
805 #else
806         if (mc->class < UAC_NCLASSES) {
807                 DPRINTF(("%s: adding %s.%s\n",
808                          __func__, uac_names[mc->class], mc->ctlname));
809         } else {
810                 DPRINTF(("%s: adding %s\n", __func__, mc->ctlname));
811         }
812 #endif
813         len = sizeof(*mc) * (sc->sc_nctls + 1);
814         nmc = kmalloc(len, M_USBDEV, M_NOWAIT);
815         if (nmc == NULL) {
816                 kprintf("uaudio_mixer_add_ctl: no memory\n");
817                 return;
818         }
819         /* Copy old data, if there was any */
820         if (sc->sc_nctls != 0) {
821                 memcpy(nmc, sc->sc_ctls, sizeof(*mc) * (sc->sc_nctls));
822                 kfree(sc->sc_ctls, M_USBDEV);
823         }
824         sc->sc_ctls = nmc;
825
826         mc->delta = 0;
827         if (mc->type == MIX_ON_OFF) {
828                 mc->minval = 0;
829                 mc->maxval = 1;
830         } else if (mc->type == MIX_SELECTOR) {
831                 ;
832         } else {
833                 /* Determine min and max values. */
834                 mc->minval = uaudio_signext(mc->type,
835                         uaudio_get(sc, GET_MIN, UT_READ_CLASS_INTERFACE,
836                                    mc->wValue[0], mc->wIndex,
837                                    MIX_SIZE(mc->type)));
838                 mc->maxval = 1 + uaudio_signext(mc->type,
839                         uaudio_get(sc, GET_MAX, UT_READ_CLASS_INTERFACE,
840                                    mc->wValue[0], mc->wIndex,
841                                    MIX_SIZE(mc->type)));
842                 mc->mul = mc->maxval - mc->minval;
843                 if (mc->mul == 0)
844                         mc->mul = 1;
845                 res = uaudio_get(sc, GET_RES, UT_READ_CLASS_INTERFACE,
846                                  mc->wValue[0], mc->wIndex,
847                                  MIX_SIZE(mc->type));
848                 if (res > 0)
849                         mc->delta = (res * 255 + mc->mul/2) / mc->mul;
850         }
851
852         sc->sc_ctls[sc->sc_nctls++] = *mc;
853
854 #ifdef USB_DEBUG
855         if (uaudiodebug > 2) {
856                 int i;
857                 DPRINTF(("uaudio_mixer_add_ctl: wValue=%04x",mc->wValue[0]));
858                 for (i = 1; i < mc->nchan; i++)
859                         DPRINTF((",%04x", mc->wValue[i]));
860 #if defined(__FreeBSD__) || defined(__DragonFly__)
861                 DPRINTF((" wIndex=%04x type=%d ctl='%d' "
862                          "min=%d max=%d\n",
863                          mc->wIndex, mc->type, mc->ctl,
864                          mc->minval, mc->maxval));
865 #else
866                 DPRINTF((" wIndex=%04x type=%d name='%s' unit='%s' "
867                          "min=%d max=%d\n",
868                          mc->wIndex, mc->type, mc->ctlname, mc->ctlunit,
869                          mc->minval, mc->maxval));
870 #endif
871         }
872 #endif
873 }
874
875 #if defined(__NetBSD__) || defined(__OpenBSD__)
876 static char *
877 uaudio_id_name(struct uaudio_softc *sc, const struct io_terminal *iot, int id)
878 {
879         static char buf[32];
880
881         ksnprintf(buf, sizeof(buf), "i%d", id);
882         return buf;
883 }
884 #endif
885
886 #ifdef USB_DEBUG
887 static void
888 uaudio_dump_cluster(const struct usb_audio_cluster *cl)
889 {
890         static const char *channel_names[16] = {
891                 "LEFT", "RIGHT", "CENTER", "LFE",
892                 "LEFT_SURROUND", "RIGHT_SURROUND", "LEFT_CENTER", "RIGHT_CENTER",
893                 "SURROUND", "LEFT_SIDE", "RIGHT_SIDE", "TOP",
894                 "RESERVED12", "RESERVED13", "RESERVED14", "RESERVED15",
895         };
896         int cc, i, first;
897
898         cc = UGETW(cl->wChannelConfig);
899         kprintf("cluster: bNrChannels=%u wChannelConfig=0x%.4x",
900                   cl->bNrChannels, cc);
901         first = TRUE;
902         for (i = 0; cc != 0; i++) {
903                 if (cc & 1) {
904                         kprintf("%c%s", first ? '<' : ',', channel_names[i]);
905                         first = FALSE;
906                 }
907                 cc = cc >> 1;
908         }
909         kprintf("> iChannelNames=%u", cl->iChannelNames);
910 }
911 #endif
912
913 static struct usb_audio_cluster
914 uaudio_get_cluster(int id, const struct io_terminal *iot)
915 {
916         struct usb_audio_cluster r;
917         const usb_descriptor_t *dp;
918         int i;
919
920         for (i = 0; i < 25; i++) { /* avoid infinite loops */
921                 dp = iot[id].d.desc;
922                 if (dp == 0)
923                         goto bad;
924                 switch (dp->bDescriptorSubtype) {
925                 case UDESCSUB_AC_INPUT:
926                         r.bNrChannels = iot[id].d.it->bNrChannels;
927                         USETW(r.wChannelConfig, UGETW(iot[id].d.it->wChannelConfig));
928                         r.iChannelNames = iot[id].d.it->iChannelNames;
929                         return r;
930                 case UDESCSUB_AC_OUTPUT:
931                         id = iot[id].d.ot->bSourceId;
932                         break;
933                 case UDESCSUB_AC_MIXER:
934                         r = *(const struct usb_audio_cluster *)
935                                 &iot[id].d.mu->baSourceId[iot[id].d.mu->bNrInPins];
936                         return r;
937                 case UDESCSUB_AC_SELECTOR:
938                         /* XXX This is not really right */
939                         id = iot[id].d.su->baSourceId[0];
940                         break;
941                 case UDESCSUB_AC_FEATURE:
942                         id = iot[id].d.fu->bSourceId;
943                         break;
944                 case UDESCSUB_AC_PROCESSING:
945                         r = *(const struct usb_audio_cluster *)
946                                 &iot[id].d.pu->baSourceId[iot[id].d.pu->bNrInPins];
947                         return r;
948                 case UDESCSUB_AC_EXTENSION:
949                         r = *(const struct usb_audio_cluster *)
950                                 &iot[id].d.eu->baSourceId[iot[id].d.eu->bNrInPins];
951                         return r;
952                 default:
953                         goto bad;
954                 }
955         }
956  bad:
957         kprintf("uaudio_get_cluster: bad data\n");
958         memset(&r, 0, sizeof r);
959         return r;
960
961 }
962
963 static void
964 uaudio_add_input(struct uaudio_softc *sc, const struct io_terminal *iot, int id)
965 {
966 #ifdef USB_DEBUG
967         const struct usb_audio_input_terminal *d = iot[id].d.it;
968
969         DPRINTFN(2,("uaudio_add_input: bTerminalId=%d wTerminalType=0x%04x "
970                     "bAssocTerminal=%d bNrChannels=%d wChannelConfig=%d "
971                     "iChannelNames=%d iTerminal=%d\n",
972                     d->bTerminalId, UGETW(d->wTerminalType), d->bAssocTerminal,
973                     d->bNrChannels, UGETW(d->wChannelConfig),
974                     d->iChannelNames, d->iTerminal));
975 #endif
976 }
977
978 static void
979 uaudio_add_output(struct uaudio_softc *sc, const struct io_terminal *iot, int id)
980 {
981 #ifdef USB_DEBUG
982         const struct usb_audio_output_terminal *d;
983
984         d = iot[id].d.ot;
985         DPRINTFN(2,("uaudio_add_output: bTerminalId=%d wTerminalType=0x%04x "
986                     "bAssocTerminal=%d bSourceId=%d iTerminal=%d\n",
987                     d->bTerminalId, UGETW(d->wTerminalType), d->bAssocTerminal,
988                     d->bSourceId, d->iTerminal));
989 #endif
990 }
991
992 static void
993 uaudio_add_mixer(struct uaudio_softc *sc, const struct io_terminal *iot, int id)
994 {
995         const struct usb_audio_mixer_unit *d = iot[id].d.mu;
996         const struct usb_audio_mixer_unit_1 *d1;
997         int c, chs, ichs, ochs, i, o, bno, p, mo, mc, k;
998         const uByte *bm;
999         struct mixerctl mix;
1000
1001         DPRINTFN(2,("uaudio_add_mixer: bUnitId=%d bNrInPins=%d\n",
1002                     d->bUnitId, d->bNrInPins));
1003
1004         /* Compute the number of input channels */
1005         ichs = 0;
1006         for (i = 0; i < d->bNrInPins; i++)
1007                 ichs += uaudio_get_cluster(d->baSourceId[i], iot).bNrChannels;
1008
1009         /* and the number of output channels */
1010         d1 = (const struct usb_audio_mixer_unit_1 *)&d->baSourceId[d->bNrInPins];
1011         ochs = d1->bNrChannels;
1012         DPRINTFN(2,("uaudio_add_mixer: ichs=%d ochs=%d\n", ichs, ochs));
1013
1014         bm = d1->bmControls;
1015         mix.wIndex = MAKE(d->bUnitId, sc->sc_ac_iface);
1016         uaudio_determine_class(&iot[id], &mix);
1017         mix.type = MIX_SIGNED_16;
1018 #if !defined(__FreeBSD__) && !defined(__DragonFly__)    /* XXXXX */
1019         mix.ctlunit = AudioNvolume;
1020 #endif
1021
1022 #define BIT(bno) ((bm[bno / 8] >> (7 - bno % 8)) & 1)
1023         for (p = i = 0; i < d->bNrInPins; i++) {
1024                 chs = uaudio_get_cluster(d->baSourceId[i], iot).bNrChannels;
1025                 mc = 0;
1026                 for (c = 0; c < chs; c++) {
1027                         mo = 0;
1028                         for (o = 0; o < ochs; o++) {
1029                                 bno = (p + c) * ochs + o;
1030                                 if (BIT(bno))
1031                                         mo++;
1032                         }
1033                         if (mo == 1)
1034                                 mc++;
1035                 }
1036                 if (mc == chs && chs <= MIX_MAX_CHAN) {
1037                         k = 0;
1038                         for (c = 0; c < chs; c++)
1039                                 for (o = 0; o < ochs; o++) {
1040                                         bno = (p + c) * ochs + o;
1041                                         if (BIT(bno))
1042                                                 mix.wValue[k++] =
1043                                                         MAKE(p+c+1, o+1);
1044                                 }
1045 #if !defined(__FreeBSD__) && !defined(__DragonFly__)
1046                         ksnprintf(mix.ctlname, sizeof(mix.ctlname), "mix%d-%s",
1047                             d->bUnitId, uaudio_id_name(sc, iot,
1048                             d->baSourceId[i]));
1049 #endif
1050                         mix.nchan = chs;
1051                         uaudio_mixer_add_ctl(sc, &mix);
1052                 } else {
1053                         /* XXX */
1054                 }
1055 #undef BIT
1056                 p += chs;
1057         }
1058
1059 }
1060
1061 static void
1062 uaudio_add_selector(struct uaudio_softc *sc, const struct io_terminal *iot, int id)
1063 {
1064         const struct usb_audio_selector_unit *d;
1065         struct mixerctl mix;
1066 #if !defined(__FreeBSD__) && !defined(__DragonFly__)
1067         int i, wp;
1068 #else
1069         int i;
1070         struct mixerctl dummy;
1071 #endif
1072
1073         d = iot[id].d.su;
1074         DPRINTFN(2,("uaudio_add_selector: bUnitId=%d bNrInPins=%d\n",
1075                     d->bUnitId, d->bNrInPins));
1076         mix.wIndex = MAKE(d->bUnitId, sc->sc_ac_iface);
1077         mix.wValue[0] = MAKE(0, 0);
1078         uaudio_determine_class(&iot[id], &mix);
1079         mix.nchan = 1;
1080         mix.type = MIX_SELECTOR;
1081 #if defined(__FreeBSD__) || defined(__DragonFly__)
1082         mix.ctl = SOUND_MIXER_NRDEVICES;        /* XXXXX */
1083         mix.minval = 1;
1084         mix.maxval = d->bNrInPins;
1085         mix.mul = mix.maxval - mix.minval;
1086         for (i = 0; i < MAX_SELECTOR_INPUT_PIN; i++) {
1087                 mix.slctrtype[i] = SOUND_MIXER_NRDEVICES;
1088         }
1089         for (i = mix.minval; i <= mix.maxval; i++) {
1090                 mix.slctrtype[i - 1] = uaudio_feature_name(&iot[d->baSourceId[i - 1]], &dummy);
1091         }
1092 #else
1093         mix.ctlunit = "";
1094         mix.minval = 1;
1095         mix.maxval = d->bNrInPins;
1096         mix.mul = mix.maxval - mix.minval;
1097         wp = ksnprintf(mix.ctlname, MAX_AUDIO_DEV_LEN, "sel%d-", d->bUnitId);
1098         for (i = 1; i <= d->bNrInPins; i++) {
1099                 wp += ksnprintf(mix.ctlname + wp, MAX_AUDIO_DEV_LEN - wp,
1100                                "i%d", d->baSourceId[i - 1]);
1101                 if (wp > MAX_AUDIO_DEV_LEN - 1)
1102                         break;
1103         }
1104 #endif
1105         uaudio_mixer_add_ctl(sc, &mix);
1106 }
1107
1108 #ifdef USB_DEBUG
1109 static const char *
1110 uaudio_get_terminal_name(int terminal_type)
1111 {
1112         static char buf[100];
1113
1114         switch (terminal_type) {
1115         /* USB terminal types */
1116         case UAT_UNDEFINED:     return "UAT_UNDEFINED";
1117         case UAT_STREAM:        return "UAT_STREAM";
1118         case UAT_VENDOR:        return "UAT_VENDOR";
1119         /* input terminal types */
1120         case UATI_UNDEFINED:    return "UATI_UNDEFINED";
1121         case UATI_MICROPHONE:   return "UATI_MICROPHONE";
1122         case UATI_DESKMICROPHONE:       return "UATI_DESKMICROPHONE";
1123         case UATI_PERSONALMICROPHONE:   return "UATI_PERSONALMICROPHONE";
1124         case UATI_OMNIMICROPHONE:       return "UATI_OMNIMICROPHONE";
1125         case UATI_MICROPHONEARRAY:      return "UATI_MICROPHONEARRAY";
1126         case UATI_PROCMICROPHONEARR:    return "UATI_PROCMICROPHONEARR";
1127         /* output terminal types */
1128         case UATO_UNDEFINED:    return "UATO_UNDEFINED";
1129         case UATO_SPEAKER:      return "UATO_SPEAKER";
1130         case UATO_HEADPHONES:   return "UATO_HEADPHONES";
1131         case UATO_DISPLAYAUDIO: return "UATO_DISPLAYAUDIO";
1132         case UATO_DESKTOPSPEAKER:       return "UATO_DESKTOPSPEAKER";
1133         case UATO_ROOMSPEAKER:  return "UATO_ROOMSPEAKER";
1134         case UATO_COMMSPEAKER:  return "UATO_COMMSPEAKER";
1135         case UATO_SUBWOOFER:    return "UATO_SUBWOOFER";
1136         /* bidir terminal types */
1137         case UATB_UNDEFINED:    return "UATB_UNDEFINED";
1138         case UATB_HANDSET:      return "UATB_HANDSET";
1139         case UATB_HEADSET:      return "UATB_HEADSET";
1140         case UATB_SPEAKERPHONE: return "UATB_SPEAKERPHONE";
1141         case UATB_SPEAKERPHONEESUP:     return "UATB_SPEAKERPHONEESUP";
1142         case UATB_SPEAKERPHONEECANC:    return "UATB_SPEAKERPHONEECANC";
1143         /* telephony terminal types */
1144         case UATT_UNDEFINED:    return "UATT_UNDEFINED";
1145         case UATT_PHONELINE:    return "UATT_PHONELINE";
1146         case UATT_TELEPHONE:    return "UATT_TELEPHONE";
1147         case UATT_DOWNLINEPHONE:        return "UATT_DOWNLINEPHONE";
1148         /* external terminal types */
1149         case UATE_UNDEFINED:    return "UATE_UNDEFINED";
1150         case UATE_ANALOGCONN:   return "UATE_ANALOGCONN";
1151         case UATE_LINECONN:     return "UATE_LINECONN";
1152         case UATE_LEGACYCONN:   return "UATE_LEGACYCONN";
1153         case UATE_DIGITALAUIFC: return "UATE_DIGITALAUIFC";
1154         case UATE_SPDIF:        return "UATE_SPDIF";
1155         case UATE_1394DA:       return "UATE_1394DA";
1156         case UATE_1394DV:       return "UATE_1394DV";
1157         /* embedded function terminal types */
1158         case UATF_UNDEFINED:    return "UATF_UNDEFINED";
1159         case UATF_CALIBNOISE:   return "UATF_CALIBNOISE";
1160         case UATF_EQUNOISE:     return "UATF_EQUNOISE";
1161         case UATF_CDPLAYER:     return "UATF_CDPLAYER";
1162         case UATF_DAT:  return "UATF_DAT";
1163         case UATF_DCC:  return "UATF_DCC";
1164         case UATF_MINIDISK:     return "UATF_MINIDISK";
1165         case UATF_ANALOGTAPE:   return "UATF_ANALOGTAPE";
1166         case UATF_PHONOGRAPH:   return "UATF_PHONOGRAPH";
1167         case UATF_VCRAUDIO:     return "UATF_VCRAUDIO";
1168         case UATF_VIDEODISCAUDIO:       return "UATF_VIDEODISCAUDIO";
1169         case UATF_DVDAUDIO:     return "UATF_DVDAUDIO";
1170         case UATF_TVTUNERAUDIO: return "UATF_TVTUNERAUDIO";
1171         case UATF_SATELLITE:    return "UATF_SATELLITE";
1172         case UATF_CABLETUNER:   return "UATF_CABLETUNER";
1173         case UATF_DSS:  return "UATF_DSS";
1174         case UATF_RADIORECV:    return "UATF_RADIORECV";
1175         case UATF_RADIOXMIT:    return "UATF_RADIOXMIT";
1176         case UATF_MULTITRACK:   return "UATF_MULTITRACK";
1177         case UATF_SYNTHESIZER:  return "UATF_SYNTHESIZER";
1178         default:
1179                 ksnprintf(buf, sizeof(buf), "unknown type (0x%.4x)", terminal_type);
1180                 return buf;
1181         }
1182 }
1183 #endif
1184
1185 static int
1186 uaudio_determine_class(const struct io_terminal *iot, struct mixerctl *mix)
1187 {
1188         int terminal_type;
1189
1190         if (iot == NULL || iot->output == NULL) {
1191                 mix->class = UAC_OUTPUT;
1192                 return 0;
1193         }
1194         terminal_type = 0;
1195         if (iot->output->size == 1)
1196                 terminal_type = iot->output->terminals[0];
1197         /*
1198          * If the only output terminal is USB,
1199          * the class is UAC_RECORD.
1200          */
1201         if ((terminal_type & 0xff00) == (UAT_UNDEFINED & 0xff00)) {
1202                 mix->class = UAC_RECORD;
1203                 if (iot->inputs_size == 1
1204                     && iot->inputs[0] != NULL
1205                     && iot->inputs[0]->size == 1)
1206                         return iot->inputs[0]->terminals[0];
1207                 else
1208                         return 0;
1209         }
1210         /*
1211          * If the ultimate destination of the unit is just one output
1212          * terminal and the unit is connected to the output terminal
1213          * directly, the class is UAC_OUTPUT.
1214          */
1215         if (terminal_type != 0 && iot->direct) {
1216                 mix->class = UAC_OUTPUT;
1217                 return terminal_type;
1218         }
1219         /*
1220          * If the unit is connected to just one input terminal,
1221          * the class is UAC_INPUT.
1222          */
1223         if (iot->inputs_size == 1 && iot->inputs[0] != NULL
1224             && iot->inputs[0]->size == 1) {
1225                 mix->class = UAC_INPUT;
1226                 return iot->inputs[0]->terminals[0];
1227         }
1228         /*
1229          * Otherwise, the class is UAC_OUTPUT.
1230          */
1231         mix->class = UAC_OUTPUT;
1232         return terminal_type;
1233 }
1234
1235 #if defined(__FreeBSD__) || defined(__DragonFly__)
1236 const int 
1237 uaudio_feature_name(const struct io_terminal *iot, struct mixerctl *mix)
1238 {
1239         int terminal_type;
1240
1241         terminal_type = uaudio_determine_class(iot, mix);
1242         if (mix->class == UAC_RECORD && terminal_type == 0)
1243                 return SOUND_MIXER_IMIX;
1244         DPRINTF(("%s: terminal_type=%s\n", __func__,
1245                  uaudio_get_terminal_name(terminal_type)));
1246         switch (terminal_type) {
1247         case UAT_STREAM:
1248                 return SOUND_MIXER_PCM;
1249
1250         case UATI_MICROPHONE:
1251         case UATI_DESKMICROPHONE:
1252         case UATI_PERSONALMICROPHONE:
1253         case UATI_OMNIMICROPHONE:
1254         case UATI_MICROPHONEARRAY:
1255         case UATI_PROCMICROPHONEARR:
1256                 return SOUND_MIXER_MIC;
1257
1258         case UATO_SPEAKER:
1259         case UATO_DESKTOPSPEAKER:
1260         case UATO_ROOMSPEAKER:
1261         case UATO_COMMSPEAKER:
1262                 return SOUND_MIXER_SPEAKER;
1263
1264         case UATE_ANALOGCONN:
1265         case UATE_LINECONN:
1266         case UATE_LEGACYCONN:
1267                 return SOUND_MIXER_LINE;
1268
1269         case UATE_DIGITALAUIFC:
1270         case UATE_SPDIF:
1271         case UATE_1394DA:
1272         case UATE_1394DV:
1273                 return SOUND_MIXER_ALTPCM;
1274
1275         case UATF_CDPLAYER:
1276                 return SOUND_MIXER_CD;
1277
1278         case UATF_SYNTHESIZER:
1279                 return SOUND_MIXER_SYNTH;
1280
1281         case UATF_VIDEODISCAUDIO:
1282         case UATF_DVDAUDIO:
1283         case UATF_TVTUNERAUDIO:
1284                 return SOUND_MIXER_VIDEO;
1285
1286 /* telephony terminal types */
1287         case UATT_UNDEFINED:
1288         case UATT_PHONELINE:
1289         case UATT_TELEPHONE:
1290         case UATT_DOWNLINEPHONE:
1291                 return SOUND_MIXER_PHONEIN;
1292 /*              return SOUND_MIXER_PHONEOUT;*/
1293
1294         case UATF_RADIORECV:
1295         case UATF_RADIOXMIT:
1296                 return SOUND_MIXER_RADIO;
1297
1298         case UAT_UNDEFINED:
1299         case UAT_VENDOR:
1300         case UATI_UNDEFINED:
1301 /* output terminal types */
1302         case UATO_UNDEFINED:
1303         case UATO_DISPLAYAUDIO:
1304         case UATO_SUBWOOFER:
1305         case UATO_HEADPHONES:
1306 /* bidir terminal types */
1307         case UATB_UNDEFINED:
1308         case UATB_HANDSET:
1309         case UATB_HEADSET:
1310         case UATB_SPEAKERPHONE:
1311         case UATB_SPEAKERPHONEESUP:
1312         case UATB_SPEAKERPHONEECANC:
1313 /* external terminal types */
1314         case UATE_UNDEFINED:
1315 /* embedded function terminal types */
1316         case UATF_UNDEFINED:
1317         case UATF_CALIBNOISE:
1318         case UATF_EQUNOISE:
1319         case UATF_DAT:
1320         case UATF_DCC:
1321         case UATF_MINIDISK:
1322         case UATF_ANALOGTAPE:
1323         case UATF_PHONOGRAPH:
1324         case UATF_VCRAUDIO:
1325         case UATF_SATELLITE:
1326         case UATF_CABLETUNER:
1327         case UATF_DSS:
1328         case UATF_MULTITRACK:
1329         case 0xffff:
1330         default:
1331                 DPRINTF(("%s: 'master' for 0x%.4x\n", __func__, terminal_type));
1332                 return SOUND_MIXER_VOLUME;
1333         }
1334         return SOUND_MIXER_VOLUME;
1335 }
1336 #else
1337 static const char *
1338 uaudio_feature_name(const struct io_terminal *iot, struct mixerctl *mix)
1339 {
1340         int terminal_type;
1341
1342         terminal_type = uaudio_determine_class(iot, mix);
1343         if (mix->class == UAC_RECORD && terminal_type == 0)
1344                 return AudioNmixerout;
1345         DPRINTF(("%s: terminal_type=%s\n", __func__,
1346                  uaudio_get_terminal_name(terminal_type)));
1347         switch (terminal_type) {
1348         case UAT_STREAM:
1349                 return AudioNdac;
1350
1351         case UATI_MICROPHONE:
1352         case UATI_DESKMICROPHONE:
1353         case UATI_PERSONALMICROPHONE:
1354         case UATI_OMNIMICROPHONE:
1355         case UATI_MICROPHONEARRAY:
1356         case UATI_PROCMICROPHONEARR:
1357                 return AudioNmicrophone;
1358
1359         case UATO_SPEAKER:
1360         case UATO_DESKTOPSPEAKER:
1361         case UATO_ROOMSPEAKER:
1362         case UATO_COMMSPEAKER:
1363                 return AudioNspeaker;
1364
1365         case UATO_HEADPHONES:
1366                 return AudioNheadphone;
1367
1368         case UATO_SUBWOOFER:
1369                 return AudioNlfe;
1370
1371         /* telephony terminal types */
1372         case UATT_UNDEFINED:
1373         case UATT_PHONELINE:
1374         case UATT_TELEPHONE:
1375         case UATT_DOWNLINEPHONE:
1376                 return "phone";
1377
1378         case UATE_ANALOGCONN:
1379         case UATE_LINECONN:
1380         case UATE_LEGACYCONN:
1381                 return AudioNline;
1382
1383         case UATE_DIGITALAUIFC:
1384         case UATE_SPDIF:
1385         case UATE_1394DA:
1386         case UATE_1394DV:
1387                 return AudioNaux;
1388
1389         case UATF_CDPLAYER:
1390                 return AudioNcd;
1391
1392         case UATF_SYNTHESIZER:
1393                 return AudioNfmsynth;
1394
1395         case UATF_VIDEODISCAUDIO:
1396         case UATF_DVDAUDIO:
1397         case UATF_TVTUNERAUDIO:
1398                 return AudioNvideo;
1399
1400         case UAT_UNDEFINED:
1401         case UAT_VENDOR:
1402         case UATI_UNDEFINED:
1403 /* output terminal types */
1404         case UATO_UNDEFINED:
1405         case UATO_DISPLAYAUDIO:
1406 /* bidir terminal types */
1407         case UATB_UNDEFINED:
1408         case UATB_HANDSET:
1409         case UATB_HEADSET:
1410         case UATB_SPEAKERPHONE:
1411         case UATB_SPEAKERPHONEESUP:
1412         case UATB_SPEAKERPHONEECANC:
1413 /* external terminal types */
1414         case UATE_UNDEFINED:
1415 /* embedded function terminal types */
1416         case UATF_UNDEFINED:
1417         case UATF_CALIBNOISE:
1418         case UATF_EQUNOISE:
1419         case UATF_DAT:
1420         case UATF_DCC:
1421         case UATF_MINIDISK:
1422         case UATF_ANALOGTAPE:
1423         case UATF_PHONOGRAPH:
1424         case UATF_VCRAUDIO:
1425         case UATF_SATELLITE:
1426         case UATF_CABLETUNER:
1427         case UATF_DSS:
1428         case UATF_RADIORECV:
1429         case UATF_RADIOXMIT:
1430         case UATF_MULTITRACK:
1431         case 0xffff:
1432         default:
1433                 DPRINTF(("%s: 'master' for 0x%.4x\n", __func__, terminal_type));
1434                 return AudioNmaster;
1435         }
1436         return AudioNmaster;
1437 }
1438 #endif
1439
1440 static void
1441 uaudio_add_feature(struct uaudio_softc *sc, const struct io_terminal *iot, int id)
1442 {
1443         const struct usb_audio_feature_unit *d;
1444         const uByte *ctls;
1445         int ctlsize;
1446         int nchan;
1447         u_int fumask, mmask, cmask;
1448         struct mixerctl mix;
1449         int chan, ctl, i, unit;
1450 #if defined(__FreeBSD__) || defined(__DragonFly__)
1451         int mixernumber;
1452 #else
1453         const char *mixername;
1454 #endif
1455
1456 #define GET(i) (ctls[(i)*ctlsize] | \
1457                 (ctlsize > 1 ? ctls[(i)*ctlsize+1] << 8 : 0))
1458         d = iot[id].d.fu;
1459         ctls = d->bmaControls;
1460         ctlsize = d->bControlSize;
1461         nchan = (d->bLength - 7) / ctlsize;
1462         mmask = GET(0);
1463         /* Figure out what we can control */
1464         for (cmask = 0, chan = 1; chan < nchan; chan++) {
1465                 DPRINTFN(9,("uaudio_add_feature: chan=%d mask=%x\n",
1466                             chan, GET(chan)));
1467                 cmask |= GET(chan);
1468         }
1469
1470 #if !defined(__FreeBSD__) && !defined(__DragonFly__)
1471         DPRINTFN(1,("uaudio_add_feature: bUnitId=%d, "
1472                     "%d channels, mmask=0x%04x, cmask=0x%04x\n",
1473                     d->bUnitId, nchan, mmask, cmask));
1474 #endif
1475
1476         if (nchan > MIX_MAX_CHAN)
1477                 nchan = MIX_MAX_CHAN;
1478         unit = d->bUnitId;
1479         mix.wIndex = MAKE(unit, sc->sc_ac_iface);
1480         for (ctl = MUTE_CONTROL; ctl < LOUDNESS_CONTROL; ctl++) {
1481                 fumask = FU_MASK(ctl);
1482                 DPRINTFN(4,("uaudio_add_feature: ctl=%d fumask=0x%04x\n",
1483                             ctl, fumask));
1484                 if (mmask & fumask) {
1485                         mix.nchan = 1;
1486                         mix.wValue[0] = MAKE(ctl, 0);
1487                 } else if (cmask & fumask) {
1488                         mix.nchan = nchan - 1;
1489                         for (i = 1; i < nchan; i++) {
1490                                 if (GET(i) & fumask)
1491                                         mix.wValue[i-1] = MAKE(ctl, i);
1492                                 else
1493                                         mix.wValue[i-1] = -1;
1494                         }
1495                 } else {
1496                         continue;
1497                 }
1498 #undef GET
1499
1500 #if defined(__FreeBSD__) || defined(__DragonFly__)
1501                 mixernumber = uaudio_feature_name(&iot[id], &mix);
1502 #else
1503                 mixername = uaudio_feature_name(&iot[id], &mix);
1504 #endif
1505                 switch (ctl) {
1506                 case MUTE_CONTROL:
1507                         mix.type = MIX_ON_OFF;
1508 #if defined(__FreeBSD__) || defined(__DragonFly__)
1509                         mix.ctl = SOUND_MIXER_NRDEVICES;
1510 #else
1511                         mix.ctlunit = "";
1512                         ksnprintf(mix.ctlname, sizeof(mix.ctlname),
1513                                  "%s.%s", mixername, AudioNmute);
1514 #endif
1515                         break;
1516                 case VOLUME_CONTROL:
1517                         mix.type = MIX_SIGNED_16;
1518 #if defined(__FreeBSD__) || defined(__DragonFly__)
1519                         mix.ctl = mixernumber;
1520 #else
1521                         mix.ctlunit = AudioNvolume;
1522                         strlcpy(mix.ctlname, mixername, sizeof(mix.ctlname));
1523 #endif
1524                         break;
1525                 case BASS_CONTROL:
1526                         mix.type = MIX_SIGNED_8;
1527 #if defined(__FreeBSD__) || defined(__DragonFly__)
1528                         mix.ctl = SOUND_MIXER_BASS;
1529 #else
1530                         mix.ctlunit = AudioNbass;
1531                         ksnprintf(mix.ctlname, sizeof(mix.ctlname),
1532                                  "%s.%s", mixername, AudioNbass);
1533 #endif
1534                         break;
1535                 case MID_CONTROL:
1536                         mix.type = MIX_SIGNED_8;
1537 #if defined(__FreeBSD__) || defined(__DragonFly__)
1538                         mix.ctl = SOUND_MIXER_NRDEVICES;        /* XXXXX */
1539 #else
1540                         mix.ctlunit = AudioNmid;
1541                         ksnprintf(mix.ctlname, sizeof(mix.ctlname),
1542                                  "%s.%s", mixername, AudioNmid);
1543 #endif
1544                         break;
1545                 case TREBLE_CONTROL:
1546                         mix.type = MIX_SIGNED_8;
1547 #if defined(__FreeBSD__) || defined(__DragonFly__)
1548                         mix.ctl = SOUND_MIXER_TREBLE;
1549 #else
1550                         mix.ctlunit = AudioNtreble;
1551                         ksnprintf(mix.ctlname, sizeof(mix.ctlname),
1552                                  "%s.%s", mixername, AudioNtreble);
1553 #endif
1554                         break;
1555                 case GRAPHIC_EQUALIZER_CONTROL:
1556                         continue; /* XXX don't add anything */
1557                         break;
1558                 case AGC_CONTROL:
1559                         mix.type = MIX_ON_OFF;
1560 #if defined(__FreeBSD__) || defined(__DragonFly__)
1561                         mix.ctl = SOUND_MIXER_NRDEVICES;        /* XXXXX */
1562 #else
1563                         mix.ctlunit = "";
1564                         ksnprintf(mix.ctlname, sizeof(mix.ctlname), "%s.%s",
1565                                  mixername, AudioNagc);
1566 #endif
1567                         break;
1568                 case DELAY_CONTROL:
1569                         mix.type = MIX_UNSIGNED_16;
1570 #if defined(__FreeBSD__) || defined(__DragonFly__)
1571                         mix.ctl = SOUND_MIXER_NRDEVICES;        /* XXXXX */
1572 #else
1573                         mix.ctlunit = "4 ms";
1574                         ksnprintf(mix.ctlname, sizeof(mix.ctlname),
1575                                  "%s.%s", mixername, AudioNdelay);
1576 #endif
1577                         break;
1578                 case BASS_BOOST_CONTROL:
1579                         mix.type = MIX_ON_OFF;
1580 #if defined(__FreeBSD__) || defined(__DragonFly__)
1581                         mix.ctl = SOUND_MIXER_NRDEVICES;        /* XXXXX */
1582 #else
1583                         mix.ctlunit = "";
1584                         ksnprintf(mix.ctlname, sizeof(mix.ctlname),
1585                                  "%s.%s", mixername, AudioNbassboost);
1586 #endif
1587                         break;
1588                 case LOUDNESS_CONTROL:
1589                         mix.type = MIX_ON_OFF;
1590 #if defined(__FreeBSD__) || defined(__DragonFly__)
1591                         mix.ctl = SOUND_MIXER_LOUD;     /* Is this correct ? */
1592 #else
1593                         mix.ctlunit = "";
1594                         ksnprintf(mix.ctlname, sizeof(mix.ctlname),
1595                                  "%s.%s", mixername, AudioNloudness);
1596 #endif
1597                         break;
1598                 }
1599                 uaudio_mixer_add_ctl(sc, &mix);
1600         }
1601 }
1602
1603 static void
1604 uaudio_add_processing_updown(struct uaudio_softc *sc,
1605                              const struct io_terminal *iot, int id)
1606 {
1607         const struct usb_audio_processing_unit *d;
1608         const struct usb_audio_processing_unit_1 *d1;
1609         const struct usb_audio_processing_unit_updown *ud;
1610         struct mixerctl mix;
1611         int i;
1612
1613         d = iot[id].d.pu;
1614         d1 = (const struct usb_audio_processing_unit_1 *)
1615                 &d->baSourceId[d->bNrInPins];
1616         ud = (const struct usb_audio_processing_unit_updown *)
1617                 &d1->bmControls[d1->bControlSize];
1618         DPRINTFN(2,("uaudio_add_processing_updown: bUnitId=%d bNrModes=%d\n",
1619                     d->bUnitId, ud->bNrModes));
1620
1621         if (!(d1->bmControls[0] & UA_PROC_MASK(UD_MODE_SELECT_CONTROL))) {
1622                 DPRINTF(("uaudio_add_processing_updown: no mode select\n"));
1623                 return;
1624         }
1625
1626         mix.wIndex = MAKE(d->bUnitId, sc->sc_ac_iface);
1627         mix.nchan = 1;
1628         mix.wValue[0] = MAKE(UD_MODE_SELECT_CONTROL, 0);
1629         uaudio_determine_class(&iot[id], &mix);
1630         mix.type = MIX_ON_OFF;  /* XXX */
1631 #if !defined(__FreeBSD__) && !defined(__DragonFly__)
1632         mix.ctlunit = "";
1633         ksnprintf(mix.ctlname, sizeof(mix.ctlname), "pro%d-mode", d->bUnitId);
1634 #endif
1635
1636         for (i = 0; i < ud->bNrModes; i++) {
1637                 DPRINTFN(2,("uaudio_add_processing_updown: i=%d bm=0x%x\n",
1638                             i, UGETW(ud->waModes[i])));
1639                 /* XXX */
1640         }
1641         uaudio_mixer_add_ctl(sc, &mix);
1642 }
1643
1644 static void
1645 uaudio_add_processing(struct uaudio_softc *sc, const struct io_terminal *iot, int id)
1646 {
1647         const struct usb_audio_processing_unit *d;
1648         const struct usb_audio_processing_unit_1 *d1;
1649         int ptype;
1650         struct mixerctl mix;
1651
1652         d = iot[id].d.pu;
1653         d1 = (const struct usb_audio_processing_unit_1 *)
1654                 &d->baSourceId[d->bNrInPins];
1655         ptype = UGETW(d->wProcessType);
1656         DPRINTFN(2,("uaudio_add_processing: wProcessType=%d bUnitId=%d "
1657                     "bNrInPins=%d\n", ptype, d->bUnitId, d->bNrInPins));
1658
1659         if (d1->bmControls[0] & UA_PROC_ENABLE_MASK) {
1660                 mix.wIndex = MAKE(d->bUnitId, sc->sc_ac_iface);
1661                 mix.nchan = 1;
1662                 mix.wValue[0] = MAKE(XX_ENABLE_CONTROL, 0);
1663                 uaudio_determine_class(&iot[id], &mix);
1664                 mix.type = MIX_ON_OFF;
1665 #if !defined(__FreeBSD__) && !defined(__DragonFly__)
1666                 mix.ctlunit = "";
1667                 ksnprintf(mix.ctlname, sizeof(mix.ctlname), "pro%d.%d-enable",
1668                     d->bUnitId, ptype);
1669 #endif
1670                 uaudio_mixer_add_ctl(sc, &mix);
1671         }
1672
1673         switch(ptype) {
1674         case UPDOWNMIX_PROCESS:
1675                 uaudio_add_processing_updown(sc, iot, id);
1676                 break;
1677         case DOLBY_PROLOGIC_PROCESS:
1678         case P3D_STEREO_EXTENDER_PROCESS:
1679         case REVERBATION_PROCESS:
1680         case CHORUS_PROCESS:
1681         case DYN_RANGE_COMP_PROCESS:
1682         default:
1683 #ifdef USB_DEBUG
1684                 kprintf("uaudio_add_processing: unit %d, type=%d not impl.\n",
1685                        d->bUnitId, ptype);
1686 #endif
1687                 break;
1688         }
1689 }
1690
1691 static void
1692 uaudio_add_extension(struct uaudio_softc *sc, const struct io_terminal *iot, int id)
1693 {
1694         const struct usb_audio_extension_unit *d;
1695         const struct usb_audio_extension_unit_1 *d1;
1696         struct mixerctl mix;
1697
1698         d = iot[id].d.eu;
1699         d1 = (const struct usb_audio_extension_unit_1 *)
1700                 &d->baSourceId[d->bNrInPins];
1701         DPRINTFN(2,("uaudio_add_extension: bUnitId=%d bNrInPins=%d\n",
1702                     d->bUnitId, d->bNrInPins));
1703
1704         if (usbd_get_quirks(sc->sc_udev)->uq_flags & UQ_AU_NO_XU)
1705                 return;
1706
1707         if (d1->bmControls[0] & UA_EXT_ENABLE_MASK) {
1708                 mix.wIndex = MAKE(d->bUnitId, sc->sc_ac_iface);
1709                 mix.nchan = 1;
1710                 mix.wValue[0] = MAKE(UA_EXT_ENABLE, 0);
1711                 uaudio_determine_class(&iot[id], &mix);
1712                 mix.type = MIX_ON_OFF;
1713 #if !defined(__FreeBSD__) && !defined(__DragonFly__)
1714                 mix.ctlunit = "";
1715                 ksnprintf(mix.ctlname, sizeof(mix.ctlname), "ext%d-enable",
1716                     d->bUnitId);
1717 #endif
1718                 uaudio_mixer_add_ctl(sc, &mix);
1719         }
1720 }
1721
1722 static struct terminal_list*
1723 uaudio_merge_terminal_list(const struct io_terminal *iot)
1724 {
1725         struct terminal_list *tml;
1726         uint16_t *ptm;
1727         int i, len;
1728
1729         len = 0;
1730         if (iot->inputs == NULL)
1731                 return NULL;
1732         for (i = 0; i < iot->inputs_size; i++) {
1733                 if (iot->inputs[i] != NULL)
1734                         len += iot->inputs[i]->size;
1735         }
1736         tml = kmalloc(TERMINAL_LIST_SIZE(len), M_TEMP, M_NOWAIT);
1737         if (tml == NULL) {
1738                 kprintf("uaudio_merge_terminal_list: no memory\n");
1739                 return NULL;
1740         }
1741         tml->size = 0;
1742         ptm = tml->terminals;
1743         for (i = 0; i < iot->inputs_size; i++) {
1744                 if (iot->inputs[i] == NULL)
1745                         continue;
1746                 if (iot->inputs[i]->size > len)
1747                         break;
1748                 memcpy(ptm, iot->inputs[i]->terminals,
1749                        iot->inputs[i]->size * sizeof(uint16_t));
1750                 tml->size += iot->inputs[i]->size;
1751                 ptm += iot->inputs[i]->size;
1752                 len -= iot->inputs[i]->size;
1753         }
1754         return tml;
1755 }
1756
1757 static struct terminal_list *
1758 uaudio_io_terminaltype(int outtype, struct io_terminal *iot, int id)
1759 {
1760         struct terminal_list *tml;
1761         struct io_terminal *it;
1762         int src_id, i;
1763
1764         it = &iot[id];
1765         if (it->output != NULL) {
1766                 /* already has outtype? */
1767                 for (i = 0; i < it->output->size; i++)
1768                         if (it->output->terminals[i] == outtype)
1769                                 return uaudio_merge_terminal_list(it);
1770                 tml = kmalloc(TERMINAL_LIST_SIZE(it->output->size + 1),
1771                              M_TEMP, M_NOWAIT);
1772                 if (tml == NULL) {
1773                         kprintf("uaudio_io_terminaltype: no memory\n");
1774                         return uaudio_merge_terminal_list(it);
1775                 }
1776                 memcpy(tml, it->output, TERMINAL_LIST_SIZE(it->output->size));
1777                 tml->terminals[it->output->size] = outtype;
1778                 tml->size++;
1779                 kfree(it->output, M_TEMP);
1780                 it->output = tml;
1781                 if (it->inputs != NULL) {
1782                         for (i = 0; i < it->inputs_size; i++)
1783                                 if (it->inputs[i] != NULL)
1784                                         kfree(it->inputs[i], M_TEMP);
1785                         kfree(it->inputs, M_TEMP);
1786                 }
1787                 it->inputs_size = 0;
1788                 it->inputs = NULL;
1789         } else {                /* end `iot[id] != NULL' */
1790                 it->inputs_size = 0;
1791                 it->inputs = NULL;
1792                 it->output = kmalloc(TERMINAL_LIST_SIZE(1), M_TEMP, M_NOWAIT);
1793                 if (it->output == NULL) {
1794                         kprintf("uaudio_io_terminaltype: no memory\n");
1795                         return NULL;
1796                 }
1797                 it->output->terminals[0] = outtype;
1798                 it->output->size = 1;
1799                 it->direct = FALSE;
1800         }
1801
1802         switch (it->d.desc->bDescriptorSubtype) {
1803         case UDESCSUB_AC_INPUT:
1804                 it->inputs = kmalloc(sizeof(struct terminal_list *), M_TEMP, M_NOWAIT);
1805                 if (it->inputs == NULL) {
1806                         kprintf("uaudio_io_terminaltype: no memory\n");
1807                         return NULL;
1808                 }
1809                 tml = kmalloc(TERMINAL_LIST_SIZE(1), M_TEMP, M_NOWAIT);
1810                 if (tml == NULL) {
1811                         kprintf("uaudio_io_terminaltype: no memory\n");
1812                         kfree(it->inputs, M_TEMP);
1813                         it->inputs = NULL;
1814                         return NULL;
1815                 }
1816                 it->inputs[0] = tml;
1817                 tml->terminals[0] = UGETW(it->d.it->wTerminalType);
1818                 tml->size = 1;
1819                 it->inputs_size = 1;
1820                 return uaudio_merge_terminal_list(it);
1821         case UDESCSUB_AC_FEATURE:
1822                 src_id = it->d.fu->bSourceId;
1823                 it->inputs = kmalloc(sizeof(struct terminal_list *), M_TEMP, M_NOWAIT);
1824                 if (it->inputs == NULL) {
1825                         kprintf("uaudio_io_terminaltype: no memory\n");
1826                         return uaudio_io_terminaltype(outtype, iot, src_id);
1827                 }
1828                 it->inputs[0] = uaudio_io_terminaltype(outtype, iot, src_id);
1829                 it->inputs_size = 1;
1830                 return uaudio_merge_terminal_list(it);
1831         case UDESCSUB_AC_OUTPUT:
1832                 it->inputs = kmalloc(sizeof(struct terminal_list *), M_TEMP, M_NOWAIT);
1833                 if (it->inputs == NULL) {
1834                         kprintf("uaudio_io_terminaltype: no memory\n");
1835                         return NULL;
1836                 }
1837                 src_id = it->d.ot->bSourceId;
1838                 it->inputs[0] = uaudio_io_terminaltype(outtype, iot, src_id);
1839                 it->inputs_size = 1;
1840                 iot[src_id].direct = TRUE;
1841                 return NULL;
1842         case UDESCSUB_AC_MIXER:
1843                 it->inputs_size = 0;
1844                 it->inputs = kmalloc(sizeof(struct terminal_list *)
1845                                     * it->d.mu->bNrInPins, M_TEMP, M_NOWAIT);
1846                 if (it->inputs == NULL) {
1847                         kprintf("uaudio_io_terminaltype: no memory\n");
1848                         return NULL;
1849                 }
1850                 for (i = 0; i < it->d.mu->bNrInPins; i++) {
1851                         src_id = it->d.mu->baSourceId[i];
1852                         it->inputs[i] = uaudio_io_terminaltype(outtype, iot,
1853                                                                src_id);
1854                         it->inputs_size++;
1855                 }
1856                 return uaudio_merge_terminal_list(it);
1857         case UDESCSUB_AC_SELECTOR:
1858                 it->inputs_size = 0;
1859                 it->inputs = kmalloc(sizeof(struct terminal_list *)
1860                                     * it->d.su->bNrInPins, M_TEMP, M_NOWAIT);
1861                 if (it->inputs == NULL) {
1862                         kprintf("uaudio_io_terminaltype: no memory\n");
1863                         return NULL;
1864                 }
1865                 for (i = 0; i < it->d.su->bNrInPins; i++) {
1866                         src_id = it->d.su->baSourceId[i];
1867                         it->inputs[i] = uaudio_io_terminaltype(outtype, iot,
1868                                                                src_id);
1869                         it->inputs_size++;
1870                 }
1871                 return uaudio_merge_terminal_list(it);
1872         case UDESCSUB_AC_PROCESSING:
1873                 it->inputs_size = 0;
1874                 it->inputs = kmalloc(sizeof(struct terminal_list *)
1875                                     * it->d.pu->bNrInPins, M_TEMP, M_NOWAIT);
1876                 if (it->inputs == NULL) {
1877                         kprintf("uaudio_io_terminaltype: no memory\n");
1878                         return NULL;
1879                 }
1880                 for (i = 0; i < it->d.pu->bNrInPins; i++) {
1881                         src_id = it->d.pu->baSourceId[i];
1882                         it->inputs[i] = uaudio_io_terminaltype(outtype, iot,
1883                                                                src_id);
1884                         it->inputs_size++;
1885                 }
1886                 return uaudio_merge_terminal_list(it);
1887         case UDESCSUB_AC_EXTENSION:
1888                 it->inputs_size = 0;
1889                 it->inputs = kmalloc(sizeof(struct terminal_list *)
1890                                     * it->d.eu->bNrInPins, M_TEMP, M_NOWAIT);
1891                 if (it->inputs == NULL) {
1892                         kprintf("uaudio_io_terminaltype: no memory\n");
1893                         return NULL;
1894                 }
1895                 for (i = 0; i < it->d.eu->bNrInPins; i++) {
1896                         src_id = it->d.eu->baSourceId[i];
1897                         it->inputs[i] = uaudio_io_terminaltype(outtype, iot,
1898                                                                src_id);
1899                         it->inputs_size++;
1900                 }
1901                 return uaudio_merge_terminal_list(it);
1902         case UDESCSUB_AC_HEADER:
1903         default:
1904                 return NULL;
1905         }
1906 }
1907
1908 static usbd_status
1909 uaudio_identify(struct uaudio_softc *sc, const usb_config_descriptor_t *cdesc)
1910 {
1911         usbd_status err;
1912
1913         err = uaudio_identify_ac(sc, cdesc);
1914         if (err)
1915                 return err;
1916         return uaudio_identify_as(sc, cdesc);
1917 }
1918
1919 static void
1920 uaudio_add_alt(struct uaudio_softc *sc, const struct as_info *ai)
1921 {
1922         size_t len;
1923         struct as_info *nai;
1924
1925         len = sizeof(*ai) * (sc->sc_nalts + 1);
1926         nai = kmalloc(len, M_USBDEV, M_NOWAIT);
1927         if (nai == NULL) {
1928                 kprintf("uaudio_add_alt: no memory\n");
1929                 return;
1930         }
1931         /* Copy old data, if there was any */
1932         if (sc->sc_nalts != 0) {
1933                 memcpy(nai, sc->sc_alts, sizeof(*ai) * (sc->sc_nalts));
1934                 kfree(sc->sc_alts, M_USBDEV);
1935         }
1936         sc->sc_alts = nai;
1937         DPRINTFN(2,("uaudio_add_alt: adding alt=%d, enc=%d\n",
1938                     ai->alt, ai->encoding));
1939         sc->sc_alts[sc->sc_nalts++] = *ai;
1940 }
1941
1942 static usbd_status
1943 uaudio_process_as(struct uaudio_softc *sc, const char *buf, int *offsp,
1944                   int size, const usb_interface_descriptor_t *id)
1945 #define offs (*offsp)
1946 {
1947         const struct usb_audio_streaming_interface_descriptor *asid;
1948         const struct usb_audio_streaming_type1_descriptor *asf1d;
1949         const usb_endpoint_descriptor_audio_t *ed;
1950         const usb_endpoint_descriptor_audio_t *epdesc1;
1951         const struct usb_audio_streaming_endpoint_descriptor *sed;
1952         int format, chan, prec, enc;
1953         int dir, type, sync;
1954         struct as_info ai;
1955         const char *format_str;
1956
1957         asid = (const void *)(buf + offs);
1958
1959         if (asid->bDescriptorType != UDESC_CS_INTERFACE ||
1960             asid->bDescriptorSubtype != AS_GENERAL)
1961                 return USBD_INVAL;
1962         DPRINTF(("uaudio_process_as: asid: bTerminakLink=%d wFormatTag=%d\n",
1963                  asid->bTerminalLink, UGETW(asid->wFormatTag)));
1964         offs += asid->bLength;
1965         if (offs > size)
1966                 return USBD_INVAL;
1967
1968         asf1d = (const void *)(buf + offs);
1969         if (asf1d->bDescriptorType != UDESC_CS_INTERFACE ||
1970             asf1d->bDescriptorSubtype != FORMAT_TYPE)
1971                 return USBD_INVAL;
1972         offs += asf1d->bLength;
1973         if (offs > size)
1974                 return USBD_INVAL;
1975
1976         if (asf1d->bFormatType != FORMAT_TYPE_I) {
1977                 kprintf("%s: ignored setting with type %d format\n",
1978                        device_get_nameunit(sc->sc_dev), UGETW(asid->wFormatTag));
1979                 return USBD_NORMAL_COMPLETION;
1980         }
1981
1982         ed = (const void *)(buf + offs);
1983         if (ed->bDescriptorType != UDESC_ENDPOINT)
1984                 return USBD_INVAL;
1985         DPRINTF(("uaudio_process_as: endpoint[0] bLength=%d bDescriptorType=%d "
1986                  "bEndpointAddress=%d bmAttributes=0x%x wMaxPacketSize=%d "
1987                  "bInterval=%d bRefresh=%d bSynchAddress=%d\n",
1988                  ed->bLength, ed->bDescriptorType, ed->bEndpointAddress,
1989                  ed->bmAttributes, UGETW(ed->wMaxPacketSize),
1990                  ed->bInterval, ed->bRefresh, ed->bSynchAddress));
1991         offs += ed->bLength;
1992         if (offs > size)
1993                 return USBD_INVAL;
1994         if (UE_GET_XFERTYPE(ed->bmAttributes) != UE_ISOCHRONOUS)
1995                 return USBD_INVAL;
1996
1997         dir = UE_GET_DIR(ed->bEndpointAddress);
1998         type = UE_GET_ISO_TYPE(ed->bmAttributes);
1999         if ((usbd_get_quirks(sc->sc_udev)->uq_flags & UQ_AU_INP_ASYNC) &&
2000             dir == UE_DIR_IN && type == UE_ISO_ADAPT)
2001                 type = UE_ISO_ASYNC;
2002
2003         /* We can't handle endpoints that need a sync pipe yet. */
2004         sync = FALSE;
2005         if (dir == UE_DIR_IN && type == UE_ISO_ADAPT) {
2006                 sync = TRUE;
2007 #ifndef UAUDIO_MULTIPLE_ENDPOINTS
2008                 kprintf("%s: ignored input endpoint of type adaptive\n",
2009                        device_get_nameunit(sc->sc_dev));
2010                 return USBD_NORMAL_COMPLETION;
2011 #endif
2012         }
2013         if (dir != UE_DIR_IN && type == UE_ISO_ASYNC) {
2014                 sync = TRUE;
2015 #ifndef UAUDIO_MULTIPLE_ENDPOINTS
2016                 kprintf("%s: ignored output endpoint of type async\n",
2017                        device_get_nameunit(sc->sc_dev));
2018                 return USBD_NORMAL_COMPLETION;
2019 #endif
2020         }
2021
2022         sed = (const void *)(buf + offs);
2023         if (sed->bDescriptorType != UDESC_CS_ENDPOINT ||
2024             sed->bDescriptorSubtype != AS_GENERAL)
2025                 return USBD_INVAL;
2026         DPRINTF((" streadming_endpoint: offset=%d bLength=%d\n", offs, sed->bLength));
2027         offs += sed->bLength;
2028         if (offs > size)
2029                 return USBD_INVAL;
2030
2031         if (sync && id->bNumEndpoints <= 1) {
2032                 kprintf("%s: a sync-pipe endpoint but no other endpoint\n",
2033                        device_get_nameunit(sc->sc_dev));
2034                 return USBD_INVAL;
2035         }
2036         if (!sync && id->bNumEndpoints > 1) {
2037                 kprintf("%s: non sync-pipe endpoint but multiple endpoints\n",
2038                        device_get_nameunit(sc->sc_dev));
2039                 return USBD_INVAL;
2040         }
2041         epdesc1 = NULL;
2042         if (id->bNumEndpoints > 1) {
2043                 epdesc1 = (const void*)(buf + offs);
2044                 if (epdesc1->bDescriptorType != UDESC_ENDPOINT)
2045                         return USBD_INVAL;
2046                 DPRINTF(("uaudio_process_as: endpoint[1] bLength=%d "
2047                          "bDescriptorType=%d bEndpointAddress=%d "
2048                          "bmAttributes=0x%x wMaxPacketSize=%d bInterval=%d "
2049                          "bRefresh=%d bSynchAddress=%d\n",
2050                          epdesc1->bLength, epdesc1->bDescriptorType,
2051                          epdesc1->bEndpointAddress, epdesc1->bmAttributes,
2052                          UGETW(epdesc1->wMaxPacketSize), epdesc1->bInterval,
2053                          epdesc1->bRefresh, epdesc1->bSynchAddress));
2054                 offs += epdesc1->bLength;
2055                 if (offs > size)
2056                         return USBD_INVAL;
2057                 if (epdesc1->bSynchAddress != 0) {
2058                         kprintf("%s: invalid endpoint: bSynchAddress=0\n",
2059                                device_get_nameunit(sc->sc_dev));
2060                         return USBD_INVAL;
2061                 }
2062                 if (UE_GET_XFERTYPE(epdesc1->bmAttributes) != UE_ISOCHRONOUS) {
2063                         kprintf("%s: invalid endpoint: bmAttributes=0x%x\n",
2064                                device_get_nameunit(sc->sc_dev), epdesc1->bmAttributes);
2065                         return USBD_INVAL;
2066                 }
2067                 if (epdesc1->bEndpointAddress != ed->bSynchAddress) {
2068                         kprintf("%s: invalid endpoint addresses: "
2069                                "ep[0]->bSynchAddress=0x%x "
2070                                "ep[1]->bEndpointAddress=0x%x\n",
2071                                device_get_nameunit(sc->sc_dev), ed->bSynchAddress,
2072                                epdesc1->bEndpointAddress);
2073                         return USBD_INVAL;
2074                 }
2075                 /* UE_GET_ADDR(epdesc1->bEndpointAddress), and epdesc1->bRefresh */
2076         }
2077
2078         format = UGETW(asid->wFormatTag);
2079         chan = asf1d->bNrChannels;
2080         prec = asf1d->bBitResolution;
2081         if (prec != 8 && prec != 16 && prec != 24 && prec != 32) {
2082                 kprintf("%s: ignored setting with precision %d\n",
2083                        device_get_nameunit(sc->sc_dev), prec);
2084                 return USBD_NORMAL_COMPLETION;
2085         }
2086         switch (format) {
2087         case UA_FMT_PCM:
2088                 if (prec == 8) {
2089                         sc->sc_altflags |= HAS_8;
2090                 } else if (prec == 16) {
2091                         sc->sc_altflags |= HAS_16;
2092                 } else if (prec == 24) {
2093                         sc->sc_altflags |= HAS_24;
2094                 } else if (prec == 32) {
2095                         sc->sc_altflags |= HAS_32;
2096                 }
2097                 enc = AUDIO_ENCODING_SLINEAR_LE;
2098                 format_str = "pcm";
2099                 break;
2100         case UA_FMT_PCM8:
2101                 enc = AUDIO_ENCODING_ULINEAR_LE;
2102                 sc->sc_altflags |= HAS_8U;
2103                 format_str = "pcm8";
2104                 break;
2105         case UA_FMT_ALAW:
2106                 enc = AUDIO_ENCODING_ALAW;
2107                 sc->sc_altflags |= HAS_ALAW;
2108                 format_str = "alaw";
2109                 break;
2110         case UA_FMT_MULAW:
2111                 enc = AUDIO_ENCODING_ULAW;
2112                 sc->sc_altflags |= HAS_MULAW;
2113                 format_str = "mulaw";
2114                 break;
2115         case UA_FMT_IEEE_FLOAT:
2116         default:
2117                 kprintf("%s: ignored setting with format %d\n",
2118                        device_get_nameunit(sc->sc_dev), format);
2119                 return USBD_NORMAL_COMPLETION;
2120         }
2121 #ifdef USB_DEBUG
2122         kprintf("%s: %s: %dch, %d/%dbit, %s,", device_get_nameunit(sc->sc_dev),
2123                dir == UE_DIR_IN ? "recording" : "playback",
2124                chan, prec, asf1d->bSubFrameSize * 8, format_str);
2125         if (asf1d->bSamFreqType == UA_SAMP_CONTNUOUS) {
2126                 kprintf(" %d-%dHz\n", UA_SAMP_LO(asf1d), UA_SAMP_HI(asf1d));
2127         } else {
2128                 int r;
2129                 kprintf(" %d", UA_GETSAMP(asf1d, 0));
2130                 for (r = 1; r < asf1d->bSamFreqType; r++)
2131                         kprintf(",%d", UA_GETSAMP(asf1d, r));
2132                 kprintf("Hz\n");
2133         }
2134 #endif
2135 #if defined(__FreeBSD__) || defined(__DragonFly__)
2136         if (sc->uaudio_sndstat_flag != 0) {
2137                 sbuf_printf(&(sc->uaudio_sndstat), "\n\t");
2138                 sbuf_printf(&(sc->uaudio_sndstat), 
2139                     "mode %d:(%s) %dch, %d/%dbit, %s,", 
2140                     id->bAlternateSetting,
2141                     dir == UE_DIR_IN ? "input" : "output",
2142                     chan, prec, asf1d->bSubFrameSize * 8, format_str);
2143                 if (asf1d->bSamFreqType == UA_SAMP_CONTNUOUS) {
2144                         sbuf_printf(&(sc->uaudio_sndstat), " %d-%dHz", 
2145                             UA_SAMP_LO(asf1d), UA_SAMP_HI(asf1d));
2146                 } else {
2147                         int r;
2148                         sbuf_printf(&(sc->uaudio_sndstat), 
2149                             " %d", UA_GETSAMP(asf1d, 0));
2150                         for (r = 1; r < asf1d->bSamFreqType; r++)
2151                                 sbuf_printf(&(sc->uaudio_sndstat), 
2152                                     ",%d", UA_GETSAMP(asf1d, r));
2153                         sbuf_printf(&(sc->uaudio_sndstat), "Hz");
2154                 }
2155         }
2156 #endif
2157         ai.alt = id->bAlternateSetting;
2158         ai.encoding = enc;
2159         ai.attributes = sed->bmAttributes;
2160         ai.idesc = id;
2161         ai.edesc = ed;
2162         ai.edesc1 = epdesc1;
2163         ai.asf1desc = asf1d;
2164         ai.sc_busy = 0;
2165         uaudio_add_alt(sc, &ai);
2166 #ifdef USB_DEBUG
2167         if (ai.attributes & UA_SED_FREQ_CONTROL)
2168                 DPRINTFN(1, ("uaudio_process_as:  FREQ_CONTROL\n"));
2169         if (ai.attributes & UA_SED_PITCH_CONTROL)
2170                 DPRINTFN(1, ("uaudio_process_as:  PITCH_CONTROL\n"));
2171 #endif
2172         sc->sc_mode |= (dir == UE_DIR_OUT) ? AUMODE_PLAY : AUMODE_RECORD;
2173
2174         return USBD_NORMAL_COMPLETION;
2175 }
2176 #undef offs
2177
2178 static usbd_status
2179 uaudio_identify_as(struct uaudio_softc *sc,
2180                    const usb_config_descriptor_t *cdesc)
2181 {
2182         const usb_interface_descriptor_t *id;
2183         const char *buf;
2184         int size, offs;
2185
2186         size = UGETW(cdesc->wTotalLength);
2187         buf = (const char *)cdesc;
2188
2189         /* Locate the AudioStreaming interface descriptor. */
2190         offs = 0;
2191         id = uaudio_find_iface(buf, size, &offs, UISUBCLASS_AUDIOSTREAM);
2192         if (id == NULL)
2193                 return USBD_INVAL;
2194
2195 #if defined(__FreeBSD__) || defined(__DragonFly__)
2196         sc->uaudio_sndstat_flag = 0;
2197         if (sbuf_new(&(sc->uaudio_sndstat), NULL, 4096, SBUF_AUTOEXTEND) != NULL)
2198                 sc->uaudio_sndstat_flag = 1;
2199 #endif
2200         /* Loop through all the alternate settings. */
2201         while (offs <= size) {
2202                 DPRINTFN(2, ("uaudio_identify: interface=%d offset=%d\n",
2203                     id->bInterfaceNumber, offs));
2204                 switch (id->bNumEndpoints) {
2205                 case 0:
2206                         DPRINTFN(2, ("uaudio_identify: AS null alt=%d\n",
2207                                      id->bAlternateSetting));
2208                         sc->sc_nullalt = id->bAlternateSetting;
2209                         break;
2210                 case 1:
2211 #ifdef UAUDIO_MULTIPLE_ENDPOINTS
2212                 case 2:
2213 #endif
2214                         uaudio_process_as(sc, buf, &offs, size, id);
2215                         break;
2216                 default:
2217                         kprintf("%s: ignored audio interface with %d "
2218                                "endpoints\n",
2219                                device_get_nameunit(sc->sc_dev), id->bNumEndpoints);
2220                         break;
2221                 }
2222                 id = uaudio_find_iface(buf, size, &offs,UISUBCLASS_AUDIOSTREAM);
2223                 if (id == NULL)
2224                         break;
2225         }
2226 #if defined(__FreeBSD__) || defined(__DragonFly__)
2227         sbuf_finish(&(sc->uaudio_sndstat));
2228 #endif
2229         if (offs > size)
2230                 return USBD_INVAL;
2231         DPRINTF(("uaudio_identify_as: %d alts available\n", sc->sc_nalts));
2232
2233         if (sc->sc_mode == 0) {
2234                 kprintf("%s: no usable endpoint found\n",
2235                        device_get_nameunit(sc->sc_dev));
2236                 return USBD_INVAL;
2237         }
2238
2239         return USBD_NORMAL_COMPLETION;
2240 }
2241
2242 static usbd_status
2243 uaudio_identify_ac(struct uaudio_softc *sc, const usb_config_descriptor_t *cdesc)
2244 {
2245         struct io_terminal* iot;
2246         const usb_interface_descriptor_t *id;
2247         const struct usb_audio_control_descriptor *acdp;
2248         const usb_descriptor_t *dp;
2249         const struct usb_audio_output_terminal *pot;
2250         struct terminal_list *tml;
2251         const char *buf, *ibuf, *ibufend;
2252         int size, offs, aclen, ndps, i, j;
2253
2254         size = UGETW(cdesc->wTotalLength);
2255         buf = (const char *)cdesc;
2256
2257         /* Locate the AudioControl interface descriptor. */
2258         offs = 0;
2259         id = uaudio_find_iface(buf, size, &offs, UISUBCLASS_AUDIOCONTROL);
2260         if (id == NULL)
2261                 return USBD_INVAL;
2262         if (offs + sizeof *acdp > size)
2263                 return USBD_INVAL;
2264         sc->sc_ac_iface = id->bInterfaceNumber;
2265         DPRINTFN(2,("uaudio_identify_ac: AC interface is %d\n", sc->sc_ac_iface));
2266
2267         /* A class-specific AC interface header should follow. */
2268         ibuf = buf + offs;
2269         acdp = (const struct usb_audio_control_descriptor *)ibuf;
2270         if (acdp->bDescriptorType != UDESC_CS_INTERFACE ||
2271             acdp->bDescriptorSubtype != UDESCSUB_AC_HEADER)
2272                 return USBD_INVAL;
2273         aclen = UGETW(acdp->wTotalLength);
2274         if (offs + aclen > size)
2275                 return USBD_INVAL;
2276
2277         if (!(usbd_get_quirks(sc->sc_udev)->uq_flags & UQ_BAD_ADC) &&
2278              UGETW(acdp->bcdADC) != UAUDIO_VERSION)
2279                 return USBD_INVAL;
2280
2281         sc->sc_audio_rev = UGETW(acdp->bcdADC);
2282         DPRINTFN(2,("uaudio_identify_ac: found AC header, vers=%03x, len=%d\n",
2283                  sc->sc_audio_rev, aclen));
2284
2285         sc->sc_nullalt = -1;
2286
2287         /* Scan through all the AC specific descriptors */
2288         ibufend = ibuf + aclen;
2289         dp = (const usb_descriptor_t *)ibuf;
2290         ndps = 0;
2291         iot = kmalloc(sizeof(struct io_terminal) * 256, M_TEMP, M_NOWAIT | M_ZERO);
2292         if (iot == NULL) {
2293                 kprintf("%s: no memory\n", __func__);
2294                 return USBD_NOMEM;
2295         }
2296         for (;;) {
2297                 ibuf += dp->bLength;
2298                 if (ibuf >= ibufend)
2299                         break;
2300                 dp = (const usb_descriptor_t *)ibuf;
2301                 if (ibuf + dp->bLength > ibufend) {
2302                         kfree(iot, M_TEMP);
2303                         return USBD_INVAL;
2304                 }
2305                 if (dp->bDescriptorType != UDESC_CS_INTERFACE) {
2306                         kprintf("uaudio_identify_ac: skip desc type=0x%02x\n",
2307                                dp->bDescriptorType);
2308                         continue;
2309                 }
2310                 i = ((const struct usb_audio_input_terminal *)dp)->bTerminalId;
2311                 iot[i].d.desc = dp;
2312                 if (i > ndps)
2313                         ndps = i;
2314         }
2315         ndps++;
2316
2317         /* construct io_terminal */
2318         for (i = 0; i < ndps; i++) {
2319                 dp = iot[i].d.desc;
2320                 if (dp == NULL)
2321                         continue;
2322                 if (dp->bDescriptorSubtype != UDESCSUB_AC_OUTPUT)
2323                         continue;
2324                 pot = iot[i].d.ot;
2325                 tml = uaudio_io_terminaltype(UGETW(pot->wTerminalType), iot, i);
2326                 if (tml != NULL)
2327                         kfree(tml, M_TEMP);
2328         }
2329
2330 #ifdef USB_DEBUG
2331         for (i = 0; i < 256; i++) {
2332                 struct usb_audio_cluster cluster;
2333
2334                 if (iot[i].d.desc == NULL)
2335                         continue;
2336                 kprintf("id %d:\t", i);
2337                 switch (iot[i].d.desc->bDescriptorSubtype) {
2338                 case UDESCSUB_AC_INPUT:
2339                         kprintf("AC_INPUT type=%s\n", uaudio_get_terminal_name
2340                                   (UGETW(iot[i].d.it->wTerminalType)));
2341                         kprintf("\t");
2342                         cluster = uaudio_get_cluster(i, iot);
2343                         uaudio_dump_cluster(&cluster);
2344                         kprintf("\n");
2345                         break;
2346                 case UDESCSUB_AC_OUTPUT:
2347                         kprintf("AC_OUTPUT type=%s ", uaudio_get_terminal_name
2348                                   (UGETW(iot[i].d.ot->wTerminalType)));
2349                         kprintf("src=%d\n", iot[i].d.ot->bSourceId);
2350                         break;
2351                 case UDESCSUB_AC_MIXER:
2352                         kprintf("AC_MIXER src=");
2353                         for (j = 0; j < iot[i].d.mu->bNrInPins; j++)
2354                                 kprintf("%d ", iot[i].d.mu->baSourceId[j]);
2355                         kprintf("\n\t");
2356                         cluster = uaudio_get_cluster(i, iot);
2357                         uaudio_dump_cluster(&cluster);
2358                         kprintf("\n");
2359                         break;
2360                 case UDESCSUB_AC_SELECTOR:
2361                         kprintf("AC_SELECTOR src=");
2362                         for (j = 0; j < iot[i].d.su->bNrInPins; j++)
2363                                 kprintf("%d ", iot[i].d.su->baSourceId[j]);
2364                         kprintf("\n");
2365                         break;
2366                 case UDESCSUB_AC_FEATURE:
2367                         kprintf("AC_FEATURE src=%d\n", iot[i].d.fu->bSourceId);
2368                         break;
2369                 case UDESCSUB_AC_PROCESSING:
2370                         kprintf("AC_PROCESSING src=");
2371                         for (j = 0; j < iot[i].d.pu->bNrInPins; j++)
2372                                 kprintf("%d ", iot[i].d.pu->baSourceId[j]);
2373                         kprintf("\n\t");
2374                         cluster = uaudio_get_cluster(i, iot);
2375                         uaudio_dump_cluster(&cluster);
2376                         kprintf("\n");
2377                         break;
2378                 case UDESCSUB_AC_EXTENSION:
2379                         kprintf("AC_EXTENSION src=");
2380                         for (j = 0; j < iot[i].d.eu->bNrInPins; j++)
2381                                 kprintf("%d ", iot[i].d.eu->baSourceId[j]);
2382                         kprintf("\n\t");
2383                         cluster = uaudio_get_cluster(i, iot);
2384                         uaudio_dump_cluster(&cluster);
2385                         kprintf("\n");
2386                         break;
2387                 default:
2388                         kprintf("unknown audio control (subtype=%d)\n",
2389                                   iot[i].d.desc->bDescriptorSubtype);
2390                 }
2391                 for (j = 0; j < iot[i].inputs_size; j++) {
2392                         int k;
2393                         kprintf("\tinput%d: ", j);
2394                         tml = iot[i].inputs[j];
2395                         if (tml == NULL) {
2396                                 kprintf("NULL\n");
2397                                 continue;
2398                         }
2399                         for (k = 0; k < tml->size; k++)
2400                                 kprintf("%s ", uaudio_get_terminal_name
2401                                           (tml->terminals[k]));
2402                         kprintf("\n");
2403                 }
2404                 kprintf("\toutput: ");
2405                 tml = iot[i].output;
2406                 for (j = 0; j < tml->size; j++)
2407                         kprintf("%s ", uaudio_get_terminal_name(tml->terminals[j]));
2408                 kprintf("\n");
2409         }
2410 #endif
2411
2412         for (i = 0; i < ndps; i++) {
2413                 dp = iot[i].d.desc;
2414                 if (dp == NULL)
2415                         continue;
2416                 DPRINTF(("uaudio_identify_ac: id=%d subtype=%d\n",
2417                          i, dp->bDescriptorSubtype));
2418                 switch (dp->bDescriptorSubtype) {
2419                 case UDESCSUB_AC_HEADER:
2420                         kprintf("uaudio_identify_ac: unexpected AC header\n");
2421                         break;
2422                 case UDESCSUB_AC_INPUT:
2423                         uaudio_add_input(sc, iot, i);
2424                         break;
2425                 case UDESCSUB_AC_OUTPUT:
2426                         uaudio_add_output(sc, iot, i);
2427                         break;
2428                 case UDESCSUB_AC_MIXER:
2429                         uaudio_add_mixer(sc, iot, i);
2430                         break;
2431                 case UDESCSUB_AC_SELECTOR:
2432                         uaudio_add_selector(sc, iot, i);
2433                         break;
2434                 case UDESCSUB_AC_FEATURE:
2435                         uaudio_add_feature(sc, iot, i);
2436                         break;
2437                 case UDESCSUB_AC_PROCESSING:
2438                         uaudio_add_processing(sc, iot, i);
2439                         break;
2440                 case UDESCSUB_AC_EXTENSION:
2441                         uaudio_add_extension(sc, iot, i);
2442                         break;
2443                 default:
2444                         kprintf("uaudio_identify_ac: bad AC desc subtype=0x%02x\n",
2445                                dp->bDescriptorSubtype);
2446                         break;
2447                 }
2448         }
2449
2450         /* delete io_terminal */
2451         for (i = 0; i < 256; i++) {
2452                 if (iot[i].d.desc == NULL)
2453                         continue;
2454                 if (iot[i].inputs != NULL) {
2455                         for (j = 0; j < iot[i].inputs_size; j++) {
2456                                 if (iot[i].inputs[j] != NULL)
2457                                         kfree(iot[i].inputs[j], M_TEMP);
2458                         }
2459                         kfree(iot[i].inputs, M_TEMP);
2460                 }
2461                 if (iot[i].output != NULL)
2462                         kfree(iot[i].output, M_TEMP);
2463                 iot[i].d.desc = NULL;
2464         }
2465         kfree(iot, M_TEMP);
2466
2467         return USBD_NORMAL_COMPLETION;
2468 }
2469
2470 #if defined(__NetBSD__) || defined(__OpenBSD__)
2471 static int
2472 uaudio_query_devinfo(void *addr, mixer_devinfo_t *mi)
2473 {
2474         struct uaudio_softc *sc;
2475         struct mixerctl *mc;
2476         int n, nctls, i;
2477
2478         sc = addr;
2479         DPRINTFN(2,("uaudio_query_devinfo: index=%d\n", mi->index));
2480         if (sc->sc_dying)
2481                 return EIO;
2482
2483         n = mi->index;
2484         nctls = sc->sc_nctls;
2485
2486         switch (n) {
2487         case UAC_OUTPUT:
2488                 mi->type = AUDIO_MIXER_CLASS;
2489                 mi->mixer_class = UAC_OUTPUT;
2490                 mi->next = mi->prev = AUDIO_MIXER_LAST;
2491                 strlcpy(mi->label.name, AudioCoutputs, sizeof(mi->label.name));
2492                 return 0;
2493         case UAC_INPUT:
2494                 mi->type = AUDIO_MIXER_CLASS;
2495                 mi->mixer_class = UAC_INPUT;
2496                 mi->next = mi->prev = AUDIO_MIXER_LAST;
2497                 strlcpy(mi->label.name, AudioCinputs, sizeof(mi->label.name));
2498                 return 0;
2499         case UAC_EQUAL:
2500                 mi->type = AUDIO_MIXER_CLASS;
2501                 mi->mixer_class = UAC_EQUAL;
2502                 mi->next = mi->prev = AUDIO_MIXER_LAST;
2503                 strlcpy(mi->label.name, AudioCequalization,
2504                     sizeof(mi->label.name));
2505                 return 0;
2506         case UAC_RECORD:
2507                 mi->type = AUDIO_MIXER_CLASS;
2508                 mi->mixer_class = UAC_RECORD;
2509                 mi->next = mi->prev = AUDIO_MIXER_LAST;
2510                 strlcpy(mi->label.name, AudioCrecord, sizeof(mi->label.name));
2511                 return 0;
2512         default:
2513                 break;
2514         }
2515
2516         n -= UAC_NCLASSES;
2517         if (n < 0 || n >= nctls)
2518                 return ENXIO;
2519
2520         mc = &sc->sc_ctls[n];
2521         strlcpy(mi->label.name, mc->ctlname, sizeof(mi->label.name));
2522         mi->mixer_class = mc->class;
2523         mi->next = mi->prev = AUDIO_MIXER_LAST; /* XXX */
2524         switch (mc->type) {
2525         case MIX_ON_OFF:
2526                 mi->type = AUDIO_MIXER_ENUM;
2527                 mi->un.e.num_mem = 2;
2528                 strlcpy(mi->un.e.member[0].label.name, AudioNoff,
2529                     sizeof(mi->un.e.member[0].label.name));
2530                 mi->un.e.member[0].ord = 0;
2531                 strlcpy(mi->un.e.member[1].label.name, AudioNon,
2532                     sizeof(mi->un.e.member[1].label.name));
2533                 mi->un.e.member[1].ord = 1;
2534                 break;
2535         case MIX_SELECTOR:
2536                 mi->type = AUDIO_MIXER_ENUM;
2537                 mi->un.e.num_mem = mc->maxval - mc->minval + 1;
2538                 for (i = 0; i <= mc->maxval - mc->minval; i++) {
2539                         ksnprintf(mi->un.e.member[i].label.name,
2540                                  sizeof(mi->un.e.member[i].label.name),
2541                                  "%d", i + mc->minval);
2542                         mi->un.e.member[i].ord = i + mc->minval;
2543                 }
2544                 break;
2545         default:
2546                 mi->type = AUDIO_MIXER_VALUE;
2547                 strncpy(mi->un.v.units.name, mc->ctlunit, MAX_AUDIO_DEV_LEN);
2548                 mi->un.v.num_channels = mc->nchan;
2549                 mi->un.v.delta = mc->delta;
2550                 break;
2551         }
2552         return 0;
2553 }
2554
2555 static int
2556 uaudio_open(void *addr, int flags)
2557 {
2558         struct uaudio_softc *sc;
2559
2560         sc = addr;
2561         DPRINTF(("uaudio_open: sc=%p\n", sc));
2562         if (sc->sc_dying)
2563                 return EIO;
2564
2565         if ((flags & FWRITE) && !(sc->sc_mode & AUMODE_PLAY))
2566                 return EACCES;
2567         if ((flags & FREAD) && !(sc->sc_mode & AUMODE_RECORD))
2568                 return EACCES;
2569
2570         return 0;
2571 }
2572
2573 /*
2574  * Close function is called at splaudio().
2575  */
2576 static void
2577 uaudio_close(void *addr)
2578 {
2579 }
2580
2581 static int
2582 uaudio_drain(void *addr)
2583 {
2584         struct uaudio_softc *sc;
2585
2586         sc = addr;
2587         usbd_delay_ms(sc->sc_udev, UAUDIO_NCHANBUFS * UAUDIO_NFRAMES);
2588
2589         return 0;
2590 }
2591
2592 static int
2593 uaudio_halt_out_dma(void *addr)
2594 {
2595         struct uaudio_softc *sc;
2596
2597         sc = addr;
2598         if (sc->sc_dying)
2599                 return EIO;
2600
2601         DPRINTF(("uaudio_halt_out_dma: enter\n"));
2602         if (sc->sc_playchan.pipe != NULL) {
2603                 uaudio_chan_close(sc, &sc->sc_playchan);
2604                 sc->sc_playchan.pipe = NULL;
2605                 uaudio_chan_free_buffers(sc, &sc->sc_playchan);
2606                 sc->sc_playchan.intr = NULL;
2607         }
2608         return 0;
2609 }
2610
2611 static int
2612 uaudio_halt_in_dma(void *addr)
2613 {
2614         struct uaudio_softc *sc;
2615
2616         DPRINTF(("uaudio_halt_in_dma: enter\n"));
2617         sc = addr;
2618         if (sc->sc_recchan.pipe != NULL) {
2619                 uaudio_chan_close(sc, &sc->sc_recchan);
2620                 sc->sc_recchan.pipe = NULL;
2621                 uaudio_chan_free_buffers(sc, &sc->sc_recchan);
2622                 sc->sc_recchan.intr = NULL;
2623         }
2624         return 0;
2625 }
2626
2627 static int
2628 uaudio_getdev(void *addr, struct audio_device *retp)
2629 {
2630         struct uaudio_softc *sc;
2631
2632         DPRINTF(("uaudio_mixer_getdev:\n"));
2633         sc = addr;
2634         if (sc->sc_dying)
2635                 return EIO;
2636
2637         *retp = uaudio_device;
2638         return 0;
2639 }
2640
2641 /*
2642  * Make sure the block size is large enough to hold all outstanding transfers.
2643  */
2644 static int
2645 uaudio_round_blocksize(void *addr, int blk)
2646 {
2647         struct uaudio_softc *sc;
2648         int b;
2649
2650         sc = addr;
2651         DPRINTF(("uaudio_round_blocksize: blk=%d mode=%s\n", blk,
2652                 mode == AUMODE_PLAY ? "AUMODE_PLAY" : "AUMODE_RECORD"));
2653
2654         /* chan.bytes_per_frame can be 0. */
2655         if (mode == AUMODE_PLAY || sc->sc_recchan.bytes_per_frame <= 0) {
2656                 b = param->sample_rate * UAUDIO_NFRAMES * UAUDIO_NCHANBUFS;
2657
2658                 /*
2659                  * This does not make accurate value in the case
2660                  * of b % USB_FRAMES_PER_SECOND != 0
2661                  */
2662                 b /= USB_FRAMES_PER_SECOND;
2663
2664                 b *= param->precision / 8 * param->channels;
2665         } else {
2666                 /*
2667                  * use wMaxPacketSize in bytes_per_frame.
2668                  * See uaudio_set_params() and uaudio_chan_init()
2669                  */
2670                 b = sc->sc_recchan.bytes_per_frame
2671                         * UAUDIO_NFRAMES * UAUDIO_NCHANBUFS;
2672         }
2673
2674         if (b <= 0)
2675                 b = 1;
2676         blk = blk <= b ? b : blk / b * b;
2677
2678 #ifdef DIAGNOSTIC
2679         if (blk <= 0) {
2680                 kprintf("uaudio_round_blocksize: blk=%d\n", blk);
2681                 blk = 512;
2682         }
2683 #endif
2684
2685         DPRINTF(("uaudio_round_blocksize: resultant blk=%d\n", blk));
2686         return blk;
2687 }
2688
2689 static int
2690 uaudio_get_props(void *addr)
2691 {
2692         return AUDIO_PROP_FULLDUPLEX | AUDIO_PROP_INDEPENDENT;
2693
2694 }
2695 #endif  /* NetBSD or OpenBSD */
2696
2697 static int
2698 uaudio_get(struct uaudio_softc *sc, int which, int type, int wValue,
2699            int wIndex, int len)
2700 {
2701         usb_device_request_t req;
2702         uint8_t data[4];
2703         usbd_status err;
2704         int val;
2705
2706 #if defined(__FreeBSD__) || defined(__DragonFly__)
2707         if (sc->sc_dying)
2708                 return EIO;
2709 #endif
2710
2711         if (wValue == -1)
2712                 return 0;
2713
2714         req.bmRequestType = type;
2715         req.bRequest = which;
2716         USETW(req.wValue, wValue);
2717         USETW(req.wIndex, wIndex);
2718         USETW(req.wLength, len);
2719         DPRINTFN(2,("uaudio_get: type=0x%02x req=0x%02x wValue=0x%04x "
2720                     "wIndex=0x%04x len=%d\n",
2721                     type, which, wValue, wIndex, len));
2722         err = usbd_do_request(sc->sc_udev, &req, data);
2723         if (err) {
2724                 DPRINTF(("uaudio_get: err=%s\n", usbd_errstr(err)));
2725                 return -1;
2726         }
2727         switch (len) {
2728         case 1:
2729                 val = data[0];
2730                 break;
2731         case 2:
2732                 val = data[0] | (data[1] << 8);
2733                 break;
2734         default:
2735                 DPRINTF(("uaudio_get: bad length=%d\n", len));
2736                 return -1;
2737         }
2738         DPRINTFN(2,("uaudio_get: val=%d\n", val));
2739         return val;
2740 }
2741
2742 static void
2743 uaudio_set(struct uaudio_softc *sc, int which, int type, int wValue,
2744            int wIndex, int len, int val)
2745 {
2746         usb_device_request_t req;
2747         uint8_t data[4];
2748         usbd_status err;
2749
2750 #if defined(__FreeBSD__) || defined(__DragonFly__)
2751         if (sc->sc_dying)
2752                 return;
2753 #endif
2754
2755         if (wValue == -1)
2756                 return;
2757
2758         req.bmRequestType = type;
2759         req.bRequest = which;
2760         USETW(req.wValue, wValue);
2761         USETW(req.wIndex, wIndex);
2762         USETW(req.wLength, len);
2763         switch (len) {
2764         case 1:
2765                 data[0] = val;
2766                 break;
2767         case 2:
2768                 data[0] = val;
2769                 data[1] = val >> 8;
2770                 break;
2771         default:
2772                 return;
2773         }
2774         DPRINTFN(2,("uaudio_set: type=0x%02x req=0x%02x wValue=0x%04x "
2775                     "wIndex=0x%04x len=%d, val=%d\n",
2776                     type, which, wValue, wIndex, len, val & 0xffff));
2777         err = usbd_do_request(sc->sc_udev, &req, data);
2778 #ifdef USB_DEBUG
2779         if (err)
2780                 DPRINTF(("uaudio_set: err=%d\n", err));
2781 #endif
2782 }
2783
2784 static int
2785 uaudio_signext(int type, int val)
2786 {
2787         if (!MIX_UNSIGNED(type)) {
2788                 if (MIX_SIZE(type) == 2)
2789                         val = (int16_t)val;
2790                 else
2791                         val = (int8_t)val;
2792         }
2793         return val;
2794 }
2795
2796 #if defined(__NetBSD__) || defined(__OpenBSD__)
2797 static int
2798 uaudio_value2bsd(struct mixerctl *mc, int val)
2799 {
2800         DPRINTFN(5, ("uaudio_value2bsd: type=%03x val=%d min=%d max=%d ",
2801                      mc->type, val, mc->minval, mc->maxval));
2802         if (mc->type == MIX_ON_OFF) {
2803                 val = (val != 0);
2804         } else if (mc->type == MIX_SELECTOR) {
2805                 if (val < mc->minval || val > mc->maxval)
2806                         val = mc->minval;
2807         } else
2808                 val = ((uaudio_signext(mc->type, val) - mc->minval) * 255
2809                         + mc->mul/2) / mc->mul;
2810         DPRINTFN(5, ("val'=%d\n", val));
2811         return val;
2812 }
2813 #endif
2814
2815 int
2816 uaudio_bsd2value(struct mixerctl *mc, int val)
2817 {
2818         DPRINTFN(5,("uaudio_bsd2value: type=%03x val=%d min=%d max=%d ",
2819                     mc->type, val, mc->minval, mc->maxval));
2820         if (mc->type == MIX_ON_OFF) {
2821                 val = (val != 0);
2822         } else if (mc->type == MIX_SELECTOR) {
2823                 if (val < mc->minval || val > mc->maxval)
2824                         val = mc->minval;
2825         } else
2826                 val = (val + mc->delta/2) * mc->mul / 255 + mc->minval;
2827         DPRINTFN(5, ("val'=%d\n", val));
2828         return val;
2829 }
2830
2831 #if defined(__NetBSD__) || defined(__OpenBSD__)
2832 static int
2833 uaudio_ctl_get(struct uaudio_softc *sc, int which, struct mixerctl *mc,
2834                int chan)
2835 {
2836         int val;
2837
2838         DPRINTFN(5,("uaudio_ctl_get: which=%d chan=%d\n", which, chan));
2839         val = uaudio_get(sc, which, UT_READ_CLASS_INTERFACE, mc->wValue[chan],
2840                          mc->wIndex, MIX_SIZE(mc->type));
2841         return uaudio_value2bsd(mc, val);
2842 }
2843 #endif
2844
2845 static void
2846 uaudio_ctl_set(struct uaudio_softc *sc, int which, struct mixerctl *mc,
2847                int chan, int val)
2848 {
2849         val = uaudio_bsd2value(mc, val);
2850         uaudio_set(sc, which, UT_WRITE_CLASS_INTERFACE, mc->wValue[chan],
2851                    mc->wIndex, MIX_SIZE(mc->type), val);
2852 }
2853
2854 #if defined(__NetBSD__) || defined(__OpenBSD__)
2855 static int
2856 uaudio_mixer_get_port(void *addr, mixer_ctrl_t *cp)
2857 {
2858         struct uaudio_softc *sc;
2859         struct mixerctl *mc;
2860         int i, n, vals[MIX_MAX_CHAN], val;
2861
2862         DPRINTFN(2,("uaudio_mixer_get_port: index=%d\n", cp->dev));
2863         sc = addr;
2864         if (sc->sc_dying)
2865                 return EIO;
2866
2867         n = cp->dev - UAC_NCLASSES;
2868         if (n < 0 || n >= sc->sc_nctls)
2869                 return ENXIO;
2870         mc = &sc->sc_ctls[n];
2871
2872         if (mc->type == MIX_ON_OFF) {
2873                 if (cp->type != AUDIO_MIXER_ENUM)
2874                         return EINVAL;
2875                 cp->un.ord = uaudio_ctl_get(sc, GET_CUR, mc, 0);
2876         } else if (mc->type == MIX_SELECTOR) {
2877                 if (cp->type != AUDIO_MIXER_ENUM)
2878                         return EINVAL;
2879                 cp->un.ord = uaudio_ctl_get(sc, GET_CUR, mc, 0);
2880         } else {
2881                 if (cp->type != AUDIO_MIXER_VALUE)
2882                         return (EINVAL);
2883                 if (cp->un.value.num_channels != 1 &&
2884                     cp->un.value.num_channels != mc->nchan)
2885                         return EINVAL;
2886                 for (i = 0; i < mc->nchan; i++)
2887                         vals[i] = uaudio_ctl_get(sc, GET_CUR, mc, i);
2888                 if (cp->un.value.num_channels == 1 && mc->nchan != 1) {
2889                         for (val = 0, i = 0; i < mc->nchan; i++)
2890                                 val += vals[i];
2891                         vals[0] = val / mc->nchan;
2892                 }
2893                 for (i = 0; i < cp->un.value.num_channels; i++)
2894                         cp->un.value.level[i] = vals[i];
2895         }
2896
2897         return 0;
2898 }
2899
2900 static int
2901 uaudio_mixer_set_port(void *addr, mixer_ctrl_t *cp)
2902 {
2903         struct uaudio_softc *sc;
2904         struct mixerctl *mc;
2905         int i, n, vals[MIX_MAX_CHAN];
2906
2907         DPRINTFN(2,("uaudio_mixer_set_port: index = %d\n", cp->dev));
2908         sc = addr;
2909         if (sc->sc_dying)
2910                 return EIO;
2911
2912         n = cp->dev - UAC_NCLASSES;
2913         if (n < 0 || n >= sc->sc_nctls)
2914                 return ENXIO;
2915         mc = &sc->sc_ctls[n];
2916
2917         if (mc->type == MIX_ON_OFF) {
2918                 if (cp->type != AUDIO_MIXER_ENUM)
2919                         return EINVAL;
2920                 uaudio_ctl_set(sc, SET_CUR, mc, 0, cp->un.ord);
2921         } else if (mc->type == MIX_SELECTOR) {
2922                 if (cp->type != AUDIO_MIXER_ENUM)
2923                         return EINVAL;
2924                 uaudio_ctl_set(sc, SET_CUR, mc, 0, cp->un.ord);
2925         } else {
2926                 if (cp->type != AUDIO_MIXER_VALUE)
2927                         return EINVAL;
2928                 if (cp->un.value.num_channels == 1)
2929                         for (i = 0; i < mc->nchan; i++)
2930                                 vals[i] = cp->un.value.level[0];
2931                 else if (cp->un.value.num_channels == mc->nchan)
2932                         for (i = 0; i < mc->nchan; i++)
2933                                 vals[i] = cp->un.value.level[i];
2934                 else
2935                         return EINVAL;
2936                 for (i = 0; i < mc->nchan; i++)
2937                         uaudio_ctl_set(sc, SET_CUR, mc, i, vals[i]);
2938         }
2939         return 0;
2940 }
2941
2942 static int
2943 uaudio_trigger_input(void *addr, void *start, void *end, int blksize,
2944                      void (*intr)(void *), void *arg,
2945                      struct audio_params *param)
2946 {
2947         struct uaudio_softc *sc;
2948         struct chan *ch;
2949         usbd_status err;
2950         int i, s;
2951
2952         sc = addr;
2953         if (sc->sc_dying)
2954                 return EIO;
2955
2956         DPRINTFN(3,("uaudio_trigger_input: sc=%p start=%p end=%p "
2957                     "blksize=%d\n", sc, start, end, blksize));
2958         ch = &sc->sc_recchan;
2959         uaudio_chan_set_param(ch, start, end, blksize);
2960         DPRINTFN(3,("uaudio_trigger_input: sample_size=%d bytes/frame=%d "
2961                     "fraction=0.%03d\n", ch->sample_size, ch->bytes_per_frame,
2962                     ch->fraction));
2963
2964         err = uaudio_chan_alloc_buffers(sc, ch);
2965         if (err)
2966                 return EIO;
2967
2968         err = uaudio_chan_open(sc, ch);
2969         if (err) {
2970                 uaudio_chan_free_buffers(sc, ch);
2971                 return EIO;
2972         }
2973
2974         ch->intr = intr;
2975         ch->arg = arg;
2976
2977         s = splusb();
2978         for (i = 0; i < UAUDIO_NCHANBUFS-1; i++) /* XXX -1 shouldn't be needed */
2979                 uaudio_chan_rtransfer(ch);
2980         splx(s);
2981
2982         return 0;
2983 }
2984
2985 static int
2986 uaudio_trigger_output(void *addr, void *start, void *end, int blksize,
2987                       void (*intr)(void *), void *arg,
2988                       struct audio_params *param)
2989 {
2990         struct uaudio_softc *sc;
2991         struct chan *ch;
2992         usbd_status err;
2993         int i, s;
2994
2995         sc = addr;
2996         if (sc->sc_dying)
2997                 return EIO;
2998
2999         DPRINTFN(3,("uaudio_trigger_output: sc=%p start=%p end=%p "
3000                     "blksize=%d\n", sc, start, end, blksize));
3001         ch = &sc->sc_playchan;
3002         uaudio_chan_set_param(ch, start, end, blksize);
3003         DPRINTFN(3,("uaudio_trigger_output: sample_size=%d bytes/frame=%d "
3004                     "fraction=0.%03d\n", ch->sample_size, ch->bytes_per_frame,
3005                     ch->fraction));
3006
3007         err = uaudio_chan_alloc_buffers(sc, ch);
3008         if (err)
3009                 return EIO;
3010
3011         err = uaudio_chan_open(sc, ch);
3012         if (err) {
3013                 uaudio_chan_free_buffers(sc, ch);
3014                 return EIO;
3015         }
3016
3017         ch->intr = intr;
3018         ch->arg = arg;
3019
3020         s = splusb();
3021         for (i = 0; i < UAUDIO_NCHANBUFS-1; i++) /* XXX */
3022                 uaudio_chan_ptransfer(ch);
3023         splx(s);
3024
3025         return 0;
3026 }
3027 #endif  /* NetBSD or OpenBSD */
3028
3029 /* Set up a pipe for a channel. */
3030 static usbd_status
3031 uaudio_chan_open(struct uaudio_softc *sc, struct chan *ch)
3032 {
3033         struct as_info *as;
3034         int endpt;
3035         usbd_status err;
3036
3037 #if defined(__FreeBSD__) || defined(__DragonFly__)
3038         if (sc->sc_dying)
3039                 return EIO;
3040 #endif
3041
3042         as = &sc->sc_alts[ch->altidx];
3043         endpt = as->edesc->bEndpointAddress;
3044         DPRINTF(("uaudio_chan_open: endpt=0x%02x, speed=%d, alt=%d\n",
3045                  endpt, ch->sample_rate, as->alt));
3046
3047         /* Set alternate interface corresponding to the mode. */
3048         err = usbd_set_interface(as->ifaceh, as->alt);
3049         if (err)
3050                 return err;
3051
3052         /*
3053          * If just one sampling rate is supported,
3054          * no need to call uaudio_set_speed().
3055          * Roland SD-90 freezes by a SAMPLING_FREQ_CONTROL request.
3056          */
3057         if (as->asf1desc->bSamFreqType != 1) {
3058                 err = uaudio_set_speed(sc, endpt, ch->sample_rate);
3059                 if (err)
3060                         DPRINTF(("uaudio_chan_open: set_speed failed err=%s\n",
3061                                  usbd_errstr(err)));
3062         }
3063
3064         ch->pipe = 0;
3065         ch->sync_pipe = 0;
3066         DPRINTF(("uaudio_chan_open: create pipe to 0x%02x\n", endpt));
3067         err = usbd_open_pipe(as->ifaceh, endpt, 0, &ch->pipe);
3068         if (err)
3069                 return err;
3070         if (as->edesc1 != NULL) {
3071                 endpt = as->edesc1->bEndpointAddress;
3072                 DPRINTF(("uaudio_chan_open: create sync-pipe to 0x%02x\n", endpt));
3073                 err = usbd_open_pipe(as->ifaceh, endpt, 0, &ch->sync_pipe);
3074         }
3075         return err;
3076 }
3077
3078 static void
3079 uaudio_chan_close(struct uaudio_softc *sc, struct chan *ch)
3080 {
3081         struct as_info *as;
3082
3083 #if defined(__FreeBSD__) || defined(__DragonFly__)
3084         if (sc->sc_dying)
3085                 return ;
3086 #endif
3087
3088         as = &sc->sc_alts[ch->altidx];
3089         as->sc_busy = 0;
3090         if (sc->sc_nullalt >= 0) {
3091                 DPRINTF(("uaudio_chan_close: set null alt=%d\n",
3092                          sc->sc_nullalt));
3093                 usbd_set_interface(as->ifaceh, sc->sc_nullalt);
3094         }
3095         if (ch->pipe) {
3096                 usbd_abort_pipe(ch->pipe);
3097                 usbd_close_pipe(ch->pipe);
3098         }
3099         if (ch->sync_pipe) {
3100                 usbd_abort_pipe(ch->sync_pipe);
3101                 usbd_close_pipe(ch->sync_pipe);
3102         }
3103 }
3104
3105 static usbd_status
3106 uaudio_chan_alloc_buffers(struct uaudio_softc *sc, struct chan *ch)
3107 {
3108         usbd_xfer_handle xfer;
3109         void *buf;
3110         int i, size;
3111
3112         size = (ch->bytes_per_frame + ch->sample_size) * UAUDIO_NFRAMES;
3113         for (i = 0; i < UAUDIO_NCHANBUFS; i++) {
3114                 xfer = usbd_alloc_xfer(sc->sc_udev);
3115                 if (xfer == 0)
3116                         goto bad;
3117                 ch->chanbufs[i].xfer = xfer;
3118                 buf = usbd_alloc_buffer(xfer, size);
3119                 if (buf == 0) {
3120                         i++;
3121                         goto bad;
3122                 }
3123                 ch->chanbufs[i].buffer = buf;
3124                 ch->chanbufs[i].chan = ch;
3125         }
3126
3127         return USBD_NORMAL_COMPLETION;
3128
3129 bad:
3130         while (--i >= 0)
3131                 /* implicit buffer kfree */
3132                 usbd_free_xfer(ch->chanbufs[i].xfer);
3133         return USBD_NOMEM;
3134 }
3135
3136 static void
3137 uaudio_chan_free_buffers(struct uaudio_softc *sc, struct chan *ch)
3138 {
3139         int i;
3140
3141         for (i = 0; i < UAUDIO_NCHANBUFS; i++)
3142                 usbd_free_xfer(ch->chanbufs[i].xfer);
3143 }
3144
3145 /* Called at splusb() */
3146 static void
3147 uaudio_chan_ptransfer(struct chan *ch)
3148 {
3149         struct chanbuf *cb;
3150         int i, n, size, residue, total;
3151
3152         if (ch->sc->sc_dying)
3153                 return;
3154
3155         /* Pick the next channel buffer. */
3156         cb = &ch->chanbufs[ch->curchanbuf];
3157         if (++ch->curchanbuf >= UAUDIO_NCHANBUFS)
3158                 ch->curchanbuf = 0;
3159
3160         /* Compute the size of each frame in the next transfer. */
3161         residue = ch->residue;
3162         total = 0;
3163         for (i = 0; i < UAUDIO_NFRAMES; i++) {
3164                 size = ch->bytes_per_frame;
3165                 residue += ch->fraction;
3166                 if (residue >= USB_FRAMES_PER_SECOND) {
3167                         if ((ch->sc->sc_altflags & UA_NOFRAC) == 0)
3168                                 size += ch->sample_size;
3169                         residue -= USB_FRAMES_PER_SECOND;
3170                 }
3171                 cb->sizes[i] = size;
3172                 total += size;
3173         }
3174         ch->residue = residue;
3175         cb->size = total;
3176
3177         /*
3178          * Transfer data from upper layer buffer to channel buffer, taking
3179          * care of wrapping the upper layer buffer.
3180          */
3181         n = min(total, ch->end - ch->cur);
3182         memcpy(cb->buffer, ch->cur, n);
3183         ch->cur += n;
3184         if (ch->cur >= ch->end)
3185                 ch->cur = ch->start;
3186         if (total > n) {
3187                 total -= n;
3188                 memcpy(cb->buffer + n, ch->cur, total);
3189                 ch->cur += total;
3190         }
3191
3192 #ifdef USB_DEBUG
3193         if (uaudiodebug > 8) {
3194                 DPRINTF(("uaudio_chan_ptransfer: buffer=%p, residue=0.%03d\n",
3195                          cb->buffer, ch->residue));
3196                 for (i = 0; i < UAUDIO_NFRAMES; i++) {
3197                         DPRINTF(("   [%d] length %d\n", i, cb->sizes[i]));
3198                 }
3199         }
3200 #endif
3201
3202         DPRINTFN(5,("uaudio_chan_transfer: ptransfer xfer=%p\n", cb->xfer));
3203         /* Fill the request */
3204         usbd_setup_isoc_xfer(cb->xfer, ch->pipe, cb, cb->sizes,
3205                              UAUDIO_NFRAMES, USBD_NO_COPY,
3206                              uaudio_chan_pintr);
3207
3208         (void)usbd_transfer(cb->xfer);
3209 }
3210
3211 static void
3212 uaudio_chan_pintr(usbd_xfer_handle xfer, usbd_private_handle priv,
3213                   usbd_status status)
3214 {
3215         struct chanbuf *cb;
3216         struct chan *ch;
3217         u_int32_t count;
3218 #if !defined(__DragonFly__)
3219         int s;
3220 #endif
3221
3222         cb = priv;
3223         ch = cb->chan;
3224         /* Return if we are aborting. */
3225         if (status == USBD_CANCELLED)
3226                 return;
3227
3228         usbd_get_xfer_status(xfer, NULL, NULL, &count, NULL);
3229         DPRINTFN(5,("uaudio_chan_pintr: count=%d, transferred=%d\n",
3230                     count, ch->transferred));
3231 #ifdef DIAGNOSTIC
3232         if (count != cb->size) {
3233                 kprintf("uaudio_chan_pintr: count(%d) != size(%d)\n",
3234                        count, cb->size);
3235         }
3236 #endif
3237
3238         ch->transferred += cb->size;
3239 #if defined(__FreeBSD__)
3240         /* s = spltty(); */
3241         s = splhigh();
3242         chn_intr(ch->pcm_ch);
3243         splx(s);
3244 #elif defined(__DragonFly__)
3245         crit_enter();
3246         chn_intr(ch->pcm_ch);
3247         crit_exit();
3248 #else
3249         s = splaudio();
3250         /* Call back to upper layer */
3251         while (ch->transferred >= ch->blksize) {
3252                 ch->transferred -= ch->blksize;
3253                 DPRINTFN(5,("uaudio_chan_pintr: call %p(%p)\n",
3254                             ch->intr, ch->arg));
3255                 ch->intr(ch->arg);
3256         }
3257         splx(s);
3258 #endif
3259
3260         /* start next transfer */
3261         uaudio_chan_ptransfer(ch);
3262 }
3263
3264 /* Called at splusb() */
3265 static void
3266 uaudio_chan_rtransfer(struct chan *ch)
3267 {
3268         struct chanbuf *cb;
3269         int i, size, residue, total;
3270
3271         if (ch->sc->sc_dying)
3272                 return;
3273
3274         /* Pick the next channel buffer. */
3275         cb = &ch->chanbufs[ch->curchanbuf];
3276         if (++ch->curchanbuf >= UAUDIO_NCHANBUFS)
3277                 ch->curchanbuf = 0;
3278
3279         /* Compute the size of each frame in the next transfer. */
3280         residue = ch->residue;
3281         total = 0;
3282         for (i = 0; i < UAUDIO_NFRAMES; i++) {
3283                 size = ch->bytes_per_frame;
3284                 cb->sizes[i] = size;
3285                 cb->offsets[i] = total;
3286                 total += size;
3287         }
3288         ch->residue = residue;
3289         cb->size = total;
3290
3291 #ifdef USB_DEBUG
3292         if (uaudiodebug > 8) {
3293                 DPRINTF(("uaudio_chan_rtransfer: buffer=%p, residue=0.%03d\n",
3294                          cb->buffer, ch->residue));
3295                 for (i = 0; i < UAUDIO_NFRAMES; i++) {
3296                         DPRINTF(("   [%d] length %d\n", i, cb->sizes[i]));
3297                 }
3298         }
3299 #endif
3300
3301         DPRINTFN(5,("uaudio_chan_rtransfer: transfer xfer=%p\n", cb->xfer));
3302         /* Fill the request */
3303         usbd_setup_isoc_xfer(cb->xfer, ch->pipe, cb, cb->sizes,
3304                              UAUDIO_NFRAMES, USBD_NO_COPY,
3305                              uaudio_chan_rintr);
3306
3307         (void)usbd_transfer(cb->xfer);
3308 }
3309
3310 static void
3311 uaudio_chan_rintr(usbd_xfer_handle xfer, usbd_private_handle priv,
3312                   usbd_status status)
3313 {
3314         struct chanbuf *cb = priv;
3315         struct chan *ch = cb->chan;
3316         u_int32_t count;
3317 #if !defined(__DragonFly__)
3318         int s;
3319 #endif
3320         int i, n, frsize;
3321
3322         /* Return if we are aborting. */
3323         if (status == USBD_CANCELLED)
3324                 return;
3325
3326         usbd_get_xfer_status(xfer, NULL, NULL, &count, NULL);
3327         DPRINTFN(5,("uaudio_chan_rintr: count=%d, transferred=%d\n",
3328                     count, ch->transferred));
3329
3330         /* count < cb->size is normal for asynchronous source */
3331 #ifdef DIAGNOSTIC
3332         if (count > cb->size) {
3333                 kprintf("uaudio_chan_rintr: count(%d) > size(%d)\n",
3334                        count, cb->size);
3335         }
3336 #endif
3337
3338         /*
3339          * Transfer data from channel buffer to upper layer buffer, taking
3340          * care of wrapping the upper layer buffer.
3341          */
3342         for(i = 0; i < UAUDIO_NFRAMES; i++) {
3343                 frsize = cb->sizes[i];
3344                 n = min(frsize, ch->end - ch->cur);
3345                 memcpy(ch->cur, cb->buffer + cb->offsets[i], n);
3346                 ch->cur += n;
3347                 if (ch->cur >= ch->end)
3348                         ch->cur = ch->start;
3349                 if (frsize > n) {
3350                         memcpy(ch->cur, cb->buffer + cb->offsets[i] + n,
3351                             frsize - n);
3352                         ch->cur += frsize - n;
3353                 }
3354         }
3355
3356         /* Call back to upper layer */
3357         ch->transferred += count;
3358 #if defined(__FreeBSD__)
3359         s = spltty();
3360         chn_intr(ch->pcm_ch);
3361         splx(s);
3362 #elif defined(__DragonFly__)
3363         crit_enter();
3364         chn_intr(ch->pcm_ch);
3365         crit_exit();
3366 #else
3367         s = splaudio();
3368         while (ch->transferred >= ch->blksize) {
3369                 ch->transferred -= ch->blksize;
3370                 DPRINTFN(5,("uaudio_chan_rintr: call %p(%p)\n",
3371                             ch->intr, ch->arg));
3372                 ch->intr(ch->arg);
3373         }
3374         splx(s);
3375 #endif
3376
3377         /* start next transfer */
3378         uaudio_chan_rtransfer(ch);
3379 }
3380
3381 #if defined(__NetBSD__) || defined(__OpenBSD__)
3382 static void
3383 uaudio_chan_init(struct chan *ch, int altidx, const struct audio_params *param,
3384     int maxpktsize)
3385 {
3386         int samples_per_frame, sample_size;
3387
3388         ch->altidx = altidx;
3389         sample_size = param->precision * param->factor * param->hw_channels / 8;
3390         samples_per_frame = param->hw_sample_rate / USB_FRAMES_PER_SECOND;
3391         ch->sample_size = sample_size;
3392         ch->sample_rate = param->hw_sample_rate;
3393         if (maxpktsize == 0) {
3394                 ch->fraction = param->hw_sample_rate % USB_FRAMES_PER_SECOND;
3395                 ch->bytes_per_frame = samples_per_frame * sample_size;
3396         } else {
3397                 ch->fraction = 0;
3398                 ch->bytes_per_frame = maxpktsize;
3399         }
3400         ch->residue = 0;
3401 }
3402
3403 static void
3404 uaudio_chan_set_param(struct chan *ch, u_char *start, u_char *end, int blksize)
3405 {
3406         ch->start = start;
3407         ch->end = end;
3408         ch->cur = start;
3409         ch->blksize = blksize;
3410         ch->transferred = 0;
3411         ch->curchanbuf = 0;
3412 }
3413
3414 static void
3415 uaudio_get_minmax_rates(int nalts, const struct as_info *alts,
3416                         const struct audio_params *p, int mode,
3417                         u_long *min, u_long *max)
3418 {
3419         const struct usb_audio_streaming_type1_descriptor *a1d;
3420         int i, j;
3421
3422         *min = ULONG_MAX;
3423         *max = 0;
3424         for (i = 0; i < nalts; i++) {
3425                 a1d = alts[i].asf1desc;
3426                 if (alts[i].sc_busy)
3427                         continue;
3428                 if (p->hw_channels != a1d->bNrChannels)
3429                         continue;
3430                 if (p->hw_precision != a1d->bBitResolution)
3431                         continue;
3432                 if (p->hw_encoding != alts[i].encoding)
3433                         continue;
3434                 if (mode != UE_GET_DIR(alts[i].edesc->bEndpointAddress))
3435                         continue;
3436                 if (a1d->bSamFreqType == UA_SAMP_CONTNUOUS) {
3437                         DPRINTFN(2,("uaudio_get_minmax_rates: cont %d-%d\n",
3438                                     UA_SAMP_LO(a1d), UA_SAMP_HI(a1d)));
3439                         if (UA_SAMP_LO(a1d) < *min)
3440                                 *min = UA_SAMP_LO(a1d);
3441                         if (UA_SAMP_HI(a1d) > *max)
3442                                 *max = UA_SAMP_HI(a1d);
3443                 } else {
3444                         for (j = 0; j < a1d->bSamFreqType; j++) {
3445                                 DPRINTFN(2,("uaudio_get_minmax_rates: disc #%d: %d\n",
3446                                             j, UA_GETSAMP(a1d, j)));
3447                                 if (UA_GETSAMP(a1d, j) < *min)
3448                                         *min = UA_GETSAMP(a1d, j);
3449                                 if (UA_GETSAMP(a1d, j) > *max)
3450                                         *max = UA_GETSAMP(a1d, j);
3451                         }
3452                 }
3453         }
3454 }
3455
3456 static int
3457 uaudio_match_alt_sub(int nalts, const struct as_info *alts,
3458                      const struct audio_params *p, int mode, u_long rate)
3459 {
3460         const struct usb_audio_streaming_type1_descriptor *a1d;
3461         int i, j;
3462
3463         DPRINTF(("uaudio_match_alt_sub: search for %luHz %dch\n",
3464                  rate, p->hw_channels));
3465         for (i = 0; i < nalts; i++) {
3466                 a1d = alts[i].asf1desc;
3467                 if (alts[i].sc_busy)
3468                         continue;
3469                 if (p->hw_channels != a1d->bNrChannels)
3470                         continue;
3471                 if (p->hw_precision != a1d->bBitResolution)
3472                         continue;
3473                 if (p->hw_encoding != alts[i].encoding)
3474                         continue;
3475                 if (mode != UE_GET_DIR(alts[i].edesc->bEndpointAddress))
3476                         continue;
3477                 if (a1d->bSamFreqType == UA_SAMP_CONTNUOUS) {
3478                         DPRINTFN(3,("uaudio_match_alt_sub: cont %d-%d\n",
3479                                     UA_SAMP_LO(a1d), UA_SAMP_HI(a1d)));
3480                         if (UA_SAMP_LO(a1d) <= rate && rate <= UA_SAMP_HI(a1d))
3481                                 return i;
3482                 } else {
3483                         for (j = 0; j < a1d->bSamFreqType; j++) {
3484                                 DPRINTFN(3,("uaudio_match_alt_sub: disc #%d: %d\n",
3485                                             j, UA_GETSAMP(a1d, j)));
3486                                 /* XXX allow for some slack */
3487                                 if (UA_GETSAMP(a1d, j) == rate)
3488                                         return i;
3489                         }
3490                 }
3491         }
3492         return -1;
3493 }
3494
3495 static int
3496 uaudio_match_alt_chan(int nalts, const struct as_info *alts,
3497                       struct audio_params *p, int mode)
3498 {
3499         int i, n;
3500         u_long min, max;
3501         u_long rate;
3502
3503         /* Exact match */
3504         DPRINTF(("uaudio_match_alt_chan: examine %ldHz %dch %dbit.\n",
3505                  p->sample_rate, p->hw_channels, p->hw_precision));
3506         i = uaudio_match_alt_sub(nalts, alts, p, mode, p->sample_rate);
3507         if (i >= 0)
3508                 return i;
3509
3510         uaudio_get_minmax_rates(nalts, alts, p, mode, &min, &max);
3511         DPRINTF(("uaudio_match_alt_chan: min=%lu max=%lu\n", min, max));
3512         if (max <= 0)
3513                 return -1;
3514         /* Search for biggers */
3515         n = 2;
3516         while ((rate = p->sample_rate * n++) <= max) {
3517                 i = uaudio_match_alt_sub(nalts, alts, p, mode, rate);
3518                 if (i >= 0) {
3519                         p->hw_sample_rate = rate;
3520                         return i;
3521                 }
3522         }
3523         if (p->sample_rate >= min) {
3524                 i = uaudio_match_alt_sub(nalts, alts, p, mode, max);
3525                 if (i >= 0) {
3526                         p->hw_sample_rate = max;
3527                         return i;
3528                 }
3529         } else {
3530                 i = uaudio_match_alt_sub(nalts, alts, p, mode, min);
3531                 if (i >= 0) {
3532                         p->hw_sample_rate = min;
3533                         return i;
3534                 }
3535         }
3536         return -1;
3537 }
3538
3539 static int
3540 uaudio_match_alt(int nalts, const struct as_info *alts,
3541                  struct audio_params *p, int mode)
3542 {
3543         int i, n;
3544
3545         mode = mode == AUMODE_PLAY ? UE_DIR_OUT : UE_DIR_IN;
3546         i = uaudio_match_alt_chan(nalts, alts, p, mode);
3547         if (i >= 0)
3548                 return i;
3549
3550         for (n = p->channels + 1; n <= AUDIO_MAX_CHANNELS; n++) {
3551                 p->hw_channels = n;
3552                 i = uaudio_match_alt_chan(nalts, alts, p, mode);
3553                 if (i >= 0)
3554                         return i;
3555         }
3556
3557         if (p->channels != 2)
3558                 return -1;
3559         p->hw_channels = 1;
3560         return uaudio_match_alt_chan(nalts, alts, p, mode);
3561 }
3562
3563 static int
3564 uaudio_set_params(void *addr, int setmode, int usemode,
3565                   struct audio_params *play, struct audio_params *rec)
3566 {
3567         struct uaudio_softc *sc;
3568         int flags;
3569         int factor;
3570         int enc, i;
3571         int paltidx, raltidx;
3572         void (*swcode)(void *, u_char *buf, int cnt);
3573         struct audio_params *p;
3574         int mode;
3575
3576         sc = addr;
3577         flags = sc->sc_altflags;
3578         paltidx = -1;
3579         raltidx = -1;
3580         if (sc->sc_dying)
3581                 return EIO;
3582
3583         if (((usemode & AUMODE_PLAY) && sc->sc_playchan.pipe != NULL) ||
3584             ((usemode & AUMODE_RECORD) && sc->sc_recchan.pipe != NULL))
3585                 return EBUSY;
3586
3587         if ((usemode & AUMODE_PLAY) && sc->sc_playchan.altidx != -1)
3588                 sc->sc_alts[sc->sc_playchan.altidx].sc_busy = 0;
3589         if ((usemode & AUMODE_RECORD) && sc->sc_recchan.altidx != -1)
3590                 sc->sc_alts[sc->sc_recchan.altidx].sc_busy = 0;
3591
3592         /* Some uaudio devices are unidirectional.  Don't try to find a
3593            matching mode for the unsupported direction. */
3594         setmode &= sc->sc_mode;
3595
3596         for (mode = AUMODE_RECORD; mode != -1;
3597              mode = mode == AUMODE_RECORD ? AUMODE_PLAY : -1) {
3598                 if ((setmode & mode) == 0)
3599                         continue;
3600
3601                 p = (mode == AUMODE_PLAY) ? play : rec;
3602
3603                 factor = 1;
3604                 swcode = 0;
3605                 enc = p->encoding;
3606                 switch (enc) {
3607                 case AUDIO_ENCODING_SLINEAR_BE:
3608                         /* FALLTHROUGH */
3609                 case AUDIO_ENCODING_SLINEAR_LE:
3610                         if (enc == AUDIO_ENCODING_SLINEAR_BE
3611                             && p->precision == 16 && (flags & HAS_16)) {
3612                                 swcode = swap_bytes;
3613                                 enc = AUDIO_ENCODING_SLINEAR_LE;
3614                         } else if (p->precision == 8) {
3615                                 if (flags & HAS_8) {
3616                                         /* No conversion */
3617                                 } else if (flags & HAS_8U) {
3618                                         swcode = change_sign8;
3619                                         enc = AUDIO_ENCODING_ULINEAR_LE;
3620                                 } else if (flags & HAS_16) {
3621                                         factor = 2;
3622                                         p->hw_precision = 16;
3623                                         if (mode == AUMODE_PLAY)
3624                                                 swcode = linear8_to_linear16_le;
3625                                         else
3626                                                 swcode = linear16_to_linear8_le;
3627                                 }
3628                         }
3629                         break;
3630                 case AUDIO_ENCODING_ULINEAR_BE:
3631                         /* FALLTHROUGH */
3632                 case AUDIO_ENCODING_ULINEAR_LE:
3633                         if (p->precision == 16) {
3634                                 if (enc == AUDIO_ENCODING_ULINEAR_LE)
3635                                         swcode = change_sign16_le;
3636                                 else if (mode == AUMODE_PLAY)
3637                                         swcode = swap_bytes_change_sign16_le;
3638                                 else
3639                                         swcode = change_sign16_swap_bytes_le;
3640                                 enc = AUDIO_ENCODING_SLINEAR_LE;
3641                         } else if (p->precision == 8) {
3642                                 if (flags & HAS_8U) {
3643                                         /* No conversion */
3644                                 } else if (flags & HAS_8) {
3645                                         swcode = change_sign8;
3646                                         enc = AUDIO_ENCODING_SLINEAR_LE;
3647                                 } else if (flags & HAS_16) {
3648                                         factor = 2;
3649                                         p->hw_precision = 16;
3650                                         enc = AUDIO_ENCODING_SLINEAR_LE;
3651                                         if (mode == AUMODE_PLAY)
3652                                                 swcode = ulinear8_to_slinear16_le;
3653                                         else
3654                                                 swcode = slinear16_to_ulinear8_le;
3655                                 }
3656                         }
3657                         break;
3658                 case AUDIO_ENCODING_ULAW:
3659                         if (flags & HAS_MULAW)
3660                                 break;
3661                         if (flags & HAS_16) {
3662                                 if (mode == AUMODE_PLAY)
3663                                         swcode = mulaw_to_slinear16_le;
3664                                 else
3665                                         swcode = slinear16_to_mulaw_le;
3666                                 factor = 2;
3667                                 enc = AUDIO_ENCODING_SLINEAR_LE;
3668                                 p->hw_precision = 16;
3669                         } else if (flags & HAS_8U) {
3670                                 if (mode == AUMODE_PLAY)
3671                                         swcode = mulaw_to_ulinear8;
3672                                 else
3673                                         swcode = ulinear8_to_mulaw;
3674                                 enc = AUDIO_ENCODING_ULINEAR_LE;
3675                         } else if (flags & HAS_8) {
3676                                 if (mode == AUMODE_PLAY)
3677                                         swcode = mulaw_to_slinear8;
3678                                 else
3679                                         swcode = slinear8_to_mulaw;
3680                                 enc = AUDIO_ENCODING_SLINEAR_LE;
3681                         } else
3682                                 return (EINVAL);
3683                         break;
3684                 case AUDIO_ENCODING_ALAW:
3685                         if (flags & HAS_ALAW)
3686                                 break;
3687                         if (mode == AUMODE_PLAY && (flags & HAS_16)) {
3688                                 swcode = alaw_to_slinear16_le;
3689                                 factor = 2;
3690                                 enc = AUDIO_ENCODING_SLINEAR_LE;
3691                                 p->hw_precision = 16;
3692                         } else if (flags & HAS_8U) {
3693                                 if (mode == AUMODE_PLAY)
3694                                         swcode = alaw_to_ulinear8;
3695                                 else
3696                                         swcode = ulinear8_to_alaw;
3697                                 enc = AUDIO_ENCODING_ULINEAR_LE;
3698                         } else if (flags & HAS_8) {
3699                                 if (mode == AUMODE_PLAY)
3700                                         swcode = alaw_to_slinear8;
3701                                 else
3702                                         swcode = slinear8_to_alaw;
3703                                 enc = AUDIO_ENCODING_SLINEAR_LE;
3704                         } else
3705                                 return (EINVAL);
3706                         break;
3707                 default:
3708                         return (EINVAL);
3709                 }
3710                 /* XXX do some other conversions... */
3711
3712                 DPRINTF(("uaudio_set_params: chan=%d prec=%d enc=%d rate=%ld\n",
3713                          p->channels, p->hw_precision, enc, p->sample_rate));
3714
3715                 p->hw_encoding = enc;
3716                 i = uaudio_match_alt(sc->sc_nalts, sc->sc_alts, p, mode);
3717                 if (i < 0)
3718                         return (EINVAL);
3719
3720                 p->sw_code = swcode;
3721                 p->factor  = factor;
3722
3723                 if (mode == AUMODE_PLAY)
3724                         paltidx = i;
3725                 else
3726                         raltidx = i;
3727         }
3728
3729         if ((setmode & AUMODE_PLAY)) {
3730                 /* XXX abort transfer if currently happening? */
3731                 uaudio_chan_init(&sc->sc_playchan, paltidx, play, 0);
3732         }
3733         if ((setmode & AUMODE_RECORD)) {
3734                 /* XXX abort transfer if currently happening? */
3735                 uaudio_chan_init(&sc->sc_recchan, raltidx, rec,
3736                     UGETW(sc->sc_alts[raltidx].edesc->wMaxPacketSize));
3737         }
3738
3739         if ((usemode & AUMODE_PLAY) && sc->sc_playchan.altidx != -1)
3740                 sc->sc_alts[sc->sc_playchan.altidx].sc_busy = 1;
3741         if ((usemode & AUMODE_RECORD) && sc->sc_recchan.altidx != -1)
3742                 sc->sc_alts[sc->sc_recchan.altidx].sc_busy = 1;
3743
3744         DPRINTF(("uaudio_set_params: use altidx=p%d/r%d, altno=p%d/r%d\n",
3745                  sc->sc_playchan.altidx, sc->sc_recchan.altidx,
3746                  (sc->sc_playchan.altidx >= 0)
3747                    ?sc->sc_alts[sc->sc_playchan.altidx].idesc->bAlternateSetting
3748                    : -1,
3749                  (sc->sc_recchan.altidx >= 0)
3750                    ? sc->sc_alts[sc->sc_recchan.altidx].idesc->bAlternateSetting
3751                    : -1));
3752
3753         return 0;
3754 }
3755 #endif /* NetBSD or OpenBSD */
3756
3757 static usbd_status
3758 uaudio_set_speed(struct uaudio_softc *sc, int endpt, u_int speed)
3759 {
3760         usb_device_request_t req;
3761         uint8_t data[3];
3762
3763         DPRINTFN(5,("uaudio_set_speed: endpt=%d speed=%u\n", endpt, speed));
3764         req.bmRequestType = UT_WRITE_CLASS_ENDPOINT;
3765         req.bRequest = SET_CUR;
3766         USETW2(req.wValue, SAMPLING_FREQ_CONTROL, 0);
3767         USETW(req.wIndex, endpt);
3768         USETW(req.wLength, 3);
3769         data[0] = speed;
3770         data[1] = speed >> 8;
3771         data[2] = speed >> 16;
3772
3773         return usbd_do_request(sc->sc_udev, &req, data);
3774 }
3775
3776
3777 #if defined(__FreeBSD__) || defined(__DragonFly__)
3778 /************************************************************/
3779 int
3780 uaudio_init_params(struct uaudio_softc *sc, struct chan *ch, int mode)
3781 {
3782         int i, j, enc;
3783         int samples_per_frame, sample_size;
3784
3785         if ((sc->sc_playchan.pipe != NULL) || (sc->sc_recchan.pipe != NULL))
3786                 return (-1);
3787
3788         switch(ch->format & 0x000FFFFF) {
3789         case AFMT_U8:
3790                 enc = AUDIO_ENCODING_ULINEAR_LE;
3791                 ch->precision = 8;
3792                 break;
3793         case AFMT_S8:
3794                 enc = AUDIO_ENCODING_SLINEAR_LE;
3795                 ch->precision = 8;
3796                 break;
3797         case AFMT_A_LAW:        /* ? */
3798                 enc = AUDIO_ENCODING_ALAW;
3799                 ch->precision = 8;
3800                 break;
3801         case AFMT_MU_LAW:       /* ? */
3802                 enc = AUDIO_ENCODING_ULAW;
3803                 ch->precision = 8;
3804                 break;
3805         case AFMT_S16_LE:
3806                 enc = AUDIO_ENCODING_SLINEAR_LE;
3807                 ch->precision = 16;
3808                 break;
3809         case AFMT_S16_BE:
3810                 enc = AUDIO_ENCODING_SLINEAR_BE;
3811                 ch->precision = 16;
3812                 break;
3813         case AFMT_U16_LE:
3814                 enc = AUDIO_ENCODING_ULINEAR_LE;
3815                 ch->precision = 16;
3816                 break;
3817         case AFMT_U16_BE:
3818                 enc = AUDIO_ENCODING_ULINEAR_BE;
3819                 ch->precision = 16;
3820                 break;
3821         case AFMT_S24_LE:
3822                 enc = AUDIO_ENCODING_SLINEAR_LE;
3823                 ch->precision = 24;
3824                 break;
3825         case AFMT_S24_BE:
3826                 enc = AUDIO_ENCODING_SLINEAR_BE;
3827                 ch->precision = 24;
3828                 break;
3829         case AFMT_U24_LE:
3830                 enc = AUDIO_ENCODING_ULINEAR_LE;
3831                 ch->precision = 24;
3832                 break;
3833         case AFMT_U24_BE:
3834                 enc = AUDIO_ENCODING_ULINEAR_BE;
3835                 ch->precision = 24;
3836                 break;
3837         case AFMT_S32_LE:
3838                 enc = AUDIO_ENCODING_SLINEAR_LE;
3839                 ch->precision = 32;
3840                 break;
3841         case AFMT_S32_BE:
3842                 enc = AUDIO_ENCODING_SLINEAR_BE;
3843                 ch->precision = 32;
3844                 break;
3845         case AFMT_U32_LE:
3846                 enc = AUDIO_ENCODING_ULINEAR_LE;
3847                 ch->precision = 32;
3848                 break;
3849         case AFMT_U32_BE:
3850                 enc = AUDIO_ENCODING_ULINEAR_BE;
3851                 ch->precision = 32;
3852                 break;
3853         default:
3854                 enc = 0;
3855                 ch->precision = 16;
3856                 kprintf("Unknown format %x\n", ch->format);
3857         }
3858
3859         if (ch->format & AFMT_STEREO) {
3860                 ch->channels = 2;
3861         } else {
3862                 ch->channels = 1;
3863         }
3864
3865 /*      for (mode =  ......      */
3866                 for (i = 0; i < sc->sc_nalts; i++) {
3867                         const struct usb_audio_streaming_type1_descriptor *a1d =
3868                                 sc->sc_alts[i].asf1desc;
3869                         if (ch->channels == a1d->bNrChannels &&
3870                             ch->precision == a1d->bBitResolution &&
3871 #if 0
3872                             enc == sc->sc_alts[i].encoding) {
3873 #else
3874                             enc == sc->sc_alts[i].encoding &&
3875                             (mode == AUMODE_PLAY ? UE_DIR_OUT : UE_DIR_IN) ==
3876                             UE_GET_DIR(sc->sc_alts[i].edesc->bEndpointAddress)) {
3877 #endif
3878                                 if (a1d->bSamFreqType == UA_SAMP_CONTNUOUS) {
3879                                         DPRINTFN(2,("uaudio_set_params: cont %d-%d\n",
3880                                             UA_SAMP_LO(a1d), UA_SAMP_HI(a1d)));
3881                                         if (UA_SAMP_LO(a1d) <= ch->sample_rate &&
3882                                             ch->sample_rate <= UA_SAMP_HI(a1d)) {
3883                                                 if (mode == AUMODE_PLAY)
3884                                                         sc->sc_playchan.altidx = i;
3885                                                 else
3886                                                         sc->sc_recchan.altidx = i;
3887                                                 goto found;
3888                                         }
3889                                 } else {
3890                                         for (j = 0; j < a1d->bSamFreqType; j++) {
3891                                                 DPRINTFN(2,("uaudio_set_params: disc #"
3892                                                     "%d: %d\n", j, UA_GETSAMP(a1d, j)));
3893                                                 /* XXX allow for some slack */
3894                                                 if (UA_GETSAMP(a1d, j) ==
3895                                                     ch->sample_rate) {
3896                                                         if (mode == AUMODE_PLAY)
3897                                                                 sc->sc_playchan.altidx = i;
3898                                                         else
3899                                                                 sc->sc_recchan.altidx = i;
3900                                                         goto found;
3901                                                 }
3902                                         }
3903                                 }
3904                         }
3905                 }
3906                 /* return (EINVAL); */
3907                 if (mode == AUMODE_PLAY) 
3908                         kprintf("uaudio: This device can't play in rate=%d.\n", ch->sample_rate);
3909                 else
3910                         kprintf("uaudio: This device can't record in rate=%d.\n", ch->sample_rate);
3911                 return (-1);
3912