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