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