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