Annotation of src/sys/dev/usb/uaudio.c, Revision 1.133.2.2
1.133.2.2! tls 1: /* $NetBSD$ */
1.1 augustss 2:
3: /*
1.133 mrg 4: * Copyright (c) 1999, 2012 The NetBSD Foundation, Inc.
1.1 augustss 5: * All rights reserved.
6: *
1.5 augustss 7: * This code is derived from software contributed to The NetBSD Foundation
1.24 augustss 8: * by Lennart Augustsson (lennart@augustsson.net) at
1.133 mrg 9: * Carlstedt Research & Technology, and Matthew R. Green (mrg@eterna.com.au).
1.1 augustss 10: *
11: * Redistribution and use in source and binary forms, with or without
12: * modification, are permitted provided that the following conditions
13: * are met:
14: * 1. Redistributions of source code must retain the above copyright
15: * notice, this list of conditions and the following disclaimer.
16: * 2. Redistributions in binary form must reproduce the above copyright
17: * notice, this list of conditions and the following disclaimer in the
18: * documentation and/or other materials provided with the distribution.
19: *
20: * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
21: * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22: * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
24: * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30: * POSSIBILITY OF SUCH DAMAGE.
31: */
32:
33: /*
1.68 augustss 34: * USB audio specs: http://www.usb.org/developers/devclass_docs/audio10.pdf
35: * http://www.usb.org/developers/devclass_docs/frmts10.pdf
36: * http://www.usb.org/developers/devclass_docs/termt10.pdf
1.1 augustss 37: */
1.44 lukem 38:
39: #include <sys/cdefs.h>
1.133.2.2! tls 40: __KERNEL_RCSID(0, "$NetBSD$");
1.1 augustss 41:
42: #include <sys/param.h>
43: #include <sys/systm.h>
44: #include <sys/kernel.h>
45: #include <sys/malloc.h>
46: #include <sys/device.h>
47: #include <sys/ioctl.h>
48: #include <sys/file.h>
1.40 augustss 49: #include <sys/reboot.h> /* for bootverbose */
1.1 augustss 50: #include <sys/select.h>
51: #include <sys/proc.h>
52: #include <sys/vnode.h>
53: #include <sys/poll.h>
1.114 kent 54: #include <sys/module.h>
1.119 jmcneill 55: #include <sys/bus.h>
1.122 mrg 56: #include <sys/cpu.h>
1.133.2.2! tls 57: #include <sys/atomic.h>
1.1 augustss 58:
59: #include <sys/audioio.h>
60: #include <dev/audio_if.h>
1.77 mycroft 61: #include <dev/audiovar.h>
1.1 augustss 62: #include <dev/mulaw.h>
63: #include <dev/auconv.h>
64:
65: #include <dev/usb/usb.h>
66: #include <dev/usb/usbdi.h>
1.119 jmcneill 67: #include <dev/usb/usbdivar.h>
1.1 augustss 68: #include <dev/usb/usbdi_util.h>
69: #include <dev/usb/usb_quirks.h>
70:
1.120 jakllsch 71: #include <dev/usb/usbdevs.h>
72:
1.1 augustss 73: #include <dev/usb/uaudioreg.h>
74:
1.80 kent 75: /* #define UAUDIO_DEBUG */
76: /* #define UAUDIO_MULTIPLE_ENDPOINTS */
1.4 augustss 77: #ifdef UAUDIO_DEBUG
1.122 mrg 78: #define DPRINTF(x,y...) do { \
79: if (uaudiodebug) { \
80: struct lwp *l = curlwp; \
81: printf("%s[%d:%d]: "x, __func__, l->l_proc->p_pid, l->l_lid, y); \
82: } \
83: } while (0)
84: #define DPRINTFN_CLEAN(n,x...) do { \
85: if (uaudiodebug > (n)) \
86: printf(x); \
87: } while (0)
88: #define DPRINTFN(n,x,y...) do { \
89: if (uaudiodebug > (n)) { \
90: struct lwp *l = curlwp; \
91: printf("%s[%d:%d]: "x, __func__, l->l_proc->p_pid, l->l_lid, y); \
92: } \
93: } while (0)
1.133.2.1 tls 94: int uaudiodebug = 0;
1.1 augustss 95: #else
1.122 mrg 96: #define DPRINTF(x,y...)
97: #define DPRINTFN_CLEAN(n,x...)
98: #define DPRINTFN(n,x,y...)
1.1 augustss 99: #endif
100:
1.22 augustss 101: #define UAUDIO_NCHANBUFS 6 /* number of outstanding request */
1.55 kent 102: #define UAUDIO_NFRAMES 10 /* ms of sound in each request */
1.1 augustss 103:
104:
105: #define MIX_MAX_CHAN 8
106: struct mixerctl {
1.94 kent 107: uint16_t wValue[MIX_MAX_CHAN]; /* using nchan */
108: uint16_t wIndex;
109: uint8_t nchan;
110: uint8_t type;
1.1 augustss 111: #define MIX_ON_OFF 1
112: #define MIX_SIGNED_16 2
113: #define MIX_UNSIGNED_16 3
114: #define MIX_SIGNED_8 4
1.79 kent 115: #define MIX_SELECTOR 5
1.1 augustss 116: #define MIX_SIZE(n) ((n) == MIX_SIGNED_16 || (n) == MIX_UNSIGNED_16 ? 2 : 1)
117: #define MIX_UNSIGNED(n) ((n) == MIX_UNSIGNED_16)
1.34 augustss 118: int minval, maxval;
119: u_int delta;
120: u_int mul;
1.94 kent 121: uint8_t class;
1.1 augustss 122: char ctlname[MAX_AUDIO_DEV_LEN];
1.99 christos 123: const char *ctlunit;
1.1 augustss 124: };
125: #define MAKE(h,l) (((h) << 8) | (l))
126:
127: struct as_info {
1.94 kent 128: uint8_t alt;
129: uint8_t encoding;
130: uint8_t attributes; /* Copy of bmAttributes of
1.50 kent 131: * usb_audio_streaming_endpoint_descriptor
132: */
1.37 mycroft 133: usbd_interface_handle ifaceh;
1.78 kent 134: const usb_interface_descriptor_t *idesc;
135: const usb_endpoint_descriptor_audio_t *edesc;
1.80 kent 136: const usb_endpoint_descriptor_audio_t *edesc1;
1.78 kent 137: const struct usb_audio_streaming_type1_descriptor *asf1desc;
1.92 kent 138: struct audio_format *aformat;
1.47 jdolecek 139: int sc_busy; /* currently used */
1.1 augustss 140: };
141:
142: struct chan {
1.67 wiz 143: void (*intr)(void *); /* DMA completion intr handler */
1.1 augustss 144: void *arg; /* arg for intr() */
145: usbd_pipe_handle pipe;
1.83 kent 146: usbd_pipe_handle sync_pipe;
1.1 augustss 147:
148: u_int sample_size;
149: u_int sample_rate;
150: u_int bytes_per_frame;
151: u_int fraction; /* fraction/1000 is the extra samples/frame */
152: u_int residue; /* accumulates the fractional samples */
153:
154: u_char *start; /* upper layer buffer start */
155: u_char *end; /* upper layer buffer end */
156: u_char *cur; /* current position in upper layer buffer */
157: int blksize; /* chunk size to report up */
158: int transferred; /* transferred bytes not reported up */
159:
1.47 jdolecek 160: int altidx; /* currently used altidx */
1.31 augustss 161:
1.1 augustss 162: int curchanbuf;
163: struct chanbuf {
1.56 kent 164: struct chan *chan;
1.9 augustss 165: usbd_xfer_handle xfer;
1.56 kent 166: u_char *buffer;
1.94 kent 167: uint16_t sizes[UAUDIO_NFRAMES];
168: uint16_t offsets[UAUDIO_NFRAMES];
169: uint16_t size;
1.1 augustss 170: } chanbufs[UAUDIO_NCHANBUFS];
1.8 augustss 171:
172: struct uaudio_softc *sc; /* our softc */
1.1 augustss 173: };
174:
1.121 jmcneill 175: /*
176: * XXX Locking notes:
177: *
178: * The MI USB audio subsystem is not MP-SAFE. Our strategy here
179: * is to ensure we have the kernel lock held when calling into
180: * usbd, and, generally, to have dropped the sc_intr_lock during
181: * these sections as well since the usb code will sleep.
182: */
1.1 augustss 183: struct uaudio_softc {
1.118 dyoung 184: device_t sc_dev; /* base device */
1.121 jmcneill 185: kmutex_t sc_lock;
186: kmutex_t sc_intr_lock;
1.1 augustss 187: usbd_device_handle sc_udev; /* USB device */
1.86 kent 188: int sc_ac_iface; /* Audio Control interface */
1.1 augustss 189: usbd_interface_handle sc_ac_ifaceh;
1.86 kent 190: struct chan sc_playchan; /* play channel */
191: struct chan sc_recchan; /* record channel */
192: int sc_nullalt;
193: int sc_audio_rev;
194: struct as_info *sc_alts; /* alternate settings */
195: int sc_nalts; /* # of alternate settings */
196: int sc_altflags;
1.56 kent 197: #define HAS_8 0x01
198: #define HAS_16 0x02
199: #define HAS_8U 0x04
200: #define HAS_ALAW 0x08
201: #define HAS_MULAW 0x10
1.47 jdolecek 202: #define UA_NOFRAC 0x20 /* don't do sample rate adjustment */
1.51 kent 203: #define HAS_24 0x40
1.86 kent 204: int sc_mode; /* play/record capability */
205: struct mixerctl *sc_ctls; /* mixer controls */
206: int sc_nctls; /* # of mixer controls */
1.117 dyoung 207: device_t sc_audiodev;
1.92 kent 208: struct audio_format *sc_formats;
209: int sc_nformats;
210: struct audio_encoding_set *sc_encodings;
211: u_int sc_channel_config;
1.86 kent 212: char sc_dying;
1.119 jmcneill 213: struct audio_device sc_adev;
1.1 augustss 214: };
215:
1.82 kent 216: struct terminal_list {
217: int size;
218: uint16_t terminals[1];
219: };
220: #define TERMINAL_LIST_SIZE(N) (offsetof(struct terminal_list, terminals) \
221: + sizeof(uint16_t) * (N))
222:
223: struct io_terminal {
224: union {
1.109 drochner 225: const uaudio_cs_descriptor_t *desc;
1.82 kent 226: const struct usb_audio_input_terminal *it;
227: const struct usb_audio_output_terminal *ot;
228: const struct usb_audio_mixer_unit *mu;
229: const struct usb_audio_selector_unit *su;
230: const struct usb_audio_feature_unit *fu;
231: const struct usb_audio_processing_unit *pu;
232: const struct usb_audio_extension_unit *eu;
233: } d;
234: int inputs_size;
235: struct terminal_list **inputs; /* list of source input terminals */
236: struct terminal_list *output; /* list of destination output terminals */
1.83 kent 237: int direct; /* directly connected to an output terminal */
1.82 kent 238: };
239:
240: #define UAC_OUTPUT 0
241: #define UAC_INPUT 1
242: #define UAC_EQUAL 2
243: #define UAC_RECORD 3
244: #define UAC_NCLASSES 4
245: #ifdef UAUDIO_DEBUG
246: Static const char *uac_names[] = {
247: AudioCoutputs, AudioCinputs, AudioCequalization, AudioCrecord,
248: };
249: #endif
1.1 augustss 250:
1.86 kent 251: Static usbd_status uaudio_identify_ac
252: (struct uaudio_softc *, const usb_config_descriptor_t *);
253: Static usbd_status uaudio_identify_as
254: (struct uaudio_softc *, const usb_config_descriptor_t *);
255: Static usbd_status uaudio_process_as
256: (struct uaudio_softc *, const char *, int *, int,
257: const usb_interface_descriptor_t *);
1.78 kent 258:
259: Static void uaudio_add_alt(struct uaudio_softc *, const struct as_info *);
260:
261: Static const usb_interface_descriptor_t *uaudio_find_iface
262: (const char *, int, int *, int);
263:
264: Static void uaudio_mixer_add_ctl(struct uaudio_softc *, struct mixerctl *);
1.86 kent 265: Static char *uaudio_id_name
266: (struct uaudio_softc *, const struct io_terminal *, int);
1.91 kent 267: #ifdef UAUDIO_DEBUG
268: Static void uaudio_dump_cluster(const struct usb_audio_cluster *);
269: #endif
1.86 kent 270: Static struct usb_audio_cluster uaudio_get_cluster
271: (int, const struct io_terminal *);
272: Static void uaudio_add_input
273: (struct uaudio_softc *, const struct io_terminal *, int);
274: Static void uaudio_add_output
275: (struct uaudio_softc *, const struct io_terminal *, int);
276: Static void uaudio_add_mixer
277: (struct uaudio_softc *, const struct io_terminal *, int);
278: Static void uaudio_add_selector
279: (struct uaudio_softc *, const struct io_terminal *, int);
1.82 kent 280: #ifdef UAUDIO_DEBUG
281: Static const char *uaudio_get_terminal_name(int);
282: #endif
1.86 kent 283: Static int uaudio_determine_class
284: (const struct io_terminal *, struct mixerctl *);
285: Static const char *uaudio_feature_name
286: (const struct io_terminal *, struct mixerctl *);
287: Static void uaudio_add_feature
288: (struct uaudio_softc *, const struct io_terminal *, int);
289: Static void uaudio_add_processing_updown
290: (struct uaudio_softc *, const struct io_terminal *, int);
291: Static void uaudio_add_processing
292: (struct uaudio_softc *, const struct io_terminal *, int);
293: Static void uaudio_add_extension
294: (struct uaudio_softc *, const struct io_terminal *, int);
295: Static struct terminal_list *uaudio_merge_terminal_list
296: (const struct io_terminal *);
297: Static struct terminal_list *uaudio_io_terminaltype
298: (int, struct io_terminal *, int);
299: Static usbd_status uaudio_identify
300: (struct uaudio_softc *, const usb_config_descriptor_t *);
1.78 kent 301:
302: Static int uaudio_signext(int, int);
303: Static int uaudio_value2bsd(struct mixerctl *, int);
304: Static int uaudio_bsd2value(struct mixerctl *, int);
305: Static int uaudio_get(struct uaudio_softc *, int, int, int, int, int);
1.86 kent 306: Static int uaudio_ctl_get
307: (struct uaudio_softc *, int, struct mixerctl *, int);
308: Static void uaudio_set
309: (struct uaudio_softc *, int, int, int, int, int, int);
310: Static void uaudio_ctl_set
311: (struct uaudio_softc *, int, struct mixerctl *, int, int);
1.78 kent 312:
313: Static usbd_status uaudio_set_speed(struct uaudio_softc *, int, u_int);
314:
315: Static usbd_status uaudio_chan_open(struct uaudio_softc *, struct chan *);
316: Static void uaudio_chan_close(struct uaudio_softc *, struct chan *);
1.86 kent 317: Static usbd_status uaudio_chan_alloc_buffers
318: (struct uaudio_softc *, struct chan *);
1.78 kent 319: Static void uaudio_chan_free_buffers(struct uaudio_softc *, struct chan *);
1.86 kent 320: Static void uaudio_chan_init
321: (struct chan *, int, const struct audio_params *, int);
1.78 kent 322: Static void uaudio_chan_set_param(struct chan *, u_char *, u_char *, int);
323: Static void uaudio_chan_ptransfer(struct chan *);
1.86 kent 324: Static void uaudio_chan_pintr
325: (usbd_xfer_handle, usbd_private_handle, usbd_status);
1.78 kent 326:
327: Static void uaudio_chan_rtransfer(struct chan *);
1.86 kent 328: Static void uaudio_chan_rintr
329: (usbd_xfer_handle, usbd_private_handle, usbd_status);
1.78 kent 330:
331: Static int uaudio_open(void *, int);
332: Static void uaudio_close(void *);
333: Static int uaudio_drain(void *);
334: Static int uaudio_query_encoding(void *, struct audio_encoding *);
1.86 kent 335: Static int uaudio_set_params
1.93 kent 336: (void *, int, int, struct audio_params *, struct audio_params *,
337: stream_filter_list_t *, stream_filter_list_t *);
338: Static int uaudio_round_blocksize(void *, int, int, const audio_params_t *);
1.86 kent 339: Static int uaudio_trigger_output
340: (void *, void *, void *, int, void (*)(void *), void *,
1.93 kent 341: const audio_params_t *);
1.86 kent 342: Static int uaudio_trigger_input
343: (void *, void *, void *, int, void (*)(void *), void *,
1.93 kent 344: const audio_params_t *);
1.78 kent 345: Static int uaudio_halt_in_dma(void *);
346: Static int uaudio_halt_out_dma(void *);
347: Static int uaudio_getdev(void *, struct audio_device *);
348: Static int uaudio_mixer_set_port(void *, mixer_ctrl_t *);
349: Static int uaudio_mixer_get_port(void *, mixer_ctrl_t *);
350: Static int uaudio_query_devinfo(void *, mixer_devinfo_t *);
351: Static int uaudio_get_props(void *);
1.121 jmcneill 352: Static void uaudio_get_locks(void *, kmutex_t **, kmutex_t **);
1.1 augustss 353:
1.88 yamt 354: Static const struct audio_hw_if uaudio_hw_if = {
1.1 augustss 355: uaudio_open,
356: uaudio_close,
357: uaudio_drain,
358: uaudio_query_encoding,
359: uaudio_set_params,
360: uaudio_round_blocksize,
361: NULL,
362: NULL,
363: NULL,
364: NULL,
365: NULL,
366: uaudio_halt_out_dma,
367: uaudio_halt_in_dma,
368: NULL,
369: uaudio_getdev,
370: NULL,
371: uaudio_mixer_set_port,
372: uaudio_mixer_get_port,
373: uaudio_query_devinfo,
374: NULL,
375: NULL,
376: NULL,
377: NULL,
378: uaudio_get_props,
379: uaudio_trigger_output,
380: uaudio_trigger_input,
1.43 augustss 381: NULL,
1.121 jmcneill 382: uaudio_get_locks,
1.1 augustss 383: };
384:
1.113 cube 385: int uaudio_match(device_t, cfdata_t, void *);
1.111 dyoung 386: void uaudio_attach(device_t, device_t, void *);
387: int uaudio_detach(device_t, int);
388: void uaudio_childdet(device_t, device_t);
389: int uaudio_activate(device_t, enum devact);
390:
391: extern struct cfdriver uaudio_cd;
392:
1.113 cube 393: CFATTACH_DECL2_NEW(uaudio, sizeof(struct uaudio_softc),
1.111 dyoung 394: uaudio_match, uaudio_attach, uaudio_detach, uaudio_activate, NULL,
395: uaudio_childdet);
1.1 augustss 396:
1.133.2.2! tls 397: int
1.118 dyoung 398: uaudio_match(device_t parent, cfdata_t match, void *aux)
1.1 augustss 399: {
1.118 dyoung 400: struct usbif_attach_arg *uaa = aux;
1.1 augustss 401:
402: /* Trigger on the control interface. */
1.110 drochner 403: if (uaa->class != UICLASS_AUDIO ||
404: uaa->subclass != UISUBCLASS_AUDIOCONTROL ||
1.10 augustss 405: (usbd_get_quirks(uaa->device)->uq_flags & UQ_BAD_AUDIO))
1.94 kent 406: return UMATCH_NONE;
1.1 augustss 407:
1.94 kent 408: return UMATCH_IFACECLASS_IFACESUBCLASS;
1.1 augustss 409: }
410:
1.133.2.2! tls 411: void
1.118 dyoung 412: uaudio_attach(device_t parent, device_t self, void *aux)
1.1 augustss 413: {
1.118 dyoung 414: struct uaudio_softc *sc = device_private(self);
415: struct usbif_attach_arg *uaa = aux;
1.1 augustss 416: usb_interface_descriptor_t *id;
417: usb_config_descriptor_t *cdesc;
1.98 augustss 418: char *devinfop;
1.9 augustss 419: usbd_status err;
1.37 mycroft 420: int i, j, found;
1.1 augustss 421:
1.113 cube 422: sc->sc_dev = self;
1.116 plunky 423: sc->sc_udev = uaa->device;
1.121 jmcneill 424: mutex_init(&sc->sc_lock, MUTEX_DEFAULT, IPL_NONE);
1.133 mrg 425: mutex_init(&sc->sc_intr_lock, MUTEX_DEFAULT, IPL_SCHED);
1.116 plunky 426:
1.119 jmcneill 427: strlcpy(sc->sc_adev.name, "USB audio", sizeof(sc->sc_adev.name));
428: strlcpy(sc->sc_adev.version, "", sizeof(sc->sc_adev.version));
429: snprintf(sc->sc_adev.config, sizeof(sc->sc_adev.config), "usb:%08x",
430: sc->sc_udev->cookie.cookie);
431:
1.116 plunky 432: aprint_naive("\n");
433: aprint_normal("\n");
1.113 cube 434:
1.98 augustss 435: devinfop = usbd_devinfo_alloc(uaa->device, 0);
1.116 plunky 436: aprint_normal_dev(self, "%s\n", devinfop);
1.98 augustss 437: usbd_devinfo_free(devinfop);
1.1 augustss 438:
439: cdesc = usbd_get_config_descriptor(sc->sc_udev);
1.13 augustss 440: if (cdesc == NULL) {
1.113 cube 441: aprint_error_dev(self,
442: "failed to get configuration descriptor\n");
1.118 dyoung 443: return;
1.13 augustss 444: }
1.1 augustss 445:
1.9 augustss 446: err = uaudio_identify(sc, cdesc);
447: if (err) {
1.113 cube 448: aprint_error_dev(self,
449: "audio descriptors make no sense, error=%d\n", err);
1.118 dyoung 450: return;
1.1 augustss 451: }
452:
453: sc->sc_ac_ifaceh = uaa->iface;
454: /* Pick up the AS interface. */
455: for (i = 0; i < uaa->nifaces; i++) {
1.37 mycroft 456: if (uaa->ifaces[i] == NULL)
457: continue;
458: id = usbd_get_interface_descriptor(uaa->ifaces[i]);
459: if (id == NULL)
460: continue;
461: found = 0;
462: for (j = 0; j < sc->sc_nalts; j++) {
463: if (id->bInterfaceNumber ==
464: sc->sc_alts[j].idesc->bInterfaceNumber) {
465: sc->sc_alts[j].ifaceh = uaa->ifaces[i];
466: found = 1;
1.1 augustss 467: }
468: }
1.37 mycroft 469: if (found)
470: uaa->ifaces[i] = NULL;
1.1 augustss 471: }
472:
1.37 mycroft 473: for (j = 0; j < sc->sc_nalts; j++) {
474: if (sc->sc_alts[j].ifaceh == NULL) {
1.113 cube 475: aprint_error_dev(self,
476: "alt %d missing AS interface(s)\n", j);
1.118 dyoung 477: return;
1.37 mycroft 478: }
1.1 augustss 479: }
480:
1.113 cube 481: aprint_normal_dev(self, "audio rev %d.%02x\n",
1.7 augustss 482: sc->sc_audio_rev >> 8, sc->sc_audio_rev & 0xff);
483:
1.47 jdolecek 484: sc->sc_playchan.sc = sc->sc_recchan.sc = sc;
1.60 kent 485: sc->sc_playchan.altidx = -1;
486: sc->sc_recchan.altidx = -1;
1.8 augustss 487:
1.31 augustss 488: if (usbd_get_quirks(sc->sc_udev)->uq_flags & UQ_AU_NO_FRAC)
1.47 jdolecek 489: sc->sc_altflags |= UA_NOFRAC;
1.31 augustss 490:
1.40 augustss 491: #ifndef UAUDIO_DEBUG
492: if (bootverbose)
493: #endif
1.113 cube 494: aprint_normal_dev(self, "%d mixer controls\n",
1.40 augustss 495: sc->sc_nctls);
496:
1.41 augustss 497: usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev,
1.118 dyoung 498: sc->sc_dev);
1.41 augustss 499:
1.122 mrg 500: DPRINTF("%s", "doing audio_attach_mi\n");
1.113 cube 501: sc->sc_audiodev = audio_attach_mi(&uaudio_hw_if, sc, sc->sc_dev);
1.17 augustss 502:
1.118 dyoung 503: return;
1.1 augustss 504: }
505:
506: int
1.117 dyoung 507: uaudio_activate(device_t self, enum devact act)
1.1 augustss 508: {
1.117 dyoung 509: struct uaudio_softc *sc = device_private(self);
1.1 augustss 510:
511: switch (act) {
512: case DVACT_DEACTIVATE:
513: sc->sc_dying = 1;
1.117 dyoung 514: return 0;
515: default:
516: return EOPNOTSUPP;
1.1 augustss 517: }
518: }
519:
1.111 dyoung 520: void
521: uaudio_childdet(device_t self, device_t child)
522: {
523: struct uaudio_softc *sc = device_private(self);
524:
525: KASSERT(sc->sc_audiodev == child);
526: sc->sc_audiodev = NULL;
527: }
528:
1.1 augustss 529: int
1.111 dyoung 530: uaudio_detach(device_t self, int flags)
1.1 augustss 531: {
1.111 dyoung 532: struct uaudio_softc *sc = device_private(self);
1.94 kent 533: int rv;
1.1 augustss 534:
1.94 kent 535: rv = 0;
1.8 augustss 536: /* Wait for outstanding requests to complete. */
537: usbd_delay_ms(sc->sc_udev, UAUDIO_NCHANBUFS * UAUDIO_NFRAMES);
538:
1.9 augustss 539: if (sc->sc_audiodev != NULL)
1.1 augustss 540: rv = config_detach(sc->sc_audiodev, flags);
1.17 augustss 541:
542: usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev,
1.118 dyoung 543: sc->sc_dev);
1.1 augustss 544:
1.92 kent 545: if (sc->sc_formats != NULL)
546: free(sc->sc_formats, M_USBDEV);
547: auconv_delete_encodings(sc->sc_encodings);
1.121 jmcneill 548:
549: mutex_destroy(&sc->sc_lock);
550: mutex_destroy(&sc->sc_intr_lock);
551:
1.94 kent 552: return rv;
1.1 augustss 553: }
554:
1.86 kent 555: Static int
1.26 augustss 556: uaudio_query_encoding(void *addr, struct audio_encoding *fp)
1.1 augustss 557: {
1.94 kent 558: struct uaudio_softc *sc;
559: int flags;
1.1 augustss 560:
1.94 kent 561: sc = addr;
562: flags = sc->sc_altflags;
1.1 augustss 563: if (sc->sc_dying)
1.94 kent 564: return EIO;
1.56 kent 565:
1.1 augustss 566: if (sc->sc_nalts == 0 || flags == 0)
1.94 kent 567: return ENXIO;
1.1 augustss 568:
1.92 kent 569: return auconv_query_encoding(sc->sc_encodings, fp);
1.1 augustss 570: }
571:
1.86 kent 572: Static const usb_interface_descriptor_t *
1.99 christos 573: uaudio_find_iface(const char *tbuf, int size, int *offsp, int subtype)
1.1 augustss 574: {
1.78 kent 575: const usb_interface_descriptor_t *d;
1.1 augustss 576:
577: while (*offsp < size) {
1.99 christos 578: d = (const void *)(tbuf + *offsp);
1.1 augustss 579: *offsp += d->bLength;
580: if (d->bDescriptorType == UDESC_INTERFACE &&
1.19 augustss 581: d->bInterfaceClass == UICLASS_AUDIO &&
1.1 augustss 582: d->bInterfaceSubClass == subtype)
1.94 kent 583: return d;
1.1 augustss 584: }
1.94 kent 585: return NULL;
1.1 augustss 586: }
587:
1.86 kent 588: Static void
1.26 augustss 589: uaudio_mixer_add_ctl(struct uaudio_softc *sc, struct mixerctl *mc)
1.1 augustss 590: {
1.33 augustss 591: int res;
1.84 kent 592: size_t len;
593: struct mixerctl *nmc;
1.33 augustss 594:
1.82 kent 595: if (mc->class < UAC_NCLASSES) {
1.122 mrg 596: DPRINTF("adding %s.%s\n", uac_names[mc->class], mc->ctlname);
1.82 kent 597: } else {
1.122 mrg 598: DPRINTF("adding %s\n", mc->ctlname);
1.82 kent 599: }
1.84 kent 600: len = sizeof(*mc) * (sc->sc_nctls + 1);
601: nmc = malloc(len, M_USBDEV, M_NOWAIT);
1.42 christos 602: if (nmc == NULL) {
1.113 cube 603: aprint_error("uaudio_mixer_add_ctl: no memory\n");
1.1 augustss 604: return;
605: }
1.84 kent 606: /* Copy old data, if there was any */
607: if (sc->sc_nctls != 0) {
608: memcpy(nmc, sc->sc_ctls, sizeof(*mc) * (sc->sc_nctls));
609: free(sc->sc_ctls, M_USBDEV);
610: }
1.42 christos 611: sc->sc_ctls = nmc;
1.1 augustss 612:
1.33 augustss 613: mc->delta = 0;
1.79 kent 614: if (mc->type == MIX_ON_OFF) {
615: mc->minval = 0;
616: mc->maxval = 1;
617: } else if (mc->type == MIX_SELECTOR) {
618: ;
619: } else {
1.1 augustss 620: /* Determine min and max values. */
1.56 kent 621: mc->minval = uaudio_signext(mc->type,
622: uaudio_get(sc, GET_MIN, UT_READ_CLASS_INTERFACE,
623: mc->wValue[0], mc->wIndex,
1.1 augustss 624: MIX_SIZE(mc->type)));
1.56 kent 625: mc->maxval = 1 + uaudio_signext(mc->type,
1.1 augustss 626: uaudio_get(sc, GET_MAX, UT_READ_CLASS_INTERFACE,
627: mc->wValue[0], mc->wIndex,
628: MIX_SIZE(mc->type)));
1.34 augustss 629: mc->mul = mc->maxval - mc->minval;
630: if (mc->mul == 0)
631: mc->mul = 1;
1.33 augustss 632: res = uaudio_get(sc, GET_RES, UT_READ_CLASS_INTERFACE,
633: mc->wValue[0], mc->wIndex,
634: MIX_SIZE(mc->type));
1.34 augustss 635: if (res > 0)
1.69 wiz 636: mc->delta = (res * 255 + mc->mul/2) / mc->mul;
1.1 augustss 637: }
638:
639: sc->sc_ctls[sc->sc_nctls++] = *mc;
640:
1.4 augustss 641: #ifdef UAUDIO_DEBUG
1.1 augustss 642: if (uaudiodebug > 2) {
643: int i;
1.122 mrg 644:
645: DPRINTFN_CLEAN(2, "wValue=%04x", mc->wValue[0]);
1.1 augustss 646: for (i = 1; i < mc->nchan; i++)
1.122 mrg 647: DPRINTFN_CLEAN(2, ",%04x", mc->wValue[i]);
648: DPRINTFN_CLEAN(2, " wIndex=%04x type=%d name='%s' unit='%s' "
1.1 augustss 649: "min=%d max=%d\n",
650: mc->wIndex, mc->type, mc->ctlname, mc->ctlunit,
1.122 mrg 651: mc->minval, mc->maxval);
1.1 augustss 652: }
653: #endif
654: }
655:
1.86 kent 656: Static char *
1.107 christos 657: uaudio_id_name(struct uaudio_softc *sc,
658: const struct io_terminal *iot, int id)
1.1 augustss 659: {
1.99 christos 660: static char tbuf[32];
1.94 kent 661:
1.99 christos 662: snprintf(tbuf, sizeof(tbuf), "i%d", id);
663: return tbuf;
1.1 augustss 664: }
665:
1.91 kent 666: #ifdef UAUDIO_DEBUG
667: Static void
668: uaudio_dump_cluster(const struct usb_audio_cluster *cl)
669: {
670: static const char *channel_names[16] = {
671: "LEFT", "RIGHT", "CENTER", "LFE",
672: "LEFT_SURROUND", "RIGHT_SURROUND", "LEFT_CENTER", "RIGHT_CENTER",
673: "SURROUND", "LEFT_SIDE", "RIGHT_SIDE", "TOP",
674: "RESERVED12", "RESERVED13", "RESERVED14", "RESERVED15",
675: };
676: int cc, i, first;
677:
678: cc = UGETW(cl->wChannelConfig);
1.118 dyoung 679: printf("cluster: bNrChannels=%u wChannelConfig=0x%.4x",
1.91 kent 680: cl->bNrChannels, cc);
681: first = TRUE;
682: for (i = 0; cc != 0; i++) {
683: if (cc & 1) {
1.118 dyoung 684: printf("%c%s", first ? '<' : ',', channel_names[i]);
1.91 kent 685: first = FALSE;
686: }
687: cc = cc >> 1;
688: }
1.118 dyoung 689: printf("> iChannelNames=%u", cl->iChannelNames);
1.91 kent 690: }
691: #endif
692:
1.86 kent 693: Static struct usb_audio_cluster
1.82 kent 694: uaudio_get_cluster(int id, const struct io_terminal *iot)
1.1 augustss 695: {
696: struct usb_audio_cluster r;
1.109 drochner 697: const uaudio_cs_descriptor_t *dp;
1.1 augustss 698: int i;
699:
700: for (i = 0; i < 25; i++) { /* avoid infinite loops */
1.82 kent 701: dp = iot[id].d.desc;
1.1 augustss 702: if (dp == 0)
703: goto bad;
704: switch (dp->bDescriptorSubtype) {
705: case UDESCSUB_AC_INPUT:
1.82 kent 706: r.bNrChannels = iot[id].d.it->bNrChannels;
707: USETW(r.wChannelConfig, UGETW(iot[id].d.it->wChannelConfig));
708: r.iChannelNames = iot[id].d.it->iChannelNames;
1.94 kent 709: return r;
1.1 augustss 710: case UDESCSUB_AC_OUTPUT:
1.82 kent 711: id = iot[id].d.ot->bSourceId;
1.1 augustss 712: break;
713: case UDESCSUB_AC_MIXER:
1.99 christos 714: r = *(const struct usb_audio_cluster *)
1.82 kent 715: &iot[id].d.mu->baSourceId[iot[id].d.mu->bNrInPins];
1.94 kent 716: return r;
1.1 augustss 717: case UDESCSUB_AC_SELECTOR:
718: /* XXX This is not really right */
1.82 kent 719: id = iot[id].d.su->baSourceId[0];
1.1 augustss 720: break;
721: case UDESCSUB_AC_FEATURE:
1.82 kent 722: id = iot[id].d.fu->bSourceId;
1.1 augustss 723: break;
724: case UDESCSUB_AC_PROCESSING:
1.99 christos 725: r = *(const struct usb_audio_cluster *)
1.82 kent 726: &iot[id].d.pu->baSourceId[iot[id].d.pu->bNrInPins];
1.94 kent 727: return r;
1.1 augustss 728: case UDESCSUB_AC_EXTENSION:
1.99 christos 729: r = *(const struct usb_audio_cluster *)
1.82 kent 730: &iot[id].d.eu->baSourceId[iot[id].d.eu->bNrInPins];
1.94 kent 731: return r;
1.1 augustss 732: default:
733: goto bad;
734: }
735: }
736: bad:
1.113 cube 737: aprint_error("uaudio_get_cluster: bad data\n");
1.1 augustss 738: memset(&r, 0, sizeof r);
1.94 kent 739: return r;
1.1 augustss 740:
741: }
742:
1.86 kent 743: Static void
1.82 kent 744: uaudio_add_input(struct uaudio_softc *sc, const struct io_terminal *iot, int id)
1.1 augustss 745: {
1.94 kent 746: const struct usb_audio_input_terminal *d;
1.1 augustss 747:
1.94 kent 748: d = iot[id].d.it;
1.92 kent 749: #ifdef UAUDIO_DEBUG
1.122 mrg 750: DPRINTFN(2,"bTerminalId=%d wTerminalType=0x%04x "
1.1 augustss 751: "bAssocTerminal=%d bNrChannels=%d wChannelConfig=%d "
752: "iChannelNames=%d iTerminal=%d\n",
753: d->bTerminalId, UGETW(d->wTerminalType), d->bAssocTerminal,
754: d->bNrChannels, UGETW(d->wChannelConfig),
1.122 mrg 755: d->iChannelNames, d->iTerminal);
1.1 augustss 756: #endif
1.92 kent 757: /* If USB input terminal, record wChannelConfig */
758: if ((UGETW(d->wTerminalType) & 0xff00) != 0x0100)
759: return;
760: sc->sc_channel_config = UGETW(d->wChannelConfig);
1.1 augustss 761: }
762:
1.86 kent 763: Static void
1.107 christos 764: uaudio_add_output(struct uaudio_softc *sc,
765: const struct io_terminal *iot, int id)
1.1 augustss 766: {
1.4 augustss 767: #ifdef UAUDIO_DEBUG
1.94 kent 768: const struct usb_audio_output_terminal *d;
1.1 augustss 769:
1.94 kent 770: d = iot[id].d.ot;
1.122 mrg 771: DPRINTFN(2,"bTerminalId=%d wTerminalType=0x%04x "
1.1 augustss 772: "bAssocTerminal=%d bSourceId=%d iTerminal=%d\n",
773: d->bTerminalId, UGETW(d->wTerminalType), d->bAssocTerminal,
1.122 mrg 774: d->bSourceId, d->iTerminal);
1.1 augustss 775: #endif
776: }
777:
1.86 kent 778: Static void
1.82 kent 779: uaudio_add_mixer(struct uaudio_softc *sc, const struct io_terminal *iot, int id)
1.1 augustss 780: {
1.94 kent 781: const struct usb_audio_mixer_unit *d;
1.99 christos 782: const struct usb_audio_mixer_unit_1 *d1;
1.1 augustss 783: int c, chs, ichs, ochs, i, o, bno, p, mo, mc, k;
1.99 christos 784: const uByte *bm;
1.1 augustss 785: struct mixerctl mix;
786:
1.94 kent 787: d = iot[id].d.mu;
1.122 mrg 788: DPRINTFN(2,"bUnitId=%d bNrInPins=%d\n",
789: d->bUnitId, d->bNrInPins);
1.56 kent 790:
1.1 augustss 791: /* Compute the number of input channels */
792: ichs = 0;
793: for (i = 0; i < d->bNrInPins; i++)
1.82 kent 794: ichs += uaudio_get_cluster(d->baSourceId[i], iot).bNrChannels;
1.1 augustss 795:
796: /* and the number of output channels */
1.99 christos 797: d1 = (const struct usb_audio_mixer_unit_1 *)&d->baSourceId[d->bNrInPins];
1.1 augustss 798: ochs = d1->bNrChannels;
1.122 mrg 799: DPRINTFN(2,"ichs=%d ochs=%d\n", ichs, ochs);
1.1 augustss 800:
801: bm = d1->bmControls;
802: mix.wIndex = MAKE(d->bUnitId, sc->sc_ac_iface);
1.82 kent 803: uaudio_determine_class(&iot[id], &mix);
1.1 augustss 804: mix.type = MIX_SIGNED_16;
805: mix.ctlunit = AudioNvolume;
1.101 dyoung 806: #define _BIT(bno) ((bm[bno / 8] >> (7 - bno % 8)) & 1)
1.1 augustss 807: for (p = i = 0; i < d->bNrInPins; i++) {
1.82 kent 808: chs = uaudio_get_cluster(d->baSourceId[i], iot).bNrChannels;
1.1 augustss 809: mc = 0;
810: for (c = 0; c < chs; c++) {
811: mo = 0;
812: for (o = 0; o < ochs; o++) {
813: bno = (p + c) * ochs + o;
1.101 dyoung 814: if (_BIT(bno))
1.1 augustss 815: mo++;
816: }
817: if (mo == 1)
818: mc++;
819: }
820: if (mc == chs && chs <= MIX_MAX_CHAN) {
821: k = 0;
822: for (c = 0; c < chs; c++)
823: for (o = 0; o < ochs; o++) {
824: bno = (p + c) * ochs + o;
1.101 dyoung 825: if (_BIT(bno))
1.56 kent 826: mix.wValue[k++] =
1.1 augustss 827: MAKE(p+c+1, o+1);
828: }
1.70 itojun 829: snprintf(mix.ctlname, sizeof(mix.ctlname), "mix%d-%s",
1.82 kent 830: d->bUnitId, uaudio_id_name(sc, iot,
1.70 itojun 831: d->baSourceId[i]));
1.1 augustss 832: mix.nchan = chs;
833: uaudio_mixer_add_ctl(sc, &mix);
834: } else {
835: /* XXX */
836: }
1.101 dyoung 837: #undef _BIT
1.1 augustss 838: p += chs;
839: }
840:
841: }
842:
1.86 kent 843: Static void
1.82 kent 844: uaudio_add_selector(struct uaudio_softc *sc, const struct io_terminal *iot, int id)
1.1 augustss 845: {
1.94 kent 846: const struct usb_audio_selector_unit *d;
1.79 kent 847: struct mixerctl mix;
848: int i, wp;
1.1 augustss 849:
1.94 kent 850: d = iot[id].d.su;
1.122 mrg 851: DPRINTFN(2,"bUnitId=%d bNrInPins=%d\n",
852: d->bUnitId, d->bNrInPins);
1.79 kent 853: mix.wIndex = MAKE(d->bUnitId, sc->sc_ac_iface);
854: mix.wValue[0] = MAKE(0, 0);
1.82 kent 855: uaudio_determine_class(&iot[id], &mix);
1.79 kent 856: mix.nchan = 1;
857: mix.type = MIX_SELECTOR;
858: mix.ctlunit = "";
859: mix.minval = 1;
860: mix.maxval = d->bNrInPins;
861: mix.mul = mix.maxval - mix.minval;
1.81 kent 862: wp = snprintf(mix.ctlname, MAX_AUDIO_DEV_LEN, "sel%d-", d->bUnitId);
1.79 kent 863: for (i = 1; i <= d->bNrInPins; i++) {
864: wp += snprintf(mix.ctlname + wp, MAX_AUDIO_DEV_LEN - wp,
865: "i%d", d->baSourceId[i - 1]);
866: if (wp > MAX_AUDIO_DEV_LEN - 1)
867: break;
868: }
869: uaudio_mixer_add_ctl(sc, &mix);
1.1 augustss 870: }
871:
1.82 kent 872: #ifdef UAUDIO_DEBUG
1.86 kent 873: Static const char *
1.82 kent 874: uaudio_get_terminal_name(int terminal_type)
875: {
1.99 christos 876: static char tbuf[100];
1.82 kent 877:
878: switch (terminal_type) {
1.87 kent 879: /* USB terminal types */
880: case UAT_UNDEFINED: return "UAT_UNDEFINED";
1.82 kent 881: case UAT_STREAM: return "UAT_STREAM";
1.87 kent 882: case UAT_VENDOR: return "UAT_VENDOR";
883: /* input terminal types */
884: case UATI_UNDEFINED: return "UATI_UNDEFINED";
1.82 kent 885: case UATI_MICROPHONE: return "UATI_MICROPHONE";
886: case UATI_DESKMICROPHONE: return "UATI_DESKMICROPHONE";
887: case UATI_PERSONALMICROPHONE: return "UATI_PERSONALMICROPHONE";
888: case UATI_OMNIMICROPHONE: return "UATI_OMNIMICROPHONE";
889: case UATI_MICROPHONEARRAY: return "UATI_MICROPHONEARRAY";
890: case UATI_PROCMICROPHONEARR: return "UATI_PROCMICROPHONEARR";
1.87 kent 891: /* output terminal types */
892: case UATO_UNDEFINED: return "UATO_UNDEFINED";
1.82 kent 893: case UATO_SPEAKER: return "UATO_SPEAKER";
1.87 kent 894: case UATO_HEADPHONES: return "UATO_HEADPHONES";
895: case UATO_DISPLAYAUDIO: return "UATO_DISPLAYAUDIO";
1.82 kent 896: case UATO_DESKTOPSPEAKER: return "UATO_DESKTOPSPEAKER";
897: case UATO_ROOMSPEAKER: return "UATO_ROOMSPEAKER";
898: case UATO_COMMSPEAKER: return "UATO_COMMSPEAKER";
899: case UATO_SUBWOOFER: return "UATO_SUBWOOFER";
1.87 kent 900: /* bidir terminal types */
1.82 kent 901: case UATB_UNDEFINED: return "UATB_UNDEFINED";
902: case UATB_HANDSET: return "UATB_HANDSET";
903: case UATB_HEADSET: return "UATB_HEADSET";
904: case UATB_SPEAKERPHONE: return "UATB_SPEAKERPHONE";
905: case UATB_SPEAKERPHONEESUP: return "UATB_SPEAKERPHONEESUP";
906: case UATB_SPEAKERPHONEECANC: return "UATB_SPEAKERPHONEECANC";
1.87 kent 907: /* telephony terminal types */
1.82 kent 908: case UATT_UNDEFINED: return "UATT_UNDEFINED";
909: case UATT_PHONELINE: return "UATT_PHONELINE";
910: case UATT_TELEPHONE: return "UATT_TELEPHONE";
911: case UATT_DOWNLINEPHONE: return "UATT_DOWNLINEPHONE";
1.87 kent 912: /* external terminal types */
1.82 kent 913: case UATE_UNDEFINED: return "UATE_UNDEFINED";
1.87 kent 914: case UATE_ANALOGCONN: return "UATE_ANALOGCONN";
915: case UATE_LINECONN: return "UATE_LINECONN";
916: case UATE_LEGACYCONN: return "UATE_LEGACYCONN";
917: case UATE_DIGITALAUIFC: return "UATE_DIGITALAUIFC";
918: case UATE_SPDIF: return "UATE_SPDIF";
919: case UATE_1394DA: return "UATE_1394DA";
920: case UATE_1394DV: return "UATE_1394DV";
921: /* embedded function terminal types */
1.82 kent 922: case UATF_UNDEFINED: return "UATF_UNDEFINED";
923: case UATF_CALIBNOISE: return "UATF_CALIBNOISE";
924: case UATF_EQUNOISE: return "UATF_EQUNOISE";
1.87 kent 925: case UATF_CDPLAYER: return "UATF_CDPLAYER";
1.82 kent 926: case UATF_DAT: return "UATF_DAT";
927: case UATF_DCC: return "UATF_DCC";
928: case UATF_MINIDISK: return "UATF_MINIDISK";
929: case UATF_ANALOGTAPE: return "UATF_ANALOGTAPE";
930: case UATF_PHONOGRAPH: return "UATF_PHONOGRAPH";
931: case UATF_VCRAUDIO: return "UATF_VCRAUDIO";
1.87 kent 932: case UATF_VIDEODISCAUDIO: return "UATF_VIDEODISCAUDIO";
933: case UATF_DVDAUDIO: return "UATF_DVDAUDIO";
934: case UATF_TVTUNERAUDIO: return "UATF_TVTUNERAUDIO";
1.82 kent 935: case UATF_SATELLITE: return "UATF_SATELLITE";
936: case UATF_CABLETUNER: return "UATF_CABLETUNER";
937: case UATF_DSS: return "UATF_DSS";
938: case UATF_RADIORECV: return "UATF_RADIORECV";
939: case UATF_RADIOXMIT: return "UATF_RADIOXMIT";
940: case UATF_MULTITRACK: return "UATF_MULTITRACK";
1.87 kent 941: case UATF_SYNTHESIZER: return "UATF_SYNTHESIZER";
1.82 kent 942: default:
1.99 christos 943: snprintf(tbuf, sizeof(tbuf), "unknown type (0x%.4x)", terminal_type);
944: return tbuf;
1.82 kent 945: }
946: }
947: #endif
948:
1.86 kent 949: Static int
1.82 kent 950: uaudio_determine_class(const struct io_terminal *iot, struct mixerctl *mix)
951: {
952: int terminal_type;
953:
954: if (iot == NULL || iot->output == NULL) {
955: mix->class = UAC_OUTPUT;
956: return 0;
957: }
958: terminal_type = 0;
959: if (iot->output->size == 1)
960: terminal_type = iot->output->terminals[0];
961: /*
962: * If the only output terminal is USB,
963: * the class is UAC_RECORD.
964: */
965: if ((terminal_type & 0xff00) == (UAT_UNDEFINED & 0xff00)) {
966: mix->class = UAC_RECORD;
967: if (iot->inputs_size == 1
968: && iot->inputs[0] != NULL
969: && iot->inputs[0]->size == 1)
970: return iot->inputs[0]->terminals[0];
971: else
972: return 0;
973: }
974: /*
1.83 kent 975: * If the ultimate destination of the unit is just one output
1.82 kent 976: * terminal and the unit is connected to the output terminal
977: * directly, the class is UAC_OUTPUT.
978: */
979: if (terminal_type != 0 && iot->direct) {
980: mix->class = UAC_OUTPUT;
981: return terminal_type;
982: }
983: /*
984: * If the unit is connected to just one input terminal,
985: * the class is UAC_INPUT.
986: */
987: if (iot->inputs_size == 1 && iot->inputs[0] != NULL
988: && iot->inputs[0]->size == 1) {
989: mix->class = UAC_INPUT;
990: return iot->inputs[0]->terminals[0];
991: }
992: /*
993: * Otherwise, the class is UAC_OUTPUT.
994: */
995: mix->class = UAC_OUTPUT;
996: return terminal_type;
997: }
998:
1.86 kent 999: Static const char *
1.82 kent 1000: uaudio_feature_name(const struct io_terminal *iot, struct mixerctl *mix)
1001: {
1002: int terminal_type;
1003:
1004: terminal_type = uaudio_determine_class(iot, mix);
1005: if (mix->class == UAC_RECORD && terminal_type == 0)
1006: return AudioNmixerout;
1.122 mrg 1007: DPRINTF("terminal_type=%s\n", uaudio_get_terminal_name(terminal_type));
1.82 kent 1008: switch (terminal_type) {
1009: case UAT_STREAM:
1010: return AudioNdac;
1011:
1012: case UATI_MICROPHONE:
1013: case UATI_DESKMICROPHONE:
1014: case UATI_PERSONALMICROPHONE:
1015: case UATI_OMNIMICROPHONE:
1016: case UATI_MICROPHONEARRAY:
1017: case UATI_PROCMICROPHONEARR:
1018: return AudioNmicrophone;
1019:
1020: case UATO_SPEAKER:
1021: case UATO_DESKTOPSPEAKER:
1022: case UATO_ROOMSPEAKER:
1023: case UATO_COMMSPEAKER:
1024: return AudioNspeaker;
1025:
1026: case UATO_HEADPHONES:
1027: return AudioNheadphone;
1028:
1.87 kent 1029: case UATO_SUBWOOFER:
1030: return AudioNlfe;
1031:
1032: /* telephony terminal types */
1033: case UATT_UNDEFINED:
1034: case UATT_PHONELINE:
1035: case UATT_TELEPHONE:
1036: case UATT_DOWNLINEPHONE:
1037: return "phone";
1038:
1.82 kent 1039: case UATE_ANALOGCONN:
1040: case UATE_LINECONN:
1041: case UATE_LEGACYCONN:
1042: return AudioNline;
1043:
1044: case UATE_DIGITALAUIFC:
1045: case UATE_SPDIF:
1046: case UATE_1394DA:
1047: case UATE_1394DV:
1048: return AudioNaux;
1049:
1050: case UATF_CDPLAYER:
1051: return AudioNcd;
1052:
1053: case UATF_SYNTHESIZER:
1054: return AudioNfmsynth;
1055:
1056: case UATF_VIDEODISCAUDIO:
1057: case UATF_DVDAUDIO:
1058: case UATF_TVTUNERAUDIO:
1059: return AudioNvideo;
1060:
1061: case UAT_UNDEFINED:
1062: case UAT_VENDOR:
1063: case UATI_UNDEFINED:
1064: /* output terminal types */
1065: case UATO_UNDEFINED:
1066: case UATO_DISPLAYAUDIO:
1067: /* bidir terminal types */
1068: case UATB_UNDEFINED:
1069: case UATB_HANDSET:
1070: case UATB_HEADSET:
1071: case UATB_SPEAKERPHONE:
1072: case UATB_SPEAKERPHONEESUP:
1073: case UATB_SPEAKERPHONEECANC:
1074: /* external terminal types */
1075: case UATE_UNDEFINED:
1076: /* embedded function terminal types */
1077: case UATF_UNDEFINED:
1078: case UATF_CALIBNOISE:
1079: case UATF_EQUNOISE:
1080: case UATF_DAT:
1081: case UATF_DCC:
1082: case UATF_MINIDISK:
1083: case UATF_ANALOGTAPE:
1084: case UATF_PHONOGRAPH:
1085: case UATF_VCRAUDIO:
1086: case UATF_SATELLITE:
1087: case UATF_CABLETUNER:
1088: case UATF_DSS:
1089: case UATF_RADIORECV:
1090: case UATF_RADIOXMIT:
1091: case UATF_MULTITRACK:
1092: case 0xffff:
1093: default:
1.122 mrg 1094: DPRINTF("'master' for 0x%.4x\n", terminal_type);
1.82 kent 1095: return AudioNmaster;
1096: }
1097: return AudioNmaster;
1098: }
1099:
1.86 kent 1100: Static void
1.82 kent 1101: uaudio_add_feature(struct uaudio_softc *sc, const struct io_terminal *iot, int id)
1.1 augustss 1102: {
1.94 kent 1103: const struct usb_audio_feature_unit *d;
1104: const uByte *ctls;
1105: int ctlsize;
1106: int nchan;
1.1 augustss 1107: u_int fumask, mmask, cmask;
1108: struct mixerctl mix;
1109: int chan, ctl, i, unit;
1.82 kent 1110: const char *mixername;
1.1 augustss 1111:
1112: #define GET(i) (ctls[(i)*ctlsize] | \
1113: (ctlsize > 1 ? ctls[(i)*ctlsize+1] << 8 : 0))
1.94 kent 1114: d = iot[id].d.fu;
1115: ctls = d->bmaControls;
1116: ctlsize = d->bControlSize;
1117: nchan = (d->bLength - 7) / ctlsize;
1.1 augustss 1118: mmask = GET(0);
1119: /* Figure out what we can control */
1120: for (cmask = 0, chan = 1; chan < nchan; chan++) {
1.122 mrg 1121: DPRINTFN(9,"chan=%d mask=%x\n",
1122: chan, GET(chan));
1.1 augustss 1123: cmask |= GET(chan);
1124: }
1125:
1.122 mrg 1126: DPRINTFN(1,"bUnitId=%d, "
1.56 kent 1127: "%d channels, mmask=0x%04x, cmask=0x%04x\n",
1.122 mrg 1128: d->bUnitId, nchan, mmask, cmask);
1.1 augustss 1129:
1130: if (nchan > MIX_MAX_CHAN)
1131: nchan = MIX_MAX_CHAN;
1132: unit = d->bUnitId;
1133: mix.wIndex = MAKE(unit, sc->sc_ac_iface);
1134: for (ctl = MUTE_CONTROL; ctl < LOUDNESS_CONTROL; ctl++) {
1135: fumask = FU_MASK(ctl);
1.122 mrg 1136: DPRINTFN(4,"ctl=%d fumask=0x%04x\n",
1137: ctl, fumask);
1.1 augustss 1138: if (mmask & fumask) {
1139: mix.nchan = 1;
1140: mix.wValue[0] = MAKE(ctl, 0);
1141: } else if (cmask & fumask) {
1142: mix.nchan = nchan - 1;
1143: for (i = 1; i < nchan; i++) {
1144: if (GET(i) & fumask)
1145: mix.wValue[i-1] = MAKE(ctl, i);
1146: else
1147: mix.wValue[i-1] = -1;
1148: }
1149: } else {
1150: continue;
1151: }
1152: #undef GET
1.82 kent 1153: mixername = uaudio_feature_name(&iot[id], &mix);
1.1 augustss 1154: switch (ctl) {
1155: case MUTE_CONTROL:
1156: mix.type = MIX_ON_OFF;
1.63 augustss 1157: mix.ctlunit = "";
1.70 itojun 1158: snprintf(mix.ctlname, sizeof(mix.ctlname),
1.82 kent 1159: "%s.%s", mixername, AudioNmute);
1.1 augustss 1160: break;
1161: case VOLUME_CONTROL:
1162: mix.type = MIX_SIGNED_16;
1.63 augustss 1163: mix.ctlunit = AudioNvolume;
1.82 kent 1164: strlcpy(mix.ctlname, mixername, sizeof(mix.ctlname));
1.1 augustss 1165: break;
1166: case BASS_CONTROL:
1167: mix.type = MIX_SIGNED_8;
1.63 augustss 1168: mix.ctlunit = AudioNbass;
1.70 itojun 1169: snprintf(mix.ctlname, sizeof(mix.ctlname),
1.82 kent 1170: "%s.%s", mixername, AudioNbass);
1.1 augustss 1171: break;
1172: case MID_CONTROL:
1173: mix.type = MIX_SIGNED_8;
1.63 augustss 1174: mix.ctlunit = AudioNmid;
1.70 itojun 1175: snprintf(mix.ctlname, sizeof(mix.ctlname),
1.82 kent 1176: "%s.%s", mixername, AudioNmid);
1.1 augustss 1177: break;
1178: case TREBLE_CONTROL:
1179: mix.type = MIX_SIGNED_8;
1.63 augustss 1180: mix.ctlunit = AudioNtreble;
1.70 itojun 1181: snprintf(mix.ctlname, sizeof(mix.ctlname),
1.82 kent 1182: "%s.%s", mixername, AudioNtreble);
1.1 augustss 1183: break;
1184: case GRAPHIC_EQUALIZER_CONTROL:
1.7 augustss 1185: continue; /* XXX don't add anything */
1.1 augustss 1186: break;
1187: case AGC_CONTROL:
1188: mix.type = MIX_ON_OFF;
1189: mix.ctlunit = "";
1.82 kent 1190: snprintf(mix.ctlname, sizeof(mix.ctlname), "%s.%s",
1191: mixername, AudioNagc);
1.1 augustss 1192: break;
1193: case DELAY_CONTROL:
1194: mix.type = MIX_UNSIGNED_16;
1.82 kent 1195: mix.ctlunit = "4 ms";
1.70 itojun 1196: snprintf(mix.ctlname, sizeof(mix.ctlname),
1.82 kent 1197: "%s.%s", mixername, AudioNdelay);
1.1 augustss 1198: break;
1199: case BASS_BOOST_CONTROL:
1200: mix.type = MIX_ON_OFF;
1.82 kent 1201: mix.ctlunit = "";
1.70 itojun 1202: snprintf(mix.ctlname, sizeof(mix.ctlname),
1.82 kent 1203: "%s.%s", mixername, AudioNbassboost);
1.1 augustss 1204: break;
1205: case LOUDNESS_CONTROL:
1206: mix.type = MIX_ON_OFF;
1.82 kent 1207: mix.ctlunit = "";
1.70 itojun 1208: snprintf(mix.ctlname, sizeof(mix.ctlname),
1.82 kent 1209: "%s.%s", mixername, AudioNloudness);
1.1 augustss 1210: break;
1211: }
1212: uaudio_mixer_add_ctl(sc, &mix);
1213: }
1214: }
1215:
1.86 kent 1216: Static void
1.78 kent 1217: uaudio_add_processing_updown(struct uaudio_softc *sc,
1.82 kent 1218: const struct io_terminal *iot, int id)
1.78 kent 1219: {
1.94 kent 1220: const struct usb_audio_processing_unit *d;
1221: const struct usb_audio_processing_unit_1 *d1;
1222: const struct usb_audio_processing_unit_updown *ud;
1.16 augustss 1223: struct mixerctl mix;
1224: int i;
1225:
1.94 kent 1226: d = iot[id].d.pu;
1227: d1 = (const struct usb_audio_processing_unit_1 *)
1228: &d->baSourceId[d->bNrInPins];
1229: ud = (const struct usb_audio_processing_unit_updown *)
1230: &d1->bmControls[d1->bControlSize];
1.122 mrg 1231: DPRINTFN(2,"bUnitId=%d bNrModes=%d\n",
1232: d->bUnitId, ud->bNrModes);
1.16 augustss 1233:
1234: if (!(d1->bmControls[0] & UA_PROC_MASK(UD_MODE_SELECT_CONTROL))) {
1.122 mrg 1235: DPRINTF("%s", "no mode select\n");
1.16 augustss 1236: return;
1237: }
1238:
1239: mix.wIndex = MAKE(d->bUnitId, sc->sc_ac_iface);
1240: mix.nchan = 1;
1241: mix.wValue[0] = MAKE(UD_MODE_SELECT_CONTROL, 0);
1.82 kent 1242: uaudio_determine_class(&iot[id], &mix);
1.16 augustss 1243: mix.type = MIX_ON_OFF; /* XXX */
1244: mix.ctlunit = "";
1.70 itojun 1245: snprintf(mix.ctlname, sizeof(mix.ctlname), "pro%d-mode", d->bUnitId);
1.16 augustss 1246:
1247: for (i = 0; i < ud->bNrModes; i++) {
1.122 mrg 1248: DPRINTFN(2,"i=%d bm=0x%x\n",
1249: i, UGETW(ud->waModes[i]));
1.16 augustss 1250: /* XXX */
1251: }
1252: uaudio_mixer_add_ctl(sc, &mix);
1253: }
1254:
1.86 kent 1255: Static void
1.82 kent 1256: uaudio_add_processing(struct uaudio_softc *sc, const struct io_terminal *iot, int id)
1.1 augustss 1257: {
1.94 kent 1258: const struct usb_audio_processing_unit *d;
1259: const struct usb_audio_processing_unit_1 *d1;
1260: int ptype;
1.15 augustss 1261: struct mixerctl mix;
1262:
1.94 kent 1263: d = iot[id].d.pu;
1264: d1 = (const struct usb_audio_processing_unit_1 *)
1265: &d->baSourceId[d->bNrInPins];
1266: ptype = UGETW(d->wProcessType);
1.122 mrg 1267: DPRINTFN(2,"wProcessType=%d bUnitId=%d "
1268: "bNrInPins=%d\n", ptype, d->bUnitId, d->bNrInPins);
1.15 augustss 1269:
1270: if (d1->bmControls[0] & UA_PROC_ENABLE_MASK) {
1271: mix.wIndex = MAKE(d->bUnitId, sc->sc_ac_iface);
1272: mix.nchan = 1;
1273: mix.wValue[0] = MAKE(XX_ENABLE_CONTROL, 0);
1.82 kent 1274: uaudio_determine_class(&iot[id], &mix);
1.15 augustss 1275: mix.type = MIX_ON_OFF;
1276: mix.ctlunit = "";
1.70 itojun 1277: snprintf(mix.ctlname, sizeof(mix.ctlname), "pro%d.%d-enable",
1278: d->bUnitId, ptype);
1.15 augustss 1279: uaudio_mixer_add_ctl(sc, &mix);
1280: }
1.1 augustss 1281:
1.15 augustss 1282: switch(ptype) {
1283: case UPDOWNMIX_PROCESS:
1.82 kent 1284: uaudio_add_processing_updown(sc, iot, id);
1.16 augustss 1285: break;
1.15 augustss 1286: case DOLBY_PROLOGIC_PROCESS:
1287: case P3D_STEREO_EXTENDER_PROCESS:
1288: case REVERBATION_PROCESS:
1289: case CHORUS_PROCESS:
1290: case DYN_RANGE_COMP_PROCESS:
1291: default:
1292: #ifdef UAUDIO_DEBUG
1.113 cube 1293: aprint_debug(
1294: "uaudio_add_processing: unit %d, type=%d not impl.\n",
1295: d->bUnitId, ptype);
1.1 augustss 1296: #endif
1.15 augustss 1297: break;
1298: }
1.1 augustss 1299: }
1300:
1.86 kent 1301: Static void
1.82 kent 1302: uaudio_add_extension(struct uaudio_softc *sc, const struct io_terminal *iot, int id)
1.1 augustss 1303: {
1.94 kent 1304: const struct usb_audio_extension_unit *d;
1305: const struct usb_audio_extension_unit_1 *d1;
1.1 augustss 1306: struct mixerctl mix;
1307:
1.94 kent 1308: d = iot[id].d.eu;
1309: d1 = (const struct usb_audio_extension_unit_1 *)
1310: &d->baSourceId[d->bNrInPins];
1.122 mrg 1311: DPRINTFN(2,"bUnitId=%d bNrInPins=%d\n",
1312: d->bUnitId, d->bNrInPins);
1.28 augustss 1313:
1.31 augustss 1314: if (usbd_get_quirks(sc->sc_udev)->uq_flags & UQ_AU_NO_XU)
1.28 augustss 1315: return;
1.1 augustss 1316:
1.15 augustss 1317: if (d1->bmControls[0] & UA_EXT_ENABLE_MASK) {
1.1 augustss 1318: mix.wIndex = MAKE(d->bUnitId, sc->sc_ac_iface);
1319: mix.nchan = 1;
1320: mix.wValue[0] = MAKE(UA_EXT_ENABLE, 0);
1.82 kent 1321: uaudio_determine_class(&iot[id], &mix);
1.1 augustss 1322: mix.type = MIX_ON_OFF;
1323: mix.ctlunit = "";
1.70 itojun 1324: snprintf(mix.ctlname, sizeof(mix.ctlname), "ext%d-enable",
1325: d->bUnitId);
1.1 augustss 1326: uaudio_mixer_add_ctl(sc, &mix);
1327: }
1328: }
1329:
1.86 kent 1330: Static struct terminal_list*
1.82 kent 1331: uaudio_merge_terminal_list(const struct io_terminal *iot)
1332: {
1333: struct terminal_list *tml;
1334: uint16_t *ptm;
1335: int i, len;
1336:
1337: len = 0;
1338: if (iot->inputs == NULL)
1339: return NULL;
1340: for (i = 0; i < iot->inputs_size; i++) {
1341: if (iot->inputs[i] != NULL)
1342: len += iot->inputs[i]->size;
1343: }
1344: tml = malloc(TERMINAL_LIST_SIZE(len), M_TEMP, M_NOWAIT);
1345: if (tml == NULL) {
1.113 cube 1346: aprint_error("uaudio_merge_terminal_list: no memory\n");
1.82 kent 1347: return NULL;
1348: }
1349: tml->size = 0;
1350: ptm = tml->terminals;
1351: for (i = 0; i < iot->inputs_size; i++) {
1352: if (iot->inputs[i] == NULL)
1353: continue;
1354: if (iot->inputs[i]->size > len)
1355: break;
1356: memcpy(ptm, iot->inputs[i]->terminals,
1357: iot->inputs[i]->size * sizeof(uint16_t));
1358: tml->size += iot->inputs[i]->size;
1359: ptm += iot->inputs[i]->size;
1360: len -= iot->inputs[i]->size;
1361: }
1362: return tml;
1363: }
1364:
1.86 kent 1365: Static struct terminal_list *
1.82 kent 1366: uaudio_io_terminaltype(int outtype, struct io_terminal *iot, int id)
1367: {
1368: struct terminal_list *tml;
1369: struct io_terminal *it;
1370: int src_id, i;
1371:
1372: it = &iot[id];
1373: if (it->output != NULL) {
1374: /* already has outtype? */
1375: for (i = 0; i < it->output->size; i++)
1376: if (it->output->terminals[i] == outtype)
1377: return uaudio_merge_terminal_list(it);
1378: tml = malloc(TERMINAL_LIST_SIZE(it->output->size + 1),
1379: M_TEMP, M_NOWAIT);
1380: if (tml == NULL) {
1.113 cube 1381: aprint_error("uaudio_io_terminaltype: no memory\n");
1.82 kent 1382: return uaudio_merge_terminal_list(it);
1383: }
1384: memcpy(tml, it->output, TERMINAL_LIST_SIZE(it->output->size));
1385: tml->terminals[it->output->size] = outtype;
1386: tml->size++;
1387: free(it->output, M_TEMP);
1388: it->output = tml;
1389: if (it->inputs != NULL) {
1390: for (i = 0; i < it->inputs_size; i++)
1391: if (it->inputs[i] != NULL)
1392: free(it->inputs[i], M_TEMP);
1393: free(it->inputs, M_TEMP);
1394: }
1395: it->inputs_size = 0;
1396: it->inputs = NULL;
1397: } else { /* end `iot[id] != NULL' */
1398: it->inputs_size = 0;
1399: it->inputs = NULL;
1400: it->output = malloc(TERMINAL_LIST_SIZE(1), M_TEMP, M_NOWAIT);
1401: if (it->output == NULL) {
1.113 cube 1402: aprint_error("uaudio_io_terminaltype: no memory\n");
1.82 kent 1403: return NULL;
1404: }
1405: it->output->terminals[0] = outtype;
1406: it->output->size = 1;
1407: it->direct = FALSE;
1408: }
1409:
1410: switch (it->d.desc->bDescriptorSubtype) {
1411: case UDESCSUB_AC_INPUT:
1412: it->inputs = malloc(sizeof(struct terminal_list *), M_TEMP, M_NOWAIT);
1413: if (it->inputs == NULL) {
1.113 cube 1414: aprint_error("uaudio_io_terminaltype: no memory\n");
1.82 kent 1415: return NULL;
1416: }
1417: tml = malloc(TERMINAL_LIST_SIZE(1), M_TEMP, M_NOWAIT);
1418: if (tml == NULL) {
1.113 cube 1419: aprint_error("uaudio_io_terminaltype: no memory\n");
1.82 kent 1420: free(it->inputs, M_TEMP);
1421: it->inputs = NULL;
1422: return NULL;
1423: }
1424: it->inputs[0] = tml;
1425: tml->terminals[0] = UGETW(it->d.it->wTerminalType);
1426: tml->size = 1;
1427: it->inputs_size = 1;
1428: return uaudio_merge_terminal_list(it);
1429: case UDESCSUB_AC_FEATURE:
1430: src_id = it->d.fu->bSourceId;
1431: it->inputs = malloc(sizeof(struct terminal_list *), M_TEMP, M_NOWAIT);
1432: if (it->inputs == NULL) {
1.113 cube 1433: aprint_error("uaudio_io_terminaltype: no memory\n");
1.82 kent 1434: return uaudio_io_terminaltype(outtype, iot, src_id);
1435: }
1436: it->inputs[0] = uaudio_io_terminaltype(outtype, iot, src_id);
1437: it->inputs_size = 1;
1438: return uaudio_merge_terminal_list(it);
1439: case UDESCSUB_AC_OUTPUT:
1440: it->inputs = malloc(sizeof(struct terminal_list *), M_TEMP, M_NOWAIT);
1441: if (it->inputs == NULL) {
1.113 cube 1442: aprint_error("uaudio_io_terminaltype: no memory\n");
1.82 kent 1443: return NULL;
1444: }
1445: src_id = it->d.ot->bSourceId;
1446: it->inputs[0] = uaudio_io_terminaltype(outtype, iot, src_id);
1447: it->inputs_size = 1;
1448: iot[src_id].direct = TRUE;
1449: return NULL;
1450: case UDESCSUB_AC_MIXER:
1451: it->inputs_size = 0;
1452: it->inputs = malloc(sizeof(struct terminal_list *)
1453: * it->d.mu->bNrInPins, M_TEMP, M_NOWAIT);
1454: if (it->inputs == NULL) {
1.113 cube 1455: aprint_error("uaudio_io_terminaltype: no memory\n");
1.82 kent 1456: return NULL;
1457: }
1458: for (i = 0; i < it->d.mu->bNrInPins; i++) {
1459: src_id = it->d.mu->baSourceId[i];
1460: it->inputs[i] = uaudio_io_terminaltype(outtype, iot,
1461: src_id);
1462: it->inputs_size++;
1463: }
1464: return uaudio_merge_terminal_list(it);
1465: case UDESCSUB_AC_SELECTOR:
1466: it->inputs_size = 0;
1467: it->inputs = malloc(sizeof(struct terminal_list *)
1468: * it->d.su->bNrInPins, M_TEMP, M_NOWAIT);
1469: if (it->inputs == NULL) {
1.113 cube 1470: aprint_error("uaudio_io_terminaltype: no memory\n");
1.82 kent 1471: return NULL;
1472: }
1473: for (i = 0; i < it->d.su->bNrInPins; i++) {
1474: src_id = it->d.su->baSourceId[i];
1475: it->inputs[i] = uaudio_io_terminaltype(outtype, iot,
1476: src_id);
1477: it->inputs_size++;
1478: }
1479: return uaudio_merge_terminal_list(it);
1480: case UDESCSUB_AC_PROCESSING:
1481: it->inputs_size = 0;
1482: it->inputs = malloc(sizeof(struct terminal_list *)
1483: * it->d.pu->bNrInPins, M_TEMP, M_NOWAIT);
1484: if (it->inputs == NULL) {
1.113 cube 1485: aprint_error("uaudio_io_terminaltype: no memory\n");
1.82 kent 1486: return NULL;
1487: }
1488: for (i = 0; i < it->d.pu->bNrInPins; i++) {
1489: src_id = it->d.pu->baSourceId[i];
1490: it->inputs[i] = uaudio_io_terminaltype(outtype, iot,
1491: src_id);
1492: it->inputs_size++;
1493: }
1494: return uaudio_merge_terminal_list(it);
1495: case UDESCSUB_AC_EXTENSION:
1496: it->inputs_size = 0;
1497: it->inputs = malloc(sizeof(struct terminal_list *)
1498: * it->d.eu->bNrInPins, M_TEMP, M_NOWAIT);
1499: if (it->inputs == NULL) {
1.113 cube 1500: aprint_error("uaudio_io_terminaltype: no memory\n");
1.82 kent 1501: return NULL;
1502: }
1503: for (i = 0; i < it->d.eu->bNrInPins; i++) {
1504: src_id = it->d.eu->baSourceId[i];
1505: it->inputs[i] = uaudio_io_terminaltype(outtype, iot,
1506: src_id);
1507: it->inputs_size++;
1508: }
1509: return uaudio_merge_terminal_list(it);
1510: case UDESCSUB_AC_HEADER:
1511: default:
1512: return NULL;
1513: }
1514: }
1515:
1.86 kent 1516: Static usbd_status
1.78 kent 1517: uaudio_identify(struct uaudio_softc *sc, const usb_config_descriptor_t *cdesc)
1.1 augustss 1518: {
1.9 augustss 1519: usbd_status err;
1.1 augustss 1520:
1.9 augustss 1521: err = uaudio_identify_ac(sc, cdesc);
1522: if (err)
1.94 kent 1523: return err;
1524: return uaudio_identify_as(sc, cdesc);
1.1 augustss 1525: }
1526:
1.86 kent 1527: Static void
1.78 kent 1528: uaudio_add_alt(struct uaudio_softc *sc, const struct as_info *ai)
1.1 augustss 1529: {
1.84 kent 1530: size_t len;
1531: struct as_info *nai;
1.42 christos 1532:
1.84 kent 1533: len = sizeof(*ai) * (sc->sc_nalts + 1);
1534: nai = malloc(len, M_USBDEV, M_NOWAIT);
1.42 christos 1535: if (nai == NULL) {
1.113 cube 1536: aprint_error("uaudio_add_alt: no memory\n");
1.1 augustss 1537: return;
1538: }
1.84 kent 1539: /* Copy old data, if there was any */
1540: if (sc->sc_nalts != 0) {
1541: memcpy(nai, sc->sc_alts, sizeof(*ai) * (sc->sc_nalts));
1542: free(sc->sc_alts, M_USBDEV);
1543: }
1.42 christos 1544: sc->sc_alts = nai;
1.122 mrg 1545: DPRINTFN(2,"adding alt=%d, enc=%d\n",
1546: ai->alt, ai->encoding);
1.1 augustss 1547: sc->sc_alts[sc->sc_nalts++] = *ai;
1548: }
1549:
1.86 kent 1550: Static usbd_status
1.99 christos 1551: uaudio_process_as(struct uaudio_softc *sc, const char *tbuf, int *offsp,
1.78 kent 1552: int size, const usb_interface_descriptor_t *id)
1.1 augustss 1553: #define offs (*offsp)
1554: {
1.78 kent 1555: const struct usb_audio_streaming_interface_descriptor *asid;
1556: const struct usb_audio_streaming_type1_descriptor *asf1d;
1557: const usb_endpoint_descriptor_audio_t *ed;
1.80 kent 1558: const usb_endpoint_descriptor_audio_t *epdesc1;
1.78 kent 1559: const struct usb_audio_streaming_endpoint_descriptor *sed;
1.1 augustss 1560: int format, chan, prec, enc;
1.80 kent 1561: int dir, type, sync;
1.1 augustss 1562: struct as_info ai;
1.78 kent 1563: const char *format_str;
1.1 augustss 1564:
1.99 christos 1565: asid = (const void *)(tbuf + offs);
1.1 augustss 1566: if (asid->bDescriptorType != UDESC_CS_INTERFACE ||
1567: asid->bDescriptorSubtype != AS_GENERAL)
1.94 kent 1568: return USBD_INVAL;
1.122 mrg 1569: DPRINTF("asid: bTerminakLink=%d wFormatTag=%d\n",
1570: asid->bTerminalLink, UGETW(asid->wFormatTag));
1.1 augustss 1571: offs += asid->bLength;
1572: if (offs > size)
1.94 kent 1573: return USBD_INVAL;
1.78 kent 1574:
1.99 christos 1575: asf1d = (const void *)(tbuf + offs);
1.1 augustss 1576: if (asf1d->bDescriptorType != UDESC_CS_INTERFACE ||
1577: asf1d->bDescriptorSubtype != FORMAT_TYPE)
1.94 kent 1578: return USBD_INVAL;
1.1 augustss 1579: offs += asf1d->bLength;
1580: if (offs > size)
1.94 kent 1581: return USBD_INVAL;
1.1 augustss 1582:
1.3 augustss 1583: if (asf1d->bFormatType != FORMAT_TYPE_I) {
1.113 cube 1584: aprint_error_dev(sc->sc_dev,
1585: "ignored setting with type %d format\n", UGETW(asid->wFormatTag));
1.94 kent 1586: return USBD_NORMAL_COMPLETION;
1.3 augustss 1587: }
1588:
1.99 christos 1589: ed = (const void *)(tbuf + offs);
1.1 augustss 1590: if (ed->bDescriptorType != UDESC_ENDPOINT)
1.94 kent 1591: return USBD_INVAL;
1.122 mrg 1592: DPRINTF("endpoint[0] bLength=%d bDescriptorType=%d "
1.5 augustss 1593: "bEndpointAddress=%d bmAttributes=0x%x wMaxPacketSize=%d "
1594: "bInterval=%d bRefresh=%d bSynchAddress=%d\n",
1595: ed->bLength, ed->bDescriptorType, ed->bEndpointAddress,
1596: ed->bmAttributes, UGETW(ed->wMaxPacketSize),
1.122 mrg 1597: ed->bInterval, ed->bRefresh, ed->bSynchAddress);
1.1 augustss 1598: offs += ed->bLength;
1599: if (offs > size)
1.94 kent 1600: return USBD_INVAL;
1.5 augustss 1601: if (UE_GET_XFERTYPE(ed->bmAttributes) != UE_ISOCHRONOUS)
1.94 kent 1602: return USBD_INVAL;
1.5 augustss 1603:
1604: dir = UE_GET_DIR(ed->bEndpointAddress);
1605: type = UE_GET_ISO_TYPE(ed->bmAttributes);
1.31 augustss 1606: if ((usbd_get_quirks(sc->sc_udev)->uq_flags & UQ_AU_INP_ASYNC) &&
1607: dir == UE_DIR_IN && type == UE_ISO_ADAPT)
1608: type = UE_ISO_ASYNC;
1609:
1.40 augustss 1610: /* We can't handle endpoints that need a sync pipe yet. */
1.80 kent 1611: sync = FALSE;
1.78 kent 1612: if (dir == UE_DIR_IN && type == UE_ISO_ADAPT) {
1.80 kent 1613: sync = TRUE;
1614: #ifndef UAUDIO_MULTIPLE_ENDPOINTS
1.113 cube 1615: aprint_error_dev(sc->sc_dev,
1616: "ignored input endpoint of type adaptive\n");
1.94 kent 1617: return USBD_NORMAL_COMPLETION;
1.80 kent 1618: #endif
1.78 kent 1619: }
1620: if (dir != UE_DIR_IN && type == UE_ISO_ASYNC) {
1.80 kent 1621: sync = TRUE;
1622: #ifndef UAUDIO_MULTIPLE_ENDPOINTS
1.113 cube 1623: aprint_error_dev(sc->sc_dev,
1624: "ignored output endpoint of type async\n");
1.94 kent 1625: return USBD_NORMAL_COMPLETION;
1.80 kent 1626: #endif
1.1 augustss 1627: }
1.56 kent 1628:
1.99 christos 1629: sed = (const void *)(tbuf + offs);
1.1 augustss 1630: if (sed->bDescriptorType != UDESC_CS_ENDPOINT ||
1631: sed->bDescriptorSubtype != AS_GENERAL)
1.94 kent 1632: return USBD_INVAL;
1.122 mrg 1633: DPRINTF(" streadming_endpoint: offset=%d bLength=%d\n", offs, sed->bLength);
1.1 augustss 1634: offs += sed->bLength;
1635: if (offs > size)
1.94 kent 1636: return USBD_INVAL;
1.56 kent 1637:
1.102 christos 1638: #ifdef UAUDIO_MULTIPLE_ENDPOINTS
1.80 kent 1639: if (sync && id->bNumEndpoints <= 1) {
1.113 cube 1640: aprint_error_dev(sc->sc_dev,
1641: "a sync-pipe endpoint but no other endpoint\n");
1.80 kent 1642: return USBD_INVAL;
1643: }
1.102 christos 1644: #endif
1.80 kent 1645: if (!sync && id->bNumEndpoints > 1) {
1.113 cube 1646: aprint_error_dev(sc->sc_dev,
1647: "non sync-pipe endpoint but multiple endpoints\n");
1.80 kent 1648: return USBD_INVAL;
1649: }
1650: epdesc1 = NULL;
1651: if (id->bNumEndpoints > 1) {
1.99 christos 1652: epdesc1 = (const void*)(tbuf + offs);
1.80 kent 1653: if (epdesc1->bDescriptorType != UDESC_ENDPOINT)
1654: return USBD_INVAL;
1.122 mrg 1655: DPRINTF("endpoint[1] bLength=%d "
1.80 kent 1656: "bDescriptorType=%d bEndpointAddress=%d "
1657: "bmAttributes=0x%x wMaxPacketSize=%d bInterval=%d "
1658: "bRefresh=%d bSynchAddress=%d\n",
1659: epdesc1->bLength, epdesc1->bDescriptorType,
1660: epdesc1->bEndpointAddress, epdesc1->bmAttributes,
1661: UGETW(epdesc1->wMaxPacketSize), epdesc1->bInterval,
1.122 mrg 1662: epdesc1->bRefresh, epdesc1->bSynchAddress);
1.80 kent 1663: offs += epdesc1->bLength;
1664: if (offs > size)
1665: return USBD_INVAL;
1666: if (epdesc1->bSynchAddress != 0) {
1.113 cube 1667: aprint_error_dev(sc->sc_dev,
1668: "invalid endpoint: bSynchAddress=0\n");
1.80 kent 1669: return USBD_INVAL;
1670: }
1671: if (UE_GET_XFERTYPE(epdesc1->bmAttributes) != UE_ISOCHRONOUS) {
1.113 cube 1672: aprint_error_dev(sc->sc_dev,
1673: "invalid endpoint: bmAttributes=0x%x\n",
1674: epdesc1->bmAttributes);
1.80 kent 1675: return USBD_INVAL;
1676: }
1677: if (epdesc1->bEndpointAddress != ed->bSynchAddress) {
1.113 cube 1678: aprint_error_dev(sc->sc_dev,
1679: "invalid endpoint addresses: "
1680: "ep[0]->bSynchAddress=0x%x "
1681: "ep[1]->bEndpointAddress=0x%x\n",
1682: ed->bSynchAddress, epdesc1->bEndpointAddress);
1.80 kent 1683: return USBD_INVAL;
1684: }
1685: /* UE_GET_ADDR(epdesc1->bEndpointAddress), and epdesc1->bRefresh */
1686: }
1687:
1.3 augustss 1688: format = UGETW(asid->wFormatTag);
1.1 augustss 1689: chan = asf1d->bNrChannels;
1690: prec = asf1d->bBitResolution;
1.51 kent 1691: if (prec != 8 && prec != 16 && prec != 24) {
1.113 cube 1692: aprint_error_dev(sc->sc_dev,
1693: "ignored setting with precision %d\n", prec);
1.94 kent 1694: return USBD_NORMAL_COMPLETION;
1.1 augustss 1695: }
1696: switch (format) {
1.3 augustss 1697: case UA_FMT_PCM:
1.51 kent 1698: if (prec == 8) {
1699: sc->sc_altflags |= HAS_8;
1700: } else if (prec == 16) {
1701: sc->sc_altflags |= HAS_16;
1702: } else if (prec == 24) {
1703: sc->sc_altflags |= HAS_24;
1704: }
1.5 augustss 1705: enc = AUDIO_ENCODING_SLINEAR_LE;
1.78 kent 1706: format_str = "pcm";
1.1 augustss 1707: break;
1.3 augustss 1708: case UA_FMT_PCM8:
1.5 augustss 1709: enc = AUDIO_ENCODING_ULINEAR_LE;
1.1 augustss 1710: sc->sc_altflags |= HAS_8U;
1.78 kent 1711: format_str = "pcm8";
1.1 augustss 1712: break;
1.3 augustss 1713: case UA_FMT_ALAW:
1.5 augustss 1714: enc = AUDIO_ENCODING_ALAW;
1.1 augustss 1715: sc->sc_altflags |= HAS_ALAW;
1.78 kent 1716: format_str = "alaw";
1.1 augustss 1717: break;
1.3 augustss 1718: case UA_FMT_MULAW:
1.5 augustss 1719: enc = AUDIO_ENCODING_ULAW;
1.1 augustss 1720: sc->sc_altflags |= HAS_MULAW;
1.78 kent 1721: format_str = "mulaw";
1.1 augustss 1722: break;
1.80 kent 1723: case UA_FMT_IEEE_FLOAT:
1.1 augustss 1724: default:
1.113 cube 1725: aprint_error_dev(sc->sc_dev,
1726: "ignored setting with format %d\n", format);
1.94 kent 1727: return USBD_NORMAL_COMPLETION;
1.1 augustss 1728: }
1.78 kent 1729: #ifdef UAUDIO_DEBUG
1.113 cube 1730: aprint_debug_dev(sc->sc_dev, "%s: %dch, %d/%dbit, %s,",
1.78 kent 1731: dir == UE_DIR_IN ? "recording" : "playback",
1732: chan, prec, asf1d->bSubFrameSize * 8, format_str);
1733: if (asf1d->bSamFreqType == UA_SAMP_CONTNUOUS) {
1.113 cube 1734: aprint_debug(" %d-%dHz\n", UA_SAMP_LO(asf1d),
1735: UA_SAMP_HI(asf1d));
1.78 kent 1736: } else {
1737: int r;
1.113 cube 1738: aprint_debug(" %d", UA_GETSAMP(asf1d, 0));
1.78 kent 1739: for (r = 1; r < asf1d->bSamFreqType; r++)
1.113 cube 1740: aprint_debug(",%d", UA_GETSAMP(asf1d, r));
1741: aprint_debug("Hz\n");
1.78 kent 1742: }
1743: #endif
1.1 augustss 1744: ai.alt = id->bAlternateSetting;
1745: ai.encoding = enc;
1.50 kent 1746: ai.attributes = sed->bmAttributes;
1.1 augustss 1747: ai.idesc = id;
1748: ai.edesc = ed;
1.80 kent 1749: ai.edesc1 = epdesc1;
1.1 augustss 1750: ai.asf1desc = asf1d;
1.50 kent 1751: ai.sc_busy = 0;
1.103 mrg 1752: ai.aformat = NULL;
1753: ai.ifaceh = NULL;
1.1 augustss 1754: uaudio_add_alt(sc, &ai);
1.50 kent 1755: #ifdef UAUDIO_DEBUG
1.78 kent 1756: if (ai.attributes & UA_SED_FREQ_CONTROL)
1.122 mrg 1757: DPRINTFN(1, "%s", "FREQ_CONTROL\n");
1.78 kent 1758: if (ai.attributes & UA_SED_PITCH_CONTROL)
1.122 mrg 1759: DPRINTFN(1, "%s", "PITCH_CONTROL\n");
1.50 kent 1760: #endif
1.47 jdolecek 1761: sc->sc_mode |= (dir == UE_DIR_OUT) ? AUMODE_PLAY : AUMODE_RECORD;
1762:
1.94 kent 1763: return USBD_NORMAL_COMPLETION;
1.1 augustss 1764: }
1765: #undef offs
1.56 kent 1766:
1.86 kent 1767: Static usbd_status
1.78 kent 1768: uaudio_identify_as(struct uaudio_softc *sc,
1769: const usb_config_descriptor_t *cdesc)
1.1 augustss 1770: {
1.78 kent 1771: const usb_interface_descriptor_t *id;
1.99 christos 1772: const char *tbuf;
1.92 kent 1773: struct audio_format *auf;
1774: const struct usb_audio_streaming_type1_descriptor *t1desc;
1.1 augustss 1775: int size, offs;
1.92 kent 1776: int i, j;
1.1 augustss 1777:
1778: size = UGETW(cdesc->wTotalLength);
1.99 christos 1779: tbuf = (const char *)cdesc;
1.1 augustss 1780:
1781: /* Locate the AudioStreaming interface descriptor. */
1782: offs = 0;
1.99 christos 1783: id = uaudio_find_iface(tbuf, size, &offs, UISUBCLASS_AUDIOSTREAM);
1.9 augustss 1784: if (id == NULL)
1.94 kent 1785: return USBD_INVAL;
1.1 augustss 1786:
1787: /* Loop through all the alternate settings. */
1788: while (offs <= size) {
1.122 mrg 1789: DPRINTFN(2, "interface=%d offset=%d\n",
1790: id->bInterfaceNumber, offs);
1.1 augustss 1791: switch (id->bNumEndpoints) {
1792: case 0:
1.122 mrg 1793: DPRINTFN(2, "AS null alt=%d\n",
1794: id->bAlternateSetting);
1.1 augustss 1795: sc->sc_nullalt = id->bAlternateSetting;
1796: break;
1797: case 1:
1.80 kent 1798: #ifdef UAUDIO_MULTIPLE_ENDPOINTS
1799: case 2:
1800: #endif
1.99 christos 1801: uaudio_process_as(sc, tbuf, &offs, size, id);
1.1 augustss 1802: break;
1803: default:
1.113 cube 1804: aprint_error_dev(sc->sc_dev,
1805: "ignored audio interface with %d endpoints\n",
1806: id->bNumEndpoints);
1.1 augustss 1807: break;
1808: }
1.99 christos 1809: id = uaudio_find_iface(tbuf, size, &offs,UISUBCLASS_AUDIOSTREAM);
1.9 augustss 1810: if (id == NULL)
1.1 augustss 1811: break;
1812: }
1813: if (offs > size)
1.94 kent 1814: return USBD_INVAL;
1.122 mrg 1815: DPRINTF("%d alts available\n", sc->sc_nalts);
1.47 jdolecek 1816:
1.74 mycroft 1817: if (sc->sc_mode == 0) {
1.113 cube 1818: aprint_error_dev(sc->sc_dev, "no usable endpoint found\n");
1.94 kent 1819: return USBD_INVAL;
1.5 augustss 1820: }
1.47 jdolecek 1821:
1.92 kent 1822: /* build audio_format array */
1823: sc->sc_formats = malloc(sizeof(struct audio_format) * sc->sc_nalts,
1824: M_USBDEV, M_NOWAIT);
1825: if (sc->sc_formats == NULL)
1826: return USBD_NOMEM;
1827: sc->sc_nformats = sc->sc_nalts;
1828: for (i = 0; i < sc->sc_nalts; i++) {
1829: auf = &sc->sc_formats[i];
1830: t1desc = sc->sc_alts[i].asf1desc;
1831: auf->driver_data = NULL;
1832: if (UE_GET_DIR(sc->sc_alts[i].edesc->bEndpointAddress) == UE_DIR_OUT)
1833: auf->mode = AUMODE_PLAY;
1834: else
1835: auf->mode = AUMODE_RECORD;
1836: auf->encoding = sc->sc_alts[i].encoding;
1.93 kent 1837: auf->validbits = t1desc->bBitResolution;
1838: auf->precision = t1desc->bSubFrameSize * 8;
1.92 kent 1839: auf->channels = t1desc->bNrChannels;
1840: auf->channel_mask = sc->sc_channel_config;
1841: auf->frequency_type = t1desc->bSamFreqType;
1842: if (t1desc->bSamFreqType == UA_SAMP_CONTNUOUS) {
1843: auf->frequency[0] = UA_SAMP_LO(t1desc);
1844: auf->frequency[1] = UA_SAMP_HI(t1desc);
1845: } else {
1846: for (j = 0; j < t1desc->bSamFreqType; j++) {
1847: if (j >= AUFMT_MAX_FREQUENCIES) {
1.113 cube 1848: aprint_error("%s: please increase "
1.92 kent 1849: "AUFMT_MAX_FREQUENCIES to %d\n",
1850: __func__, t1desc->bSamFreqType);
1.132 jdc 1851: auf->frequency_type =
1852: AUFMT_MAX_FREQUENCIES;
1.130 bouyer 1853: break;
1854: }
1.92 kent 1855: auf->frequency[j] = UA_GETSAMP(t1desc, j);
1856: }
1857: }
1858: sc->sc_alts[i].aformat = auf;
1859: }
1860:
1861: if (0 != auconv_create_encodings(sc->sc_formats, sc->sc_nformats,
1862: &sc->sc_encodings)) {
1863: free(sc->sc_formats, M_DEVBUF);
1864: sc->sc_formats = NULL;
1865: return ENOMEM;
1866: }
1867:
1.94 kent 1868: return USBD_NORMAL_COMPLETION;
1.1 augustss 1869: }
1870:
1.86 kent 1871: Static usbd_status
1.78 kent 1872: uaudio_identify_ac(struct uaudio_softc *sc, const usb_config_descriptor_t *cdesc)
1.1 augustss 1873: {
1.82 kent 1874: struct io_terminal* iot;
1.78 kent 1875: const usb_interface_descriptor_t *id;
1876: const struct usb_audio_control_descriptor *acdp;
1.109 drochner 1877: const uaudio_cs_descriptor_t *dp;
1.82 kent 1878: const struct usb_audio_output_terminal *pot;
1879: struct terminal_list *tml;
1.99 christos 1880: const char *tbuf, *ibuf, *ibufend;
1.120 jakllsch 1881: int size, offs, ndps, i, j;
1.1 augustss 1882:
1883: size = UGETW(cdesc->wTotalLength);
1.99 christos 1884: tbuf = (const char *)cdesc;
1.1 augustss 1885:
1886: /* Locate the AudioControl interface descriptor. */
1887: offs = 0;
1.99 christos 1888: id = uaudio_find_iface(tbuf, size, &offs, UISUBCLASS_AUDIOCONTROL);
1.14 augustss 1889: if (id == NULL)
1.94 kent 1890: return USBD_INVAL;
1.1 augustss 1891: if (offs + sizeof *acdp > size)
1.94 kent 1892: return USBD_INVAL;
1.1 augustss 1893: sc->sc_ac_iface = id->bInterfaceNumber;
1.122 mrg 1894: DPRINTFN(2,"AC interface is %d\n", sc->sc_ac_iface);
1.1 augustss 1895:
1896: /* A class-specific AC interface header should follow. */
1.99 christos 1897: ibuf = tbuf + offs;
1.120 jakllsch 1898: ibufend = tbuf + size;
1.78 kent 1899: acdp = (const struct usb_audio_control_descriptor *)ibuf;
1.1 augustss 1900: if (acdp->bDescriptorType != UDESC_CS_INTERFACE ||
1901: acdp->bDescriptorSubtype != UDESCSUB_AC_HEADER)
1.94 kent 1902: return USBD_INVAL;
1.5 augustss 1903:
1.1 augustss 1904: if (!(usbd_get_quirks(sc->sc_udev)->uq_flags & UQ_BAD_ADC) &&
1905: UGETW(acdp->bcdADC) != UAUDIO_VERSION)
1.94 kent 1906: return USBD_INVAL;
1.1 augustss 1907:
1.7 augustss 1908: sc->sc_audio_rev = UGETW(acdp->bcdADC);
1.122 mrg 1909: DPRINTFN(2, "found AC header, vers=%03x\n", sc->sc_audio_rev);
1.1 augustss 1910:
1911: sc->sc_nullalt = -1;
1912:
1913: /* Scan through all the AC specific descriptors */
1.109 drochner 1914: dp = (const uaudio_cs_descriptor_t *)ibuf;
1.1 augustss 1915: ndps = 0;
1.82 kent 1916: iot = malloc(sizeof(struct io_terminal) * 256, M_TEMP, M_NOWAIT | M_ZERO);
1917: if (iot == NULL) {
1.113 cube 1918: aprint_error("%s: no memory\n", __func__);
1.82 kent 1919: return USBD_NOMEM;
1920: }
1.1 augustss 1921: for (;;) {
1922: ibuf += dp->bLength;
1923: if (ibuf >= ibufend)
1924: break;
1.109 drochner 1925: dp = (const uaudio_cs_descriptor_t *)ibuf;
1.97 martin 1926: if (ibuf + dp->bLength > ibufend) {
1927: free(iot, M_TEMP);
1.94 kent 1928: return USBD_INVAL;
1.97 martin 1929: }
1.120 jakllsch 1930: if (dp->bDescriptorType != UDESC_CS_INTERFACE)
1931: break;
1.82 kent 1932: i = ((const struct usb_audio_input_terminal *)dp)->bTerminalId;
1933: iot[i].d.desc = dp;
1.1 augustss 1934: if (i > ndps)
1935: ndps = i;
1936: }
1937: ndps++;
1938:
1.82 kent 1939: /* construct io_terminal */
1940: for (i = 0; i < ndps; i++) {
1941: dp = iot[i].d.desc;
1942: if (dp == NULL)
1943: continue;
1944: if (dp->bDescriptorSubtype != UDESCSUB_AC_OUTPUT)
1945: continue;
1946: pot = iot[i].d.ot;
1947: tml = uaudio_io_terminaltype(UGETW(pot->wTerminalType), iot, i);
1948: if (tml != NULL)
1949: free(tml, M_TEMP);
1950: }
1951:
1952: #ifdef UAUDIO_DEBUG
1953: for (i = 0; i < 256; i++) {
1.91 kent 1954: struct usb_audio_cluster cluster;
1955:
1.82 kent 1956: if (iot[i].d.desc == NULL)
1957: continue;
1.118 dyoung 1958: printf("id %d:\t", i);
1.82 kent 1959: switch (iot[i].d.desc->bDescriptorSubtype) {
1960: case UDESCSUB_AC_INPUT:
1.118 dyoung 1961: printf("AC_INPUT type=%s\n", uaudio_get_terminal_name
1.89 kent 1962: (UGETW(iot[i].d.it->wTerminalType)));
1.118 dyoung 1963: printf("\t");
1.91 kent 1964: cluster = uaudio_get_cluster(i, iot);
1965: uaudio_dump_cluster(&cluster);
1.118 dyoung 1966: printf("\n");
1.82 kent 1967: break;
1968: case UDESCSUB_AC_OUTPUT:
1.118 dyoung 1969: printf("AC_OUTPUT type=%s ", uaudio_get_terminal_name
1.89 kent 1970: (UGETW(iot[i].d.ot->wTerminalType)));
1.118 dyoung 1971: printf("src=%d\n", iot[i].d.ot->bSourceId);
1.82 kent 1972: break;
1973: case UDESCSUB_AC_MIXER:
1.118 dyoung 1974: printf("AC_MIXER src=");
1.82 kent 1975: for (j = 0; j < iot[i].d.mu->bNrInPins; j++)
1.118 dyoung 1976: printf("%d ", iot[i].d.mu->baSourceId[j]);
1977: printf("\n\t");
1.91 kent 1978: cluster = uaudio_get_cluster(i, iot);
1979: uaudio_dump_cluster(&cluster);
1.118 dyoung 1980: printf("\n");
1.82 kent 1981: break;
1982: case UDESCSUB_AC_SELECTOR:
1.118 dyoung 1983: printf("AC_SELECTOR src=");
1.82 kent 1984: for (j = 0; j < iot[i].d.su->bNrInPins; j++)
1.118 dyoung 1985: printf("%d ", iot[i].d.su->baSourceId[j]);
1986: printf("\n");
1.82 kent 1987: break;
1988: case UDESCSUB_AC_FEATURE:
1.118 dyoung 1989: printf("AC_FEATURE src=%d\n", iot[i].d.fu->bSourceId);
1.82 kent 1990: break;
1991: case UDESCSUB_AC_PROCESSING:
1.118 dyoung 1992: printf("AC_PROCESSING src=");
1.82 kent 1993: for (j = 0; j < iot[i].d.pu->bNrInPins; j++)
1.118 dyoung 1994: printf("%d ", iot[i].d.pu->baSourceId[j]);
1995: printf("\n\t");
1.91 kent 1996: cluster = uaudio_get_cluster(i, iot);
1997: uaudio_dump_cluster(&cluster);
1.118 dyoung 1998: printf("\n");
1.82 kent 1999: break;
2000: case UDESCSUB_AC_EXTENSION:
1.118 dyoung 2001: printf("AC_EXTENSION src=");
1.82 kent 2002: for (j = 0; j < iot[i].d.eu->bNrInPins; j++)
1.118 dyoung 2003: printf("%d ", iot[i].d.eu->baSourceId[j]);
2004: printf("\n\t");
1.91 kent 2005: cluster = uaudio_get_cluster(i, iot);
2006: uaudio_dump_cluster(&cluster);
1.118 dyoung 2007: printf("\n");
1.82 kent 2008: break;
2009: default:
1.118 dyoung 2010: printf("unknown audio control (subtype=%d)\n",
1.89 kent 2011: iot[i].d.desc->bDescriptorSubtype);
1.82 kent 2012: }
2013: for (j = 0; j < iot[i].inputs_size; j++) {
2014: int k;
1.118 dyoung 2015: printf("\tinput%d: ", j);
1.82 kent 2016: tml = iot[i].inputs[j];
2017: if (tml == NULL) {
1.118 dyoung 2018: printf("NULL\n");
1.82 kent 2019: continue;
2020: }
2021: for (k = 0; k < tml->size; k++)
1.118 dyoung 2022: printf("%s ", uaudio_get_terminal_name
1.89 kent 2023: (tml->terminals[k]));
1.118 dyoung 2024: printf("\n");
1.82 kent 2025: }
1.118 dyoung 2026: printf("\toutput: ");
1.82 kent 2027: tml = iot[i].output;
2028: for (j = 0; j < tml->size; j++)
1.118 dyoung 2029: printf("%s ", uaudio_get_terminal_name(tml->terminals[j]));
2030: printf("\n");
1.82 kent 2031: }
2032: #endif
2033:
1.1 augustss 2034: for (i = 0; i < ndps; i++) {
1.82 kent 2035: dp = iot[i].d.desc;
1.14 augustss 2036: if (dp == NULL)
1.1 augustss 2037: continue;
1.122 mrg 2038: DPRINTF("id=%d subtype=%d\n", i, dp->bDescriptorSubtype);
1.1 augustss 2039: switch (dp->bDescriptorSubtype) {
2040: case UDESCSUB_AC_HEADER:
1.113 cube 2041: aprint_error("uaudio_identify_ac: unexpected AC header\n");
1.1 augustss 2042: break;
2043: case UDESCSUB_AC_INPUT:
1.82 kent 2044: uaudio_add_input(sc, iot, i);
1.1 augustss 2045: break;
2046: case UDESCSUB_AC_OUTPUT:
1.82 kent 2047: uaudio_add_output(sc, iot, i);
1.1 augustss 2048: break;
2049: case UDESCSUB_AC_MIXER:
1.82 kent 2050: uaudio_add_mixer(sc, iot, i);
1.1 augustss 2051: break;
2052: case UDESCSUB_AC_SELECTOR:
1.82 kent 2053: uaudio_add_selector(sc, iot, i);
1.1 augustss 2054: break;
2055: case UDESCSUB_AC_FEATURE:
1.82 kent 2056: uaudio_add_feature(sc, iot, i);
1.1 augustss 2057: break;
2058: case UDESCSUB_AC_PROCESSING:
1.82 kent 2059: uaudio_add_processing(sc, iot, i);
1.1 augustss 2060: break;
2061: case UDESCSUB_AC_EXTENSION:
1.82 kent 2062: uaudio_add_extension(sc, iot, i);
1.1 augustss 2063: break;
2064: default:
1.113 cube 2065: aprint_error(
2066: "uaudio_identify_ac: bad AC desc subtype=0x%02x\n",
2067: dp->bDescriptorSubtype);
1.1 augustss 2068: break;
2069: }
2070: }
1.82 kent 2071:
2072: /* delete io_terminal */
2073: for (i = 0; i < 256; i++) {
2074: if (iot[i].d.desc == NULL)
2075: continue;
2076: if (iot[i].inputs != NULL) {
2077: for (j = 0; j < iot[i].inputs_size; j++) {
2078: if (iot[i].inputs[j] != NULL)
2079: free(iot[i].inputs[j], M_TEMP);
2080: }
2081: free(iot[i].inputs, M_TEMP);
2082: }
2083: if (iot[i].output != NULL)
2084: free(iot[i].output, M_TEMP);
2085: iot[i].d.desc = NULL;
2086: }
2087: free(iot, M_TEMP);
2088:
1.94 kent 2089: return USBD_NORMAL_COMPLETION;
1.1 augustss 2090: }
2091:
1.86 kent 2092: Static int
1.26 augustss 2093: uaudio_query_devinfo(void *addr, mixer_devinfo_t *mi)
1.1 augustss 2094: {
1.94 kent 2095: struct uaudio_softc *sc;
1.1 augustss 2096: struct mixerctl *mc;
1.79 kent 2097: int n, nctls, i;
1.1 augustss 2098:
1.133 mrg 2099: DPRINTFN(7, "index=%d\n", mi->index);
1.94 kent 2100: sc = addr;
1.1 augustss 2101: if (sc->sc_dying)
1.94 kent 2102: return EIO;
1.56 kent 2103:
1.1 augustss 2104: n = mi->index;
2105: nctls = sc->sc_nctls;
2106:
1.63 augustss 2107: switch (n) {
2108: case UAC_OUTPUT:
2109: mi->type = AUDIO_MIXER_CLASS;
2110: mi->mixer_class = UAC_OUTPUT;
2111: mi->next = mi->prev = AUDIO_MIXER_LAST;
1.71 itojun 2112: strlcpy(mi->label.name, AudioCoutputs, sizeof(mi->label.name));
1.94 kent 2113: return 0;
1.63 augustss 2114: case UAC_INPUT:
2115: mi->type = AUDIO_MIXER_CLASS;
2116: mi->mixer_class = UAC_INPUT;
2117: mi->next = mi->prev = AUDIO_MIXER_LAST;
1.71 itojun 2118: strlcpy(mi->label.name, AudioCinputs, sizeof(mi->label.name));
1.94 kent 2119: return 0;
1.63 augustss 2120: case UAC_EQUAL:
2121: mi->type = AUDIO_MIXER_CLASS;
2122: mi->mixer_class = UAC_EQUAL;
2123: mi->next = mi->prev = AUDIO_MIXER_LAST;
1.71 itojun 2124: strlcpy(mi->label.name, AudioCequalization,
2125: sizeof(mi->label.name));
1.94 kent 2126: return 0;
1.82 kent 2127: case UAC_RECORD:
2128: mi->type = AUDIO_MIXER_CLASS;
2129: mi->mixer_class = UAC_RECORD;
2130: mi->next = mi->prev = AUDIO_MIXER_LAST;
2131: strlcpy(mi->label.name, AudioCrecord, sizeof(mi->label.name));
2132: return 0;
1.63 augustss 2133: default:
2134: break;
1.1 augustss 2135: }
1.63 augustss 2136:
2137: n -= UAC_NCLASSES;
2138: if (n < 0 || n >= nctls)
1.94 kent 2139: return ENXIO;
1.63 augustss 2140:
1.1 augustss 2141: mc = &sc->sc_ctls[n];
1.71 itojun 2142: strlcpy(mi->label.name, mc->ctlname, sizeof(mi->label.name));
1.1 augustss 2143: mi->mixer_class = mc->class;
2144: mi->next = mi->prev = AUDIO_MIXER_LAST; /* XXX */
2145: switch (mc->type) {
2146: case MIX_ON_OFF:
2147: mi->type = AUDIO_MIXER_ENUM;
2148: mi->un.e.num_mem = 2;
1.71 itojun 2149: strlcpy(mi->un.e.member[0].label.name, AudioNoff,
2150: sizeof(mi->un.e.member[0].label.name));
1.1 augustss 2151: mi->un.e.member[0].ord = 0;
1.71 itojun 2152: strlcpy(mi->un.e.member[1].label.name, AudioNon,
2153: sizeof(mi->un.e.member[1].label.name));
1.1 augustss 2154: mi->un.e.member[1].ord = 1;
2155: break;
1.79 kent 2156: case MIX_SELECTOR:
2157: mi->type = AUDIO_MIXER_ENUM;
2158: mi->un.e.num_mem = mc->maxval - mc->minval + 1;
2159: for (i = 0; i <= mc->maxval - mc->minval; i++) {
2160: snprintf(mi->un.e.member[i].label.name,
2161: sizeof(mi->un.e.member[i].label.name),
2162: "%d", i + mc->minval);
2163: mi->un.e.member[i].ord = i + mc->minval;
2164: }
2165: break;
1.1 augustss 2166: default:
2167: mi->type = AUDIO_MIXER_VALUE;
2168: strncpy(mi->un.v.units.name, mc->ctlunit, MAX_AUDIO_DEV_LEN);
2169: mi->un.v.num_channels = mc->nchan;
1.33 augustss 2170: mi->un.v.delta = mc->delta;
1.1 augustss 2171: break;
2172: }
1.94 kent 2173: return 0;
1.1 augustss 2174: }
2175:
1.86 kent 2176: Static int
1.26 augustss 2177: uaudio_open(void *addr, int flags)
1.1 augustss 2178: {
1.94 kent 2179: struct uaudio_softc *sc;
1.1 augustss 2180:
1.95 dsainty 2181: sc = addr;
1.122 mrg 2182: DPRINTF("sc=%p\n", sc);
1.1 augustss 2183: if (sc->sc_dying)
1.94 kent 2184: return EIO;
1.1 augustss 2185:
1.77 mycroft 2186: if ((flags & FWRITE) && !(sc->sc_mode & AUMODE_PLAY))
1.94 kent 2187: return EACCES;
1.77 mycroft 2188: if ((flags & FREAD) && !(sc->sc_mode & AUMODE_RECORD))
1.94 kent 2189: return EACCES;
1.1 augustss 2190:
1.94 kent 2191: return 0;
1.1 augustss 2192: }
2193:
2194: /*
2195: * Close function is called at splaudio().
2196: */
1.86 kent 2197: Static void
1.107 christos 2198: uaudio_close(void *addr)
1.1 augustss 2199: {
2200: }
2201:
1.86 kent 2202: Static int
1.26 augustss 2203: uaudio_drain(void *addr)
1.1 augustss 2204: {
1.121 jmcneill 2205: struct uaudio_softc *sc = addr;
2206:
2207: KASSERT(mutex_owned(&sc->sc_intr_lock));
1.1 augustss 2208:
1.121 jmcneill 2209: kpause("uaudiodr", false,
2210: mstohz(UAUDIO_NCHANBUFS * UAUDIO_NFRAMES), &sc->sc_intr_lock);
1.1 augustss 2211:
1.94 kent 2212: return 0;
1.1 augustss 2213: }
2214:
1.86 kent 2215: Static int
1.26 augustss 2216: uaudio_halt_out_dma(void *addr)
1.1 augustss 2217: {
1.121 jmcneill 2218: struct uaudio_softc *sc = addr;
1.1 augustss 2219:
1.122 mrg 2220: DPRINTF("%s", "enter\n");
1.121 jmcneill 2221:
2222: mutex_spin_exit(&sc->sc_intr_lock);
1.47 jdolecek 2223: if (sc->sc_playchan.pipe != NULL) {
2224: uaudio_chan_close(sc, &sc->sc_playchan);
2225: uaudio_chan_free_buffers(sc, &sc->sc_playchan);
1.74 mycroft 2226: sc->sc_playchan.intr = NULL;
1.1 augustss 2227: }
1.121 jmcneill 2228: mutex_spin_enter(&sc->sc_intr_lock);
2229:
1.94 kent 2230: return 0;
1.1 augustss 2231: }
2232:
1.86 kent 2233: Static int
1.26 augustss 2234: uaudio_halt_in_dma(void *addr)
1.1 augustss 2235: {
1.121 jmcneill 2236: struct uaudio_softc *sc = addr;
1.1 augustss 2237:
1.122 mrg 2238: DPRINTF("%s", "enter\n");
1.121 jmcneill 2239:
2240: mutex_spin_exit(&sc->sc_intr_lock);
1.47 jdolecek 2241: if (sc->sc_recchan.pipe != NULL) {
2242: uaudio_chan_close(sc, &sc->sc_recchan);
2243: uaudio_chan_free_buffers(sc, &sc->sc_recchan);
1.74 mycroft 2244: sc->sc_recchan.intr = NULL;
1.5 augustss 2245: }
1.121 jmcneill 2246: mutex_spin_enter(&sc->sc_intr_lock);
2247:
1.94 kent 2248: return 0;
1.1 augustss 2249: }
2250:
1.86 kent 2251: Static int
1.26 augustss 2252: uaudio_getdev(void *addr, struct audio_device *retp)
1.1 augustss 2253: {
1.94 kent 2254: struct uaudio_softc *sc;
1.1 augustss 2255:
1.122 mrg 2256: DPRINTF("%s", "\n");
1.94 kent 2257: sc = addr;
1.1 augustss 2258: if (sc->sc_dying)
1.94 kent 2259: return EIO;
1.56 kent 2260:
1.119 jmcneill 2261: *retp = sc->sc_adev;
1.94 kent 2262: return 0;
1.1 augustss 2263: }
2264:
2265: /*
2266: * Make sure the block size is large enough to hold all outstanding transfers.
2267: */
1.86 kent 2268: Static int
1.93 kent 2269: uaudio_round_blocksize(void *addr, int blk,
2270: int mode, const audio_params_t *param)
1.1 augustss 2271: {
1.94 kent 2272: struct uaudio_softc *sc;
1.96 kent 2273: int b;
1.1 augustss 2274:
1.94 kent 2275: sc = addr;
1.122 mrg 2276: DPRINTF("blk=%d mode=%s\n", blk,
2277: mode == AUMODE_PLAY ? "AUMODE_PLAY" : "AUMODE_RECORD");
1.96 kent 2278:
2279: /* chan.bytes_per_frame can be 0. */
2280: if (mode == AUMODE_PLAY || sc->sc_recchan.bytes_per_frame <= 0) {
2281: b = param->sample_rate * UAUDIO_NFRAMES * UAUDIO_NCHANBUFS;
2282:
2283: /*
2284: * This does not make accurate value in the case
2285: * of b % USB_FRAMES_PER_SECOND != 0
2286: */
2287: b /= USB_FRAMES_PER_SECOND;
2288:
2289: b *= param->precision / 8 * param->channels;
1.47 jdolecek 2290: } else {
1.96 kent 2291: /*
2292: * use wMaxPacketSize in bytes_per_frame.
2293: * See uaudio_set_params() and uaudio_chan_init()
2294: */
2295: b = sc->sc_recchan.bytes_per_frame
2296: * UAUDIO_NFRAMES * UAUDIO_NCHANBUFS;
1.47 jdolecek 2297: }
1.1 augustss 2298:
1.96 kent 2299: if (b <= 0)
2300: b = 1;
2301: blk = blk <= b ? b : blk / b * b;
1.1 augustss 2302:
1.5 augustss 2303: #ifdef DIAGNOSTIC
2304: if (blk <= 0) {
1.113 cube 2305: aprint_debug("uaudio_round_blocksize: blk=%d\n", blk);
1.5 augustss 2306: blk = 512;
2307: }
2308: #endif
2309:
1.122 mrg 2310: DPRINTF("resultant blk=%d\n", blk);
1.94 kent 2311: return blk;
1.1 augustss 2312: }
2313:
1.86 kent 2314: Static int
1.107 christos 2315: uaudio_get_props(void *addr)
1.1 augustss 2316: {
1.94 kent 2317: return AUDIO_PROP_FULLDUPLEX | AUDIO_PROP_INDEPENDENT;
1.1 augustss 2318:
2319: }
2320:
1.121 jmcneill 2321: Static void
2322: uaudio_get_locks(void *addr, kmutex_t **intr, kmutex_t **thread)
2323: {
2324: struct uaudio_softc *sc;
2325:
2326: sc = addr;
2327: *intr = &sc->sc_intr_lock;
2328: *thread = &sc->sc_lock;
2329: }
2330:
1.86 kent 2331: Static int
1.27 augustss 2332: uaudio_get(struct uaudio_softc *sc, int which, int type, int wValue,
1.26 augustss 2333: int wIndex, int len)
1.1 augustss 2334: {
2335: usb_device_request_t req;
2336: u_int8_t data[4];
1.9 augustss 2337: usbd_status err;
1.1 augustss 2338: int val;
2339:
2340: if (wValue == -1)
1.94 kent 2341: return 0;
1.1 augustss 2342:
2343: req.bmRequestType = type;
2344: req.bRequest = which;
2345: USETW(req.wValue, wValue);
2346: USETW(req.wIndex, wIndex);
2347: USETW(req.wLength, len);
1.122 mrg 2348: DPRINTFN(2,"type=0x%02x req=0x%02x wValue=0x%04x "
1.56 kent 2349: "wIndex=0x%04x len=%d\n",
1.122 mrg 2350: type, which, wValue, wIndex, len);
1.47 jdolecek 2351: err = usbd_do_request(sc->sc_udev, &req, data);
1.9 augustss 2352: if (err) {
1.122 mrg 2353: DPRINTF("err=%s\n", usbd_errstr(err));
1.94 kent 2354: return -1;
1.1 augustss 2355: }
2356: switch (len) {
2357: case 1:
2358: val = data[0];
2359: break;
2360: case 2:
2361: val = data[0] | (data[1] << 8);
2362: break;
2363: default:
1.122 mrg 2364: DPRINTF("bad length=%d\n", len);
1.94 kent 2365: return -1;
1.1 augustss 2366: }
1.122 mrg 2367: DPRINTFN(2,"val=%d\n", val);
1.94 kent 2368: return val;
1.1 augustss 2369: }
2370:
1.86 kent 2371: Static void
1.27 augustss 2372: uaudio_set(struct uaudio_softc *sc, int which, int type, int wValue,
1.26 augustss 2373: int wIndex, int len, int val)
1.1 augustss 2374: {
2375: usb_device_request_t req;
2376: u_int8_t data[4];
1.9 augustss 2377: usbd_status err;
1.1 augustss 2378:
2379: if (wValue == -1)
2380: return;
2381:
2382: req.bmRequestType = type;
2383: req.bRequest = which;
2384: USETW(req.wValue, wValue);
2385: USETW(req.wIndex, wIndex);
2386: USETW(req.wLength, len);
2387: switch (len) {
2388: case 1:
2389: data[0] = val;
2390: break;
2391: case 2:
2392: data[0] = val;
2393: data[1] = val >> 8;
2394: break;
2395: default:
2396: return;
2397: }
1.122 mrg 2398: DPRINTFN(2,"type=0x%02x req=0x%02x wValue=0x%04x "
1.56 kent 2399: "wIndex=0x%04x len=%d, val=%d\n",
1.122 mrg 2400: type, which, wValue, wIndex, len, val & 0xffff);
1.47 jdolecek 2401: err = usbd_do_request(sc->sc_udev, &req, data);
1.4 augustss 2402: #ifdef UAUDIO_DEBUG
1.12 augustss 2403: if (err)
1.122 mrg 2404: DPRINTF("err=%d\n", err);
1.1 augustss 2405: #endif
2406: }
2407:
1.86 kent 2408: Static int
1.26 augustss 2409: uaudio_signext(int type, int val)
1.1 augustss 2410: {
2411: if (!MIX_UNSIGNED(type)) {
2412: if (MIX_SIZE(type) == 2)
2413: val = (int16_t)val;
2414: else
2415: val = (int8_t)val;
2416: }
1.94 kent 2417: return val;
1.1 augustss 2418: }
2419:
1.86 kent 2420: Static int
1.26 augustss 2421: uaudio_value2bsd(struct mixerctl *mc, int val)
1.1 augustss 2422: {
1.122 mrg 2423: DPRINTFN(5, "type=%03x val=%d min=%d max=%d ",
2424: mc->type, val, mc->minval, mc->maxval);
1.79 kent 2425: if (mc->type == MIX_ON_OFF) {
1.47 jdolecek 2426: val = (val != 0);
1.79 kent 2427: } else if (mc->type == MIX_SELECTOR) {
2428: if (val < mc->minval || val > mc->maxval)
2429: val = mc->minval;
2430: } else
1.69 wiz 2431: val = ((uaudio_signext(mc->type, val) - mc->minval) * 255
1.34 augustss 2432: + mc->mul/2) / mc->mul;
1.122 mrg 2433: DPRINTFN_CLEAN(5, "val'=%d\n", val);
1.94 kent 2434: return val;
1.1 augustss 2435: }
2436:
2437: int
1.26 augustss 2438: uaudio_bsd2value(struct mixerctl *mc, int val)
1.1 augustss 2439: {
1.122 mrg 2440: DPRINTFN(5,"type=%03x val=%d min=%d max=%d ",
2441: mc->type, val, mc->minval, mc->maxval);
1.79 kent 2442: if (mc->type == MIX_ON_OFF) {
1.47 jdolecek 2443: val = (val != 0);
1.79 kent 2444: } else if (mc->type == MIX_SELECTOR) {
2445: if (val < mc->minval || val > mc->maxval)
2446: val = mc->minval;
2447: } else
1.69 wiz 2448: val = (val + mc->delta/2) * mc->mul / 255 + mc->minval;
1.122 mrg 2449: DPRINTFN_CLEAN(5, "val'=%d\n", val);
1.94 kent 2450: return val;
1.1 augustss 2451: }
2452:
1.86 kent 2453: Static int
1.56 kent 2454: uaudio_ctl_get(struct uaudio_softc *sc, int which, struct mixerctl *mc,
1.26 augustss 2455: int chan)
1.1 augustss 2456: {
2457: int val;
2458:
1.122 mrg 2459: DPRINTFN(5,"which=%d chan=%d\n", which, chan);
1.133 mrg 2460: mutex_exit(&sc->sc_lock);
1.1 augustss 2461: val = uaudio_get(sc, which, UT_READ_CLASS_INTERFACE, mc->wValue[chan],
2462: mc->wIndex, MIX_SIZE(mc->type));
1.133 mrg 2463: mutex_enter(&sc->sc_lock);
1.94 kent 2464: return uaudio_value2bsd(mc, val);
1.1 augustss 2465: }
2466:
1.86 kent 2467: Static void
1.26 augustss 2468: uaudio_ctl_set(struct uaudio_softc *sc, int which, struct mixerctl *mc,
2469: int chan, int val)
1.1 augustss 2470: {
1.124 mrg 2471:
1.1 augustss 2472: val = uaudio_bsd2value(mc, val);
1.133 mrg 2473: mutex_exit(&sc->sc_lock);
1.1 augustss 2474: uaudio_set(sc, which, UT_WRITE_CLASS_INTERFACE, mc->wValue[chan],
2475: mc->wIndex, MIX_SIZE(mc->type), val);
1.133 mrg 2476: mutex_enter(&sc->sc_lock);
1.1 augustss 2477: }
2478:
1.86 kent 2479: Static int
1.26 augustss 2480: uaudio_mixer_get_port(void *addr, mixer_ctrl_t *cp)
1.1 augustss 2481: {
1.94 kent 2482: struct uaudio_softc *sc;
1.1 augustss 2483: struct mixerctl *mc;
2484: int i, n, vals[MIX_MAX_CHAN], val;
2485:
1.122 mrg 2486: DPRINTFN(2, "index=%d\n", cp->dev);
1.94 kent 2487: sc = addr;
1.1 augustss 2488: if (sc->sc_dying)
1.94 kent 2489: return EIO;
1.56 kent 2490:
1.63 augustss 2491: n = cp->dev - UAC_NCLASSES;
1.1 augustss 2492: if (n < 0 || n >= sc->sc_nctls)
1.94 kent 2493: return ENXIO;
1.1 augustss 2494: mc = &sc->sc_ctls[n];
2495:
2496: if (mc->type == MIX_ON_OFF) {
2497: if (cp->type != AUDIO_MIXER_ENUM)
1.94 kent 2498: return EINVAL;
1.1 augustss 2499: cp->un.ord = uaudio_ctl_get(sc, GET_CUR, mc, 0);
1.79 kent 2500: } else if (mc->type == MIX_SELECTOR) {
2501: if (cp->type != AUDIO_MIXER_ENUM)
1.94 kent 2502: return EINVAL;
1.79 kent 2503: cp->un.ord = uaudio_ctl_get(sc, GET_CUR, mc, 0);
1.1 augustss 2504: } else {
2505: if (cp->type != AUDIO_MIXER_VALUE)
1.94 kent 2506: return EINVAL;
1.1 augustss 2507: if (cp->un.value.num_channels != 1 &&
2508: cp->un.value.num_channels != mc->nchan)
1.94 kent 2509: return EINVAL;
1.1 augustss 2510: for (i = 0; i < mc->nchan; i++)
2511: vals[i] = uaudio_ctl_get(sc, GET_CUR, mc, i);
2512: if (cp->un.value.num_channels == 1 && mc->nchan != 1) {
2513: for (val = 0, i = 0; i < mc->nchan; i++)
2514: val += vals[i];
2515: vals[0] = val / mc->nchan;
2516: }
2517: for (i = 0; i < cp->un.value.num_channels; i++)
2518: cp->un.value.level[i] = vals[i];
2519: }
2520:
1.94 kent 2521: return 0;
1.1 augustss 2522: }
1.56 kent 2523:
1.86 kent 2524: Static int
1.26 augustss 2525: uaudio_mixer_set_port(void *addr, mixer_ctrl_t *cp)
1.1 augustss 2526: {
1.94 kent 2527: struct uaudio_softc *sc;
1.1 augustss 2528: struct mixerctl *mc;
2529: int i, n, vals[MIX_MAX_CHAN];
2530:
1.122 mrg 2531: DPRINTFN(2, "index = %d\n", cp->dev);
1.94 kent 2532: sc = addr;
1.1 augustss 2533: if (sc->sc_dying)
1.94 kent 2534: return EIO;
1.56 kent 2535:
1.63 augustss 2536: n = cp->dev - UAC_NCLASSES;
1.1 augustss 2537: if (n < 0 || n >= sc->sc_nctls)
1.94 kent 2538: return ENXIO;
1.1 augustss 2539: mc = &sc->sc_ctls[n];
2540:
2541: if (mc->type == MIX_ON_OFF) {
2542: if (cp->type != AUDIO_MIXER_ENUM)
1.94 kent 2543: return EINVAL;
1.1 augustss 2544: uaudio_ctl_set(sc, SET_CUR, mc, 0, cp->un.ord);
1.79 kent 2545: } else if (mc->type == MIX_SELECTOR) {
2546: if (cp->type != AUDIO_MIXER_ENUM)
1.94 kent 2547: return EINVAL;
1.79 kent 2548: uaudio_ctl_set(sc, SET_CUR, mc, 0, cp->un.ord);
1.1 augustss 2549: } else {
2550: if (cp->type != AUDIO_MIXER_VALUE)
1.94 kent 2551: return EINVAL;
1.1 augustss 2552: if (cp->un.value.num_channels == 1)
2553: for (i = 0; i < mc->nchan; i++)
2554: vals[i] = cp->un.value.level[0];
2555: else if (cp->un.value.num_channels == mc->nchan)
2556: for (i = 0; i < mc->nchan; i++)
2557: vals[i] = cp->un.value.level[i];
2558: else
1.94 kent 2559: return EINVAL;
1.1 augustss 2560: for (i = 0; i < mc->nchan; i++)
2561: uaudio_ctl_set(sc, SET_CUR, mc, i, vals[i]);
2562: }
1.94 kent 2563: return 0;
1.1 augustss 2564: }
2565:
1.86 kent 2566: Static int
1.26 augustss 2567: uaudio_trigger_input(void *addr, void *start, void *end, int blksize,
2568: void (*intr)(void *), void *arg,
1.107 christos 2569: const audio_params_t *param)
1.1 augustss 2570: {
1.94 kent 2571: struct uaudio_softc *sc;
2572: struct chan *ch;
1.9 augustss 2573: usbd_status err;
1.133 mrg 2574: int i;
1.1 augustss 2575:
1.94 kent 2576: sc = addr;
1.1 augustss 2577: if (sc->sc_dying)
1.94 kent 2578: return EIO;
1.1 augustss 2579:
1.122 mrg 2580: DPRINTFN(3, "sc=%p start=%p end=%p "
2581: "blksize=%d\n", sc, start, end, blksize);
1.94 kent 2582: ch = &sc->sc_recchan;
1.54 kent 2583: uaudio_chan_set_param(ch, start, end, blksize);
1.122 mrg 2584: DPRINTFN(3, "sample_size=%d bytes/frame=%d "
1.5 augustss 2585: "fraction=0.%03d\n", ch->sample_size, ch->bytes_per_frame,
1.122 mrg 2586: ch->fraction);
1.5 augustss 2587:
1.121 jmcneill 2588: mutex_spin_exit(&sc->sc_intr_lock);
1.9 augustss 2589: err = uaudio_chan_alloc_buffers(sc, ch);
1.121 jmcneill 2590: if (err) {
2591: mutex_spin_enter(&sc->sc_intr_lock);
1.94 kent 2592: return EIO;
1.121 jmcneill 2593: }
1.5 augustss 2594:
1.9 augustss 2595: err = uaudio_chan_open(sc, ch);
1.121 jmcneill 2596: mutex_spin_enter(&sc->sc_intr_lock);
1.9 augustss 2597: if (err) {
1.5 augustss 2598: uaudio_chan_free_buffers(sc, ch);
1.94 kent 2599: return EIO;
1.5 augustss 2600: }
2601:
1.47 jdolecek 2602: ch->intr = intr;
2603: ch->arg = arg;
1.5 augustss 2604:
1.124 mrg 2605: mutex_spin_exit(&sc->sc_intr_lock);
1.22 augustss 2606: for (i = 0; i < UAUDIO_NCHANBUFS-1; i++) /* XXX -1 shouldn't be needed */
1.5 augustss 2607: uaudio_chan_rtransfer(ch);
1.124 mrg 2608: mutex_spin_enter(&sc->sc_intr_lock);
1.5 augustss 2609:
1.94 kent 2610: return 0;
1.1 augustss 2611: }
1.56 kent 2612:
1.86 kent 2613: Static int
1.26 augustss 2614: uaudio_trigger_output(void *addr, void *start, void *end, int blksize,
2615: void (*intr)(void *), void *arg,
1.107 christos 2616: const audio_params_t *param)
1.1 augustss 2617: {
1.94 kent 2618: struct uaudio_softc *sc;
2619: struct chan *ch;
1.9 augustss 2620: usbd_status err;
1.133 mrg 2621: int i;
1.1 augustss 2622:
1.94 kent 2623: sc = addr;
1.1 augustss 2624: if (sc->sc_dying)
1.94 kent 2625: return EIO;
1.1 augustss 2626:
1.122 mrg 2627: DPRINTFN(3, "sc=%p start=%p end=%p "
2628: "blksize=%d\n", sc, start, end, blksize);
1.94 kent 2629: ch = &sc->sc_playchan;
1.54 kent 2630: uaudio_chan_set_param(ch, start, end, blksize);
1.122 mrg 2631: DPRINTFN(3, "sample_size=%d bytes/frame=%d "
1.1 augustss 2632: "fraction=0.%03d\n", ch->sample_size, ch->bytes_per_frame,
1.122 mrg 2633: ch->fraction);
1.1 augustss 2634:
1.121 jmcneill 2635: mutex_spin_exit(&sc->sc_intr_lock);
1.9 augustss 2636: err = uaudio_chan_alloc_buffers(sc, ch);
1.121 jmcneill 2637: if (err) {
2638: mutex_spin_enter(&sc->sc_intr_lock);
1.94 kent 2639: return EIO;
1.121 jmcneill 2640: }
1.1 augustss 2641:
1.9 augustss 2642: err = uaudio_chan_open(sc, ch);
1.121 jmcneill 2643: mutex_spin_enter(&sc->sc_intr_lock);
1.9 augustss 2644: if (err) {
1.1 augustss 2645: uaudio_chan_free_buffers(sc, ch);
1.94 kent 2646: return EIO;
1.1 augustss 2647: }
2648:
1.47 jdolecek 2649: ch->intr = intr;
2650: ch->arg = arg;
1.1 augustss 2651:
1.123 mrg 2652: mutex_spin_exit(&sc->sc_intr_lock);
1.22 augustss 2653: for (i = 0; i < UAUDIO_NCHANBUFS-1; i++) /* XXX */
1.5 augustss 2654: uaudio_chan_ptransfer(ch);
1.123 mrg 2655: mutex_spin_enter(&sc->sc_intr_lock);
1.1 augustss 2656:
1.94 kent 2657: return 0;
1.1 augustss 2658: }
2659:
2660: /* Set up a pipe for a channel. */
1.86 kent 2661: Static usbd_status
1.26 augustss 2662: uaudio_chan_open(struct uaudio_softc *sc, struct chan *ch)
1.1 augustss 2663: {
1.94 kent 2664: struct as_info *as;
1.131 jakllsch 2665: usb_device_descriptor_t *ddesc;
1.94 kent 2666: int endpt;
1.9 augustss 2667: usbd_status err;
1.1 augustss 2668:
1.94 kent 2669: as = &sc->sc_alts[ch->altidx];
2670: endpt = as->edesc->bEndpointAddress;
1.122 mrg 2671: DPRINTF("endpt=0x%02x, speed=%d, alt=%d\n",
2672: endpt, ch->sample_rate, as->alt);
1.1 augustss 2673:
2674: /* Set alternate interface corresponding to the mode. */
1.37 mycroft 2675: err = usbd_set_interface(as->ifaceh, as->alt);
1.9 augustss 2676: if (err)
1.94 kent 2677: return err;
1.1 augustss 2678:
1.90 kent 2679: /*
2680: * Roland SD-90 freezes by a SAMPLING_FREQ_CONTROL request.
2681: */
1.131 jakllsch 2682: ddesc = usbd_get_device_descriptor(sc->sc_udev);
2683: if ((UGETW(ddesc->idVendor) != USB_VENDOR_ROLAND) &&
2684: (UGETW(ddesc->idProduct) != USB_PRODUCT_ROLAND_SD90)) {
1.90 kent 2685: err = uaudio_set_speed(sc, endpt, ch->sample_rate);
1.105 christos 2686: if (err) {
1.122 mrg 2687: DPRINTF("set_speed failed err=%s\n", usbd_errstr(err));
1.105 christos 2688: }
1.90 kent 2689: }
1.1 augustss 2690:
1.122 mrg 2691: DPRINTF("create pipe to 0x%02x\n", endpt);
1.133.2.1 tls 2692: err = usbd_open_pipe(as->ifaceh, endpt, USBD_MPSAFE, &ch->pipe);
1.83 kent 2693: if (err)
2694: return err;
2695: if (as->edesc1 != NULL) {
2696: endpt = as->edesc1->bEndpointAddress;
1.122 mrg 2697: DPRINTF("create sync-pipe to 0x%02x\n", endpt);
1.133.2.1 tls 2698: err = usbd_open_pipe(as->ifaceh, endpt, USBD_MPSAFE,
2699: &ch->sync_pipe);
1.83 kent 2700: }
2701: return err;
1.1 augustss 2702: }
2703:
1.86 kent 2704: Static void
1.26 augustss 2705: uaudio_chan_close(struct uaudio_softc *sc, struct chan *ch)
1.1 augustss 2706: {
1.133.2.2! tls 2707: usbd_pipe_handle pipe;
1.94 kent 2708: struct as_info *as;
1.37 mycroft 2709:
1.94 kent 2710: as = &sc->sc_alts[ch->altidx];
1.58 kent 2711: as->sc_busy = 0;
1.92 kent 2712: AUFMT_VALIDATE(as->aformat);
1.1 augustss 2713: if (sc->sc_nullalt >= 0) {
1.122 mrg 2714: DPRINTF("set null alt=%d\n", sc->sc_nullalt);
1.37 mycroft 2715: usbd_set_interface(as->ifaceh, sc->sc_nullalt);
1.1 augustss 2716: }
1.133.2.2! tls 2717: pipe = atomic_swap_ptr(&ch->pipe, NULL);
! 2718: if (pipe) {
! 2719: usbd_abort_pipe(pipe);
! 2720: usbd_close_pipe(pipe);
! 2721: }
! 2722: pipe = atomic_swap_ptr(&ch->sync_pipe, NULL);
! 2723: if (pipe) {
! 2724: usbd_abort_pipe(pipe);
! 2725: usbd_close_pipe(pipe);
1.83 kent 2726: }
1.1 augustss 2727: }
2728:
1.86 kent 2729: Static usbd_status
1.26 augustss 2730: uaudio_chan_alloc_buffers(struct uaudio_softc *sc, struct chan *ch)
1.1 augustss 2731: {
1.9 augustss 2732: usbd_xfer_handle xfer;
1.99 christos 2733: void *tbuf;
1.1 augustss 2734: int i, size;
2735:
2736: size = (ch->bytes_per_frame + ch->sample_size) * UAUDIO_NFRAMES;
2737: for (i = 0; i < UAUDIO_NCHANBUFS; i++) {
1.11 augustss 2738: xfer = usbd_alloc_xfer(sc->sc_udev);
1.9 augustss 2739: if (xfer == 0)
1.1 augustss 2740: goto bad;
1.9 augustss 2741: ch->chanbufs[i].xfer = xfer;
1.99 christos 2742: tbuf = usbd_alloc_buffer(xfer, size);
2743: if (tbuf == 0) {
1.1 augustss 2744: i++;
2745: goto bad;
2746: }
1.99 christos 2747: ch->chanbufs[i].buffer = tbuf;
1.1 augustss 2748: ch->chanbufs[i].chan = ch;
2749: }
2750:
1.94 kent 2751: return USBD_NORMAL_COMPLETION;
1.1 augustss 2752:
2753: bad:
2754: while (--i >= 0)
2755: /* implicit buffer free */
1.11 augustss 2756: usbd_free_xfer(ch->chanbufs[i].xfer);
1.94 kent 2757: return USBD_NOMEM;
1.1 augustss 2758: }
2759:
1.86 kent 2760: Static void
1.107 christos 2761: uaudio_chan_free_buffers(struct uaudio_softc *sc, struct chan *ch)
1.1 augustss 2762: {
2763: int i;
2764:
2765: for (i = 0; i < UAUDIO_NCHANBUFS; i++)
1.11 augustss 2766: usbd_free_xfer(ch->chanbufs[i].xfer);
1.1 augustss 2767: }
2768:
1.133 mrg 2769: /* Called with USB lock held. */
1.86 kent 2770: Static void
1.26 augustss 2771: uaudio_chan_ptransfer(struct chan *ch)
1.1 augustss 2772: {
2773: struct chanbuf *cb;
2774: int i, n, size, residue, total;
2775:
1.8 augustss 2776: if (ch->sc->sc_dying)
2777: return;
2778:
1.1 augustss 2779: /* Pick the next channel buffer. */
2780: cb = &ch->chanbufs[ch->curchanbuf];
2781: if (++ch->curchanbuf >= UAUDIO_NCHANBUFS)
2782: ch->curchanbuf = 0;
2783:
2784: /* Compute the size of each frame in the next transfer. */
2785: residue = ch->residue;
2786: total = 0;
2787: for (i = 0; i < UAUDIO_NFRAMES; i++) {
2788: size = ch->bytes_per_frame;
2789: residue += ch->fraction;
2790: if (residue >= USB_FRAMES_PER_SECOND) {
1.47 jdolecek 2791: if ((ch->sc->sc_altflags & UA_NOFRAC) == 0)
1.31 augustss 2792: size += ch->sample_size;
1.1 augustss 2793: residue -= USB_FRAMES_PER_SECOND;
2794: }
2795: cb->sizes[i] = size;
2796: total += size;
2797: }
2798: ch->residue = residue;
2799: cb->size = total;
2800:
1.56 kent 2801: /*
1.1 augustss 2802: * Transfer data from upper layer buffer to channel buffer, taking
2803: * care of wrapping the upper layer buffer.
2804: */
2805: n = min(total, ch->end - ch->cur);
2806: memcpy(cb->buffer, ch->cur, n);
2807: ch->cur += n;
2808: if (ch->cur >= ch->end)
2809: ch->cur = ch->start;
2810: if (total > n) {
2811: total -= n;
2812: memcpy(cb->buffer + n, ch->cur, total);
2813: ch->cur += total;
2814: }
2815:
1.4 augustss 2816: #ifdef UAUDIO_DEBUG
1.1 augustss 2817: if (uaudiodebug > 8) {
1.122 mrg 2818: DPRINTF("buffer=%p, residue=0.%03d\n", cb->buffer, ch->residue);
1.1 augustss 2819: for (i = 0; i < UAUDIO_NFRAMES; i++) {
1.122 mrg 2820: DPRINTF(" [%d] length %d\n", i, cb->sizes[i]);
1.1 augustss 2821: }
2822: }
2823: #endif
2824:
1.124 mrg 2825: //DPRINTFN(5, "ptransfer xfer=%p\n", cb->xfer);
1.1 augustss 2826: /* Fill the request */
1.56 kent 2827: usbd_setup_isoc_xfer(cb->xfer, ch->pipe, cb, cb->sizes,
2828: UAUDIO_NFRAMES, USBD_NO_COPY,
1.11 augustss 2829: uaudio_chan_pintr);
1.1 augustss 2830:
1.9 augustss 2831: (void)usbd_transfer(cb->xfer);
1.1 augustss 2832: }
2833:
1.86 kent 2834: Static void
1.26 augustss 2835: uaudio_chan_pintr(usbd_xfer_handle xfer, usbd_private_handle priv,
2836: usbd_status status)
1.1 augustss 2837: {
1.94 kent 2838: struct chanbuf *cb;
2839: struct chan *ch;
2840: uint32_t count;
1.1 augustss 2841:
1.94 kent 2842: cb = priv;
2843: ch = cb->chan;
1.1 augustss 2844: /* Return if we are aborting. */
2845: if (status == USBD_CANCELLED)
2846: return;
2847:
1.18 augustss 2848: usbd_get_xfer_status(xfer, NULL, NULL, &count, NULL);
1.122 mrg 2849: DPRINTFN(5, "count=%d, transferred=%d\n",
2850: count, ch->transferred);
1.5 augustss 2851: #ifdef DIAGNOSTIC
2852: if (count != cb->size) {
1.113 cube 2853: aprint_error("uaudio_chan_pintr: count(%d) != size(%d)\n",
1.5 augustss 2854: count, cb->size);
2855: }
2856: #endif
2857:
2858: ch->transferred += cb->size;
1.121 jmcneill 2859: mutex_spin_enter(&ch->sc->sc_intr_lock);
1.1 augustss 2860: /* Call back to upper layer */
1.5 augustss 2861: while (ch->transferred >= ch->blksize) {
2862: ch->transferred -= ch->blksize;
1.122 mrg 2863: DPRINTFN(5, "call %p(%p)\n", ch->intr, ch->arg);
1.5 augustss 2864: ch->intr(ch->arg);
2865: }
1.121 jmcneill 2866: mutex_spin_exit(&ch->sc->sc_intr_lock);
1.5 augustss 2867:
2868: /* start next transfer */
2869: uaudio_chan_ptransfer(ch);
2870: }
2871:
1.133 mrg 2872: /* Called with USB lock held. */
1.86 kent 2873: Static void
1.26 augustss 2874: uaudio_chan_rtransfer(struct chan *ch)
1.5 augustss 2875: {
2876: struct chanbuf *cb;
2877: int i, size, residue, total;
1.8 augustss 2878:
2879: if (ch->sc->sc_dying)
2880: return;
1.5 augustss 2881:
2882: /* Pick the next channel buffer. */
2883: cb = &ch->chanbufs[ch->curchanbuf];
2884: if (++ch->curchanbuf >= UAUDIO_NCHANBUFS)
2885: ch->curchanbuf = 0;
2886:
2887: /* Compute the size of each frame in the next transfer. */
2888: residue = ch->residue;
2889: total = 0;
2890: for (i = 0; i < UAUDIO_NFRAMES; i++) {
2891: size = ch->bytes_per_frame;
2892: cb->sizes[i] = size;
1.62 toshii 2893: cb->offsets[i] = total;
1.5 augustss 2894: total += size;
2895: }
2896: ch->residue = residue;
2897: cb->size = total;
2898:
2899: #ifdef UAUDIO_DEBUG
2900: if (uaudiodebug > 8) {
1.122 mrg 2901: DPRINTF("buffer=%p, residue=0.%03d\n", cb->buffer, ch->residue);
1.5 augustss 2902: for (i = 0; i < UAUDIO_NFRAMES; i++) {
1.122 mrg 2903: DPRINTF(" [%d] length %d\n", i, cb->sizes[i]);
1.5 augustss 2904: }
2905: }
2906: #endif
2907:
1.122 mrg 2908: DPRINTFN(5, "transfer xfer=%p\n", cb->xfer);
1.5 augustss 2909: /* Fill the request */
1.56 kent 2910: usbd_setup_isoc_xfer(cb->xfer, ch->pipe, cb, cb->sizes,
2911: UAUDIO_NFRAMES, USBD_NO_COPY,
1.11 augustss 2912: uaudio_chan_rintr);
1.5 augustss 2913:
1.9 augustss 2914: (void)usbd_transfer(cb->xfer);
1.5 augustss 2915: }
2916:
1.86 kent 2917: Static void
1.26 augustss 2918: uaudio_chan_rintr(usbd_xfer_handle xfer, usbd_private_handle priv,
2919: usbd_status status)
1.5 augustss 2920: {
1.94 kent 2921: struct chanbuf *cb;
2922: struct chan *ch;
2923: uint32_t count;
1.121 jmcneill 2924: int i, n, frsize;
1.5 augustss 2925:
1.94 kent 2926: cb = priv;
2927: ch = cb->chan;
1.5 augustss 2928: /* Return if we are aborting. */
2929: if (status == USBD_CANCELLED)
2930: return;
2931:
1.18 augustss 2932: usbd_get_xfer_status(xfer, NULL, NULL, &count, NULL);
1.122 mrg 2933: DPRINTFN(5, "count=%d, transferred=%d\n", count, ch->transferred);
1.31 augustss 2934:
1.62 toshii 2935: /* count < cb->size is normal for asynchronous source */
1.1 augustss 2936: #ifdef DIAGNOSTIC
1.62 toshii 2937: if (count > cb->size) {
1.113 cube 2938: aprint_error("uaudio_chan_rintr: count(%d) > size(%d)\n",
1.1 augustss 2939: count, cb->size);
2940: }
2941: #endif
2942:
1.56 kent 2943: /*
1.5 augustss 2944: * Transfer data from channel buffer to upper layer buffer, taking
2945: * care of wrapping the upper layer buffer.
2946: */
1.62 toshii 2947: for(i = 0; i < UAUDIO_NFRAMES; i++) {
2948: frsize = cb->sizes[i];
2949: n = min(frsize, ch->end - ch->cur);
2950: memcpy(ch->cur, cb->buffer + cb->offsets[i], n);
2951: ch->cur += n;
2952: if (ch->cur >= ch->end)
2953: ch->cur = ch->start;
2954: if (frsize > n) {
2955: memcpy(ch->cur, cb->buffer + cb->offsets[i] + n,
2956: frsize - n);
2957: ch->cur += frsize - n;
2958: }
1.5 augustss 2959: }
2960:
2961: /* Call back to upper layer */
1.62 toshii 2962: ch->transferred += count;
1.121 jmcneill 2963: mutex_spin_enter(&ch->sc->sc_intr_lock);
1.1 augustss 2964: while (ch->transferred >= ch->blksize) {
2965: ch->transferred -= ch->blksize;
1.122 mrg 2966: DPRINTFN(5, "call %p(%p)\n", ch->intr, ch->arg);
1.1 augustss 2967: ch->intr(ch->arg);
2968: }
1.121 jmcneill 2969: mutex_spin_exit(&ch->sc->sc_intr_lock);
1.1 augustss 2970:
2971: /* start next transfer */
1.5 augustss 2972: uaudio_chan_rtransfer(ch);
1.1 augustss 2973: }
2974:
1.86 kent 2975: Static void
1.65 toshii 2976: uaudio_chan_init(struct chan *ch, int altidx, const struct audio_params *param,
2977: int maxpktsize)
1.1 augustss 2978: {
2979: int samples_per_frame, sample_size;
2980:
1.54 kent 2981: ch->altidx = altidx;
1.93 kent 2982: sample_size = param->precision * param->channels / 8;
2983: samples_per_frame = param->sample_rate / USB_FRAMES_PER_SECOND;
1.1 augustss 2984: ch->sample_size = sample_size;
1.93 kent 2985: ch->sample_rate = param->sample_rate;
1.65 toshii 2986: if (maxpktsize == 0) {
1.93 kent 2987: ch->fraction = param->sample_rate % USB_FRAMES_PER_SECOND;
1.65 toshii 2988: ch->bytes_per_frame = samples_per_frame * sample_size;
2989: } else {
2990: ch->fraction = 0;
2991: ch->bytes_per_frame = maxpktsize;
2992: }
1.1 augustss 2993: ch->residue = 0;
1.54 kent 2994: }
1.1 augustss 2995:
1.86 kent 2996: Static void
1.54 kent 2997: uaudio_chan_set_param(struct chan *ch, u_char *start, u_char *end, int blksize)
2998: {
1.94 kent 2999:
1.1 augustss 3000: ch->start = start;
3001: ch->end = end;
3002: ch->cur = start;
3003: ch->blksize = blksize;
3004: ch->transferred = 0;
3005: ch->curchanbuf = 0;
3006: }
3007:
1.86 kent 3008: Static int
1.26 augustss 3009: uaudio_set_params(void *addr, int setmode, int usemode,
1.93 kent 3010: struct audio_params *play, struct audio_params *rec,
3011: stream_filter_list_t *pfil, stream_filter_list_t *rfil)
1.1 augustss 3012: {
1.94 kent 3013: struct uaudio_softc *sc;
3014: int paltidx, raltidx;
1.38 mycroft 3015: struct audio_params *p;
1.93 kent 3016: stream_filter_list_t *fil;
1.92 kent 3017: int mode, i;
1.1 augustss 3018:
1.94 kent 3019: sc = addr;
3020: paltidx = -1;
3021: raltidx = -1;
1.1 augustss 3022: if (sc->sc_dying)
1.94 kent 3023: return EIO;
1.1 augustss 3024:
1.73 mycroft 3025: if (((usemode & AUMODE_PLAY) && sc->sc_playchan.pipe != NULL) ||
3026: ((usemode & AUMODE_RECORD) && sc->sc_recchan.pipe != NULL))
1.94 kent 3027: return EBUSY;
1.1 augustss 3028:
1.92 kent 3029: if ((usemode & AUMODE_PLAY) && sc->sc_playchan.altidx != -1) {
1.47 jdolecek 3030: sc->sc_alts[sc->sc_playchan.altidx].sc_busy = 0;
1.92 kent 3031: AUFMT_VALIDATE(sc->sc_alts[sc->sc_playchan.altidx].aformat);
3032: }
3033: if ((usemode & AUMODE_RECORD) && sc->sc_recchan.altidx != -1) {
1.47 jdolecek 3034: sc->sc_alts[sc->sc_recchan.altidx].sc_busy = 0;
1.92 kent 3035: AUFMT_VALIDATE(sc->sc_alts[sc->sc_recchan.altidx].aformat);
3036: }
1.47 jdolecek 3037:
1.76 mycroft 3038: /* Some uaudio devices are unidirectional. Don't try to find a
3039: matching mode for the unsupported direction. */
3040: setmode &= sc->sc_mode;
3041:
1.38 mycroft 3042: for (mode = AUMODE_RECORD; mode != -1;
3043: mode = mode == AUMODE_RECORD ? AUMODE_PLAY : -1) {
1.76 mycroft 3044: if ((setmode & mode) == 0)
1.38 mycroft 3045: continue;
1.56 kent 3046:
1.93 kent 3047: if (mode == AUMODE_PLAY) {
3048: p = play;
3049: fil = pfil;
3050: } else {
3051: p = rec;
3052: fil = rfil;
3053: }
1.92 kent 3054: i = auconv_set_converter(sc->sc_formats, sc->sc_nformats,
1.93 kent 3055: mode, p, TRUE, fil);
1.50 kent 3056: if (i < 0)
1.92 kent 3057: return EINVAL;
1.73 mycroft 3058:
3059: if (mode == AUMODE_PLAY)
3060: paltidx = i;
3061: else
3062: raltidx = i;
1.1 augustss 3063: }
3064:
1.73 mycroft 3065: if ((setmode & AUMODE_PLAY)) {
1.93 kent 3066: p = pfil->req_size > 0 ? &pfil->filters[0].param : play;
1.47 jdolecek 3067: /* XXX abort transfer if currently happening? */
1.93 kent 3068: uaudio_chan_init(&sc->sc_playchan, paltidx, p, 0);
1.47 jdolecek 3069: }
1.73 mycroft 3070: if ((setmode & AUMODE_RECORD)) {
1.93 kent 3071: p = rfil->req_size > 0 ? &pfil->filters[0].param : rec;
1.47 jdolecek 3072: /* XXX abort transfer if currently happening? */
1.93 kent 3073: uaudio_chan_init(&sc->sc_recchan, raltidx, p,
1.65 toshii 3074: UGETW(sc->sc_alts[raltidx].edesc->wMaxPacketSize));
1.47 jdolecek 3075: }
3076:
1.92 kent 3077: if ((usemode & AUMODE_PLAY) && sc->sc_playchan.altidx != -1) {
1.73 mycroft 3078: sc->sc_alts[sc->sc_playchan.altidx].sc_busy = 1;
1.92 kent 3079: AUFMT_INVALIDATE(sc->sc_alts[sc->sc_playchan.altidx].aformat);
3080: }
3081: if ((usemode & AUMODE_RECORD) && sc->sc_recchan.altidx != -1) {
1.73 mycroft 3082: sc->sc_alts[sc->sc_recchan.altidx].sc_busy = 1;
1.92 kent 3083: AUFMT_INVALIDATE(sc->sc_alts[sc->sc_recchan.altidx].aformat);
3084: }
1.73 mycroft 3085:
1.122 mrg 3086: DPRINTF("use altidx=p%d/r%d, altno=p%d/r%d\n",
1.56 kent 3087: sc->sc_playchan.altidx, sc->sc_recchan.altidx,
1.47 jdolecek 3088: (sc->sc_playchan.altidx >= 0)
3089: ?sc->sc_alts[sc->sc_playchan.altidx].idesc->bAlternateSetting
3090: : -1,
3091: (sc->sc_recchan.altidx >= 0)
3092: ? sc->sc_alts[sc->sc_recchan.altidx].idesc->bAlternateSetting
1.122 mrg 3093: : -1);
1.56 kent 3094:
1.94 kent 3095: return 0;
1.1 augustss 3096: }
3097:
1.86 kent 3098: Static usbd_status
1.26 augustss 3099: uaudio_set_speed(struct uaudio_softc *sc, int endpt, u_int speed)
1.1 augustss 3100: {
3101: usb_device_request_t req;
1.121 jmcneill 3102: usbd_status err;
1.94 kent 3103: uint8_t data[3];
1.1 augustss 3104:
1.122 mrg 3105: DPRINTFN(5, "endpt=%d speed=%u\n", endpt, speed);
1.1 augustss 3106: req.bmRequestType = UT_WRITE_CLASS_ENDPOINT;
3107: req.bRequest = SET_CUR;
3108: USETW2(req.wValue, SAMPLING_FREQ_CONTROL, 0);
3109: USETW(req.wIndex, endpt);
3110: USETW(req.wLength, 3);
3111: data[0] = speed;
3112: data[1] = speed >> 8;
3113: data[2] = speed >> 16;
3114:
1.121 jmcneill 3115: err = usbd_do_request(sc->sc_udev, &req, data);
3116:
3117: return err;
1.1 augustss 3118: }
1.114 kent 3119:
3120: #ifdef _MODULE
3121:
3122: MODULE(MODULE_CLASS_DRIVER, uaudio, NULL);
3123:
3124: static const struct cfiattrdata audiobuscf_iattrdata = {
3125: "audiobus", 0, { { NULL, NULL, 0 }, }
3126: };
3127: static const struct cfiattrdata * const uaudio_attrs[] = {
3128: &audiobuscf_iattrdata, NULL
3129: };
3130: CFDRIVER_DECL(uaudio, DV_DULL, uaudio_attrs);
3131: extern struct cfattach uaudio_ca;
3132: static int uaudioloc[6/*USBIFIFCF_NLOCS*/] = {
3133: -1/*USBIFIFCF_PORT_DEFAULT*/,
3134: -1/*USBIFIFCF_CONFIGURATION_DEFAULT*/,
3135: -1/*USBIFIFCF_INTERFACE_DEFAULT*/,
3136: -1/*USBIFIFCF_VENDOR_DEFAULT*/,
3137: -1/*USBIFIFCF_PRODUCT_DEFAULT*/,
3138: -1/*USBIFIFCF_RELEASE_DEFAULT*/};
3139: static struct cfparent uhubparent = {
3140: "usbifif", NULL, DVUNIT_ANY
3141: };
3142: static struct cfdata uaudio_cfdata[] = {
3143: {
3144: .cf_name = "uaudio",
3145: .cf_atname = "uaudio",
3146: .cf_unit = 0,
3147: .cf_fstate = FSTATE_STAR,
3148: .cf_loc = uaudioloc,
3149: .cf_flags = 0,
3150: .cf_pspec = &uhubparent,
3151: },
3152: { NULL }
3153: };
3154:
3155: static int
3156: uaudio_modcmd(modcmd_t cmd, void *arg)
3157: {
3158: int err;
3159:
3160: switch (cmd) {
3161: case MODULE_CMD_INIT:
3162: err = config_cfdriver_attach(&uaudio_cd);
3163: if (err) {
3164: return err;
3165: }
3166: err = config_cfattach_attach("uaudio", &uaudio_ca);
3167: if (err) {
3168: config_cfdriver_detach(&uaudio_cd);
3169: return err;
3170: }
3171: err = config_cfdata_attach(uaudio_cfdata, 1);
3172: if (err) {
3173: config_cfattach_detach("uaudio", &uaudio_ca);
3174: config_cfdriver_detach(&uaudio_cd);
3175: return err;
3176: }
3177: return 0;
3178: case MODULE_CMD_FINI:
3179: err = config_cfdata_detach(uaudio_cfdata);
3180: if (err)
3181: return err;
3182: config_cfattach_detach("uaudio", &uaudio_ca);
3183: config_cfdriver_detach(&uaudio_cd);
3184: return 0;
3185: default:
3186: return ENOTTY;
3187: }
3188: }
3189:
3190: #endif
CVSweb <webmaster@jp.NetBSD.org>
![[BACK]](/icons/back.gif){kind=icon}
Return to uaudio.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [cvs.NetBSD.org] / src / sys / dev / usb