Remove ASR_MEASURE_PERFORMANCE, it doesn't work anyway.
[dragonfly.git] / sys / dev / sound / usb / uaudio.c
1 /*      $NetBSD: uaudio.c,v 1.41 2001/01/23 14:04:13 augustss Exp $     */
2 /*      $FreeBSD: src/sys/dev/sound/usb/uaudio.c,v 1.6.2.2 2002/11/06 21:18:17 joe Exp $: */
3 /*      $DragonFly: src/sys/dev/sound/usb/uaudio.c,v 1.5 2004/02/12 00:00:19 dillon 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/data/devclass/audio10.pdf
44  *                  http://www.usb.org/developers/data/devclass/frmts10.pdf
45  *                  http://www.usb.org/developers/data/devclass/termt10.pdf
46  */
47
48 #include <sys/param.h>
49 #include <sys/systm.h>
50 #include <sys/kernel.h>
51 #include <sys/malloc.h>
52 #if defined(__NetBSD__) || defined(__OpenBSD__)
53 #include <sys/device.h>
54 #include <sys/ioctl.h>
55 #endif
56 #include <sys/tty.h>
57 #include <sys/file.h>
58 #include <sys/reboot.h>         /* for bootverbose */
59 #include <sys/select.h>
60 #include <sys/proc.h>
61 #if defined(__NetBSD__) || defined(__OpenBSD__)
62 #include <sys/device.h>
63 #elif defined(__DragonFly__)
64 #include <sys/module.h>
65 #include <sys/bus.h>
66 #include <sys/conf.h>
67 #endif
68 #include <sys/poll.h>
69 #include <sys/sysctl.h>
70
71 #if defined(__NetBSD__) || defined(__OpenBSD__)
72 #include <sys/audioio.h>
73 #include <dev/audio_if.h>
74 #include <dev/mulaw.h>
75 #include <dev/auconv.h>
76 #elif defined(__DragonFly__)
77 #include <dev/sound/pcm/sound.h>        /* XXXXX */
78 #include <dev/sound/chip.h>
79 #endif
80
81 #include <bus/usb/usb.h>
82 #include <bus/usb/usbdi.h>
83 #include <bus/usb/usbdi_util.h>
84 #include <bus/usb/usb_quirks.h>
85
86 #include <dev/sound/usb/uaudioreg.h>
87 #include <dev/sound/usb/uaudio.h>
88
89 #ifdef USB_DEBUG
90 #define DPRINTF(x)      if (uaudiodebug) logprintf x
91 #define DPRINTFN(n,x)   if (uaudiodebug>(n)) logprintf x
92 int     uaudiodebug = 0;
93 SYSCTL_NODE(_hw_usb, OID_AUTO, uaudio, CTLFLAG_RW, 0, "USB uaudio");
94 SYSCTL_INT(_hw_usb_uaudio, OID_AUTO, debug, CTLFLAG_RW,
95            &uaudiodebug, 0, "uaudio debug level");
96 #else
97 #define DPRINTF(x)
98 #define DPRINTFN(n,x)
99 #endif
100
101 #define UAUDIO_NCHANBUFS 6      /* number of outstanding request */
102 #define UAUDIO_NFRAMES   20     /* ms of sound in each request */
103
104
105 #define MIX_MAX_CHAN 8
106 struct mixerctl {
107         u_int16_t       wValue[MIX_MAX_CHAN]; /* using nchan */
108         u_int16_t       wIndex;
109         u_int8_t        nchan;
110         u_int8_t        type;
111 #define MIX_ON_OFF      1
112 #define MIX_SIGNED_16   2
113 #define MIX_UNSIGNED_16 3
114 #define MIX_SIGNED_8    4
115 #define MIX_SIZE(n) ((n) == MIX_SIGNED_16 || (n) == MIX_UNSIGNED_16 ? 2 : 1)
116 #define MIX_UNSIGNED(n) ((n) == MIX_UNSIGNED_16)
117         int             minval, maxval;
118         u_int           delta;
119         u_int           mul;
120 #if defined(__DragonFly__) /* XXXXX */
121         unsigned        ctl;
122 #else
123         u_int8_t        class;
124         char            ctlname[MAX_AUDIO_DEV_LEN];
125         char            *ctlunit;
126 #endif
127 };
128 #define MAKE(h,l) (((h) << 8) | (l))
129
130 struct as_info {
131         u_int8_t        alt;
132         u_int8_t        encoding;
133         usbd_interface_handle   ifaceh;
134         usb_interface_descriptor_t *idesc;
135         usb_endpoint_descriptor_audio_t *edesc;
136         struct usb_audio_streaming_type1_descriptor *asf1desc;
137 };
138
139 struct chan {
140         int     terminal;       /* terminal id */
141 #if defined(__NetBSD__) || defined(__OpenBSD__)
142         void    (*intr)(void *);        /* dma completion intr handler */
143         void    *arg;           /* arg for intr() */
144 #else
145         struct pcm_channel *pcm_ch;
146 #endif
147         usbd_pipe_handle pipe;
148         int     dir;            /* direction */
149
150         u_int   sample_size;
151         u_int   sample_rate;
152         u_int   bytes_per_frame;
153         u_int   fraction;       /* fraction/1000 is the extra samples/frame */
154         u_int   residue;        /* accumulates the fractional samples */
155
156         u_char  *start;         /* upper layer buffer start */
157         u_char  *end;           /* upper layer buffer end */
158         u_char  *cur;           /* current position in upper layer buffer */
159         int     blksize;        /* chunk size to report up */
160         int     transferred;    /* transferred bytes not reported up */
161
162         char    nofrac;         /* don't do sample rate adjustment */
163
164         int     curchanbuf;
165         struct chanbuf {
166                 struct chan         *chan;
167                 usbd_xfer_handle xfer;
168                 u_char              *buffer;
169                 u_int16_t           sizes[UAUDIO_NFRAMES];
170                 u_int16_t           size;
171         } chanbufs[UAUDIO_NCHANBUFS];
172
173         struct uaudio_softc *sc; /* our softc */
174 #if defined(__DragonFly__)
175         u_int32_t format;
176         int     precision;
177         int     channels;
178 #endif
179 };
180
181 struct uaudio_softc {
182         USBBASEDEVICE sc_dev;           /* base device */
183         usbd_device_handle sc_udev;     /* USB device */
184
185         char    sc_dead;        /* The device is dead -- kill it */
186
187         int     sc_ac_iface;    /* Audio Control interface */
188         usbd_interface_handle   sc_ac_ifaceh;
189
190         struct chan sc_chan;
191
192         int     sc_curaltidx;
193
194         int     sc_nullalt;
195
196         int     sc_audio_rev;
197
198         struct as_info *sc_alts;
199         int     sc_nalts;
200         int     sc_props;
201
202         int     sc_altflags;
203 #define HAS_8     0x01
204 #define HAS_16    0x02
205 #define HAS_8U    0x04
206 #define HAS_ALAW  0x08
207 #define HAS_MULAW 0x10
208
209         struct mixerctl *sc_ctls;
210         int     sc_nctls;
211
212         device_ptr_t sc_audiodev;
213         char    sc_dying;
214 };
215
216 #define UAC_OUTPUT 0
217 #define UAC_INPUT  1
218 #define UAC_EQUAL  2
219
220 Static usbd_status      uaudio_identify_ac(struct uaudio_softc *sc,
221                                            usb_config_descriptor_t *cdesc);
222 Static usbd_status      uaudio_identify_as(struct uaudio_softc *sc,
223                                            usb_config_descriptor_t *cdesc);
224 Static usbd_status      uaudio_process_as(struct uaudio_softc *sc,
225                             char *buf, int *offsp, int size,
226                             usb_interface_descriptor_t *id);
227
228 Static void             uaudio_add_alt(struct uaudio_softc *sc, 
229                                        struct as_info *ai);
230
231 Static usb_interface_descriptor_t *uaudio_find_iface(char *buf,
232                             int size, int *offsp, int subtype);
233
234 Static void             uaudio_mixer_add_ctl(struct uaudio_softc *sc,
235                                              struct mixerctl *mp);
236
237 #if defined(__NetBSD__) || defined(__OpenBSD__)
238 Static char             *uaudio_id_name(struct uaudio_softc *sc,
239                                         usb_descriptor_t **dps, int id);
240 #endif
241
242 Static struct usb_audio_cluster uaudio_get_cluster(int id,
243                                                    usb_descriptor_t **dps);
244 Static void             uaudio_add_input(struct uaudio_softc *sc,
245                             usb_descriptor_t *v, usb_descriptor_t **dps);
246 Static void             uaudio_add_output(struct uaudio_softc *sc,
247                             usb_descriptor_t *v, usb_descriptor_t **dps);
248 Static void             uaudio_add_mixer(struct uaudio_softc *sc,
249                             usb_descriptor_t *v, usb_descriptor_t **dps);
250 Static void             uaudio_add_selector(struct uaudio_softc *sc,
251                             usb_descriptor_t *v, usb_descriptor_t **dps);
252 Static void             uaudio_add_feature(struct uaudio_softc *sc,
253                             usb_descriptor_t *v, usb_descriptor_t **dps);
254 Static void             uaudio_add_processing_updown(struct uaudio_softc *sc,
255                                  usb_descriptor_t *v, usb_descriptor_t **dps);
256 Static void             uaudio_add_processing(struct uaudio_softc *sc,
257                             usb_descriptor_t *v, usb_descriptor_t **dps);
258 Static void             uaudio_add_extension(struct uaudio_softc *sc,
259                             usb_descriptor_t *v, usb_descriptor_t **dps);
260 Static usbd_status      uaudio_identify(struct uaudio_softc *sc, 
261                             usb_config_descriptor_t *cdesc);
262
263 Static int              uaudio_signext(int type, int val);
264 #if defined(__NetBSD__) || defined(__OpenBSD__)
265 Static int              uaudio_value2bsd(struct mixerctl *mc, int val);
266 #endif
267 Static int              uaudio_bsd2value(struct mixerctl *mc, int val);
268 Static int              uaudio_get(struct uaudio_softc *sc, int type,
269                             int which, int wValue, int wIndex, int len);
270 #if defined(__NetBSD__) || defined(__OpenBSD__)
271 Static int              uaudio_ctl_get(struct uaudio_softc *sc, int which,
272                             struct mixerctl *mc, int chan);
273 #endif
274 Static void             uaudio_set(struct uaudio_softc *sc, int type,
275                             int which, int wValue, int wIndex, int l, int v);
276 Static void             uaudio_ctl_set(struct uaudio_softc *sc, int which,
277                             struct mixerctl *mc, int chan, int val);
278
279 Static usbd_status      uaudio_set_speed(struct uaudio_softc *, int, u_int);
280
281 Static usbd_status      uaudio_chan_open(struct uaudio_softc *sc,
282                                          struct chan *ch);
283 Static void             uaudio_chan_close(struct uaudio_softc *sc,
284                                           struct chan *ch);
285 Static usbd_status      uaudio_chan_alloc_buffers(struct uaudio_softc *,
286                                                   struct chan *);
287 Static void             uaudio_chan_free_buffers(struct uaudio_softc *,
288                                                  struct chan *);
289
290 #if defined(__NetBSD__) || defined(__OpenBSD__)
291 Static void             uaudio_chan_set_param(struct chan *ch,
292                             struct audio_params *param, u_char *start, 
293                             u_char *end, int blksize);
294 #endif
295
296 Static void             uaudio_chan_ptransfer(struct chan *ch);
297 Static void             uaudio_chan_pintr(usbd_xfer_handle xfer, 
298                             usbd_private_handle priv, usbd_status status);
299
300 Static void             uaudio_chan_rtransfer(struct chan *ch);
301 Static void             uaudio_chan_rintr(usbd_xfer_handle xfer, 
302                             usbd_private_handle priv, usbd_status status);
303
304 #if defined(__NetBSD__) || defined(__OpenBSD__)
305 Static int              uaudio_open(void *, int);
306 Static void             uaudio_close(void *);
307 Static int              uaudio_drain(void *);
308 Static int              uaudio_query_encoding(void *, struct audio_encoding *);
309 Static int              uaudio_set_params(void *, int, int, 
310                             struct audio_params *, struct audio_params *);
311 Static int              uaudio_round_blocksize(void *, int);
312 Static int              uaudio_trigger_output(void *, void *, void *,
313                                               int, void (*)(void *), void *,
314                                               struct audio_params *);
315 Static int              uaudio_trigger_input (void *, void *, void *,
316                                               int, void (*)(void *), void *,
317                                               struct audio_params *);
318 Static int              uaudio_halt_in_dma(void *);
319 Static int              uaudio_halt_out_dma(void *);
320 Static int              uaudio_getdev(void *, struct audio_device *);
321 Static int              uaudio_mixer_set_port(void *, mixer_ctrl_t *);
322 Static int              uaudio_mixer_get_port(void *, mixer_ctrl_t *);
323 Static int              uaudio_query_devinfo(void *, mixer_devinfo_t *);
324 Static int              uaudio_get_props(void *);
325
326 Static struct audio_hw_if uaudio_hw_if = {
327         uaudio_open,
328         uaudio_close,
329         uaudio_drain,
330         uaudio_query_encoding,
331         uaudio_set_params,
332         uaudio_round_blocksize,
333         NULL,
334         NULL,
335         NULL,
336         NULL,
337         NULL,
338         uaudio_halt_out_dma,
339         uaudio_halt_in_dma,
340         NULL,
341         uaudio_getdev,
342         NULL,
343         uaudio_mixer_set_port,
344         uaudio_mixer_get_port,
345         uaudio_query_devinfo,
346         NULL,
347         NULL,
348         NULL,
349         NULL,
350         uaudio_get_props,
351         uaudio_trigger_output,
352         uaudio_trigger_input,
353 };
354
355 Static struct audio_device uaudio_device = {
356         "USB audio",
357         "",
358         "uaudio"
359 };
360
361 #elif defined(__DragonFly__)
362 Static int      audio_attach_mi(device_t);
363 Static void     uaudio_init_params(struct uaudio_softc * sc, struct chan *ch);
364
365 /* for NetBSD compatibirity */
366 #define AUMODE_PLAY     0x01
367 #define AUMODE_RECORD   0x02
368
369 #define AUDIO_PROP_FULLDUPLEX   0x01
370
371 #define AUDIO_ENCODING_ULAW             1
372 #define AUDIO_ENCODING_ALAW             2
373 #define AUDIO_ENCODING_SLINEAR_LE       6
374 #define AUDIO_ENCODING_SLINEAR_BE       7
375 #define AUDIO_ENCODING_ULINEAR_LE       8
376 #define AUDIO_ENCODING_ULINEAR_BE       9
377
378 #endif  /* FreeBSD */
379
380
381 #if defined(__NetBSD__) || defined(__OpenBSD__)
382
383 USB_DECLARE_DRIVER(uaudio);
384
385 #elif defined(__DragonFly__)
386
387 USB_DECLARE_DRIVER_INIT(uaudio,
388                 DEVMETHOD(device_suspend, bus_generic_suspend),
389                 DEVMETHOD(device_resume, bus_generic_resume),
390                 DEVMETHOD(device_shutdown, bus_generic_shutdown),
391                 DEVMETHOD(bus_print_child, bus_generic_print_child)
392                 );
393 #endif
394
395
396 USB_MATCH(uaudio)
397 {
398         USB_MATCH_START(uaudio, uaa);
399         usb_interface_descriptor_t *id;
400         
401         if (uaa->iface == NULL)
402                 return (UMATCH_NONE);
403
404         id = usbd_get_interface_descriptor(uaa->iface);
405         /* Trigger on the control interface. */
406         if (id == NULL || 
407             id->bInterfaceClass != UICLASS_AUDIO ||
408             id->bInterfaceSubClass != UISUBCLASS_AUDIOCONTROL ||
409             (usbd_get_quirks(uaa->device)->uq_flags & UQ_BAD_AUDIO))
410                 return (UMATCH_NONE);
411
412         return (UMATCH_IFACECLASS_IFACESUBCLASS);
413 }
414
415 USB_ATTACH(uaudio)
416 {
417         USB_ATTACH_START(uaudio, sc, uaa);
418         usb_interface_descriptor_t *id;
419         usb_config_descriptor_t *cdesc;
420         char devinfo[1024];
421         usbd_status err;
422         int i, j, found;
423
424         usbd_devinfo(uaa->device, 0, devinfo);
425         USB_ATTACH_SETUP;
426
427 #if !defined(__DragonFly__)
428         printf(": %s\n", devinfo);
429 #endif
430
431         sc->sc_udev = uaa->device;
432
433         cdesc = usbd_get_config_descriptor(sc->sc_udev);
434         if (cdesc == NULL) {
435                 printf("%s: failed to get configuration descriptor\n",
436                        USBDEVNAME(sc->sc_dev));
437                 USB_ATTACH_ERROR_RETURN;
438         }
439
440         err = uaudio_identify(sc, cdesc);
441         if (err) {
442                 printf("%s: audio descriptors make no sense, error=%d\n",
443                        USBDEVNAME(sc->sc_dev), err);
444                 USB_ATTACH_ERROR_RETURN;
445         }
446
447         sc->sc_ac_ifaceh = uaa->iface;
448         /* Pick up the AS interface. */
449         for (i = 0; i < uaa->nifaces; i++) {
450                 if (uaa->ifaces[i] == NULL)
451                         continue;
452                 id = usbd_get_interface_descriptor(uaa->ifaces[i]);
453                 if (id == NULL)
454                         continue;
455                 found = 0;
456                 for (j = 0; j < sc->sc_nalts; j++) {
457                         if (id->bInterfaceNumber ==
458                             sc->sc_alts[j].idesc->bInterfaceNumber) {
459                                 sc->sc_alts[j].ifaceh = uaa->ifaces[i];
460                                 found = 1;
461                         }
462                 }
463                 if (found)
464                         uaa->ifaces[i] = NULL;
465         }
466
467         for (j = 0; j < sc->sc_nalts; j++) {
468                 if (sc->sc_alts[j].ifaceh == NULL) {
469                         printf("%s: alt %d missing AS interface(s)\n",
470                             USBDEVNAME(sc->sc_dev), j);
471                         USB_ATTACH_ERROR_RETURN;
472                 }
473         }
474
475         printf("%s: audio rev %d.%02x\n", USBDEVNAME(sc->sc_dev),
476                sc->sc_audio_rev >> 8, sc->sc_audio_rev & 0xff);
477
478         sc->sc_chan.sc = sc;
479
480         if (usbd_get_quirks(sc->sc_udev)->uq_flags & UQ_AU_NO_FRAC)
481                 sc->sc_chan.nofrac = 1;
482
483 #ifndef USB_DEBUG
484         if (bootverbose)
485 #endif
486                 printf("%s: %d mixer controls\n", USBDEVNAME(sc->sc_dev),
487                     sc->sc_nctls);
488
489 #if !defined(__DragonFly__)
490         usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev,
491                            USBDEV(sc->sc_dev));
492 #endif
493
494         DPRINTF(("uaudio_attach: doing audio_attach_mi\n"));
495 #if defined(__OpenBSD__)
496         audio_attach_mi(&uaudio_hw_if, sc, &sc->sc_dev);
497 #elif defined(__NetBSD__)
498         sc->sc_audiodev = audio_attach_mi(&uaudio_hw_if, sc, &sc->sc_dev);
499 #elif defined(__DragonFly__)
500         sc->sc_dying = 0;
501         if (audio_attach_mi(sc->sc_dev)) {
502                 printf("audio_attach_mi failed\n");
503                 USB_ATTACH_ERROR_RETURN;
504         }
505 #endif
506
507         USB_ATTACH_SUCCESS_RETURN;
508 }
509
510 #if defined(__NetBSD__) || defined(__OpenBSD__)
511 int
512 uaudio_activate(device_ptr_t self, enum devact act)
513 {
514         struct uaudio_softc *sc = (struct uaudio_softc *)self;
515         int rv = 0;
516
517         switch (act) {
518         case DVACT_ACTIVATE:
519                 return (EOPNOTSUPP);
520                 break;
521
522         case DVACT_DEACTIVATE:
523                 if (sc->sc_audiodev != NULL)
524                         rv = config_deactivate(sc->sc_audiodev);
525                 sc->sc_dying = 1;
526                 break;
527         }
528         return (rv);
529 }
530 #endif
531
532 #if defined(__NetBSD__) || defined(__OpenBSD__)
533 int
534 uaudio_detach(device_ptr_t self, int flags)
535 {
536         struct uaudio_softc *sc = (struct uaudio_softc *)self;
537         int rv = 0;
538
539         /* Wait for outstanding requests to complete. */
540         usbd_delay_ms(sc->sc_udev, UAUDIO_NCHANBUFS * UAUDIO_NFRAMES);
541
542         if (sc->sc_audiodev != NULL)
543                 rv = config_detach(sc->sc_audiodev, flags);
544
545         usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev,
546                            USBDEV(sc->sc_dev));
547
548         return (rv);
549 }
550 #elif defined(__DragonFly__)
551
552 USB_DETACH(uaudio)
553 {
554         USB_DETACH_START(uaudio, sc);
555
556         sc->sc_dying = 1;
557
558 #if 0 /* XXX */
559         /* Wait for outstanding requests to complete. */
560         usbd_delay_ms(sc->sc_udev, UAUDIO_NCHANBUFS * UAUDIO_NFRAMES);
561 #endif
562
563         /* do nothing ? */
564         return bus_generic_detach(sc->sc_dev);
565 }
566 #endif
567
568 #if defined(__NetBSD__) || defined(__OpenBSD__)
569 int
570 uaudio_query_encoding(void *addr, struct audio_encoding *fp)
571 {
572         struct uaudio_softc *sc = addr;
573         int flags = sc->sc_altflags;
574         int idx;
575
576         if (sc->sc_dying)
577                 return (EIO);
578     
579         if (sc->sc_nalts == 0 || flags == 0)
580                 return (ENXIO);
581
582         idx = fp->index;
583         switch (idx) {
584         case 0:
585                 strcpy(fp->name, AudioEulinear);
586                 fp->encoding = AUDIO_ENCODING_ULINEAR;
587                 fp->precision = 8;
588                 fp->flags = flags&HAS_8U ? 0 : AUDIO_ENCODINGFLAG_EMULATED;
589                 return (0);
590         case 1:
591                 strcpy(fp->name, AudioEmulaw);
592                 fp->encoding = AUDIO_ENCODING_ULAW;
593                 fp->precision = 8;
594                 fp->flags = flags&HAS_MULAW ? 0 : AUDIO_ENCODINGFLAG_EMULATED;
595                 return (0);
596         case 2:
597                 strcpy(fp->name, AudioEalaw);
598                 fp->encoding = AUDIO_ENCODING_ALAW;
599                 fp->precision = 8;
600                 fp->flags = flags&HAS_ALAW ? 0 : AUDIO_ENCODINGFLAG_EMULATED;
601                 return (0);
602         case 3:
603                 strcpy(fp->name, AudioEslinear);
604                 fp->encoding = AUDIO_ENCODING_SLINEAR;
605                 fp->precision = 8;
606                 fp->flags = flags&HAS_8 ? 0 : AUDIO_ENCODINGFLAG_EMULATED;
607                 return (0);
608         case 4:
609                 strcpy(fp->name, AudioEslinear_le);
610                 fp->encoding = AUDIO_ENCODING_SLINEAR_LE;
611                 fp->precision = 16;
612                 fp->flags = 0;
613                 return (0);
614         case 5:
615                 strcpy(fp->name, AudioEulinear_le);
616                 fp->encoding = AUDIO_ENCODING_ULINEAR_LE;
617                 fp->precision = 16;
618                 fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
619                 return (0);
620         case 6:
621                 strcpy(fp->name, AudioEslinear_be);
622                 fp->encoding = AUDIO_ENCODING_SLINEAR_BE;
623                 fp->precision = 16;
624                 fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
625                 return (0);
626         case 7:
627                 strcpy(fp->name, AudioEulinear_be);
628                 fp->encoding = AUDIO_ENCODING_ULINEAR_BE;
629                 fp->precision = 16;
630                 fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
631                 return (0);
632         default:
633                 return (EINVAL);
634         }
635 }
636 #endif
637
638 usb_interface_descriptor_t *
639 uaudio_find_iface(char *buf, int size, int *offsp, int subtype)
640 {
641         usb_interface_descriptor_t *d;
642
643         while (*offsp < size) {
644                 d = (void *)(buf + *offsp);
645                 *offsp += d->bLength;
646                 if (d->bDescriptorType == UDESC_INTERFACE &&
647                     d->bInterfaceClass == UICLASS_AUDIO &&
648                     d->bInterfaceSubClass == subtype)
649                         return (d);
650         }
651         return (NULL);
652 }
653
654 void
655 uaudio_mixer_add_ctl(struct uaudio_softc *sc, struct mixerctl *mc)
656 {
657         int res;
658         size_t len = sizeof(*mc) * (sc->sc_nctls + 1);
659         struct mixerctl *nmc = sc->sc_nctls == 0 ?
660           malloc(len, M_USBDEV, M_NOWAIT) :
661           realloc(sc->sc_ctls, len, M_USBDEV, M_NOWAIT);
662
663         if(nmc == NULL){
664                 printf("uaudio_mixer_add_ctl: no memory\n");
665                 return;
666         }
667         sc->sc_ctls = nmc;
668
669         mc->delta = 0;
670         if (mc->type != MIX_ON_OFF) {
671                 /* Determine min and max values. */
672                 mc->minval = uaudio_signext(mc->type, 
673                         uaudio_get(sc, GET_MIN, UT_READ_CLASS_INTERFACE, 
674                                    mc->wValue[0], mc->wIndex, 
675                                    MIX_SIZE(mc->type)));
676                 mc->maxval = 1 + uaudio_signext(mc->type, 
677                         uaudio_get(sc, GET_MAX, UT_READ_CLASS_INTERFACE,
678                                    mc->wValue[0], mc->wIndex,
679                                    MIX_SIZE(mc->type)));
680                 mc->mul = mc->maxval - mc->minval;
681                 if (mc->mul == 0)
682                         mc->mul = 1;
683                 res = uaudio_get(sc, GET_RES, UT_READ_CLASS_INTERFACE,
684                                  mc->wValue[0], mc->wIndex,
685                                  MIX_SIZE(mc->type));
686                 if (res > 0)
687                         mc->delta = (res * 256 + mc->mul/2) / mc->mul;
688         } else {
689                 mc->minval = 0;
690                 mc->maxval = 1;
691         }
692
693         sc->sc_ctls[sc->sc_nctls++] = *mc;
694
695 #ifdef USB_DEBUG
696         if (uaudiodebug > 2) {
697                 int i;
698                 DPRINTF(("uaudio_mixer_add_ctl: wValue=%04x",mc->wValue[0]));
699                 for (i = 1; i < mc->nchan; i++)
700                         DPRINTF((",%04x", mc->wValue[i]));
701 #if defined(__DragonFly__)
702                 DPRINTF((" wIndex=%04x type=%d "
703                          "min=%d max=%d\n",
704                          mc->wIndex, mc->type, 
705                          mc->minval, mc->maxval));
706 #else
707                 DPRINTF((" wIndex=%04x type=%d ctl='%d' unit='%s'"
708                          "min=%d max=%d\n",
709                          mc->wIndex, mc->type, mc->ctlname, mc->ctlunit,
710                          mc->minval, mc->maxval));
711 #endif
712         }
713 #endif
714 }
715
716 #if defined(__NetBSD__) || defined(__OpenBSD__)
717 char *
718 uaudio_id_name(struct uaudio_softc *sc, usb_descriptor_t **dps, int id)
719 {
720         static char buf[32];
721         sprintf(buf, "i%d", id);
722         return (buf);
723 }
724 #endif
725
726 struct usb_audio_cluster
727 uaudio_get_cluster(int id, usb_descriptor_t **dps)
728 {
729         struct usb_audio_cluster r;
730         usb_descriptor_t *dp;
731         int i;
732
733         for (i = 0; i < 25; i++) { /* avoid infinite loops */
734                 dp = dps[id];
735                 if (dp == 0)
736                         goto bad;
737                 switch (dp->bDescriptorSubtype) {
738                 case UDESCSUB_AC_INPUT:
739 #define p ((struct usb_audio_input_terminal *)dp)
740                         r.bNrChannels = p->bNrChannels;
741                         USETW(r.wChannelConfig, UGETW(p->wChannelConfig));
742                         r.iChannelNames = p->iChannelNames;
743 #undef p
744                         return (r);
745                 case UDESCSUB_AC_OUTPUT:
746 #define p ((struct usb_audio_output_terminal *)dp)
747                         id = p->bSourceId;
748 #undef p
749                         break;
750                 case UDESCSUB_AC_MIXER:
751 #define p ((struct usb_audio_mixer_unit *)dp)
752                         r = *(struct usb_audio_cluster *)
753                                 &p->baSourceId[p->bNrInPins];
754 #undef p
755                         return (r);
756                 case UDESCSUB_AC_SELECTOR:
757                         /* XXX This is not really right */
758 #define p ((struct usb_audio_selector_unit *)dp)
759                         id = p->baSourceId[0];
760 #undef p
761                         break;
762                 case UDESCSUB_AC_FEATURE:
763 #define p ((struct usb_audio_feature_unit *)dp)
764                         id = p->bSourceId;
765 #undef p
766                         break;
767                 case UDESCSUB_AC_PROCESSING:
768 #define p ((struct usb_audio_processing_unit *)dp)
769                         r = *(struct usb_audio_cluster *)
770                                 &p->baSourceId[p->bNrInPins];
771 #undef p
772                         return (r);
773                 case UDESCSUB_AC_EXTENSION:
774 #define p ((struct usb_audio_extension_unit *)dp)
775                         r = *(struct usb_audio_cluster *)
776                                 &p->baSourceId[p->bNrInPins];
777 #undef p
778                         return (r);
779                 default:
780                         goto bad;
781                 }
782         }
783  bad:
784         printf("uaudio_get_cluster: bad data\n");
785         memset(&r, 0, sizeof r);
786         return (r);
787
788 }
789
790 void
791 uaudio_add_input(struct uaudio_softc *sc, usb_descriptor_t *v, 
792                  usb_descriptor_t **dps)
793 {
794 #ifdef USB_DEBUG
795         struct usb_audio_input_terminal *d = 
796                 (struct usb_audio_input_terminal *)v;
797
798         DPRINTFN(2,("uaudio_add_input: bTerminalId=%d wTerminalType=0x%04x "
799                     "bAssocTerminal=%d bNrChannels=%d wChannelConfig=%d "
800                     "iChannelNames=%d iTerminal=%d\n",
801                     d->bTerminalId, UGETW(d->wTerminalType), d->bAssocTerminal,
802                     d->bNrChannels, UGETW(d->wChannelConfig),
803                     d->iChannelNames, d->iTerminal));
804 #endif
805 }
806
807 void
808 uaudio_add_output(struct uaudio_softc *sc, usb_descriptor_t *v,
809                   usb_descriptor_t **dps)
810 {
811 #ifdef USB_DEBUG
812         struct usb_audio_output_terminal *d = 
813                 (struct usb_audio_output_terminal *)v;
814
815         DPRINTFN(2,("uaudio_add_output: bTerminalId=%d wTerminalType=0x%04x "
816                     "bAssocTerminal=%d bSourceId=%d iTerminal=%d\n",
817                     d->bTerminalId, UGETW(d->wTerminalType), d->bAssocTerminal,
818                     d->bSourceId, d->iTerminal));
819 #endif
820 }
821
822 void
823 uaudio_add_mixer(struct uaudio_softc *sc, usb_descriptor_t *v,
824                  usb_descriptor_t **dps)
825 {
826         struct usb_audio_mixer_unit *d = (struct usb_audio_mixer_unit *)v;
827         struct usb_audio_mixer_unit_1 *d1;
828         int c, chs, ichs, ochs, i, o, bno, p, mo, mc, k;
829         uByte *bm;
830         struct mixerctl mix;
831
832         DPRINTFN(2,("uaudio_add_mixer: bUnitId=%d bNrInPins=%d\n",
833                     d->bUnitId, d->bNrInPins));
834         
835         /* Compute the number of input channels */
836         ichs = 0;
837         for (i = 0; i < d->bNrInPins; i++)
838                 ichs += uaudio_get_cluster(d->baSourceId[i], dps).bNrChannels;
839
840         /* and the number of output channels */
841         d1 = (struct usb_audio_mixer_unit_1 *)&d->baSourceId[d->bNrInPins];
842         ochs = d1->bNrChannels;
843         DPRINTFN(2,("uaudio_add_mixer: ichs=%d ochs=%d\n", ichs, ochs));
844
845         bm = d1->bmControls;
846         mix.wIndex = MAKE(d->bUnitId, sc->sc_ac_iface);
847 #if !defined(__DragonFly__)
848         mix.class = -1;
849 #endif
850         mix.type = MIX_SIGNED_16;
851 #if !defined(__DragonFly__)     /* XXXXX */
852         mix.ctlunit = AudioNvolume;
853 #endif
854
855 #define BIT(bno) ((bm[bno / 8] >> (7 - bno % 8)) & 1)
856         for (p = i = 0; i < d->bNrInPins; i++) {
857                 chs = uaudio_get_cluster(d->baSourceId[i], dps).bNrChannels;
858                 mc = 0;
859                 for (c = 0; c < chs; c++) {
860                         mo = 0;
861                         for (o = 0; o < ochs; o++) {
862                                 bno = (p + c) * ochs + o;
863                                 if (BIT(bno))
864                                         mo++;
865                         }
866                         if (mo == 1)
867                                 mc++;
868                 }
869                 if (mc == chs && chs <= MIX_MAX_CHAN) {
870                         k = 0;
871                         for (c = 0; c < chs; c++)
872                                 for (o = 0; o < ochs; o++) {
873                                         bno = (p + c) * ochs + o;
874                                         if (BIT(bno))
875                                                 mix.wValue[k++] = 
876                                                         MAKE(p+c+1, o+1);
877                                 }
878 #if !defined(__DragonFly__)
879                         sprintf(mix.ctlname, "mix%d-%s", d->bUnitId,
880                                 uaudio_id_name(sc, dps, d->baSourceId[i]));
881 #endif
882                         mix.nchan = chs;
883                         uaudio_mixer_add_ctl(sc, &mix);
884                 } else {
885                         /* XXX */
886                 }
887 #undef BIT
888                 p += chs;
889         }
890
891 }
892
893 void
894 uaudio_add_selector(struct uaudio_softc *sc, usb_descriptor_t *v,
895                     usb_descriptor_t **dps)
896 {
897 #ifdef USB_DEBUG
898         struct usb_audio_selector_unit *d =
899                 (struct usb_audio_selector_unit *)v;
900
901         DPRINTFN(2,("uaudio_add_selector: bUnitId=%d bNrInPins=%d\n",
902                     d->bUnitId, d->bNrInPins));
903 #endif
904         printf("uaudio_add_selector: NOT IMPLEMENTED\n");
905 }
906
907 void
908 uaudio_add_feature(struct uaudio_softc *sc, usb_descriptor_t *v,
909                    usb_descriptor_t **dps)
910 {
911         struct usb_audio_feature_unit *d = (struct usb_audio_feature_unit *)v;
912         uByte *ctls = d->bmaControls;
913         int ctlsize = d->bControlSize;
914         int nchan = (d->bLength - 7) / ctlsize;
915 #if !defined(__DragonFly__)
916         int srcId = d->bSourceId;
917 #endif
918         u_int fumask, mmask, cmask;
919         struct mixerctl mix;
920         int chan, ctl, i, unit;
921
922 #define GET(i) (ctls[(i)*ctlsize] | \
923                 (ctlsize > 1 ? ctls[(i)*ctlsize+1] << 8 : 0))
924
925         mmask = GET(0);
926         /* Figure out what we can control */
927         for (cmask = 0, chan = 1; chan < nchan; chan++) {
928                 DPRINTFN(9,("uaudio_add_feature: chan=%d mask=%x\n",
929                             chan, GET(chan)));
930                 cmask |= GET(chan);
931         }
932
933 #if !defined(__DragonFly__)
934         DPRINTFN(1,("uaudio_add_feature: bUnitId=%d bSourceId=%d, "
935                     "%d channels, mmask=0x%04x, cmask=0x%04x\n", 
936                     d->bUnitId, srcId, nchan, mmask, cmask));
937 #endif
938
939         if (nchan > MIX_MAX_CHAN)
940                 nchan = MIX_MAX_CHAN;
941         unit = d->bUnitId;
942         mix.wIndex = MAKE(unit, sc->sc_ac_iface);
943         for (ctl = MUTE_CONTROL; ctl < LOUDNESS_CONTROL; ctl++) {
944                 fumask = FU_MASK(ctl);
945                 DPRINTFN(4,("uaudio_add_feature: ctl=%d fumask=0x%04x\n",
946                             ctl, fumask));
947                 if (mmask & fumask) {
948                         mix.nchan = 1;
949                         mix.wValue[0] = MAKE(ctl, 0);
950                 } else if (cmask & fumask) {
951                         mix.nchan = nchan - 1;
952                         for (i = 1; i < nchan; i++) {
953                                 if (GET(i) & fumask)
954                                         mix.wValue[i-1] = MAKE(ctl, i);
955                                 else
956                                         mix.wValue[i-1] = -1;
957                         }
958                 } else {
959                         continue;
960                 }
961 #undef GET
962
963 #if !defined(__DragonFly__)
964                 mix.class = -1; /* XXX */
965 #endif
966                 switch (ctl) {
967                 case MUTE_CONTROL:
968                         mix.type = MIX_ON_OFF;
969 #if defined(__DragonFly__)
970                         mix.ctl = SOUND_MIXER_NRDEVICES;
971 #else
972                         sprintf(mix.ctlname, "fea%d-%s-%s", unit,
973                                 uaudio_id_name(sc, dps, srcId), 
974                                 AudioNmute);
975                         mix.ctlunit = "";
976 #endif
977                         break;
978                 case VOLUME_CONTROL:
979                         mix.type = MIX_SIGNED_16;
980 #if defined(__DragonFly__)
981                         /* mix.ctl = SOUND_MIXER_VOLUME; */
982                         mix.ctl = SOUND_MIXER_PCM;
983 #else
984                         sprintf(mix.ctlname, "fea%d-%s-%s", unit,
985                                 uaudio_id_name(sc, dps, srcId), 
986                                 AudioNmaster);
987                         mix.ctlunit = AudioNvolume;
988 #endif
989                         break;
990                 case BASS_CONTROL:
991                         mix.type = MIX_SIGNED_8;
992 #if defined(__DragonFly__)
993                         mix.ctl = SOUND_MIXER_BASS;
994 #else
995                         sprintf(mix.ctlname, "fea%d-%s-%s", unit,
996                                 uaudio_id_name(sc, dps, srcId), 
997                                 AudioNbass);
998                         mix.ctlunit = AudioNbass;
999 #endif
1000                         break;
1001                 case MID_CONTROL:
1002                         mix.type = MIX_SIGNED_8;
1003 #if defined(__DragonFly__)
1004                         mix.ctl = SOUND_MIXER_NRDEVICES;        /* XXXXX */
1005 #else
1006                         sprintf(mix.ctlname, "fea%d-%s-%s", unit,
1007                                 uaudio_id_name(sc, dps, srcId), 
1008                                 AudioNmid);
1009                         mix.ctlunit = AudioNmid;
1010 #endif
1011                         break;
1012                 case TREBLE_CONTROL:
1013                         mix.type = MIX_SIGNED_8;
1014 #if defined(__DragonFly__)
1015                         mix.ctl = SOUND_MIXER_TREBLE;
1016 #else
1017                         sprintf(mix.ctlname, "fea%d-%s-%s", unit,
1018                                 uaudio_id_name(sc, dps, srcId), 
1019                                 AudioNtreble);
1020                         mix.ctlunit = AudioNtreble;
1021 #endif
1022                         break;
1023                 case GRAPHIC_EQUALIZER_CONTROL:
1024                         continue; /* XXX don't add anything */
1025                         break;
1026                 case AGC_CONTROL:
1027                         mix.type = MIX_ON_OFF;
1028 #if defined(__DragonFly__)
1029                         mix.ctl = SOUND_MIXER_NRDEVICES;        /* XXXXX */
1030 #else
1031                         sprintf(mix.ctlname, "fea%d-%s-%s", unit,
1032                                 uaudio_id_name(sc, dps, srcId), 
1033                                 AudioNagc);
1034                         mix.ctlunit = "";
1035 #endif
1036                         break;
1037                 case DELAY_CONTROL:
1038                         mix.type = MIX_UNSIGNED_16;
1039 #if defined(__DragonFly__)
1040                         mix.ctl = SOUND_MIXER_NRDEVICES;        /* XXXXX */
1041 #else
1042                         sprintf(mix.ctlname, "fea%d-%s-%s", unit,
1043                                 uaudio_id_name(sc, dps, srcId), 
1044                                 AudioNdelay);
1045                         mix.ctlunit = "4 ms";
1046 #endif
1047                         break;
1048                 case BASS_BOOST_CONTROL:
1049                         mix.type = MIX_ON_OFF;
1050 #if defined(__DragonFly__)
1051                         mix.ctl = SOUND_MIXER_NRDEVICES;        /* XXXXX */
1052 #else
1053                         sprintf(mix.ctlname, "fea%d-%s-%s", unit,
1054                                 uaudio_id_name(sc, dps, srcId), 
1055                                 AudioNbassboost);
1056                         mix.ctlunit = "";
1057 #endif
1058                         break;
1059                 case LOUDNESS_CONTROL:
1060                         mix.type = MIX_ON_OFF;
1061 #if defined(__DragonFly__)
1062                         mix.ctl = SOUND_MIXER_LOUD;     /* Is this correct ? */
1063 #else
1064                         sprintf(mix.ctlname, "fea%d-%s-%s", unit,
1065                                 uaudio_id_name(sc, dps, srcId), 
1066                                 AudioNloudness);
1067                         mix.ctlunit = "";
1068 #endif
1069                         break;
1070                 }
1071                 uaudio_mixer_add_ctl(sc, &mix);
1072         }
1073 }
1074
1075 void
1076 uaudio_add_processing_updown(struct uaudio_softc *sc, usb_descriptor_t *v,
1077                              usb_descriptor_t **dps)
1078 {
1079         struct usb_audio_processing_unit *d = 
1080             (struct usb_audio_processing_unit *)v;
1081         struct usb_audio_processing_unit_1 *d1 =
1082             (struct usb_audio_processing_unit_1 *)&d->baSourceId[d->bNrInPins];
1083         struct usb_audio_processing_unit_updown *ud =
1084             (struct usb_audio_processing_unit_updown *)
1085                 &d1->bmControls[d1->bControlSize];
1086         struct mixerctl mix;
1087         int i;
1088
1089         DPRINTFN(2,("uaudio_add_processing_updown: bUnitId=%d bNrModes=%d\n",
1090                     d->bUnitId, ud->bNrModes));
1091
1092         if (!(d1->bmControls[0] & UA_PROC_MASK(UD_MODE_SELECT_CONTROL))) {
1093                 DPRINTF(("uaudio_add_processing_updown: no mode select\n"));
1094                 return;
1095         }
1096
1097         mix.wIndex = MAKE(d->bUnitId, sc->sc_ac_iface);
1098         mix.nchan = 1;
1099         mix.wValue[0] = MAKE(UD_MODE_SELECT_CONTROL, 0);
1100 #if !defined(__DragonFly__)
1101         mix.class = -1;
1102 #endif
1103         mix.type = MIX_ON_OFF;  /* XXX */
1104 #if !defined(__DragonFly__)
1105         mix.ctlunit = "";
1106         sprintf(mix.ctlname, "pro%d-mode", d->bUnitId);
1107 #endif
1108
1109         for (i = 0; i < ud->bNrModes; i++) {
1110                 DPRINTFN(2,("uaudio_add_processing_updown: i=%d bm=0x%x\n",
1111                             i, UGETW(ud->waModes[i])));
1112                 /* XXX */
1113         }
1114         uaudio_mixer_add_ctl(sc, &mix);
1115 }
1116
1117 void
1118 uaudio_add_processing(struct uaudio_softc *sc, usb_descriptor_t *v,
1119                       usb_descriptor_t **dps)
1120 {
1121         struct usb_audio_processing_unit *d = 
1122             (struct usb_audio_processing_unit *)v;
1123         struct usb_audio_processing_unit_1 *d1 =
1124             (struct usb_audio_processing_unit_1 *)&d->baSourceId[d->bNrInPins];
1125         int ptype = UGETW(d->wProcessType);
1126         struct mixerctl mix;
1127
1128         DPRINTFN(2,("uaudio_add_processing: wProcessType=%d bUnitId=%d "
1129                     "bNrInPins=%d\n", ptype, d->bUnitId, d->bNrInPins));
1130
1131         if (d1->bmControls[0] & UA_PROC_ENABLE_MASK) {
1132                 mix.wIndex = MAKE(d->bUnitId, sc->sc_ac_iface);
1133                 mix.nchan = 1;
1134                 mix.wValue[0] = MAKE(XX_ENABLE_CONTROL, 0);
1135 #if !defined(__DragonFly__)
1136                 mix.class = -1;
1137 #endif
1138                 mix.type = MIX_ON_OFF;
1139 #if !defined(__DragonFly__)
1140                 mix.ctlunit = "";
1141                 sprintf(mix.ctlname, "pro%d.%d-enable", d->bUnitId, ptype);
1142 #endif
1143                 uaudio_mixer_add_ctl(sc, &mix);
1144         }
1145
1146         switch(ptype) {
1147         case UPDOWNMIX_PROCESS:
1148                 uaudio_add_processing_updown(sc, v, dps);
1149                 break;
1150         case DOLBY_PROLOGIC_PROCESS:
1151         case P3D_STEREO_EXTENDER_PROCESS:
1152         case REVERBATION_PROCESS:
1153         case CHORUS_PROCESS:
1154         case DYN_RANGE_COMP_PROCESS:
1155         default:
1156 #ifdef USB_DEBUG
1157                 printf("uaudio_add_processing: unit %d, type=%d not impl.\n",
1158                        d->bUnitId, ptype);
1159 #endif
1160                 break;
1161         }
1162 }
1163
1164 void
1165 uaudio_add_extension(struct uaudio_softc *sc, usb_descriptor_t *v,
1166                      usb_descriptor_t **dps)
1167 {
1168         struct usb_audio_extension_unit *d = 
1169             (struct usb_audio_extension_unit *)v;
1170         struct usb_audio_extension_unit_1 *d1 =
1171             (struct usb_audio_extension_unit_1 *)&d->baSourceId[d->bNrInPins];
1172         struct mixerctl mix;
1173
1174         DPRINTFN(2,("uaudio_add_extension: bUnitId=%d bNrInPins=%d\n",
1175                     d->bUnitId, d->bNrInPins));
1176
1177         if (usbd_get_quirks(sc->sc_udev)->uq_flags & UQ_AU_NO_XU)
1178                 return;
1179
1180         if (d1->bmControls[0] & UA_EXT_ENABLE_MASK) {
1181                 mix.wIndex = MAKE(d->bUnitId, sc->sc_ac_iface);
1182                 mix.nchan = 1;
1183                 mix.wValue[0] = MAKE(UA_EXT_ENABLE, 0);
1184 #if !defined(__DragonFly__)
1185                 mix.class = -1;
1186 #endif
1187                 mix.type = MIX_ON_OFF;
1188 #if !defined(__DragonFly__)
1189                 mix.ctlunit = "";
1190                 sprintf(mix.ctlname, "ext%d-enable", d->bUnitId);
1191 #endif
1192                 uaudio_mixer_add_ctl(sc, &mix);
1193         }
1194 }
1195
1196 usbd_status
1197 uaudio_identify(struct uaudio_softc *sc, usb_config_descriptor_t *cdesc)
1198 {
1199         usbd_status err;
1200
1201         err = uaudio_identify_ac(sc, cdesc);
1202         if (err)
1203                 return (err);
1204         return (uaudio_identify_as(sc, cdesc));
1205 }
1206
1207 void
1208 uaudio_add_alt(struct uaudio_softc *sc, struct as_info *ai)
1209 {
1210         size_t len = sizeof(*ai) * (sc->sc_nalts + 1);
1211         struct as_info *nai = sc->sc_nalts == 0 ?
1212           malloc(len, M_USBDEV, M_NOWAIT) :
1213           realloc(sc->sc_alts, len, M_USBDEV, M_NOWAIT);
1214
1215         if (nai == NULL) {
1216                 printf("uaudio_add_alt: no memory\n");
1217                 return;
1218         }
1219
1220         sc->sc_alts = nai;
1221         DPRINTFN(2,("uaudio_add_alt: adding alt=%d, enc=%d\n",
1222                     ai->alt, ai->encoding));
1223         sc->sc_alts[sc->sc_nalts++] = *ai;
1224 }
1225
1226 usbd_status
1227 uaudio_process_as(struct uaudio_softc *sc, char *buf, int *offsp,
1228                   int size, usb_interface_descriptor_t *id)
1229 #define offs (*offsp)
1230 {
1231         struct usb_audio_streaming_interface_descriptor *asid;
1232         struct usb_audio_streaming_type1_descriptor *asf1d;
1233         usb_endpoint_descriptor_audio_t *ed;
1234         struct usb_audio_streaming_endpoint_descriptor *sed;
1235         int format, chan, prec, enc;
1236         int dir, type;
1237         struct as_info ai;
1238
1239         asid = (void *)(buf + offs);
1240         if (asid->bDescriptorType != UDESC_CS_INTERFACE ||
1241             asid->bDescriptorSubtype != AS_GENERAL)
1242                 return (USBD_INVAL);
1243         offs += asid->bLength;
1244         if (offs > size)
1245                 return (USBD_INVAL);
1246         asf1d = (void *)(buf + offs);
1247         if (asf1d->bDescriptorType != UDESC_CS_INTERFACE ||
1248             asf1d->bDescriptorSubtype != FORMAT_TYPE)
1249                 return (USBD_INVAL);
1250         offs += asf1d->bLength;
1251         if (offs > size)
1252                 return (USBD_INVAL);
1253
1254         if (asf1d->bFormatType != FORMAT_TYPE_I) {
1255                 printf("%s: ignored setting with type %d format\n",
1256                        USBDEVNAME(sc->sc_dev), UGETW(asid->wFormatTag));
1257                 return (USBD_NORMAL_COMPLETION);
1258         }
1259
1260         ed = (void *)(buf + offs);
1261         if (ed->bDescriptorType != UDESC_ENDPOINT)
1262                 return (USBD_INVAL);
1263         DPRINTF(("uaudio_process_as: endpoint bLength=%d bDescriptorType=%d "
1264                  "bEndpointAddress=%d bmAttributes=0x%x wMaxPacketSize=%d "
1265                  "bInterval=%d bRefresh=%d bSynchAddress=%d\n",
1266                  ed->bLength, ed->bDescriptorType, ed->bEndpointAddress,
1267                  ed->bmAttributes, UGETW(ed->wMaxPacketSize),
1268                  ed->bInterval, ed->bRefresh, ed->bSynchAddress));
1269         offs += ed->bLength;
1270         if (offs > size)
1271                 return (USBD_INVAL);
1272         if (UE_GET_XFERTYPE(ed->bmAttributes) != UE_ISOCHRONOUS)
1273                 return (USBD_INVAL);
1274
1275         dir = UE_GET_DIR(ed->bEndpointAddress);
1276         type = UE_GET_ISO_TYPE(ed->bmAttributes);
1277         if ((usbd_get_quirks(sc->sc_udev)->uq_flags & UQ_AU_INP_ASYNC) &&
1278             dir == UE_DIR_IN && type == UE_ISO_ADAPT)
1279                 type = UE_ISO_ASYNC;
1280
1281         /* We can't handle endpoints that need a sync pipe yet. */
1282         if (dir == UE_DIR_IN ? type == UE_ISO_ADAPT : type == UE_ISO_ASYNC) {
1283                 printf("%s: ignored %sput endpoint of type %s\n",
1284                        USBDEVNAME(sc->sc_dev),
1285                        dir == UE_DIR_IN ? "in" : "out",
1286                        dir == UE_DIR_IN ? "adaptive" : "async");
1287                 return (USBD_NORMAL_COMPLETION);
1288         }
1289         
1290         sed = (void *)(buf + offs);
1291         if (sed->bDescriptorType != UDESC_CS_ENDPOINT ||
1292             sed->bDescriptorSubtype != AS_GENERAL)
1293                 return (USBD_INVAL);
1294         offs += sed->bLength;
1295         if (offs > size)
1296                 return (USBD_INVAL);
1297         
1298         format = UGETW(asid->wFormatTag);
1299         chan = asf1d->bNrChannels;
1300         prec = asf1d->bBitResolution;
1301         if (prec != 8 && prec != 16) {
1302 #ifdef USB_DEBUG
1303                 printf("%s: ignored setting with precision %d\n",
1304                        USBDEVNAME(sc->sc_dev), prec);
1305 #endif
1306                 return (USBD_NORMAL_COMPLETION);
1307         }
1308         switch (format) {
1309         case UA_FMT_PCM:
1310                 sc->sc_altflags |= prec == 8 ? HAS_8 : HAS_16;
1311                 enc = AUDIO_ENCODING_SLINEAR_LE;
1312                 break;
1313         case UA_FMT_PCM8:
1314                 enc = AUDIO_ENCODING_ULINEAR_LE;
1315                 sc->sc_altflags |= HAS_8U;
1316                 break;
1317         case UA_FMT_ALAW:
1318                 enc = AUDIO_ENCODING_ALAW;
1319                 sc->sc_altflags |= HAS_ALAW;
1320                 break;
1321         case UA_FMT_MULAW:
1322                 enc = AUDIO_ENCODING_ULAW;
1323                 sc->sc_altflags |= HAS_MULAW;
1324                 break;
1325         default:
1326                 printf("%s: ignored setting with format %d\n",
1327                        USBDEVNAME(sc->sc_dev), format);
1328                 return (USBD_NORMAL_COMPLETION);
1329         }
1330         DPRINTFN(1,("uaudio_identify: alt=%d enc=%d chan=%d prec=%d\n",
1331                     id->bAlternateSetting, enc, chan, prec));
1332         ai.alt = id->bAlternateSetting;
1333         ai.encoding = enc;
1334         ai.idesc = id;
1335         ai.edesc = ed;
1336         ai.asf1desc = asf1d;
1337         uaudio_add_alt(sc, &ai);
1338         sc->sc_chan.terminal = asid->bTerminalLink; /* XXX */
1339         sc->sc_chan.dir |= dir == UE_DIR_OUT ? AUMODE_PLAY : AUMODE_RECORD;
1340         return (USBD_NORMAL_COMPLETION);
1341 }
1342 #undef offs
1343         
1344 usbd_status
1345 uaudio_identify_as(struct uaudio_softc *sc, usb_config_descriptor_t *cdesc)
1346 {
1347         usb_interface_descriptor_t *id;
1348         usbd_status err;
1349         char *buf;
1350         int size, offs;
1351
1352         size = UGETW(cdesc->wTotalLength);
1353         buf = (char *)cdesc;
1354
1355         /* Locate the AudioStreaming interface descriptor. */
1356         offs = 0;
1357         id = uaudio_find_iface(buf, size, &offs, UISUBCLASS_AUDIOSTREAM);
1358         if (id == NULL)
1359                 return (USBD_INVAL);
1360
1361         sc->sc_chan.terminal = -1;
1362         sc->sc_chan.dir = 0;
1363
1364         /* Loop through all the alternate settings. */
1365         while (offs <= size) {
1366                 DPRINTFN(2, ("uaudio_identify: interface %d\n",
1367                     id->bInterfaceNumber));
1368                 switch (id->bNumEndpoints) {
1369                 case 0:
1370                         DPRINTFN(2, ("uaudio_identify: AS null alt=%d\n",
1371                                      id->bAlternateSetting));
1372                         sc->sc_nullalt = id->bAlternateSetting;
1373                         break;
1374                 case 1:
1375                         err = uaudio_process_as(sc, buf, &offs, size, id);
1376                         break;
1377                 default:
1378 #ifdef USB_DEBUG
1379                         printf("%s: ignored audio interface with %d "
1380                                "endpoints\n",
1381                                USBDEVNAME(sc->sc_dev), id->bNumEndpoints);
1382 #endif
1383                         break;
1384                 }
1385                 id = uaudio_find_iface(buf, size, &offs,UISUBCLASS_AUDIOSTREAM);
1386                 if (id == NULL)
1387                         break;
1388         }
1389         if (offs > size)
1390                 return (USBD_INVAL);
1391         DPRINTF(("uaudio_identify_as: %d alts available\n", sc->sc_nalts));
1392         if (sc->sc_chan.terminal < 0) {
1393                 printf("%s: no useable endpoint found\n", 
1394                        USBDEVNAME(sc->sc_dev));
1395                 return (USBD_INVAL);
1396         }
1397
1398 #ifndef NO_RECORDING
1399         if (sc->sc_chan.dir == (AUMODE_PLAY | AUMODE_RECORD))
1400                 sc->sc_props |= AUDIO_PROP_FULLDUPLEX;
1401 #endif
1402         return (USBD_NORMAL_COMPLETION);
1403 }
1404
1405 usbd_status
1406 uaudio_identify_ac(struct uaudio_softc *sc, usb_config_descriptor_t *cdesc)
1407 {
1408         usb_interface_descriptor_t *id;
1409         struct usb_audio_control_descriptor *acdp;
1410         usb_descriptor_t *dp, *dps[256];
1411         char *buf, *ibuf, *ibufend;
1412         int size, offs, aclen, ndps, i;
1413
1414         size = UGETW(cdesc->wTotalLength);
1415         buf = (char *)cdesc;
1416
1417         /* Locate the AudioControl interface descriptor. */
1418         offs = 0;
1419         id = uaudio_find_iface(buf, size, &offs, UISUBCLASS_AUDIOCONTROL);
1420         if (id == NULL)
1421                 return (USBD_INVAL);
1422         if (offs + sizeof *acdp > size)
1423                 return (USBD_INVAL);
1424         sc->sc_ac_iface = id->bInterfaceNumber;
1425         DPRINTFN(2,("uaudio_identify: AC interface is %d\n", sc->sc_ac_iface));
1426
1427         /* A class-specific AC interface header should follow. */
1428         ibuf = buf + offs;
1429         acdp = (struct usb_audio_control_descriptor *)ibuf;
1430         if (acdp->bDescriptorType != UDESC_CS_INTERFACE ||
1431             acdp->bDescriptorSubtype != UDESCSUB_AC_HEADER)
1432                 return (USBD_INVAL);
1433         aclen = UGETW(acdp->wTotalLength);
1434         if (offs + aclen > size)
1435                 return (USBD_INVAL);
1436
1437         if (!(usbd_get_quirks(sc->sc_udev)->uq_flags & UQ_BAD_ADC) &&
1438              UGETW(acdp->bcdADC) != UAUDIO_VERSION)
1439                 return (USBD_INVAL);
1440
1441         sc->sc_audio_rev = UGETW(acdp->bcdADC);
1442         DPRINTFN(2,("uaudio_identify: found AC header, vers=%03x, len=%d\n",
1443                  sc->sc_audio_rev, aclen));
1444
1445         sc->sc_nullalt = -1;
1446
1447         /* Scan through all the AC specific descriptors */
1448         ibufend = ibuf + aclen;
1449         dp = (usb_descriptor_t *)ibuf;
1450         ndps = 0;
1451         memset(dps, 0, sizeof dps);
1452         for (;;) {
1453                 ibuf += dp->bLength;
1454                 if (ibuf >= ibufend)
1455                         break;
1456                 dp = (usb_descriptor_t *)ibuf;
1457                 if (ibuf + dp->bLength > ibufend)
1458                         return (USBD_INVAL);
1459                 if (dp->bDescriptorType != UDESC_CS_INTERFACE) {
1460                         printf("uaudio_identify: skip desc type=0x%02x\n",
1461                                dp->bDescriptorType);
1462                         continue;
1463                 }
1464                 i = ((struct usb_audio_input_terminal *)dp)->bTerminalId;
1465                 dps[i] = dp;
1466                 if (i > ndps)
1467                         ndps = i;
1468         }
1469         ndps++;
1470
1471         for (i = 0; i < ndps; i++) {
1472                 dp = dps[i];
1473                 if (dp == NULL)
1474                         continue;
1475                 DPRINTF(("uaudio_identify: subtype=%d\n", 
1476                          dp->bDescriptorSubtype));
1477                 switch (dp->bDescriptorSubtype) {
1478                 case UDESCSUB_AC_HEADER:
1479                         printf("uaudio_identify: unexpected AC header\n");
1480                         break;
1481                 case UDESCSUB_AC_INPUT:
1482                         uaudio_add_input(sc, dp, dps);
1483                         break;
1484                 case UDESCSUB_AC_OUTPUT:
1485                         uaudio_add_output(sc, dp, dps);
1486                         break;
1487                 case UDESCSUB_AC_MIXER:
1488                         uaudio_add_mixer(sc, dp, dps);
1489                         break;
1490                 case UDESCSUB_AC_SELECTOR:
1491                         uaudio_add_selector(sc, dp, dps);
1492                         break;
1493                 case UDESCSUB_AC_FEATURE:
1494                         uaudio_add_feature(sc, dp, dps);
1495                         break;
1496                 case UDESCSUB_AC_PROCESSING:
1497                         uaudio_add_processing(sc, dp, dps);
1498                         break;
1499                 case UDESCSUB_AC_EXTENSION:
1500                         uaudio_add_extension(sc, dp, dps);
1501                         break;
1502                 default:
1503                         printf("uaudio_identify: bad AC desc subtype=0x%02x\n",
1504                                dp->bDescriptorSubtype);
1505                         break;
1506                 }
1507         }
1508         return (USBD_NORMAL_COMPLETION);
1509 }
1510
1511 #if defined(__NetBSD__) || defined(__OpenBSD__)
1512 int
1513 uaudio_query_devinfo(void *addr, mixer_devinfo_t *mi)
1514 {
1515         struct uaudio_softc *sc = addr;
1516         struct mixerctl *mc;
1517         int n, nctls;
1518
1519         DPRINTFN(2,("uaudio_query_devinfo: index=%d\n", mi->index));
1520         if (sc->sc_dying)
1521                 return (EIO);
1522     
1523         n = mi->index;
1524         nctls = sc->sc_nctls;
1525
1526         if (n < 0 || n >= nctls) {
1527                 switch (n - nctls) {
1528                 case UAC_OUTPUT:
1529                         mi->type = AUDIO_MIXER_CLASS;
1530                         mi->mixer_class = nctls + UAC_OUTPUT;
1531                         mi->next = mi->prev = AUDIO_MIXER_LAST;
1532                         strcpy(mi->label.name, AudioCoutputs);
1533                         return (0);
1534                 case UAC_INPUT:
1535                         mi->type = AUDIO_MIXER_CLASS;
1536                         mi->mixer_class = nctls + UAC_INPUT;
1537                         mi->next = mi->prev = AUDIO_MIXER_LAST;
1538                         strcpy(mi->label.name, AudioCinputs);
1539                         return (0);
1540                 case UAC_EQUAL:
1541                         mi->type = AUDIO_MIXER_CLASS;
1542                         mi->mixer_class = nctls + UAC_EQUAL;
1543                         mi->next = mi->prev = AUDIO_MIXER_LAST;
1544                         strcpy(mi->label.name, AudioCequalization);
1545                         return (0);
1546                 default:
1547                         return (ENXIO);
1548                 }
1549         }
1550         mc = &sc->sc_ctls[n];
1551         strncpy(mi->label.name, mc->ctlname, MAX_AUDIO_DEV_LEN);
1552         mi->mixer_class = mc->class;
1553         mi->next = mi->prev = AUDIO_MIXER_LAST; /* XXX */
1554         switch (mc->type) {
1555         case MIX_ON_OFF:
1556                 mi->type = AUDIO_MIXER_ENUM;
1557                 mi->un.e.num_mem = 2;
1558                 strcpy(mi->un.e.member[0].label.name, AudioNoff);
1559                 mi->un.e.member[0].ord = 0;
1560                 strcpy(mi->un.e.member[1].label.name, AudioNon);
1561                 mi->un.e.member[1].ord = 1;
1562                 break;
1563         default:
1564                 mi->type = AUDIO_MIXER_VALUE;
1565                 strncpy(mi->un.v.units.name, mc->ctlunit, MAX_AUDIO_DEV_LEN);
1566                 mi->un.v.num_channels = mc->nchan;
1567                 mi->un.v.delta = mc->delta;
1568                 break;
1569         }
1570         return (0);
1571 }
1572
1573 int
1574 uaudio_open(void *addr, int flags)
1575 {
1576         struct uaudio_softc *sc = addr;
1577
1578         DPRINTF(("uaudio_open: sc=%p\n", sc));
1579         if (sc->sc_dying)
1580                 return (EIO);
1581
1582         if (sc->sc_chan.terminal < 0)
1583                 return (ENXIO);
1584
1585         if ((flags & FREAD) && !(sc->sc_chan.dir & AUMODE_RECORD))
1586                 return (EACCES);
1587         if ((flags & FWRITE) && !(sc->sc_chan.dir & AUMODE_PLAY))
1588                 return (EACCES);
1589
1590         sc->sc_chan.intr = 0;
1591
1592         return (0);
1593 }
1594
1595 /*
1596  * Close function is called at splaudio().
1597  */
1598 void
1599 uaudio_close(void *addr)
1600 {
1601         struct uaudio_softc *sc = addr;
1602
1603         if (sc->sc_dying)
1604                 return (EIO);
1605
1606         DPRINTF(("uaudio_close: sc=%p\n", sc));
1607         uaudio_halt_in_dma(sc);
1608         uaudio_halt_out_dma(sc);
1609
1610         sc->sc_chan.intr = 0;
1611 }
1612
1613 int
1614 uaudio_drain(void *addr)
1615 {
1616         struct uaudio_softc *sc = addr;
1617
1618         if (sc->sc_dying)
1619                 return (EIO);
1620
1621         usbd_delay_ms(sc->sc_udev, UAUDIO_NCHANBUFS * UAUDIO_NFRAMES);
1622
1623         return (0);
1624 }
1625
1626 int
1627 uaudio_halt_out_dma(void *addr)
1628 {
1629         struct uaudio_softc *sc = addr;
1630
1631         if (sc->sc_dying)
1632                 return (EIO);
1633
1634         DPRINTF(("uaudio_halt_out_dma: enter\n"));
1635         if (sc->sc_chan.pipe != NULL) {
1636                 uaudio_chan_close(sc, &sc->sc_chan);
1637                 sc->sc_chan.pipe = 0;
1638                 uaudio_chan_free_buffers(sc, &sc->sc_chan);
1639         }
1640         return (0);
1641 }
1642
1643 int
1644 uaudio_halt_in_dma(void *addr)
1645 {
1646         struct uaudio_softc *sc = addr;
1647
1648         DPRINTF(("uaudio_halt_in_dma: enter\n"));
1649         if (sc->sc_chan.pipe != NULL) {
1650                 uaudio_chan_close(sc, &sc->sc_chan);
1651                 sc->sc_chan.pipe = 0;
1652                 uaudio_chan_free_buffers(sc, &sc->sc_chan);
1653         }
1654         return (0);
1655 }
1656
1657 int
1658 uaudio_getdev(void *addr, struct audio_device *retp)
1659 {
1660         struct uaudio_softc *sc = addr;
1661
1662         DPRINTF(("uaudio_mixer_getdev:\n"));
1663         if (sc->sc_dying)
1664                 return (EIO);
1665     
1666         *retp = uaudio_device;
1667         return (0);
1668 }
1669
1670 /*
1671  * Make sure the block size is large enough to hold all outstanding transfers.
1672  */
1673 int
1674 uaudio_round_blocksize(void *addr, int blk)
1675 {
1676         struct uaudio_softc *sc = addr;
1677         int bpf;
1678
1679         if (sc->sc_dying)
1680                 return (EIO);
1681
1682         bpf = sc->sc_chan.bytes_per_frame + sc->sc_chan.sample_size;
1683         /* XXX */
1684         bpf *= UAUDIO_NFRAMES * UAUDIO_NCHANBUFS;
1685
1686         bpf = (bpf + 15) &~ 15;
1687
1688         if (blk < bpf)
1689                 blk = bpf;
1690
1691 #ifdef DIAGNOSTIC
1692         if (blk <= 0) {
1693                 printf("uaudio_round_blocksize: blk=%d\n", blk);
1694                 blk = 512;
1695         }
1696 #endif
1697
1698         DPRINTFN(1,("uaudio_round_blocksize: blk=%d\n", blk));
1699         return (blk);
1700 }
1701
1702 int
1703 uaudio_get_props(void *addr)
1704 {
1705         struct uaudio_softc *sc = addr;
1706
1707         return (sc->sc_props);
1708 }
1709 #endif  /* NetBSD or OpenBSD */
1710
1711
1712 int
1713 uaudio_get(struct uaudio_softc *sc, int which, int type, int wValue,
1714            int wIndex, int len)
1715 {
1716         usb_device_request_t req;
1717         u_int8_t data[4];
1718         usbd_status err;
1719         int val;
1720
1721         if (sc->sc_dying)
1722                 return (EIO);
1723
1724         if (wValue == -1)
1725                 return (0);
1726
1727         req.bmRequestType = type;
1728         req.bRequest = which;
1729         USETW(req.wValue, wValue);
1730         USETW(req.wIndex, wIndex);
1731         USETW(req.wLength, len);
1732         DPRINTFN(2,("uaudio_get: type=0x%02x req=0x%02x wValue=0x%04x "
1733                     "wIndex=0x%04x len=%d\n", 
1734                     type, which, wValue, wIndex, len));
1735         err = usbd_do_request(sc->sc_udev, &req, &data);
1736         if (err) {
1737                 DPRINTF(("uaudio_get: err=%s\n", usbd_errstr(err)));
1738                 return (-1);
1739         }
1740         switch (len) {
1741         case 1:
1742                 val = data[0];
1743                 break;
1744         case 2:
1745                 val = data[0] | (data[1] << 8);
1746                 break;
1747         default:
1748                 DPRINTF(("uaudio_get: bad length=%d\n", len));
1749                 return (-1);
1750         }
1751         DPRINTFN(2,("uaudio_get: val=%d\n", val));
1752         return (val);
1753 }
1754
1755 void
1756 uaudio_set(struct uaudio_softc *sc, int which, int type, int wValue,
1757            int wIndex, int len, int val)
1758 {
1759         usb_device_request_t req;
1760         u_int8_t data[4];
1761         usbd_status err;
1762
1763         if (sc->sc_dying)
1764                 return;
1765
1766         if (wValue == -1)
1767                 return;
1768
1769         req.bmRequestType = type;
1770         req.bRequest = which;
1771         USETW(req.wValue, wValue);
1772         USETW(req.wIndex, wIndex);
1773         USETW(req.wLength, len);
1774         switch (len) {
1775         case 1:
1776                 data[0] = val;
1777                 break;
1778         case 2:
1779                 data[0] = val;
1780                 data[1] = val >> 8;
1781                 break;
1782         default:
1783                 return;
1784         }
1785         DPRINTFN(2,("uaudio_set: type=0x%02x req=0x%02x wValue=0x%04x "
1786                     "wIndex=0x%04x len=%d, val=%d\n", 
1787                     type, which, wValue, wIndex, len, val & 0xffff));
1788         err = usbd_do_request(sc->sc_udev, &req, &data);
1789 #ifdef USB_DEBUG
1790         if (err)
1791                 DPRINTF(("uaudio_set: err=%d\n", err));
1792 #endif
1793 }
1794
1795 int
1796 uaudio_signext(int type, int val)
1797 {
1798         if (!MIX_UNSIGNED(type)) {
1799                 if (MIX_SIZE(type) == 2)
1800                         val = (int16_t)val;
1801                 else
1802                         val = (int8_t)val;
1803         }
1804         return (val);
1805 }
1806
1807 #if defined(__NetBSD__) || defined(__OpenBSD__)
1808 int
1809 uaudio_value2bsd(struct mixerctl *mc, int val)
1810 {
1811         DPRINTFN(5, ("uaudio_value2bsd: type=%03x val=%d min=%d max=%d ",
1812                      mc->type, val, mc->minval, mc->maxval));
1813         if (mc->type == MIX_ON_OFF)
1814                 val = val != 0;
1815         else
1816                 val = ((uaudio_signext(mc->type, val) - mc->minval) * 256
1817                         + mc->mul/2) / mc->mul;
1818         DPRINTFN(5, ("val'=%d\n", val));
1819         return (val);
1820 }
1821 #endif
1822
1823 int
1824 uaudio_bsd2value(struct mixerctl *mc, int val)
1825 {
1826         DPRINTFN(5,("uaudio_bsd2value: type=%03x val=%d min=%d max=%d ",
1827                     mc->type, val, mc->minval, mc->maxval));
1828         if (mc->type == MIX_ON_OFF)
1829                 val = val != 0;
1830         else
1831                 val = (val + mc->delta/2) * mc->mul / 256 + mc->minval;
1832         DPRINTFN(5, ("val'=%d\n", val));
1833         return (val);
1834 }
1835
1836 #if defined(__NetBSD__) || defined(__OpenBSD__)
1837 int
1838 uaudio_ctl_get(struct uaudio_softc *sc, int which, struct mixerctl *mc, 
1839                int chan)
1840 {
1841         int val;
1842
1843         DPRINTFN(5,("uaudio_ctl_get: which=%d chan=%d\n", which, chan));
1844         val = uaudio_get(sc, which, UT_READ_CLASS_INTERFACE, mc->wValue[chan],
1845                          mc->wIndex, MIX_SIZE(mc->type));
1846         return (uaudio_value2bsd(mc, val));
1847 }
1848 #endif
1849
1850 void
1851 uaudio_ctl_set(struct uaudio_softc *sc, int which, struct mixerctl *mc,
1852                int chan, int val)
1853 {
1854         val = uaudio_bsd2value(mc, val);
1855         uaudio_set(sc, which, UT_WRITE_CLASS_INTERFACE, mc->wValue[chan],
1856                    mc->wIndex, MIX_SIZE(mc->type), val);
1857 }
1858
1859 #if defined(__NetBSD__) || defined(__OpenBSD__)
1860 int
1861 uaudio_mixer_get_port(void *addr, mixer_ctrl_t *cp)
1862 {
1863         struct uaudio_softc *sc = addr;
1864         struct mixerctl *mc;
1865         int i, n, vals[MIX_MAX_CHAN], val;
1866
1867         DPRINTFN(2,("uaudio_mixer_get_port: index=%d\n", cp->dev));
1868
1869         if (sc->sc_dying)
1870                 return (EIO);
1871     
1872         n = cp->dev;
1873         if (n < 0 || n >= sc->sc_nctls)
1874                 return (ENXIO);
1875         mc = &sc->sc_ctls[n];
1876
1877         if (mc->type == MIX_ON_OFF) {
1878                 if (cp->type != AUDIO_MIXER_ENUM)
1879                         return (EINVAL);
1880                 cp->un.ord = uaudio_ctl_get(sc, GET_CUR, mc, 0);
1881         } else {
1882                 if (cp->type != AUDIO_MIXER_VALUE)
1883                         return (EINVAL);
1884                 if (cp->un.value.num_channels != 1 &&
1885                     cp->un.value.num_channels != mc->nchan)
1886                         return (EINVAL);
1887                 for (i = 0; i < mc->nchan; i++)
1888                         vals[i] = uaudio_ctl_get(sc, GET_CUR, mc, i);
1889                 if (cp->un.value.num_channels == 1 && mc->nchan != 1) {
1890                         for (val = 0, i = 0; i < mc->nchan; i++)
1891                                 val += vals[i];
1892                         vals[0] = val / mc->nchan;
1893                 }
1894                 for (i = 0; i < cp->un.value.num_channels; i++)
1895                         cp->un.value.level[i] = vals[i];
1896         }
1897
1898         return (0);
1899 }
1900     
1901 int
1902 uaudio_mixer_set_port(void *addr, mixer_ctrl_t *cp)
1903 {
1904         struct uaudio_softc *sc = addr;
1905         struct mixerctl *mc;
1906         int i, n, vals[MIX_MAX_CHAN];
1907
1908         DPRINTFN(2,("uaudio_mixer_set_port: index = %d\n", cp->dev));
1909         if (sc->sc_dying)
1910                 return (EIO);
1911     
1912         n = cp->dev;
1913         if (n < 0 || n >= sc->sc_nctls)
1914                 return (ENXIO);
1915         mc = &sc->sc_ctls[n];
1916
1917         if (mc->type == MIX_ON_OFF) {
1918                 if (cp->type != AUDIO_MIXER_ENUM)
1919                         return (EINVAL);
1920                 uaudio_ctl_set(sc, SET_CUR, mc, 0, cp->un.ord);
1921         } else {
1922                 if (cp->type != AUDIO_MIXER_VALUE)
1923                         return (EINVAL);
1924                 if (cp->un.value.num_channels == 1)
1925                         for (i = 0; i < mc->nchan; i++)
1926                                 vals[i] = cp->un.value.level[0];
1927                 else if (cp->un.value.num_channels == mc->nchan)
1928                         for (i = 0; i < mc->nchan; i++)
1929                                 vals[i] = cp->un.value.level[i];
1930                 else
1931                         return (EINVAL);
1932                 for (i = 0; i < mc->nchan; i++)
1933                         uaudio_ctl_set(sc, SET_CUR, mc, i, vals[i]);
1934         }
1935         return (0);
1936 }
1937
1938 int
1939 uaudio_trigger_input(void *addr, void *start, void *end, int blksize,
1940                      void (*intr)(void *), void *arg,
1941                      struct audio_params *param)
1942 {
1943         struct uaudio_softc *sc = addr;
1944         struct chan *ch = &sc->sc_chan;
1945         usbd_status err;
1946         int i, s;
1947
1948         if (sc->sc_dying)
1949                 return (EIO);
1950
1951         DPRINTFN(3,("uaudio_trigger_input: sc=%p start=%p end=%p "
1952                     "blksize=%d\n", sc, start, end, blksize));
1953
1954         uaudio_chan_set_param(ch, param, start, end, blksize);
1955         DPRINTFN(3,("uaudio_trigger_input: sample_size=%d bytes/frame=%d "
1956                     "fraction=0.%03d\n", ch->sample_size, ch->bytes_per_frame,
1957                     ch->fraction));
1958
1959         err = uaudio_chan_alloc_buffers(sc, ch);
1960         if (err)
1961                 return (EIO);
1962
1963         err = uaudio_chan_open(sc, ch);
1964         if (err) {
1965                 uaudio_chan_free_buffers(sc, ch);
1966                 return (EIO);
1967         }
1968
1969         sc->sc_chan.intr = intr;
1970         sc->sc_chan.arg = arg;
1971
1972         s = splusb();
1973         for (i = 0; i < UAUDIO_NCHANBUFS-1; i++) /* XXX -1 shouldn't be needed */
1974                 uaudio_chan_rtransfer(ch);
1975         splx(s);
1976
1977         return (0);
1978 }
1979     
1980 int
1981 uaudio_trigger_output(void *addr, void *start, void *end, int blksize,
1982                       void (*intr)(void *), void *arg,
1983                       struct audio_params *param)
1984 {
1985         struct uaudio_softc *sc = addr;
1986         struct chan *ch = &sc->sc_chan;
1987         usbd_status err;
1988         int i, s;
1989
1990         if (sc->sc_dying)
1991                 return (EIO);
1992
1993         DPRINTFN(3,("uaudio_trigger_output: sc=%p start=%p end=%p "
1994                     "blksize=%d\n", sc, start, end, blksize));
1995
1996         uaudio_chan_set_param(ch, param, start, end, blksize);
1997         DPRINTFN(3,("uaudio_trigger_output: sample_size=%d bytes/frame=%d "
1998                     "fraction=0.%03d\n", ch->sample_size, ch->bytes_per_frame,
1999                     ch->fraction));
2000
2001         err = uaudio_chan_alloc_buffers(sc, ch);
2002         if (err)
2003                 return (EIO);
2004
2005         err = uaudio_chan_open(sc, ch);
2006         if (err) {
2007                 uaudio_chan_free_buffers(sc, ch);
2008                 return (EIO);
2009         }
2010
2011         sc->sc_chan.intr = intr;
2012         sc->sc_chan.arg = arg;
2013
2014         s = splusb();
2015         for (i = 0; i < UAUDIO_NCHANBUFS-1; i++) /* XXX */
2016                 uaudio_chan_ptransfer(ch);
2017         splx(s);
2018
2019         return (0);
2020 }
2021 #endif  /* NetBSD or OpenBSD */
2022
2023 /* Set up a pipe for a channel. */
2024 usbd_status
2025 uaudio_chan_open(struct uaudio_softc *sc, struct chan *ch)
2026 {
2027         struct as_info *as = &sc->sc_alts[sc->sc_curaltidx];
2028         int endpt = as->edesc->bEndpointAddress;
2029         usbd_status err;
2030
2031         if (sc->sc_dying)
2032                 return (EIO);
2033
2034         DPRINTF(("uaudio_open_chan: endpt=0x%02x, speed=%d, alt=%d\n", 
2035                  endpt, ch->sample_rate, as->alt));
2036
2037         /* Set alternate interface corresponding to the mode. */
2038         err = usbd_set_interface(as->ifaceh, as->alt);
2039         if (err)
2040                 return (err);
2041
2042         /* Some devices do not support this request, so ignore errors. */
2043 #ifdef USB_DEBUG
2044         err = uaudio_set_speed(sc, endpt, ch->sample_rate);
2045         if (err)
2046                 DPRINTF(("uaudio_chan_open: set_speed failed err=%s\n",
2047                          usbd_errstr(err)));
2048 #else
2049         (void)uaudio_set_speed(sc, endpt, ch->sample_rate);
2050 #endif
2051
2052         DPRINTF(("uaudio_open_chan: create pipe to 0x%02x\n", endpt));
2053         err = usbd_open_pipe(as->ifaceh, endpt, 0, &ch->pipe);
2054         return (err);
2055 }
2056
2057 void
2058 uaudio_chan_close(struct uaudio_softc *sc, struct chan *ch)
2059 {
2060         struct as_info *as = &sc->sc_alts[sc->sc_curaltidx];
2061
2062         if (sc->sc_dying)
2063                 return ;
2064
2065         if (sc->sc_nullalt >= 0) {
2066                 DPRINTF(("uaudio_close_chan: set null alt=%d\n",
2067                          sc->sc_nullalt));
2068                 usbd_set_interface(as->ifaceh, sc->sc_nullalt);
2069         }
2070         usbd_abort_pipe(ch->pipe);
2071         usbd_close_pipe(ch->pipe);
2072 }
2073
2074 usbd_status
2075 uaudio_chan_alloc_buffers(struct uaudio_softc *sc, struct chan *ch)
2076 {
2077         usbd_xfer_handle xfer;
2078         void *buf;
2079         int i, size;
2080
2081         size = (ch->bytes_per_frame + ch->sample_size) * UAUDIO_NFRAMES;
2082         for (i = 0; i < UAUDIO_NCHANBUFS; i++) {
2083                 xfer = usbd_alloc_xfer(sc->sc_udev);
2084                 if (xfer == 0)
2085                         goto bad;
2086                 ch->chanbufs[i].xfer = xfer;
2087                 buf = usbd_alloc_buffer(xfer, size);
2088                 if (buf == 0) {
2089                         i++;
2090                         goto bad;
2091                 }
2092                 ch->chanbufs[i].buffer = buf;
2093                 ch->chanbufs[i].chan = ch;
2094         }
2095
2096         return (USBD_NORMAL_COMPLETION);
2097
2098 bad:
2099         while (--i >= 0)
2100                 /* implicit buffer free */
2101                 usbd_free_xfer(ch->chanbufs[i].xfer);
2102         return (USBD_NOMEM);
2103 }
2104
2105 void
2106 uaudio_chan_free_buffers(struct uaudio_softc *sc, struct chan *ch)
2107 {
2108         int i;
2109
2110         for (i = 0; i < UAUDIO_NCHANBUFS; i++)
2111                 usbd_free_xfer(ch->chanbufs[i].xfer);
2112 }
2113
2114 /* Called at splusb() */
2115 void
2116 uaudio_chan_ptransfer(struct chan *ch)
2117 {
2118         struct chanbuf *cb;
2119         int i, n, size, residue, total;
2120
2121         if (ch->sc->sc_dying)
2122                 return;
2123
2124         /* Pick the next channel buffer. */
2125         cb = &ch->chanbufs[ch->curchanbuf];
2126         if (++ch->curchanbuf >= UAUDIO_NCHANBUFS)
2127                 ch->curchanbuf = 0;
2128
2129         /* Compute the size of each frame in the next transfer. */
2130         residue = ch->residue;
2131         total = 0;
2132         for (i = 0; i < UAUDIO_NFRAMES; i++) {
2133                 size = ch->bytes_per_frame;
2134                 residue += ch->fraction;
2135                 if (residue >= USB_FRAMES_PER_SECOND) {
2136                         if (!ch->nofrac)
2137                                 size += ch->sample_size;
2138                         residue -= USB_FRAMES_PER_SECOND;
2139                 }
2140                 cb->sizes[i] = size;
2141                 total += size;
2142         }
2143         ch->residue = residue;
2144         cb->size = total;
2145
2146         /* 
2147          * Transfer data from upper layer buffer to channel buffer, taking
2148          * care of wrapping the upper layer buffer.
2149          */
2150         n = min(total, ch->end - ch->cur);
2151         memcpy(cb->buffer, ch->cur, n);
2152         ch->cur += n;
2153         if (ch->cur >= ch->end)
2154                 ch->cur = ch->start;
2155         if (total > n) {
2156                 total -= n;
2157                 memcpy(cb->buffer + n, ch->cur, total);
2158                 ch->cur += total;
2159         }
2160
2161 #ifdef USB_DEBUG
2162         if (uaudiodebug > 8) {
2163                 DPRINTF(("uaudio_chan_ptransfer: buffer=%p, residue=0.%03d\n",
2164                          cb->buffer, ch->residue));
2165                 for (i = 0; i < UAUDIO_NFRAMES; i++) {
2166                         DPRINTF(("   [%d] length %d\n", i, cb->sizes[i]));
2167                 }
2168         }
2169 #endif
2170
2171         DPRINTFN(5,("uaudio_chan_transfer: ptransfer xfer=%p\n", cb->xfer));
2172         /* Fill the request */
2173         usbd_setup_isoc_xfer(cb->xfer, ch->pipe, cb, cb->sizes, 
2174                              UAUDIO_NFRAMES, USBD_NO_COPY, 
2175                              uaudio_chan_pintr);
2176
2177         (void)usbd_transfer(cb->xfer);
2178 }
2179
2180 void
2181 uaudio_chan_pintr(usbd_xfer_handle xfer, usbd_private_handle priv,
2182                   usbd_status status)
2183 {
2184         struct chanbuf *cb = priv;
2185         struct chan *ch = cb->chan;
2186         u_int32_t count;
2187         int s;
2188
2189         /* Return if we are aborting. */
2190         if (status == USBD_CANCELLED)
2191                 return;
2192
2193         usbd_get_xfer_status(xfer, NULL, NULL, &count, NULL);
2194         DPRINTFN(5,("uaudio_chan_pintr: count=%d, transferred=%d\n",
2195                     count, ch->transferred));
2196 #ifdef DIAGNOSTIC
2197         if (count != cb->size) {
2198                 printf("uaudio_chan_pintr: count(%d) != size(%d)\n",
2199                        count, cb->size);
2200         }
2201 #endif
2202
2203         ch->transferred += cb->size;
2204 #if defined(__DragonFly__)
2205         /* s = spltty(); */
2206         s = splhigh();
2207         chn_intr(ch->pcm_ch);
2208         splx(s);
2209 #else
2210         s = splaudio();
2211         /* Call back to upper layer */
2212         while (ch->transferred >= ch->blksize) {
2213                 ch->transferred -= ch->blksize;
2214                 DPRINTFN(5,("uaudio_chan_pintr: call %p(%p)\n", 
2215                             ch->intr, ch->arg));
2216                 ch->intr(ch->arg);
2217         }
2218         splx(s);
2219 #endif
2220
2221         /* start next transfer */
2222         uaudio_chan_ptransfer(ch);
2223 }
2224
2225 /* Called at splusb() */
2226 void
2227 uaudio_chan_rtransfer(struct chan *ch)
2228 {
2229         struct chanbuf *cb;
2230         int i, size, residue, total;
2231
2232         if (ch->sc->sc_dying)
2233                 return;
2234
2235         /* Pick the next channel buffer. */
2236         cb = &ch->chanbufs[ch->curchanbuf];
2237         if (++ch->curchanbuf >= UAUDIO_NCHANBUFS)
2238                 ch->curchanbuf = 0;
2239
2240         /* Compute the size of each frame in the next transfer. */
2241         residue = ch->residue;
2242         total = 0;
2243         for (i = 0; i < UAUDIO_NFRAMES; i++) {
2244                 size = ch->bytes_per_frame;
2245                 residue += ch->fraction;
2246                 if (residue >= USB_FRAMES_PER_SECOND) {
2247                         if (!ch->nofrac)
2248                                 size += ch->sample_size;
2249                         residue -= USB_FRAMES_PER_SECOND;
2250                 }
2251                 cb->sizes[i] = size;
2252                 total += size;
2253         }
2254         ch->residue = residue;
2255         cb->size = total;
2256
2257 #ifdef USB_DEBUG
2258         if (uaudiodebug > 8) {
2259                 DPRINTF(("uaudio_chan_rtransfer: buffer=%p, residue=0.%03d\n",
2260                          cb->buffer, ch->residue));
2261                 for (i = 0; i < UAUDIO_NFRAMES; i++) {
2262                         DPRINTF(("   [%d] length %d\n", i, cb->sizes[i]));
2263                 }
2264         }
2265 #endif
2266
2267         DPRINTFN(5,("uaudio_chan_rtransfer: transfer xfer=%p\n", cb->xfer));
2268         /* Fill the request */
2269         usbd_setup_isoc_xfer(cb->xfer, ch->pipe, cb, cb->sizes, 
2270                              UAUDIO_NFRAMES, USBD_NO_COPY, 
2271                              uaudio_chan_rintr);
2272
2273         (void)usbd_transfer(cb->xfer);
2274 }
2275
2276 void
2277 uaudio_chan_rintr(usbd_xfer_handle xfer, usbd_private_handle priv,
2278                   usbd_status status)
2279 {
2280         struct chanbuf *cb = priv;
2281         struct chan *ch = cb->chan;
2282         u_int32_t count;
2283         int s, n;
2284
2285         /* Return if we are aborting. */
2286         if (status == USBD_CANCELLED)
2287                 return;
2288
2289         usbd_get_xfer_status(xfer, NULL, NULL, &count, NULL);
2290         DPRINTFN(5,("uaudio_chan_rintr: count=%d, transferred=%d\n",
2291                     count, ch->transferred));
2292
2293         if (count < cb->size) {
2294                 /* if the device fails to keep up, copy last byte */
2295                 u_char b = count ? cb->buffer[count-1] : 0;
2296                 while (count < cb->size)
2297                         cb->buffer[count++] = b;
2298         }
2299
2300 #ifdef DIAGNOSTIC
2301         if (count != cb->size) {
2302                 printf("uaudio_chan_rintr: count(%d) != size(%d)\n",
2303                        count, cb->size);
2304         }
2305 #endif
2306
2307         /* 
2308          * Transfer data from channel buffer to upper layer buffer, taking
2309          * care of wrapping the upper layer buffer.
2310          */
2311         n = min(count, ch->end - ch->cur);
2312         memcpy(ch->cur, cb->buffer, n);
2313         ch->cur += n;
2314         if (ch->cur >= ch->end)
2315                 ch->cur = ch->start;
2316         if (count > n) {
2317                 memcpy(ch->cur, cb->buffer + n, count - n);
2318                 ch->cur += count - n;
2319         }
2320
2321         /* Call back to upper layer */
2322         ch->transferred += cb->size;
2323 #if defined(__DragonFly__)
2324         s = spltty();
2325         chn_intr(ch->pcm_ch);
2326         splx(s);
2327 #else
2328         s = splaudio();
2329         while (ch->transferred >= ch->blksize) {
2330                 ch->transferred -= ch->blksize;
2331                 DPRINTFN(5,("uaudio_chan_rintr: call %p(%p)\n", 
2332                             ch->intr, ch->arg));
2333                 ch->intr(ch->arg);
2334         }
2335         splx(s);
2336 #endif
2337
2338         /* start next transfer */
2339         uaudio_chan_rtransfer(ch);
2340 }
2341
2342 #if defined(__NetBSD__) || defined(__OpenBSD__)
2343 void
2344 uaudio_chan_set_param(struct chan *ch, struct audio_params *param,
2345                       u_char *start, u_char *end, int blksize)
2346 {
2347         int samples_per_frame, sample_size;
2348
2349         sample_size = param->precision * param->channels / 8;
2350         samples_per_frame = param->sample_rate / USB_FRAMES_PER_SECOND;
2351         ch->fraction = param->sample_rate % USB_FRAMES_PER_SECOND;
2352         ch->sample_size = sample_size;
2353         ch->sample_rate = param->sample_rate;
2354         ch->bytes_per_frame = samples_per_frame * sample_size;
2355         ch->residue = 0;
2356
2357         ch->start = start;
2358         ch->end = end;
2359         ch->cur = start;
2360         ch->blksize = blksize;
2361         ch->transferred = 0;
2362
2363         ch->curchanbuf = 0;
2364 }
2365
2366 int
2367 uaudio_set_params(void *addr, int setmode, int usemode,
2368                   struct audio_params *play, struct audio_params *rec)
2369 {
2370         struct uaudio_softc *sc = addr;
2371         int flags = sc->sc_altflags;
2372         int factor;
2373         int enc, i, j;
2374         void (*swcode)(void *, u_char *buf, int cnt);
2375         struct audio_params *p;
2376         int mode;
2377
2378         if (sc->sc_dying)
2379                 return (EIO);
2380
2381         if (sc->sc_chan.pipe != NULL)
2382                 return (EBUSY);
2383
2384         for (mode = AUMODE_RECORD; mode != -1;
2385              mode = mode == AUMODE_RECORD ? AUMODE_PLAY : -1) {
2386                 if ((setmode & mode) == 0)
2387                         continue;
2388                 if ((sc->sc_chan.dir & mode) == 0)
2389                         continue;
2390
2391                 p = mode == AUMODE_PLAY ? play : rec;
2392
2393                 factor = 1;
2394                 swcode = 0;
2395                 enc = p->encoding;
2396                 switch (enc) {
2397                 case AUDIO_ENCODING_SLINEAR_BE:
2398                         if (p->precision == 16) {
2399                                 swcode = swap_bytes;
2400                                 enc = AUDIO_ENCODING_SLINEAR_LE;
2401                         } else if (p->precision == 8 && !(flags & HAS_8)) {
2402                                 swcode = change_sign8;
2403                                 enc = AUDIO_ENCODING_ULINEAR_LE;
2404                         }
2405                         break;
2406                 case AUDIO_ENCODING_SLINEAR_LE:
2407                         if (p->precision == 8 && !(flags & HAS_8)) {
2408                                 swcode = change_sign8;
2409                                 enc = AUDIO_ENCODING_ULINEAR_LE;
2410                         }
2411                         break;
2412                 case AUDIO_ENCODING_ULINEAR_BE:
2413                         if (p->precision == 16) {
2414                                 if (mode == AUMODE_PLAY)
2415                                         swcode = swap_bytes_change_sign16_le;
2416                                 else
2417                                         swcode = change_sign16_swap_bytes_le;
2418                                 enc = AUDIO_ENCODING_SLINEAR_LE;
2419                         } else if (p->precision == 8 && !(flags & HAS_8U)) {
2420                                 swcode = change_sign8;
2421                                 enc = AUDIO_ENCODING_SLINEAR_LE;
2422                         }
2423                         break;
2424                 case AUDIO_ENCODING_ULINEAR_LE:
2425                         if (p->precision == 16) {
2426                                 swcode = change_sign16_le;
2427                                 enc = AUDIO_ENCODING_SLINEAR_LE;
2428                         } else if (p->precision == 8 && !(flags & HAS_8U)) {
2429                                 swcode = change_sign8;
2430                                 enc = AUDIO_ENCODING_SLINEAR_LE;
2431                         }
2432                         break;
2433                 case AUDIO_ENCODING_ULAW:
2434                         if (!(flags & HAS_MULAW)) {
2435                                 if (mode == AUMODE_PLAY &&
2436                                     (flags & HAS_16)) {
2437                                         swcode = mulaw_to_slinear16_le;
2438                                         factor = 2;
2439                                         enc = AUDIO_ENCODING_SLINEAR_LE;
2440                                 } else if (flags & HAS_8U) {
2441                                         if (mode == AUMODE_PLAY)
2442                                                 swcode = mulaw_to_ulinear8;
2443                                         else
2444                                                 swcode = ulinear8_to_mulaw;
2445                                         enc = AUDIO_ENCODING_ULINEAR_LE;
2446                                 } else if (flags & HAS_8) {
2447                                         if (mode == AUMODE_PLAY)
2448                                                 swcode = mulaw_to_slinear8;
2449                                         else
2450                                                 swcode = slinear8_to_mulaw;
2451                                         enc = AUDIO_ENCODING_SLINEAR_LE;
2452                                 } else
2453                                         return (EINVAL);
2454                         }
2455                         break;
2456                 case AUDIO_ENCODING_ALAW:
2457                         if (!(flags & HAS_ALAW)) {
2458                                 if (mode == AUMODE_PLAY &&
2459                                     (flags & HAS_16)) {
2460                                         swcode = alaw_to_slinear16_le;
2461                                         factor = 2;
2462                                         enc = AUDIO_ENCODING_SLINEAR_LE;
2463                                 } else if (flags & HAS_8U) {
2464                                         if (mode == AUMODE_PLAY)
2465                                                 swcode = alaw_to_ulinear8;
2466                                         else
2467                                                 swcode = ulinear8_to_alaw;
2468                                         enc = AUDIO_ENCODING_ULINEAR_LE;
2469                                 } else if (flags & HAS_8) {
2470                                         if (mode == AUMODE_PLAY)
2471                                                 swcode = alaw_to_slinear8;
2472                                         else
2473                                                 swcode = slinear8_to_alaw;
2474                                         enc = AUDIO_ENCODING_SLINEAR_LE;
2475                                 } else
2476                                         return (EINVAL);
2477                         }
2478                         break;
2479                 default:
2480                         return (EINVAL);
2481                 }
2482                 /* XXX do some other conversions... */
2483
2484                 DPRINTF(("uaudio_set_params: chan=%d prec=%d enc=%d rate=%ld\n",
2485                          p->channels, p->precision, enc, p->sample_rate));
2486
2487                 for (i = 0; i < sc->sc_nalts; i++) {
2488                         struct usb_audio_streaming_type1_descriptor *a1d =
2489                                 sc->sc_alts[i].asf1desc;
2490                         if (p->channels == a1d->bNrChannels &&
2491                             p->precision == a1d->bBitResolution &&
2492                             enc == sc->sc_alts[i].encoding &&
2493                             (mode == AUMODE_PLAY ? UE_DIR_OUT : UE_DIR_IN) ==
2494                             UE_GET_DIR(sc->sc_alts[i].edesc->bEndpointAddress)) {
2495                                 if (a1d->bSamFreqType == UA_SAMP_CONTNUOUS) {
2496                                         DPRINTFN(2,("uaudio_set_params: cont %d-%d\n",
2497                                             UA_SAMP_LO(a1d), UA_SAMP_HI(a1d)));
2498                                         if (UA_SAMP_LO(a1d) < p->sample_rate &&
2499                                             p->sample_rate < UA_SAMP_HI(a1d))
2500                                                 goto found;
2501                                 } else {
2502                                         for (j = 0; j < a1d->bSamFreqType; j++) {
2503                                                 DPRINTFN(2,("uaudio_set_params: disc #"
2504                                                     "%d: %d\n", j, UA_GETSAMP(a1d, j)));
2505                                                 /* XXX allow for some slack */
2506                                                 if (UA_GETSAMP(a1d, j) ==
2507                                                     p->sample_rate)
2508                                                         goto found;
2509                                         }
2510                                 }
2511                         }
2512                 }
2513                 return (EINVAL);
2514
2515         found:
2516                 p->sw_code = swcode;
2517                 p->factor  = factor;
2518                 if (usemode == mode)
2519                         sc->sc_curaltidx = i;
2520         }
2521
2522         DPRINTF(("uaudio_set_params: use altidx=%d, altno=%d\n", 
2523                  sc->sc_curaltidx, 
2524                  sc->sc_alts[sc->sc_curaltidx].idesc->bAlternateSetting));
2525         
2526         return (0);
2527 }
2528 #endif /* NetBSD or OpenBSD */
2529
2530 usbd_status
2531 uaudio_set_speed(struct uaudio_softc *sc, int endpt, u_int speed)
2532 {
2533         usb_device_request_t req;
2534         u_int8_t data[3];
2535
2536         DPRINTFN(5,("uaudio_set_speed: endpt=%d speed=%u\n", endpt, speed));
2537         req.bmRequestType = UT_WRITE_CLASS_ENDPOINT;
2538         req.bRequest = SET_CUR;
2539         USETW2(req.wValue, SAMPLING_FREQ_CONTROL, 0);
2540         USETW(req.wIndex, endpt);
2541         USETW(req.wLength, 3);
2542         data[0] = speed;
2543         data[1] = speed >> 8;
2544         data[2] = speed >> 16;
2545
2546         return (usbd_do_request(sc->sc_udev, &req, &data));
2547 }
2548
2549
2550 #if defined(__DragonFly__)
2551 /************************************************************/
2552 void
2553 uaudio_init_params(struct uaudio_softc *sc, struct chan *ch)
2554 {
2555         int i, j, enc;
2556         int samples_per_frame, sample_size;
2557
2558         switch(ch->format & 0x0000FFFF) {
2559         case AFMT_U8:
2560                 enc = AUDIO_ENCODING_ULINEAR_LE;
2561                 ch->precision = 8;
2562                 break;
2563         case AFMT_S8:
2564                 enc = AUDIO_ENCODING_SLINEAR_LE;
2565                 ch->precision = 8;
2566                 break;
2567         case AFMT_A_LAW:        /* ? */
2568                 enc = AUDIO_ENCODING_ALAW;
2569                 ch->precision = 8;
2570                 break;
2571         case AFMT_MU_LAW:       /* ? */
2572                 enc = AUDIO_ENCODING_ULAW;
2573                 ch->precision = 8;
2574                 break;
2575         case AFMT_S16_LE:
2576                 enc = AUDIO_ENCODING_SLINEAR_LE;
2577                 ch->precision = 16;
2578                 break;
2579         case AFMT_S16_BE:
2580                 enc = AUDIO_ENCODING_SLINEAR_BE;
2581                 ch->precision = 16;
2582                 break;
2583         case AFMT_U16_LE:
2584                 enc = AUDIO_ENCODING_ULINEAR_LE;
2585                 ch->precision = 16;
2586                 break;
2587         case AFMT_U16_BE:
2588                 enc = AUDIO_ENCODING_ULINEAR_BE;
2589                 ch->precision = 16;
2590                 break;
2591         default:
2592                 enc = 0;
2593                 ch->precision = 16;
2594                 printf("Unknown format %x\n", ch->format);
2595         }
2596
2597         if (ch->format & AFMT_STEREO) {
2598                 ch->channels = 2;
2599         } else {
2600                 ch->channels = 1;
2601         }
2602
2603 /*      for (mode =  ......      */
2604                 for (i = 0; i < sc->sc_nalts; i++) {
2605                         struct usb_audio_streaming_type1_descriptor *a1d =
2606                                 sc->sc_alts[i].asf1desc;
2607                         if (ch->channels == a1d->bNrChannels &&
2608                             ch->precision == a1d->bBitResolution &&
2609 #if 1
2610                             enc == sc->sc_alts[i].encoding) {
2611 #else
2612                             enc == sc->sc_alts[i].encoding &&
2613                             (mode == AUMODE_PLAY ? UE_DIR_OUT : UE_DIR_IN) ==
2614                             UE_GET_DIR(sc->sc_alts[i].edesc->bEndpointAddress)) {
2615 #endif
2616                                 if (a1d->bSamFreqType == UA_SAMP_CONTNUOUS) {
2617                                         DPRINTFN(2,("uaudio_set_params: cont %d-%d\n",
2618                                             UA_SAMP_LO(a1d), UA_SAMP_HI(a1d)));
2619                                         if (UA_SAMP_LO(a1d) < ch->sample_rate &&
2620                                             ch->sample_rate < UA_SAMP_HI(a1d)) {
2621                                                 sc->sc_curaltidx = i;
2622                                                 goto found;
2623                                         }
2624                                 } else {
2625                                         for (j = 0; j < a1d->bSamFreqType; j++) {
2626                                                 DPRINTFN(2,("uaudio_set_params: disc #"
2627                                                     "%d: %d\n", j, UA_GETSAMP(a1d, j)));
2628                                                 /* XXX allow for some slack */
2629                                                 if (UA_GETSAMP(a1d, j) ==
2630                                                     ch->sample_rate) {
2631                                                         sc->sc_curaltidx = i;
2632                                                         goto found;
2633                                                 }
2634                                         }
2635                                 }
2636                         }
2637                 }
2638                 /* return (EINVAL); */
2639
2640         found:
2641 #if 0 /* XXX */
2642                 p->sw_code = swcode;
2643                 p->factor  = factor;
2644                 if (usemode == mode)
2645                         sc->sc_curaltidx = i;
2646 #endif
2647 /*      } */
2648
2649         sample_size = ch->precision * ch->channels / 8;
2650         samples_per_frame = ch->sample_rate / USB_FRAMES_PER_SECOND;
2651         ch->fraction = ch->sample_rate % USB_FRAMES_PER_SECOND;
2652         ch->sample_size = sample_size;
2653         ch->bytes_per_frame = samples_per_frame * sample_size;
2654         ch->residue = 0;
2655
2656         ch->cur = ch->start;
2657         ch->transferred = 0;
2658         ch->curchanbuf = 0;
2659 }
2660
2661 void
2662 uaudio_query_formats(device_t dev, u_int32_t *pfmt, u_int32_t *rfmt)
2663 {
2664         int i, pn=0, rn=0;
2665         int prec, dir;
2666         u_int32_t fmt;
2667         struct uaudio_softc *sc;
2668
2669         struct usb_audio_streaming_type1_descriptor *a1d;
2670
2671         sc = device_get_softc(dev);
2672
2673         for (i = 0; i < sc->sc_nalts; i++) {
2674                 fmt = 0;
2675                 a1d = sc->sc_alts[i].asf1desc;
2676                 prec = a1d->bBitResolution;     /* precision */
2677
2678                 switch (sc->sc_alts[i].encoding) {
2679                 case AUDIO_ENCODING_ULINEAR_LE:
2680                         if (prec == 8) {
2681                                 fmt = AFMT_U8;
2682                         } else if (prec == 16) {
2683                                 fmt = AFMT_U16_LE;
2684                         }
2685                         break;
2686                 case AUDIO_ENCODING_SLINEAR_LE:
2687                         if (prec == 8) {
2688                                 fmt = AFMT_S8;
2689                         } else if (prec == 16) {
2690                                 fmt = AFMT_S16_LE;
2691                         }
2692                         break;
2693                 case AUDIO_ENCODING_ULINEAR_BE:
2694                         if (prec == 16) {
2695                                 fmt = AFMT_U16_BE;
2696                         }
2697                         break;
2698                 case AUDIO_ENCODING_SLINEAR_BE:
2699                         if (prec == 16) {
2700                                 fmt = AFMT_S16_BE;
2701                         }
2702                         break;
2703                 case AUDIO_ENCODING_ALAW:
2704                         if (prec == 8) {
2705                                 fmt = AFMT_A_LAW;
2706                         }
2707                         break;
2708                 case AUDIO_ENCODING_ULAW:
2709                         if (prec == 8) {
2710                                 fmt = AFMT_MU_LAW;
2711                         }
2712                         break;
2713                 }
2714
2715                 if (fmt != 0) {
2716                         if (a1d->bNrChannels == 2) {    /* stereo/mono */
2717                                 fmt |= AFMT_STEREO;
2718                         } else if (a1d->bNrChannels != 1) {
2719                                 fmt = 0;
2720                         }
2721                 }
2722
2723                 if (fmt != 0) {
2724                         dir= UE_GET_DIR(sc->sc_alts[i].edesc->bEndpointAddress);
2725                         if (dir == UE_DIR_OUT) {
2726                                 pfmt[pn++] = fmt;
2727                         } else if (dir == UE_DIR_IN) {
2728                                 rfmt[rn++] = fmt;
2729                         }
2730                 }
2731
2732                 if ((pn > 8*2) || (rn > 8*2))
2733                         break;
2734         }
2735         pfmt[pn] = 0;
2736         rfmt[rn] = 0;
2737         return;
2738 }
2739
2740 void
2741 uaudio_chan_set_param_pcm_dma_buff(device_t dev, u_char *start, u_char *end,
2742                 struct pcm_channel *pc)
2743 {
2744         struct uaudio_softc *sc;
2745         struct chan *ch;
2746
2747         sc = device_get_softc(dev);
2748         ch = &sc->sc_chan;
2749
2750         ch->start = start;
2751         ch->end = end;
2752
2753         ch->pcm_ch = pc;
2754
2755         return;
2756 }
2757
2758 void
2759 uaudio_chan_set_param_blocksize(device_t dev, u_int32_t blocksize)
2760 {
2761         struct uaudio_softc *sc;
2762         struct chan *ch;
2763
2764         sc = device_get_softc(dev);
2765         ch = &sc->sc_chan;
2766
2767         ch->blksize = blocksize;
2768
2769         return;
2770 }
2771
2772 void
2773 uaudio_chan_set_param_speed(device_t dev, u_int32_t speed)
2774 {
2775         struct uaudio_softc *sc;
2776         struct chan *ch;
2777
2778         sc = device_get_softc(dev);
2779         ch = &sc->sc_chan;
2780
2781         ch->sample_rate = speed;
2782
2783         return;
2784 }
2785
2786 int
2787 uaudio_chan_getptr(device_t dev)
2788 {
2789         struct uaudio_softc *sc;
2790         struct chan *ch;
2791         int ptr;
2792
2793         sc = device_get_softc(dev);
2794         ch = &sc->sc_chan;
2795
2796         ptr = ch->cur - ch->start;
2797
2798         return ptr;
2799 }
2800
2801 void
2802 uaudio_chan_set_param_format(device_t dev, u_int32_t format)
2803 {
2804         struct uaudio_softc *sc;
2805         struct chan *ch;
2806
2807         sc = device_get_softc(dev);
2808         ch = &sc->sc_chan;
2809
2810         ch->format = format;
2811
2812         return;
2813 }
2814
2815 int
2816 uaudio_halt_out_dma(device_t dev)
2817 {
2818         struct uaudio_softc *sc;
2819
2820         sc = device_get_softc(dev);
2821
2822         DPRINTF(("uaudio_halt_out_dma: enter\n"));
2823         if (sc->sc_chan.pipe != NULL) {
2824                 uaudio_chan_close(sc, &sc->sc_chan);
2825                 sc->sc_chan.pipe = 0;
2826                 uaudio_chan_free_buffers(sc, &sc->sc_chan);
2827         }
2828         return (0);
2829 }
2830     
2831 int
2832 uaudio_trigger_output(device_t dev)
2833 {
2834         struct uaudio_softc *sc;
2835         struct chan *ch;
2836         usbd_status err;
2837         int i, s;
2838
2839         sc = device_get_softc(dev);
2840         ch = &sc->sc_chan;
2841
2842         if (sc->sc_dying)
2843                 return (EIO);
2844
2845         uaudio_init_params(sc, ch);
2846
2847         err = uaudio_chan_alloc_buffers(sc, ch);
2848         if (err)
2849                 return (EIO);
2850
2851         err = uaudio_chan_open(sc, ch);
2852         if (err) {
2853                 uaudio_chan_free_buffers(sc, ch);
2854                 return (EIO);
2855         }
2856
2857         s = splusb();
2858         for (i = 0; i < UAUDIO_NCHANBUFS-1; i++) /* XXX */
2859                 uaudio_chan_ptransfer(ch);
2860         splx(s);
2861
2862         return (0);
2863 }
2864
2865 u_int32_t
2866 uaudio_query_mix_info(device_t dev)
2867 {
2868         int i;
2869         u_int32_t mask = 0;
2870         struct uaudio_softc *sc;
2871         struct mixerctl *mc;
2872
2873         sc = device_get_softc(dev);
2874         for (i=0; i < sc->sc_nctls; i++) {
2875                 mc = &sc->sc_ctls[i];
2876                 if (mc->ctl != SOUND_MIXER_NRDEVICES) {
2877                         /* Set device mask bits. 
2878                            See /usr/include/machine/soundcard.h */
2879                         mask |= (1 << mc->ctl);
2880                 }
2881         }
2882         return mask;
2883 }
2884
2885 void
2886 uaudio_mixer_set(device_t dev, unsigned type, unsigned left, unsigned right)
2887 {
2888         int i;
2889         struct uaudio_softc *sc;
2890         struct mixerctl *mc;
2891
2892         sc = device_get_softc(dev);
2893         for (i=0; i < sc->sc_nctls; i++) {
2894                 mc = &sc->sc_ctls[i];
2895                 if (mc->ctl == type) {
2896                         if (mc->nchan == 2) {
2897                                 /* set Right */
2898                                 uaudio_ctl_set(sc, SET_CUR, mc, 1, (int)(right*256)/100);
2899                         }
2900                         /* set Left or Mono */
2901                         uaudio_ctl_set(sc, SET_CUR, mc, 0, (int)(left*256)/100);
2902                 }
2903         }
2904         return;
2905 }
2906
2907 Static int
2908 audio_attach_mi(device_t dev)
2909 {
2910         device_t child;
2911         struct sndcard_func *func;
2912
2913         /* Attach the children. */
2914         /* PCM Audio */
2915         func = malloc(sizeof(struct sndcard_func), M_DEVBUF, M_NOWAIT);
2916         if (func == NULL)
2917                 return (ENOMEM);
2918         bzero(func, sizeof(*func));
2919         func->func = SCF_PCM;
2920         child = device_add_child(dev, "pcm", -1);
2921         device_set_ivars(child, func);
2922
2923         bus_generic_attach(dev);
2924
2925         return 0; /* XXXXX */
2926 }
2927
2928 DRIVER_MODULE(uaudio, uhub, uaudio_driver, uaudio_devclass, usbd_driver_load, 0);
2929 MODULE_VERSION(uaudio, 1);
2930
2931 #endif