1 /* $NetBSD: uaudio.c,v 1.91 2004/11/05 17:46:14 kent Exp $ */ 2 /* $FreeBSD$ */ 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 #include <sys/cdefs.h> 35 __FBSDID("$FreeBSD$"); 36 37 /* 38 * USB audio specs: http://www.usb.org/developers/devclass_docs/audio10.pdf 39 * http://www.usb.org/developers/devclass_docs/frmts10.pdf 40 * http://www.usb.org/developers/devclass_docs/termt10.pdf 41 */ 42 43 /* 44 * Also merged: 45 * $NetBSD: uaudio.c,v 1.94 2005/01/15 15:19:53 kent Exp $ 46 * $NetBSD: uaudio.c,v 1.95 2005/01/16 06:02:19 dsainty Exp $ 47 * $NetBSD: uaudio.c,v 1.96 2005/01/16 12:46:00 kent Exp $ 48 * $NetBSD: uaudio.c,v 1.97 2005/02/24 08:19:38 martin Exp $ 49 */ 50 51 #include <sys/stdint.h> 52 #include <sys/stddef.h> 53 #include <sys/param.h> 54 #include <sys/queue.h> 55 #include <sys/types.h> 56 #include <sys/systm.h> 57 #include <sys/kernel.h> 58 #include <sys/bus.h> 59 #include <sys/module.h> 60 #include <sys/lock.h> 61 #include <sys/mutex.h> 62 #include <sys/condvar.h> 63 #include <sys/sysctl.h> 64 #include <sys/sx.h> 65 #include <sys/unistd.h> 66 #include <sys/callout.h> 67 #include <sys/malloc.h> 68 #include <sys/priv.h> 69 70 #include "usbdevs.h" 71 #include <dev/usb/usb.h> 72 #include <dev/usb/usbdi.h> 73 #include <dev/usb/usbdi_util.h> 74 75 #define USB_DEBUG_VAR uaudio_debug 76 #include <dev/usb/usb_debug.h> 77 78 #include <dev/usb/quirk/usb_quirk.h> 79 80 #include <sys/reboot.h> /* for bootverbose */ 81 82 #ifdef HAVE_KERNEL_OPTION_HEADERS 83 #include "opt_snd.h" 84 #endif 85 86 #include <dev/sound/pcm/sound.h> 87 #include <dev/sound/usb/uaudioreg.h> 88 #include <dev/sound/usb/uaudio.h> 89 #include <dev/sound/chip.h> 90 #include "feeder_if.h" 91 92 static int uaudio_default_rate = 0; /* use rate list */ 93 static int uaudio_default_bits = 32; 94 static int uaudio_default_channels = 0; /* use default */ 95 96 #ifdef USB_DEBUG 97 static int uaudio_debug = 0; 98 99 static SYSCTL_NODE(_hw_usb, OID_AUTO, uaudio, CTLFLAG_RW, 0, "USB uaudio"); 100 101 SYSCTL_INT(_hw_usb_uaudio, OID_AUTO, debug, CTLFLAG_RW, 102 &uaudio_debug, 0, "uaudio debug level"); 103 104 TUNABLE_INT("hw.usb.uaudio.default_rate", &uaudio_default_rate); 105 SYSCTL_INT(_hw_usb_uaudio, OID_AUTO, default_rate, CTLFLAG_RW, 106 &uaudio_default_rate, 0, "uaudio default sample rate"); 107 108 TUNABLE_INT("hw.usb.uaudio.default_bits", &uaudio_default_bits); 109 SYSCTL_INT(_hw_usb_uaudio, OID_AUTO, default_bits, CTLFLAG_RW, 110 &uaudio_default_bits, 0, "uaudio default sample bits"); 111 112 TUNABLE_INT("hw.usb.uaudio.default_channels", &uaudio_default_channels); 113 SYSCTL_INT(_hw_usb_uaudio, OID_AUTO, default_channels, CTLFLAG_RW, 114 &uaudio_default_channels, 0, "uaudio default sample channels"); 115 #endif 116 117 #define UAUDIO_NFRAMES 64 /* must be factor of 8 due HS-USB */ 118 #define UAUDIO_NCHANBUFS 2 /* number of outstanding request */ 119 #define UAUDIO_RECURSE_LIMIT 24 /* rounds */ 120 121 #define MAKE_WORD(h,l) (((h) << 8) | (l)) 122 #define BIT_TEST(bm,bno) (((bm)[(bno) / 8] >> (7 - ((bno) % 8))) & 1) 123 #define UAUDIO_MAX_CHAN(x) (x) 124 125 struct uaudio_mixer_node { 126 int32_t minval; 127 int32_t maxval; 128 #define MIX_MAX_CHAN 8 129 int32_t wValue[MIX_MAX_CHAN]; /* using nchan */ 130 uint32_t mul; 131 uint32_t ctl; 132 133 uint16_t wData[MIX_MAX_CHAN]; /* using nchan */ 134 uint16_t wIndex; 135 136 uint8_t update[(MIX_MAX_CHAN + 7) / 8]; 137 uint8_t nchan; 138 uint8_t type; 139 #define MIX_ON_OFF 1 140 #define MIX_SIGNED_16 2 141 #define MIX_UNSIGNED_16 3 142 #define MIX_SIGNED_8 4 143 #define MIX_SELECTOR 5 144 #define MIX_UNKNOWN 6 145 #define MIX_SIZE(n) ((((n) == MIX_SIGNED_16) || \ 146 ((n) == MIX_UNSIGNED_16)) ? 2 : 1) 147 #define MIX_UNSIGNED(n) ((n) == MIX_UNSIGNED_16) 148 149 #define MAX_SELECTOR_INPUT_PIN 256 150 uint8_t slctrtype[MAX_SELECTOR_INPUT_PIN]; 151 uint8_t class; 152 153 struct uaudio_mixer_node *next; 154 }; 155 156 struct uaudio_chan { 157 struct pcmchan_caps pcm_cap; /* capabilities */ 158 159 struct snd_dbuf *pcm_buf; 160 const struct usb_config *usb_cfg; 161 struct mtx *pcm_mtx; /* lock protecting this structure */ 162 struct uaudio_softc *priv_sc; 163 struct pcm_channel *pcm_ch; 164 struct usb_xfer *xfer[UAUDIO_NCHANBUFS]; 165 const struct usb_audio_streaming_interface_descriptor *p_asid; 166 const struct usb_audio_streaming_type1_descriptor *p_asf1d; 167 const struct usb_audio_streaming_endpoint_descriptor *p_sed; 168 const usb_endpoint_descriptor_audio_t *p_ed1; 169 const usb_endpoint_descriptor_audio_t *p_ed2; 170 const struct uaudio_format *p_fmt; 171 172 uint8_t *buf; /* pointer to buffer */ 173 uint8_t *start; /* upper layer buffer start */ 174 uint8_t *end; /* upper layer buffer end */ 175 uint8_t *cur; /* current position in upper layer 176 * buffer */ 177 178 uint32_t intr_size; /* in bytes */ 179 uint32_t intr_frames; /* in units */ 180 uint32_t sample_rate; 181 uint32_t frames_per_second; 182 uint32_t sample_rem; 183 uint32_t sample_curr; 184 185 uint32_t format; 186 uint32_t pcm_format[2]; 187 188 uint16_t bytes_per_frame[2]; 189 190 uint16_t sample_size; 191 192 uint8_t valid; 193 uint8_t iface_index; 194 uint8_t iface_alt_index; 195 }; 196 197 #define UMIDI_CABLES_MAX 16 /* units */ 198 #define UMIDI_TX_FRAMES 256 /* units */ 199 #define UMIDI_TX_BUFFER (UMIDI_TX_FRAMES * 4) /* bytes */ 200 201 enum { 202 UMIDI_TX_TRANSFER, 203 UMIDI_RX_TRANSFER, 204 UMIDI_N_TRANSFER, 205 }; 206 207 struct umidi_sub_chan { 208 struct usb_fifo_sc fifo; 209 uint8_t *temp_cmd; 210 uint8_t temp_0[4]; 211 uint8_t temp_1[4]; 212 uint8_t state; 213 #define UMIDI_ST_UNKNOWN 0 /* scan for command */ 214 #define UMIDI_ST_1PARAM 1 215 #define UMIDI_ST_2PARAM_1 2 216 #define UMIDI_ST_2PARAM_2 3 217 #define UMIDI_ST_SYSEX_0 4 218 #define UMIDI_ST_SYSEX_1 5 219 #define UMIDI_ST_SYSEX_2 6 220 221 uint8_t read_open:1; 222 uint8_t write_open:1; 223 uint8_t unused:6; 224 }; 225 226 struct umidi_chan { 227 228 struct umidi_sub_chan sub[UMIDI_CABLES_MAX]; 229 struct mtx mtx; 230 231 struct usb_xfer *xfer[UMIDI_N_TRANSFER]; 232 233 uint8_t iface_index; 234 uint8_t iface_alt_index; 235 236 uint8_t read_open_refcount; 237 uint8_t write_open_refcount; 238 239 uint8_t curr_cable; 240 uint8_t max_cable; 241 uint8_t valid; 242 uint8_t single_command; 243 }; 244 245 struct uaudio_softc { 246 struct sbuf sc_sndstat; 247 struct sndcard_func sc_sndcard_func; 248 struct uaudio_chan sc_rec_chan; 249 struct uaudio_chan sc_play_chan; 250 struct umidi_chan sc_midi_chan; 251 252 struct usb_device *sc_udev; 253 struct usb_xfer *sc_mixer_xfer[1]; 254 struct uaudio_mixer_node *sc_mixer_root; 255 struct uaudio_mixer_node *sc_mixer_curr; 256 257 uint32_t sc_mix_info; 258 uint32_t sc_recsrc_info; 259 260 uint16_t sc_audio_rev; 261 uint16_t sc_mixer_count; 262 263 uint8_t sc_sndstat_valid; 264 uint8_t sc_mixer_iface_index; 265 uint8_t sc_mixer_iface_no; 266 uint8_t sc_mixer_chan; 267 uint8_t sc_pcm_registered:1; 268 uint8_t sc_mixer_init:1; 269 uint8_t sc_uq_audio_swap_lr:1; 270 uint8_t sc_uq_au_inp_async:1; 271 uint8_t sc_uq_au_no_xu:1; 272 uint8_t sc_uq_bad_adc:1; 273 uint8_t sc_uq_au_vendor_class:1; 274 }; 275 276 struct uaudio_search_result { 277 uint8_t bit_input[(256 + 7) / 8]; 278 uint8_t bit_output[(256 + 7) / 8]; 279 uint8_t bit_visited[(256 + 7) / 8]; 280 uint8_t recurse_level; 281 uint8_t id_max; 282 }; 283 284 struct uaudio_terminal_node { 285 union { 286 const struct usb_descriptor *desc; 287 const struct usb_audio_input_terminal *it; 288 const struct usb_audio_output_terminal *ot; 289 const struct usb_audio_mixer_unit_0 *mu; 290 const struct usb_audio_selector_unit *su; 291 const struct usb_audio_feature_unit *fu; 292 const struct usb_audio_processing_unit_0 *pu; 293 const struct usb_audio_extension_unit_0 *eu; 294 } u; 295 struct uaudio_search_result usr; 296 struct uaudio_terminal_node *root; 297 }; 298 299 struct uaudio_format { 300 uint16_t wFormat; 301 uint8_t bPrecision; 302 uint32_t freebsd_fmt; 303 const char *description; 304 }; 305 306 static const struct uaudio_format uaudio_formats[] = { 307 308 {UA_FMT_PCM8, 8, AFMT_U8, "8-bit U-LE PCM"}, 309 {UA_FMT_PCM8, 16, AFMT_U16_LE, "16-bit U-LE PCM"}, 310 {UA_FMT_PCM8, 24, AFMT_U24_LE, "24-bit U-LE PCM"}, 311 {UA_FMT_PCM8, 32, AFMT_U32_LE, "32-bit U-LE PCM"}, 312 313 {UA_FMT_PCM, 8, AFMT_S8, "8-bit S-LE PCM"}, 314 {UA_FMT_PCM, 16, AFMT_S16_LE, "16-bit S-LE PCM"}, 315 {UA_FMT_PCM, 24, AFMT_S24_LE, "24-bit S-LE PCM"}, 316 {UA_FMT_PCM, 32, AFMT_S32_LE, "32-bit S-LE PCM"}, 317 318 {UA_FMT_ALAW, 8, AFMT_A_LAW, "8-bit A-Law"}, 319 {UA_FMT_MULAW, 8, AFMT_MU_LAW, "8-bit mu-Law"}, 320 321 {0, 0, 0, NULL} 322 }; 323 324 #define UAC_OUTPUT 0 325 #define UAC_INPUT 1 326 #define UAC_EQUAL 2 327 #define UAC_RECORD 3 328 #define UAC_NCLASSES 4 329 330 #ifdef USB_DEBUG 331 static const char *uac_names[] = { 332 "outputs", "inputs", "equalization", "record" 333 }; 334 335 #endif 336 337 /* prototypes */ 338 339 static device_probe_t uaudio_probe; 340 static device_attach_t uaudio_attach; 341 static device_detach_t uaudio_detach; 342 343 static usb_callback_t uaudio_chan_play_callback; 344 static usb_callback_t uaudio_chan_record_callback; 345 static usb_callback_t uaudio_mixer_write_cfg_callback; 346 static usb_callback_t umidi_bulk_read_callback; 347 static usb_callback_t umidi_bulk_write_callback; 348 349 static void uaudio_chan_fill_info_sub(struct uaudio_softc *, 350 struct usb_device *, uint32_t, uint8_t, uint8_t); 351 static void uaudio_chan_fill_info(struct uaudio_softc *, 352 struct usb_device *); 353 static void uaudio_mixer_add_ctl_sub(struct uaudio_softc *, 354 struct uaudio_mixer_node *); 355 static void uaudio_mixer_add_ctl(struct uaudio_softc *, 356 struct uaudio_mixer_node *); 357 static void uaudio_mixer_add_input(struct uaudio_softc *, 358 const struct uaudio_terminal_node *, int); 359 static void uaudio_mixer_add_output(struct uaudio_softc *, 360 const struct uaudio_terminal_node *, int); 361 static void uaudio_mixer_add_mixer(struct uaudio_softc *, 362 const struct uaudio_terminal_node *, int); 363 static void uaudio_mixer_add_selector(struct uaudio_softc *, 364 const struct uaudio_terminal_node *, int); 365 static uint32_t uaudio_mixer_feature_get_bmaControls( 366 const struct usb_audio_feature_unit *, uint8_t); 367 static void uaudio_mixer_add_feature(struct uaudio_softc *, 368 const struct uaudio_terminal_node *, int); 369 static void uaudio_mixer_add_processing_updown(struct uaudio_softc *, 370 const struct uaudio_terminal_node *, int); 371 static void uaudio_mixer_add_processing(struct uaudio_softc *, 372 const struct uaudio_terminal_node *, int); 373 static void uaudio_mixer_add_extension(struct uaudio_softc *, 374 const struct uaudio_terminal_node *, int); 375 static struct usb_audio_cluster uaudio_mixer_get_cluster(uint8_t, 376 const struct uaudio_terminal_node *); 377 static uint16_t uaudio_mixer_determine_class(const struct uaudio_terminal_node *, 378 struct uaudio_mixer_node *); 379 static uint16_t uaudio_mixer_feature_name(const struct uaudio_terminal_node *, 380 struct uaudio_mixer_node *); 381 static const struct uaudio_terminal_node *uaudio_mixer_get_input( 382 const struct uaudio_terminal_node *, uint8_t); 383 static const struct uaudio_terminal_node *uaudio_mixer_get_output( 384 const struct uaudio_terminal_node *, uint8_t); 385 static void uaudio_mixer_find_inputs_sub(struct uaudio_terminal_node *, 386 const uint8_t *, uint8_t, struct uaudio_search_result *); 387 static void uaudio_mixer_find_outputs_sub(struct uaudio_terminal_node *, 388 uint8_t, uint8_t, struct uaudio_search_result *); 389 static void uaudio_mixer_fill_info(struct uaudio_softc *, 390 struct usb_device *, void *); 391 static uint16_t uaudio_mixer_get(struct usb_device *, uint8_t, 392 struct uaudio_mixer_node *); 393 static void uaudio_mixer_ctl_set(struct uaudio_softc *, 394 struct uaudio_mixer_node *, uint8_t, int32_t val); 395 static usb_error_t uaudio_set_speed(struct usb_device *, uint8_t, uint32_t); 396 static int uaudio_mixer_signext(uint8_t, int); 397 static int uaudio_mixer_bsd2value(struct uaudio_mixer_node *, int32_t val); 398 static const void *uaudio_mixer_verify_desc(const void *, uint32_t); 399 static void uaudio_mixer_init(struct uaudio_softc *); 400 static uint8_t umidi_convert_to_usb(struct umidi_sub_chan *, uint8_t, uint8_t); 401 static struct umidi_sub_chan *umidi_sub_by_fifo(struct usb_fifo *); 402 static void umidi_start_read(struct usb_fifo *); 403 static void umidi_stop_read(struct usb_fifo *); 404 static void umidi_start_write(struct usb_fifo *); 405 static void umidi_stop_write(struct usb_fifo *); 406 static int umidi_open(struct usb_fifo *, int); 407 static int umidi_ioctl(struct usb_fifo *, u_long cmd, void *, int); 408 static void umidi_close(struct usb_fifo *, int); 409 static void umidi_init(device_t dev); 410 static int umidi_probe(device_t dev); 411 static int umidi_detach(device_t dev); 412 413 #ifdef USB_DEBUG 414 static void uaudio_chan_dump_ep_desc( 415 const usb_endpoint_descriptor_audio_t *); 416 static void uaudio_mixer_dump_cluster(uint8_t, 417 const struct uaudio_terminal_node *); 418 static const char *uaudio_mixer_get_terminal_name(uint16_t); 419 #endif 420 421 static const struct usb_config 422 uaudio_cfg_record[UAUDIO_NCHANBUFS] = { 423 [0] = { 424 .type = UE_ISOCHRONOUS, 425 .endpoint = UE_ADDR_ANY, 426 .direction = UE_DIR_IN, 427 .bufsize = 0, /* use "wMaxPacketSize * frames" */ 428 .frames = UAUDIO_NFRAMES, 429 .flags = {.short_xfer_ok = 1,}, 430 .callback = &uaudio_chan_record_callback, 431 }, 432 433 [1] = { 434 .type = UE_ISOCHRONOUS, 435 .endpoint = UE_ADDR_ANY, 436 .direction = UE_DIR_IN, 437 .bufsize = 0, /* use "wMaxPacketSize * frames" */ 438 .frames = UAUDIO_NFRAMES, 439 .flags = {.short_xfer_ok = 1,}, 440 .callback = &uaudio_chan_record_callback, 441 }, 442 }; 443 444 static const struct usb_config 445 uaudio_cfg_play[UAUDIO_NCHANBUFS] = { 446 [0] = { 447 .type = UE_ISOCHRONOUS, 448 .endpoint = UE_ADDR_ANY, 449 .direction = UE_DIR_OUT, 450 .bufsize = 0, /* use "wMaxPacketSize * frames" */ 451 .frames = UAUDIO_NFRAMES, 452 .flags = {.short_xfer_ok = 1,}, 453 .callback = &uaudio_chan_play_callback, 454 }, 455 456 [1] = { 457 .type = UE_ISOCHRONOUS, 458 .endpoint = UE_ADDR_ANY, 459 .direction = UE_DIR_OUT, 460 .bufsize = 0, /* use "wMaxPacketSize * frames" */ 461 .frames = UAUDIO_NFRAMES, 462 .flags = {.short_xfer_ok = 1,}, 463 .callback = &uaudio_chan_play_callback, 464 }, 465 }; 466 467 static const struct usb_config 468 uaudio_mixer_config[1] = { 469 [0] = { 470 .type = UE_CONTROL, 471 .endpoint = 0x00, /* Control pipe */ 472 .direction = UE_DIR_ANY, 473 .bufsize = (sizeof(struct usb_device_request) + 4), 474 .callback = &uaudio_mixer_write_cfg_callback, 475 .timeout = 1000, /* 1 second */ 476 }, 477 }; 478 479 static const 480 uint8_t umidi_cmd_to_len[16] = { 481 [0x0] = 0, /* reserved */ 482 [0x1] = 0, /* reserved */ 483 [0x2] = 2, /* bytes */ 484 [0x3] = 3, /* bytes */ 485 [0x4] = 3, /* bytes */ 486 [0x5] = 1, /* bytes */ 487 [0x6] = 2, /* bytes */ 488 [0x7] = 3, /* bytes */ 489 [0x8] = 3, /* bytes */ 490 [0x9] = 3, /* bytes */ 491 [0xA] = 3, /* bytes */ 492 [0xB] = 3, /* bytes */ 493 [0xC] = 2, /* bytes */ 494 [0xD] = 2, /* bytes */ 495 [0xE] = 3, /* bytes */ 496 [0xF] = 1, /* bytes */ 497 }; 498 499 static const struct usb_config 500 umidi_config[UMIDI_N_TRANSFER] = { 501 [UMIDI_TX_TRANSFER] = { 502 .type = UE_BULK, 503 .endpoint = UE_ADDR_ANY, 504 .direction = UE_DIR_OUT, 505 .bufsize = UMIDI_TX_BUFFER, 506 .callback = &umidi_bulk_write_callback, 507 }, 508 509 [UMIDI_RX_TRANSFER] = { 510 .type = UE_BULK, 511 .endpoint = UE_ADDR_ANY, 512 .direction = UE_DIR_IN, 513 .bufsize = 4, /* bytes */ 514 .flags = {.short_xfer_ok = 1,.proxy_buffer = 1,}, 515 .callback = &umidi_bulk_read_callback, 516 }, 517 }; 518 519 static devclass_t uaudio_devclass; 520 521 static device_method_t uaudio_methods[] = { 522 DEVMETHOD(device_probe, uaudio_probe), 523 DEVMETHOD(device_attach, uaudio_attach), 524 DEVMETHOD(device_detach, uaudio_detach), 525 DEVMETHOD(device_suspend, bus_generic_suspend), 526 DEVMETHOD(device_resume, bus_generic_resume), 527 DEVMETHOD(device_shutdown, bus_generic_shutdown), 528 529 DEVMETHOD_END 530 }; 531 532 static driver_t uaudio_driver = { 533 .name = "uaudio", 534 .methods = uaudio_methods, 535 .size = sizeof(struct uaudio_softc), 536 }; 537 538 static const STRUCT_USB_HOST_ID __used uaudio_devs[] = { 539 /* Generic USB audio class match */ 540 {USB_IFACE_CLASS(UICLASS_AUDIO), 541 USB_IFACE_SUBCLASS(UISUBCLASS_AUDIOCONTROL),}, 542 /* Generic USB MIDI class match */ 543 {USB_IFACE_CLASS(UICLASS_AUDIO), 544 USB_IFACE_SUBCLASS(UISUBCLASS_MIDISTREAM),}, 545 }; 546 547 static int 548 uaudio_probe(device_t dev) 549 { 550 struct usb_attach_arg *uaa = device_get_ivars(dev); 551 552 if (uaa->usb_mode != USB_MODE_HOST) 553 return (ENXIO); 554 555 /* lookup non-standard device */ 556 557 if (uaa->info.bInterfaceClass != UICLASS_AUDIO) { 558 if (usb_test_quirk(uaa, UQ_AU_VENDOR_CLASS) == 0) 559 return (ENXIO); 560 } 561 562 /* check for AUDIO control interface */ 563 564 if (uaa->info.bInterfaceSubClass == UISUBCLASS_AUDIOCONTROL) { 565 if (usb_test_quirk(uaa, UQ_BAD_AUDIO)) 566 return (ENXIO); 567 else 568 return (BUS_PROBE_GENERIC); 569 } 570 571 /* check for MIDI stream */ 572 573 if (uaa->info.bInterfaceSubClass == UISUBCLASS_MIDISTREAM) { 574 if (usb_test_quirk(uaa, UQ_BAD_MIDI)) 575 return (ENXIO); 576 else 577 return (BUS_PROBE_GENERIC); 578 } 579 return (ENXIO); 580 } 581 582 static int 583 uaudio_attach(device_t dev) 584 { 585 struct usb_attach_arg *uaa = device_get_ivars(dev); 586 struct uaudio_softc *sc = device_get_softc(dev); 587 struct usb_interface_descriptor *id; 588 device_t child; 589 590 sc->sc_play_chan.priv_sc = sc; 591 sc->sc_rec_chan.priv_sc = sc; 592 sc->sc_udev = uaa->device; 593 sc->sc_mixer_iface_index = uaa->info.bIfaceIndex; 594 sc->sc_mixer_iface_no = uaa->info.bIfaceNum; 595 596 if (usb_test_quirk(uaa, UQ_AUDIO_SWAP_LR)) 597 sc->sc_uq_audio_swap_lr = 1; 598 599 if (usb_test_quirk(uaa, UQ_AU_INP_ASYNC)) 600 sc->sc_uq_au_inp_async = 1; 601 602 if (usb_test_quirk(uaa, UQ_AU_NO_XU)) 603 sc->sc_uq_au_no_xu = 1; 604 605 if (usb_test_quirk(uaa, UQ_BAD_ADC)) 606 sc->sc_uq_bad_adc = 1; 607 608 if (usb_test_quirk(uaa, UQ_AU_VENDOR_CLASS)) 609 sc->sc_uq_au_vendor_class = 1; 610 611 umidi_init(dev); 612 613 device_set_usb_desc(dev); 614 615 id = usbd_get_interface_descriptor(uaa->iface); 616 617 uaudio_chan_fill_info(sc, uaa->device); 618 619 uaudio_mixer_fill_info(sc, uaa->device, id); 620 621 DPRINTF("audio rev %d.%02x\n", 622 sc->sc_audio_rev >> 8, 623 sc->sc_audio_rev & 0xff); 624 625 DPRINTF("%d mixer controls\n", 626 sc->sc_mixer_count); 627 628 if (sc->sc_play_chan.valid) { 629 device_printf(dev, "Play: %d Hz, %d ch, %s format\n", 630 sc->sc_play_chan.sample_rate, 631 sc->sc_play_chan.p_asf1d->bNrChannels, 632 sc->sc_play_chan.p_fmt->description); 633 } else { 634 device_printf(dev, "No playback!\n"); 635 } 636 637 if (sc->sc_rec_chan.valid) { 638 device_printf(dev, "Record: %d Hz, %d ch, %s format\n", 639 sc->sc_rec_chan.sample_rate, 640 sc->sc_rec_chan.p_asf1d->bNrChannels, 641 sc->sc_rec_chan.p_fmt->description); 642 } else { 643 device_printf(dev, "No recording!\n"); 644 } 645 646 if (sc->sc_midi_chan.valid) { 647 648 if (umidi_probe(dev)) { 649 goto detach; 650 } 651 device_printf(dev, "MIDI sequencer\n"); 652 } else { 653 device_printf(dev, "No midi sequencer\n"); 654 } 655 656 DPRINTF("doing child attach\n"); 657 658 /* attach the children */ 659 660 sc->sc_sndcard_func.func = SCF_PCM; 661 662 child = device_add_child(dev, "pcm", -1); 663 664 if (child == NULL) { 665 DPRINTF("out of memory\n"); 666 goto detach; 667 } 668 device_set_ivars(child, &sc->sc_sndcard_func); 669 670 if (bus_generic_attach(dev)) { 671 DPRINTF("child attach failed\n"); 672 goto detach; 673 } 674 return (0); /* success */ 675 676 detach: 677 uaudio_detach(dev); 678 return (ENXIO); 679 } 680 681 static void 682 uaudio_pcm_setflags(device_t dev, uint32_t flags) 683 { 684 pcm_setflags(dev, pcm_getflags(dev) | flags); 685 } 686 687 int 688 uaudio_attach_sub(device_t dev, kobj_class_t mixer_class, kobj_class_t chan_class) 689 { 690 struct uaudio_softc *sc = device_get_softc(device_get_parent(dev)); 691 char status[SND_STATUSLEN]; 692 693 uaudio_mixer_init(sc); 694 695 if (sc->sc_uq_audio_swap_lr) { 696 DPRINTF("hardware has swapped left and right\n"); 697 /* uaudio_pcm_setflags(dev, SD_F_PSWAPLR); */ 698 } 699 if (!(sc->sc_mix_info & SOUND_MASK_PCM)) { 700 701 DPRINTF("emulating master volume\n"); 702 703 /* 704 * Emulate missing pcm mixer controller 705 * through FEEDER_VOLUME 706 */ 707 uaudio_pcm_setflags(dev, SD_F_SOFTPCMVOL); 708 } 709 if (mixer_init(dev, mixer_class, sc)) { 710 goto detach; 711 } 712 sc->sc_mixer_init = 1; 713 714 snprintf(status, sizeof(status), "at ? %s", PCM_KLDSTRING(snd_uaudio)); 715 716 if (pcm_register(dev, sc, 717 sc->sc_play_chan.valid ? 1 : 0, 718 sc->sc_rec_chan.valid ? 1 : 0)) { 719 goto detach; 720 } 721 722 uaudio_pcm_setflags(dev, SD_F_MPSAFE); 723 sc->sc_pcm_registered = 1; 724 725 if (sc->sc_play_chan.valid) { 726 pcm_addchan(dev, PCMDIR_PLAY, chan_class, sc); 727 } 728 if (sc->sc_rec_chan.valid) { 729 pcm_addchan(dev, PCMDIR_REC, chan_class, sc); 730 } 731 pcm_setstatus(dev, status); 732 733 return (0); /* success */ 734 735 detach: 736 uaudio_detach_sub(dev); 737 return (ENXIO); 738 } 739 740 int 741 uaudio_detach_sub(device_t dev) 742 { 743 struct uaudio_softc *sc = device_get_softc(device_get_parent(dev)); 744 int error = 0; 745 746 repeat: 747 if (sc->sc_pcm_registered) { 748 error = pcm_unregister(dev); 749 } else { 750 if (sc->sc_mixer_init) { 751 error = mixer_uninit(dev); 752 } 753 } 754 755 if (error) { 756 device_printf(dev, "Waiting for sound application to exit!\n"); 757 usb_pause_mtx(NULL, 2 * hz); 758 goto repeat; /* try again */ 759 } 760 return (0); /* success */ 761 } 762 763 static int 764 uaudio_detach(device_t dev) 765 { 766 struct uaudio_softc *sc = device_get_softc(dev); 767 768 /* 769 * Stop USB transfers early so that any audio applications 770 * will time out and close opened /dev/dspX.Y device(s), if 771 * any. 772 */ 773 if (sc->sc_play_chan.valid) 774 usbd_transfer_unsetup(sc->sc_play_chan.xfer, UAUDIO_NCHANBUFS); 775 if (sc->sc_rec_chan.valid) 776 usbd_transfer_unsetup(sc->sc_rec_chan.xfer, UAUDIO_NCHANBUFS); 777 778 if (bus_generic_detach(dev) != 0) { 779 DPRINTF("detach failed!\n"); 780 } 781 sbuf_delete(&sc->sc_sndstat); 782 sc->sc_sndstat_valid = 0; 783 784 umidi_detach(dev); 785 786 return (0); 787 } 788 789 /*========================================================================* 790 * AS - Audio Stream - routines 791 *========================================================================*/ 792 793 #ifdef USB_DEBUG 794 static void 795 uaudio_chan_dump_ep_desc(const usb_endpoint_descriptor_audio_t *ed) 796 { 797 if (ed) { 798 DPRINTF("endpoint=%p bLength=%d bDescriptorType=%d \n" 799 "bEndpointAddress=%d bmAttributes=0x%x \n" 800 "wMaxPacketSize=%d bInterval=%d \n" 801 "bRefresh=%d bSynchAddress=%d\n", 802 ed, ed->bLength, ed->bDescriptorType, 803 ed->bEndpointAddress, ed->bmAttributes, 804 UGETW(ed->wMaxPacketSize), ed->bInterval, 805 UEP_HAS_REFRESH(ed) ? ed->bRefresh : 0, 806 UEP_HAS_SYNCADDR(ed) ? ed->bSynchAddress : 0); 807 } 808 } 809 810 #endif 811 812 /* 813 * The following is a workaround for broken no-name USB audio devices 814 * sold by dealextreme called "3D sound". The problem is that the 815 * manufacturer computed wMaxPacketSize is too small to hold the 816 * actual data sent. In other words the device sometimes sends more 817 * data than it actually reports it can send in a single isochronous 818 * packet. 819 */ 820 static void 821 uaudio_record_fix_fs(usb_endpoint_descriptor_audio_t *ep, 822 uint32_t xps, uint32_t add) 823 { 824 uint32_t mps; 825 826 mps = UGETW(ep->wMaxPacketSize); 827 828 /* 829 * If the device indicates it can send more data than what the 830 * sample rate indicates, we apply the workaround. 831 */ 832 if (mps > xps) { 833 834 /* allow additional data */ 835 xps += add; 836 837 /* check against the maximum USB 1.x length */ 838 if (xps > 1023) 839 xps = 1023; 840 841 /* check if we should do an update */ 842 if (mps < xps) { 843 /* simply update the wMaxPacketSize field */ 844 USETW(ep->wMaxPacketSize, xps); 845 DPRINTF("Workaround: Updated wMaxPacketSize " 846 "from %d to %d bytes.\n", 847 (int)mps, (int)xps); 848 } 849 } 850 } 851 852 static void 853 uaudio_chan_fill_info_sub(struct uaudio_softc *sc, struct usb_device *udev, 854 uint32_t rate, uint8_t channels, uint8_t bit_resolution) 855 { 856 struct usb_descriptor *desc = NULL; 857 const struct usb_audio_streaming_interface_descriptor *asid = NULL; 858 const struct usb_audio_streaming_type1_descriptor *asf1d = NULL; 859 const struct usb_audio_streaming_endpoint_descriptor *sed = NULL; 860 usb_endpoint_descriptor_audio_t *ed1 = NULL; 861 const usb_endpoint_descriptor_audio_t *ed2 = NULL; 862 struct usb_config_descriptor *cd = usbd_get_config_descriptor(udev); 863 struct usb_interface_descriptor *id; 864 const struct uaudio_format *p_fmt; 865 struct uaudio_chan *chan; 866 uint16_t curidx = 0xFFFF; 867 uint16_t lastidx = 0xFFFF; 868 uint16_t alt_index = 0; 869 uint16_t wFormat; 870 uint8_t ep_dir; 871 uint8_t bChannels; 872 uint8_t bBitResolution; 873 uint8_t x; 874 uint8_t audio_if = 0; 875 uint8_t uma_if_class; 876 877 while ((desc = usb_desc_foreach(cd, desc))) { 878 879 if ((desc->bDescriptorType == UDESC_INTERFACE) && 880 (desc->bLength >= sizeof(*id))) { 881 882 id = (void *)desc; 883 884 if (id->bInterfaceNumber != lastidx) { 885 lastidx = id->bInterfaceNumber; 886 curidx++; 887 alt_index = 0; 888 889 } else { 890 alt_index++; 891 } 892 893 uma_if_class = 894 ((id->bInterfaceClass == UICLASS_AUDIO) || 895 ((id->bInterfaceClass == UICLASS_VENDOR) && 896 (sc->sc_uq_au_vendor_class != 0))); 897 898 if ((uma_if_class != 0) && (id->bInterfaceSubClass == UISUBCLASS_AUDIOSTREAM)) { 899 audio_if = 1; 900 } else { 901 audio_if = 0; 902 } 903 904 if ((uma_if_class != 0) && 905 (id->bInterfaceSubClass == UISUBCLASS_MIDISTREAM)) { 906 907 /* 908 * XXX could allow multiple MIDI interfaces 909 */ 910 911 if ((sc->sc_midi_chan.valid == 0) && 912 usbd_get_iface(udev, curidx)) { 913 sc->sc_midi_chan.iface_index = curidx; 914 sc->sc_midi_chan.iface_alt_index = alt_index; 915 sc->sc_midi_chan.valid = 1; 916 } 917 } 918 asid = NULL; 919 asf1d = NULL; 920 ed1 = NULL; 921 ed2 = NULL; 922 sed = NULL; 923 } 924 if ((desc->bDescriptorType == UDESC_CS_INTERFACE) && 925 (desc->bDescriptorSubtype == AS_GENERAL) && 926 (desc->bLength >= sizeof(*asid))) { 927 if (asid == NULL) { 928 asid = (void *)desc; 929 } 930 } 931 if ((desc->bDescriptorType == UDESC_CS_INTERFACE) && 932 (desc->bDescriptorSubtype == FORMAT_TYPE) && 933 (desc->bLength >= sizeof(*asf1d))) { 934 if (asf1d == NULL) { 935 asf1d = (void *)desc; 936 if (asf1d->bFormatType != FORMAT_TYPE_I) { 937 DPRINTFN(11, "ignored bFormatType = %d\n", 938 asf1d->bFormatType); 939 asf1d = NULL; 940 continue; 941 } 942 if (asf1d->bLength < (sizeof(*asf1d) + 943 ((asf1d->bSamFreqType == 0) ? 6 : 944 (asf1d->bSamFreqType * 3)))) { 945 DPRINTFN(11, "'asf1d' descriptor is too short\n"); 946 asf1d = NULL; 947 continue; 948 } 949 } 950 } 951 if ((desc->bDescriptorType == UDESC_ENDPOINT) && 952 (desc->bLength >= UEP_MINSIZE)) { 953 if (ed1 == NULL) { 954 ed1 = (void *)desc; 955 if (UE_GET_XFERTYPE(ed1->bmAttributes) != UE_ISOCHRONOUS) { 956 ed1 = NULL; 957 } 958 } 959 } 960 if ((desc->bDescriptorType == UDESC_CS_ENDPOINT) && 961 (desc->bDescriptorSubtype == AS_GENERAL) && 962 (desc->bLength >= sizeof(*sed))) { 963 if (sed == NULL) { 964 sed = (void *)desc; 965 } 966 } 967 if (audio_if && asid && asf1d && ed1 && sed) { 968 969 ep_dir = UE_GET_DIR(ed1->bEndpointAddress); 970 971 /* We ignore sync endpoint information until further. */ 972 973 wFormat = UGETW(asid->wFormatTag); 974 bChannels = UAUDIO_MAX_CHAN(asf1d->bNrChannels); 975 bBitResolution = asf1d->bBitResolution; 976 977 if (asf1d->bSamFreqType == 0) { 978 DPRINTFN(16, "Sample rate: %d-%dHz\n", 979 UA_SAMP_LO(asf1d), UA_SAMP_HI(asf1d)); 980 981 if ((rate >= UA_SAMP_LO(asf1d)) && 982 (rate <= UA_SAMP_HI(asf1d))) { 983 goto found_rate; 984 } 985 } else { 986 987 for (x = 0; x < asf1d->bSamFreqType; x++) { 988 DPRINTFN(16, "Sample rate = %dHz\n", 989 UA_GETSAMP(asf1d, x)); 990 991 if (rate == UA_GETSAMP(asf1d, x)) { 992 goto found_rate; 993 } 994 } 995 } 996 997 audio_if = 0; 998 continue; 999 1000 found_rate: 1001 1002 for (p_fmt = uaudio_formats; 1003 p_fmt->wFormat; 1004 p_fmt++) { 1005 if ((p_fmt->wFormat == wFormat) && 1006 (p_fmt->bPrecision == bBitResolution)) { 1007 goto found_format; 1008 } 1009 } 1010 1011 audio_if = 0; 1012 continue; 1013 1014 found_format: 1015 1016 if ((bChannels == channels) && 1017 (bBitResolution == bit_resolution)) { 1018 1019 chan = (ep_dir == UE_DIR_IN) ? 1020 &sc->sc_rec_chan : 1021 &sc->sc_play_chan; 1022 1023 if ((chan->valid == 0) && usbd_get_iface(udev, curidx)) { 1024 1025 chan->valid = 1; 1026 #ifdef USB_DEBUG 1027 uaudio_chan_dump_ep_desc(ed1); 1028 uaudio_chan_dump_ep_desc(ed2); 1029 1030 if (sed->bmAttributes & UA_SED_FREQ_CONTROL) { 1031 DPRINTFN(2, "FREQ_CONTROL\n"); 1032 } 1033 if (sed->bmAttributes & UA_SED_PITCH_CONTROL) { 1034 DPRINTFN(2, "PITCH_CONTROL\n"); 1035 } 1036 #endif 1037 DPRINTF("Sample rate = %dHz, channels = %d, " 1038 "bits = %d, format = %s\n", rate, channels, 1039 bit_resolution, p_fmt->description); 1040 1041 chan->sample_rate = rate; 1042 chan->p_asid = asid; 1043 chan->p_asf1d = asf1d; 1044 chan->p_ed1 = ed1; 1045 chan->p_ed2 = ed2; 1046 chan->p_fmt = p_fmt; 1047 chan->p_sed = sed; 1048 chan->iface_index = curidx; 1049 chan->iface_alt_index = alt_index; 1050 1051 if (ep_dir == UE_DIR_IN) 1052 chan->usb_cfg = 1053 uaudio_cfg_record; 1054 else 1055 chan->usb_cfg = 1056 uaudio_cfg_play; 1057 1058 chan->sample_size = (( 1059 UAUDIO_MAX_CHAN(chan->p_asf1d->bNrChannels) * 1060 chan->p_asf1d->bBitResolution) / 8); 1061 1062 if (ep_dir == UE_DIR_IN && 1063 usbd_get_speed(udev) == USB_SPEED_FULL) { 1064 uaudio_record_fix_fs(ed1, 1065 chan->sample_size * (rate / 1000), 1066 chan->sample_size * (rate / 4000)); 1067 } 1068 1069 if (sc->sc_sndstat_valid) { 1070 sbuf_printf(&sc->sc_sndstat, "\n\t" 1071 "mode %d.%d:(%s) %dch, %d/%dbit, %s, %dHz", 1072 curidx, alt_index, 1073 (ep_dir == UE_DIR_IN) ? "input" : "output", 1074 asf1d->bNrChannels, asf1d->bBitResolution, 1075 asf1d->bSubFrameSize * 8, 1076 p_fmt->description, rate); 1077 } 1078 } 1079 } 1080 audio_if = 0; 1081 continue; 1082 } 1083 } 1084 } 1085 1086 /* This structure defines all the supported rates. */ 1087 1088 static const uint32_t uaudio_rate_list[] = { 1089 96000, 1090 88000, 1091 80000, 1092 72000, 1093 64000, 1094 56000, 1095 48000, 1096 44100, 1097 40000, 1098 32000, 1099 24000, 1100 22050, 1101 16000, 1102 11025, 1103 8000, 1104 0 1105 }; 1106 1107 static void 1108 uaudio_chan_fill_info(struct uaudio_softc *sc, struct usb_device *udev) 1109 { 1110 uint32_t rate = uaudio_default_rate; 1111 uint8_t z; 1112 uint8_t bits = uaudio_default_bits; 1113 uint8_t y; 1114 uint8_t channels = uaudio_default_channels; 1115 uint8_t x; 1116 1117 bits -= (bits % 8); 1118 if ((bits == 0) || (bits > 32)) { 1119 /* set a valid value */ 1120 bits = 32; 1121 } 1122 if (channels == 0) { 1123 switch (usbd_get_speed(udev)) { 1124 case USB_SPEED_LOW: 1125 case USB_SPEED_FULL: 1126 /* 1127 * Due to high bandwidth usage and problems 1128 * with HIGH-speed split transactions we 1129 * disable surround setups on FULL-speed USB 1130 * by default 1131 */ 1132 channels = 2; 1133 break; 1134 default: 1135 channels = 16; 1136 break; 1137 } 1138 } else if (channels > 16) { 1139 channels = 16; 1140 } 1141 if (sbuf_new(&sc->sc_sndstat, NULL, 4096, SBUF_AUTOEXTEND)) { 1142 sc->sc_sndstat_valid = 1; 1143 } 1144 /* try to search for a valid config */ 1145 1146 for (x = channels; x; x--) { 1147 for (y = bits; y; y -= 8) { 1148 1149 /* try user defined rate, if any */ 1150 if (rate != 0) 1151 uaudio_chan_fill_info_sub(sc, udev, rate, x, y); 1152 1153 /* try find a matching rate, if any */ 1154 for (z = 0; uaudio_rate_list[z]; z++) { 1155 uaudio_chan_fill_info_sub(sc, udev, uaudio_rate_list[z], x, y); 1156 1157 if (sc->sc_rec_chan.valid && 1158 sc->sc_play_chan.valid) { 1159 goto done; 1160 } 1161 } 1162 } 1163 } 1164 1165 done: 1166 if (sc->sc_sndstat_valid) { 1167 sbuf_finish(&sc->sc_sndstat); 1168 } 1169 } 1170 1171 static void 1172 uaudio_chan_play_callback(struct usb_xfer *xfer, usb_error_t error) 1173 { 1174 struct uaudio_chan *ch = usbd_xfer_softc(xfer); 1175 struct usb_page_cache *pc; 1176 uint32_t total; 1177 uint32_t blockcount; 1178 uint32_t n; 1179 uint32_t offset; 1180 int actlen; 1181 int sumlen; 1182 1183 usbd_xfer_status(xfer, &actlen, &sumlen, NULL, NULL); 1184 1185 if (ch->end == ch->start) { 1186 DPRINTF("no buffer!\n"); 1187 return; 1188 } 1189 1190 switch (USB_GET_STATE(xfer)) { 1191 case USB_ST_TRANSFERRED: 1192 tr_transferred: 1193 if (actlen < sumlen) { 1194 DPRINTF("short transfer, " 1195 "%d of %d bytes\n", actlen, sumlen); 1196 } 1197 chn_intr(ch->pcm_ch); 1198 1199 case USB_ST_SETUP: 1200 if (ch->bytes_per_frame[1] > usbd_xfer_max_framelen(xfer)) { 1201 DPRINTF("bytes per transfer, %d, " 1202 "exceeds maximum, %d!\n", 1203 ch->bytes_per_frame[1], 1204 usbd_xfer_max_framelen(xfer)); 1205 break; 1206 } 1207 1208 blockcount = ch->intr_frames; 1209 1210 /* setup number of frames */ 1211 usbd_xfer_set_frames(xfer, blockcount); 1212 1213 /* reset total length */ 1214 total = 0; 1215 1216 /* setup frame lengths */ 1217 for (n = 0; n != blockcount; n++) { 1218 ch->sample_curr += ch->sample_rem; 1219 if (ch->sample_curr >= ch->frames_per_second) { 1220 ch->sample_curr -= ch->frames_per_second; 1221 usbd_xfer_set_frame_len(xfer, n, ch->bytes_per_frame[1]); 1222 total += ch->bytes_per_frame[1]; 1223 } else { 1224 usbd_xfer_set_frame_len(xfer, n, ch->bytes_per_frame[0]); 1225 total += ch->bytes_per_frame[0]; 1226 } 1227 } 1228 1229 DPRINTFN(6, "transfer %d bytes\n", total); 1230 1231 offset = 0; 1232 1233 pc = usbd_xfer_get_frame(xfer, 0); 1234 while (total > 0) { 1235 1236 n = (ch->end - ch->cur); 1237 if (n > total) { 1238 n = total; 1239 } 1240 usbd_copy_in(pc, offset, ch->cur, n); 1241 1242 total -= n; 1243 ch->cur += n; 1244 offset += n; 1245 1246 if (ch->cur >= ch->end) { 1247 ch->cur = ch->start; 1248 } 1249 } 1250 1251 usbd_transfer_submit(xfer); 1252 break; 1253 1254 default: /* Error */ 1255 if (error == USB_ERR_CANCELLED) { 1256 break; 1257 } 1258 goto tr_transferred; 1259 } 1260 } 1261 1262 static void 1263 uaudio_chan_record_callback(struct usb_xfer *xfer, usb_error_t error) 1264 { 1265 struct uaudio_chan *ch = usbd_xfer_softc(xfer); 1266 struct usb_page_cache *pc; 1267 uint32_t n; 1268 uint32_t m; 1269 uint32_t blockcount; 1270 uint32_t offset0; 1271 uint32_t offset1; 1272 uint32_t mfl; 1273 int len; 1274 int actlen; 1275 int nframes; 1276 1277 usbd_xfer_status(xfer, &actlen, NULL, NULL, &nframes); 1278 mfl = usbd_xfer_max_framelen(xfer); 1279 1280 if (ch->end == ch->start) { 1281 DPRINTF("no buffer!\n"); 1282 return; 1283 } 1284 1285 switch (USB_GET_STATE(xfer)) { 1286 case USB_ST_TRANSFERRED: 1287 1288 DPRINTFN(6, "transferred %d bytes\n", actlen); 1289 1290 offset0 = 0; 1291 pc = usbd_xfer_get_frame(xfer, 0); 1292 1293 for (n = 0; n != nframes; n++) { 1294 1295 offset1 = offset0; 1296 len = usbd_xfer_frame_len(xfer, n); 1297 1298 while (len > 0) { 1299 1300 m = (ch->end - ch->cur); 1301 1302 if (m > len) { 1303 m = len; 1304 } 1305 usbd_copy_out(pc, offset1, ch->cur, m); 1306 1307 len -= m; 1308 offset1 += m; 1309 ch->cur += m; 1310 1311 if (ch->cur >= ch->end) { 1312 ch->cur = ch->start; 1313 } 1314 } 1315 1316 offset0 += mfl; 1317 } 1318 1319 chn_intr(ch->pcm_ch); 1320 1321 case USB_ST_SETUP: 1322 tr_setup: 1323 blockcount = ch->intr_frames; 1324 1325 usbd_xfer_set_frames(xfer, blockcount); 1326 for (n = 0; n < blockcount; n++) { 1327 usbd_xfer_set_frame_len(xfer, n, mfl); 1328 } 1329 1330 usbd_transfer_submit(xfer); 1331 break; 1332 1333 default: /* Error */ 1334 if (error == USB_ERR_CANCELLED) { 1335 break; 1336 } 1337 goto tr_setup; 1338 } 1339 } 1340 1341 void * 1342 uaudio_chan_init(struct uaudio_softc *sc, struct snd_dbuf *b, 1343 struct pcm_channel *c, int dir) 1344 { 1345 struct uaudio_chan *ch = ((dir == PCMDIR_PLAY) ? 1346 &sc->sc_play_chan : &sc->sc_rec_chan); 1347 uint32_t buf_size; 1348 uint32_t frames; 1349 uint32_t format; 1350 uint16_t fps; 1351 uint8_t endpoint; 1352 uint8_t blocks; 1353 uint8_t iface_index; 1354 uint8_t alt_index; 1355 uint8_t fps_shift; 1356 usb_error_t err; 1357 1358 fps = usbd_get_isoc_fps(sc->sc_udev); 1359 1360 if (fps < 8000) { 1361 /* FULL speed USB */ 1362 frames = 8; 1363 } else { 1364 /* HIGH speed USB */ 1365 frames = UAUDIO_NFRAMES; 1366 } 1367 1368 /* setup play/record format */ 1369 1370 ch->pcm_cap.fmtlist = ch->pcm_format; 1371 1372 ch->pcm_format[0] = 0; 1373 ch->pcm_format[1] = 0; 1374 1375 ch->pcm_cap.minspeed = ch->sample_rate; 1376 ch->pcm_cap.maxspeed = ch->sample_rate; 1377 1378 /* setup mutex and PCM channel */ 1379 1380 ch->pcm_ch = c; 1381 ch->pcm_mtx = c->lock; 1382 1383 format = ch->p_fmt->freebsd_fmt; 1384 1385 switch (ch->p_asf1d->bNrChannels) { 1386 case 2: 1387 /* stereo */ 1388 format = SND_FORMAT(format, 2, 0); 1389 break; 1390 case 1: 1391 /* mono */ 1392 format = SND_FORMAT(format, 1, 0); 1393 break; 1394 default: 1395 /* surround and more */ 1396 format = feeder_matrix_default_format( 1397 SND_FORMAT(format, ch->p_asf1d->bNrChannels, 0)); 1398 break; 1399 } 1400 1401 ch->pcm_cap.fmtlist[0] = format; 1402 ch->pcm_cap.fmtlist[1] = 0; 1403 1404 /* check if format is not supported */ 1405 1406 if (format == 0) { 1407 DPRINTF("The selected audio format is not supported\n"); 1408 goto error; 1409 } 1410 1411 /* set alternate interface corresponding to the mode */ 1412 1413 endpoint = ch->p_ed1->bEndpointAddress; 1414 iface_index = ch->iface_index; 1415 alt_index = ch->iface_alt_index; 1416 1417 DPRINTF("endpoint=0x%02x, speed=%d, iface=%d alt=%d\n", 1418 endpoint, ch->sample_rate, iface_index, alt_index); 1419 1420 err = usbd_set_alt_interface_index(sc->sc_udev, iface_index, alt_index); 1421 if (err) { 1422 DPRINTF("setting of alternate index failed: %s!\n", 1423 usbd_errstr(err)); 1424 goto error; 1425 } 1426 usbd_set_parent_iface(sc->sc_udev, iface_index, 1427 sc->sc_mixer_iface_index); 1428 1429 /* 1430 * Only set the sample rate if the channel reports that it 1431 * supports the frequency control. 1432 */ 1433 if (ch->p_sed->bmAttributes & UA_SED_FREQ_CONTROL) { 1434 if (uaudio_set_speed(sc->sc_udev, endpoint, ch->sample_rate)) { 1435 /* 1436 * If the endpoint is adaptive setting the speed may 1437 * fail. 1438 */ 1439 DPRINTF("setting of sample rate failed! (continuing anyway)\n"); 1440 } 1441 } 1442 if (usbd_transfer_setup(sc->sc_udev, &iface_index, ch->xfer, 1443 ch->usb_cfg, UAUDIO_NCHANBUFS, ch, ch->pcm_mtx)) { 1444 DPRINTF("could not allocate USB transfers!\n"); 1445 goto error; 1446 } 1447 1448 fps_shift = usbd_xfer_get_fps_shift(ch->xfer[0]); 1449 1450 /* down shift number of frames per second, if any */ 1451 fps >>= fps_shift; 1452 frames >>= fps_shift; 1453 1454 /* bytes per frame should not be zero */ 1455 ch->bytes_per_frame[0] = ((ch->sample_rate / fps) * ch->sample_size); 1456 ch->bytes_per_frame[1] = (((ch->sample_rate + fps - 1) / fps) * ch->sample_size); 1457 1458 /* setup data rate dithering, if any */ 1459 ch->frames_per_second = fps; 1460 ch->sample_rem = ch->sample_rate % fps; 1461 ch->sample_curr = 0; 1462 ch->frames_per_second = fps; 1463 1464 /* compute required buffer size */ 1465 buf_size = (ch->bytes_per_frame[1] * frames); 1466 1467 ch->intr_size = buf_size; 1468 ch->intr_frames = frames; 1469 1470 DPRINTF("fps=%d sample_rem=%d\n", fps, ch->sample_rem); 1471 1472 if (ch->intr_frames == 0) { 1473 DPRINTF("frame shift is too high!\n"); 1474 goto error; 1475 } 1476 1477 /* setup double buffering */ 1478 buf_size *= 2; 1479 blocks = 2; 1480 1481 ch->buf = malloc(buf_size, M_DEVBUF, M_WAITOK | M_ZERO); 1482 if (ch->buf == NULL) 1483 goto error; 1484 if (sndbuf_setup(b, ch->buf, buf_size) != 0) 1485 goto error; 1486 if (sndbuf_resize(b, blocks, ch->intr_size)) 1487 goto error; 1488 1489 ch->start = ch->buf; 1490 ch->end = ch->buf + buf_size; 1491 ch->cur = ch->buf; 1492 ch->pcm_buf = b; 1493 1494 if (ch->pcm_mtx == NULL) { 1495 DPRINTF("ERROR: PCM channels does not have a mutex!\n"); 1496 goto error; 1497 } 1498 1499 return (ch); 1500 1501 error: 1502 uaudio_chan_free(ch); 1503 return (NULL); 1504 } 1505 1506 int 1507 uaudio_chan_free(struct uaudio_chan *ch) 1508 { 1509 if (ch->buf != NULL) { 1510 free(ch->buf, M_DEVBUF); 1511 ch->buf = NULL; 1512 } 1513 usbd_transfer_unsetup(ch->xfer, UAUDIO_NCHANBUFS); 1514 1515 ch->valid = 0; 1516 1517 return (0); 1518 } 1519 1520 int 1521 uaudio_chan_set_param_blocksize(struct uaudio_chan *ch, uint32_t blocksize) 1522 { 1523 return (ch->intr_size); 1524 } 1525 1526 int 1527 uaudio_chan_set_param_fragments(struct uaudio_chan *ch, uint32_t blocksize, 1528 uint32_t blockcount) 1529 { 1530 return (1); 1531 } 1532 1533 int 1534 uaudio_chan_set_param_speed(struct uaudio_chan *ch, uint32_t speed) 1535 { 1536 if (speed != ch->sample_rate) { 1537 DPRINTF("rate conversion required\n"); 1538 } 1539 return (ch->sample_rate); 1540 } 1541 1542 int 1543 uaudio_chan_getptr(struct uaudio_chan *ch) 1544 { 1545 return (ch->cur - ch->start); 1546 } 1547 1548 struct pcmchan_caps * 1549 uaudio_chan_getcaps(struct uaudio_chan *ch) 1550 { 1551 return (&ch->pcm_cap); 1552 } 1553 1554 static struct pcmchan_matrix uaudio_chan_matrix_swap_2_0 = { 1555 .id = SND_CHN_MATRIX_DRV, 1556 .channels = 2, 1557 .ext = 0, 1558 .map = { 1559 /* Right */ 1560 [0] = { 1561 .type = SND_CHN_T_FR, 1562 .members = 1563 SND_CHN_T_MASK_FR | SND_CHN_T_MASK_FC | 1564 SND_CHN_T_MASK_LF | SND_CHN_T_MASK_BR | 1565 SND_CHN_T_MASK_BC | SND_CHN_T_MASK_SR 1566 }, 1567 /* Left */ 1568 [1] = { 1569 .type = SND_CHN_T_FL, 1570 .members = 1571 SND_CHN_T_MASK_FL | SND_CHN_T_MASK_FC | 1572 SND_CHN_T_MASK_LF | SND_CHN_T_MASK_BL | 1573 SND_CHN_T_MASK_BC | SND_CHN_T_MASK_SL 1574 }, 1575 [2] = { 1576 .type = SND_CHN_T_MAX, 1577 .members = 0 1578 } 1579 }, 1580 .mask = SND_CHN_T_MASK_FR | SND_CHN_T_MASK_FL, 1581 .offset = { 1, 0, -1, -1, -1, -1, -1, -1, -1, 1582 -1, -1, -1, -1, -1, -1, -1, -1, -1 } 1583 }; 1584 1585 struct pcmchan_matrix * 1586 uaudio_chan_getmatrix(struct uaudio_chan *ch, uint32_t format) 1587 { 1588 struct uaudio_softc *sc; 1589 1590 sc = ch->priv_sc; 1591 1592 if (sc != NULL && sc->sc_uq_audio_swap_lr != 0 && 1593 AFMT_CHANNEL(format) == 2) 1594 return (&uaudio_chan_matrix_swap_2_0); 1595 1596 return (feeder_matrix_format_map(format)); 1597 } 1598 1599 int 1600 uaudio_chan_set_param_format(struct uaudio_chan *ch, uint32_t format) 1601 { 1602 ch->format = format; 1603 return (0); 1604 } 1605 1606 int 1607 uaudio_chan_start(struct uaudio_chan *ch) 1608 { 1609 ch->cur = ch->start; 1610 1611 #if (UAUDIO_NCHANBUFS != 2) 1612 #error "please update code" 1613 #endif 1614 if (ch->xfer[0]) { 1615 usbd_transfer_start(ch->xfer[0]); 1616 } 1617 if (ch->xfer[1]) { 1618 usbd_transfer_start(ch->xfer[1]); 1619 } 1620 return (0); 1621 } 1622 1623 int 1624 uaudio_chan_stop(struct uaudio_chan *ch) 1625 { 1626 #if (UAUDIO_NCHANBUFS != 2) 1627 #error "please update code" 1628 #endif 1629 usbd_transfer_stop(ch->xfer[0]); 1630 usbd_transfer_stop(ch->xfer[1]); 1631 return (0); 1632 } 1633 1634 /*========================================================================* 1635 * AC - Audio Controller - routines 1636 *========================================================================*/ 1637 1638 static void 1639 uaudio_mixer_add_ctl_sub(struct uaudio_softc *sc, struct uaudio_mixer_node *mc) 1640 { 1641 struct uaudio_mixer_node *p_mc_new = 1642 malloc(sizeof(*p_mc_new), M_USBDEV, M_WAITOK); 1643 1644 if (p_mc_new != NULL) { 1645 memcpy(p_mc_new, mc, sizeof(*p_mc_new)); 1646 p_mc_new->next = sc->sc_mixer_root; 1647 sc->sc_mixer_root = p_mc_new; 1648 sc->sc_mixer_count++; 1649 } else { 1650 DPRINTF("out of memory\n"); 1651 } 1652 } 1653 1654 static void 1655 uaudio_mixer_add_ctl(struct uaudio_softc *sc, struct uaudio_mixer_node *mc) 1656 { 1657 int32_t res; 1658 1659 if (mc->class < UAC_NCLASSES) { 1660 DPRINTF("adding %s.%d\n", 1661 uac_names[mc->class], mc->ctl); 1662 } else { 1663 DPRINTF("adding %d\n", mc->ctl); 1664 } 1665 1666 if (mc->type == MIX_ON_OFF) { 1667 mc->minval = 0; 1668 mc->maxval = 1; 1669 } else if (mc->type == MIX_SELECTOR) { 1670 } else { 1671 1672 /* determine min and max values */ 1673 1674 mc->minval = uaudio_mixer_get(sc->sc_udev, GET_MIN, mc); 1675 1676 mc->minval = uaudio_mixer_signext(mc->type, mc->minval); 1677 1678 mc->maxval = uaudio_mixer_get(sc->sc_udev, GET_MAX, mc); 1679 1680 mc->maxval = uaudio_mixer_signext(mc->type, mc->maxval); 1681 1682 /* check if max and min was swapped */ 1683 1684 if (mc->maxval < mc->minval) { 1685 res = mc->maxval; 1686 mc->maxval = mc->minval; 1687 mc->minval = res; 1688 } 1689 1690 /* compute value range */ 1691 mc->mul = mc->maxval - mc->minval; 1692 if (mc->mul == 0) 1693 mc->mul = 1; 1694 1695 /* compute value alignment */ 1696 res = uaudio_mixer_get(sc->sc_udev, GET_RES, mc); 1697 1698 DPRINTF("Resolution = %d\n", (int)res); 1699 } 1700 1701 uaudio_mixer_add_ctl_sub(sc, mc); 1702 1703 #ifdef USB_DEBUG 1704 if (uaudio_debug > 2) { 1705 uint8_t i; 1706 1707 for (i = 0; i < mc->nchan; i++) { 1708 DPRINTF("[mix] wValue=%04x\n", mc->wValue[0]); 1709 } 1710 DPRINTF("[mix] wIndex=%04x type=%d ctl='%d' " 1711 "min=%d max=%d\n", 1712 mc->wIndex, mc->type, mc->ctl, 1713 mc->minval, mc->maxval); 1714 } 1715 #endif 1716 } 1717 1718 static void 1719 uaudio_mixer_add_input(struct uaudio_softc *sc, 1720 const struct uaudio_terminal_node *iot, int id) 1721 { 1722 #ifdef USB_DEBUG 1723 const struct usb_audio_input_terminal *d = iot[id].u.it; 1724 1725 DPRINTFN(3, "bTerminalId=%d wTerminalType=0x%04x " 1726 "bAssocTerminal=%d bNrChannels=%d wChannelConfig=%d " 1727 "iChannelNames=%d\n", 1728 d->bTerminalId, UGETW(d->wTerminalType), d->bAssocTerminal, 1729 d->bNrChannels, UGETW(d->wChannelConfig), 1730 d->iChannelNames); 1731 #endif 1732 } 1733 1734 static void 1735 uaudio_mixer_add_output(struct uaudio_softc *sc, 1736 const struct uaudio_terminal_node *iot, int id) 1737 { 1738 #ifdef USB_DEBUG 1739 const struct usb_audio_output_terminal *d = iot[id].u.ot; 1740 1741 DPRINTFN(3, "bTerminalId=%d wTerminalType=0x%04x " 1742 "bAssocTerminal=%d bSourceId=%d iTerminal=%d\n", 1743 d->bTerminalId, UGETW(d->wTerminalType), d->bAssocTerminal, 1744 d->bSourceId, d->iTerminal); 1745 #endif 1746 } 1747 1748 static void 1749 uaudio_mixer_add_mixer(struct uaudio_softc *sc, 1750 const struct uaudio_terminal_node *iot, int id) 1751 { 1752 struct uaudio_mixer_node mix; 1753 1754 const struct usb_audio_mixer_unit_0 *d0 = iot[id].u.mu; 1755 const struct usb_audio_mixer_unit_1 *d1; 1756 1757 uint32_t bno; /* bit number */ 1758 uint32_t p; /* bit number accumulator */ 1759 uint32_t mo; /* matching outputs */ 1760 uint32_t mc; /* matching channels */ 1761 uint32_t ichs; /* input channels */ 1762 uint32_t ochs; /* output channels */ 1763 uint32_t c; 1764 uint32_t chs; /* channels */ 1765 uint32_t i; 1766 uint32_t o; 1767 1768 DPRINTFN(3, "bUnitId=%d bNrInPins=%d\n", 1769 d0->bUnitId, d0->bNrInPins); 1770 1771 /* compute the number of input channels */ 1772 1773 ichs = 0; 1774 for (i = 0; i < d0->bNrInPins; i++) { 1775 ichs += (uaudio_mixer_get_cluster(d0->baSourceId[i], iot) 1776 .bNrChannels); 1777 } 1778 1779 d1 = (const void *)(d0->baSourceId + d0->bNrInPins); 1780 1781 /* and the number of output channels */ 1782 1783 ochs = d1->bNrChannels; 1784 1785 DPRINTFN(3, "ichs=%d ochs=%d\n", ichs, ochs); 1786 1787 memset(&mix, 0, sizeof(mix)); 1788 1789 mix.wIndex = MAKE_WORD(d0->bUnitId, sc->sc_mixer_iface_no); 1790 uaudio_mixer_determine_class(&iot[id], &mix); 1791 mix.type = MIX_SIGNED_16; 1792 1793 if (uaudio_mixer_verify_desc(d0, ((ichs * ochs) + 7) / 8) == NULL) { 1794 return; 1795 } 1796 for (p = i = 0; i < d0->bNrInPins; i++) { 1797 chs = uaudio_mixer_get_cluster(d0->baSourceId[i], iot).bNrChannels; 1798 mc = 0; 1799 for (c = 0; c < chs; c++) { 1800 mo = 0; 1801 for (o = 0; o < ochs; o++) { 1802 bno = ((p + c) * ochs) + o; 1803 if (BIT_TEST(d1->bmControls, bno)) { 1804 mo++; 1805 } 1806 } 1807 if (mo == 1) { 1808 mc++; 1809 } 1810 } 1811 if ((mc == chs) && (chs <= MIX_MAX_CHAN)) { 1812 1813 /* repeat bit-scan */ 1814 1815 mc = 0; 1816 for (c = 0; c < chs; c++) { 1817 for (o = 0; o < ochs; o++) { 1818 bno = ((p + c) * ochs) + o; 1819 if (BIT_TEST(d1->bmControls, bno)) { 1820 mix.wValue[mc++] = MAKE_WORD(p + c + 1, o + 1); 1821 } 1822 } 1823 } 1824 mix.nchan = chs; 1825 uaudio_mixer_add_ctl(sc, &mix); 1826 } else { 1827 /* XXX */ 1828 } 1829 p += chs; 1830 } 1831 } 1832 1833 static void 1834 uaudio_mixer_add_selector(struct uaudio_softc *sc, 1835 const struct uaudio_terminal_node *iot, int id) 1836 { 1837 const struct usb_audio_selector_unit *d = iot[id].u.su; 1838 struct uaudio_mixer_node mix; 1839 uint16_t i; 1840 1841 DPRINTFN(3, "bUnitId=%d bNrInPins=%d\n", 1842 d->bUnitId, d->bNrInPins); 1843 1844 if (d->bNrInPins == 0) { 1845 return; 1846 } 1847 memset(&mix, 0, sizeof(mix)); 1848 1849 mix.wIndex = MAKE_WORD(d->bUnitId, sc->sc_mixer_iface_no); 1850 mix.wValue[0] = MAKE_WORD(0, 0); 1851 uaudio_mixer_determine_class(&iot[id], &mix); 1852 mix.nchan = 1; 1853 mix.type = MIX_SELECTOR; 1854 1855 mix.ctl = SOUND_MIXER_NRDEVICES; 1856 mix.minval = 1; 1857 mix.maxval = d->bNrInPins; 1858 1859 if (mix.maxval > MAX_SELECTOR_INPUT_PIN) { 1860 mix.maxval = MAX_SELECTOR_INPUT_PIN; 1861 } 1862 mix.mul = (mix.maxval - mix.minval); 1863 for (i = 0; i < MAX_SELECTOR_INPUT_PIN; i++) { 1864 mix.slctrtype[i] = SOUND_MIXER_NRDEVICES; 1865 } 1866 1867 for (i = 0; i < mix.maxval; i++) { 1868 mix.slctrtype[i] = uaudio_mixer_feature_name 1869 (&iot[d->baSourceId[i]], &mix); 1870 } 1871 1872 mix.class = 0; /* not used */ 1873 1874 uaudio_mixer_add_ctl(sc, &mix); 1875 } 1876 1877 static uint32_t 1878 uaudio_mixer_feature_get_bmaControls(const struct usb_audio_feature_unit *d, 1879 uint8_t index) 1880 { 1881 uint32_t temp = 0; 1882 uint32_t offset = (index * d->bControlSize); 1883 1884 if (d->bControlSize > 0) { 1885 temp |= d->bmaControls[offset]; 1886 if (d->bControlSize > 1) { 1887 temp |= d->bmaControls[offset + 1] << 8; 1888 if (d->bControlSize > 2) { 1889 temp |= d->bmaControls[offset + 2] << 16; 1890 if (d->bControlSize > 3) { 1891 temp |= d->bmaControls[offset + 3] << 24; 1892 } 1893 } 1894 } 1895 } 1896 return (temp); 1897 } 1898 1899 static void 1900 uaudio_mixer_add_feature(struct uaudio_softc *sc, 1901 const struct uaudio_terminal_node *iot, int id) 1902 { 1903 const struct usb_audio_feature_unit *d = iot[id].u.fu; 1904 struct uaudio_mixer_node mix; 1905 uint32_t fumask; 1906 uint32_t mmask; 1907 uint32_t cmask; 1908 uint16_t mixernumber; 1909 uint8_t nchan; 1910 uint8_t chan; 1911 uint8_t ctl; 1912 uint8_t i; 1913 1914 if (d->bControlSize == 0) { 1915 return; 1916 } 1917 memset(&mix, 0, sizeof(mix)); 1918 1919 nchan = (d->bLength - 7) / d->bControlSize; 1920 mmask = uaudio_mixer_feature_get_bmaControls(d, 0); 1921 cmask = 0; 1922 1923 if (nchan == 0) { 1924 return; 1925 } 1926 /* figure out what we can control */ 1927 1928 for (chan = 1; chan < nchan; chan++) { 1929 DPRINTFN(10, "chan=%d mask=%x\n", 1930 chan, uaudio_mixer_feature_get_bmaControls(d, chan)); 1931 1932 cmask |= uaudio_mixer_feature_get_bmaControls(d, chan); 1933 } 1934 1935 if (nchan > MIX_MAX_CHAN) { 1936 nchan = MIX_MAX_CHAN; 1937 } 1938 mix.wIndex = MAKE_WORD(d->bUnitId, sc->sc_mixer_iface_no); 1939 1940 for (ctl = 1; ctl <= LOUDNESS_CONTROL; ctl++) { 1941 1942 fumask = FU_MASK(ctl); 1943 1944 DPRINTFN(5, "ctl=%d fumask=0x%04x\n", 1945 ctl, fumask); 1946 1947 if (mmask & fumask) { 1948 mix.nchan = 1; 1949 mix.wValue[0] = MAKE_WORD(ctl, 0); 1950 } else if (cmask & fumask) { 1951 mix.nchan = nchan - 1; 1952 for (i = 1; i < nchan; i++) { 1953 if (uaudio_mixer_feature_get_bmaControls(d, i) & fumask) 1954 mix.wValue[i - 1] = MAKE_WORD(ctl, i); 1955 else 1956 mix.wValue[i - 1] = -1; 1957 } 1958 } else { 1959 continue; 1960 } 1961 1962 mixernumber = uaudio_mixer_feature_name(&iot[id], &mix); 1963 1964 switch (ctl) { 1965 case MUTE_CONTROL: 1966 mix.type = MIX_ON_OFF; 1967 mix.ctl = SOUND_MIXER_NRDEVICES; 1968 break; 1969 1970 case VOLUME_CONTROL: 1971 mix.type = MIX_SIGNED_16; 1972 mix.ctl = mixernumber; 1973 break; 1974 1975 case BASS_CONTROL: 1976 mix.type = MIX_SIGNED_8; 1977 mix.ctl = SOUND_MIXER_BASS; 1978 break; 1979 1980 case MID_CONTROL: 1981 mix.type = MIX_SIGNED_8; 1982 mix.ctl = SOUND_MIXER_NRDEVICES; /* XXXXX */ 1983 break; 1984 1985 case TREBLE_CONTROL: 1986 mix.type = MIX_SIGNED_8; 1987 mix.ctl = SOUND_MIXER_TREBLE; 1988 break; 1989 1990 case GRAPHIC_EQUALIZER_CONTROL: 1991 continue; /* XXX don't add anything */ 1992 break; 1993 1994 case AGC_CONTROL: 1995 mix.type = MIX_ON_OFF; 1996 mix.ctl = SOUND_MIXER_NRDEVICES; /* XXXXX */ 1997 break; 1998 1999 case DELAY_CONTROL: 2000 mix.type = MIX_UNSIGNED_16; 2001 mix.ctl = SOUND_MIXER_NRDEVICES; /* XXXXX */ 2002 break; 2003 2004 case BASS_BOOST_CONTROL: 2005 mix.type = MIX_ON_OFF; 2006 mix.ctl = SOUND_MIXER_NRDEVICES; /* XXXXX */ 2007 break; 2008 2009 case LOUDNESS_CONTROL: 2010 mix.type = MIX_ON_OFF; 2011 mix.ctl = SOUND_MIXER_LOUD; /* Is this correct ? */ 2012 break; 2013 2014 default: 2015 mix.type = MIX_UNKNOWN; 2016 break; 2017 } 2018 2019 if (mix.type != MIX_UNKNOWN) { 2020 uaudio_mixer_add_ctl(sc, &mix); 2021 } 2022 } 2023 } 2024 2025 static void 2026 uaudio_mixer_add_processing_updown(struct uaudio_softc *sc, 2027 const struct uaudio_terminal_node *iot, int id) 2028 { 2029 const struct usb_audio_processing_unit_0 *d0 = iot[id].u.pu; 2030 const struct usb_audio_processing_unit_1 *d1 = 2031 (const void *)(d0->baSourceId + d0->bNrInPins); 2032 const struct usb_audio_processing_unit_updown *ud = 2033 (const void *)(d1->bmControls + d1->bControlSize); 2034 struct uaudio_mixer_node mix; 2035 uint8_t i; 2036 2037 if (uaudio_mixer_verify_desc(d0, sizeof(*ud)) == NULL) { 2038 return; 2039 } 2040 if (uaudio_mixer_verify_desc(d0, sizeof(*ud) + (2 * ud->bNrModes)) 2041 == NULL) { 2042 return; 2043 } 2044 DPRINTFN(3, "bUnitId=%d bNrModes=%d\n", 2045 d0->bUnitId, ud->bNrModes); 2046 2047 if (!(d1->bmControls[0] & UA_PROC_MASK(UD_MODE_SELECT_CONTROL))) { 2048 DPRINTF("no mode select\n"); 2049 return; 2050 } 2051 memset(&mix, 0, sizeof(mix)); 2052 2053 mix.wIndex = MAKE_WORD(d0->bUnitId, sc->sc_mixer_iface_no); 2054 mix.nchan = 1; 2055 mix.wValue[0] = MAKE_WORD(UD_MODE_SELECT_CONTROL, 0); 2056 uaudio_mixer_determine_class(&iot[id], &mix); 2057 mix.type = MIX_ON_OFF; /* XXX */ 2058 2059 for (i = 0; i < ud->bNrModes; i++) { 2060 DPRINTFN(3, "i=%d bm=0x%x\n", i, UGETW(ud->waModes[i])); 2061 /* XXX */ 2062 } 2063 2064 uaudio_mixer_add_ctl(sc, &mix); 2065 } 2066 2067 static void 2068 uaudio_mixer_add_processing(struct uaudio_softc *sc, 2069 const struct uaudio_terminal_node *iot, int id) 2070 { 2071 const struct usb_audio_processing_unit_0 *d0 = iot[id].u.pu; 2072 const struct usb_audio_processing_unit_1 *d1 = 2073 (const void *)(d0->baSourceId + d0->bNrInPins); 2074 struct uaudio_mixer_node mix; 2075 uint16_t ptype; 2076 2077 memset(&mix, 0, sizeof(mix)); 2078 2079 ptype = UGETW(d0->wProcessType); 2080 2081 DPRINTFN(3, "wProcessType=%d bUnitId=%d " 2082 "bNrInPins=%d\n", ptype, d0->bUnitId, d0->bNrInPins); 2083 2084 if (d1->bControlSize == 0) { 2085 return; 2086 } 2087 if (d1->bmControls[0] & UA_PROC_ENABLE_MASK) { 2088 mix.wIndex = MAKE_WORD(d0->bUnitId, sc->sc_mixer_iface_no); 2089 mix.nchan = 1; 2090 mix.wValue[0] = MAKE_WORD(XX_ENABLE_CONTROL, 0); 2091 uaudio_mixer_determine_class(&iot[id], &mix); 2092 mix.type = MIX_ON_OFF; 2093 uaudio_mixer_add_ctl(sc, &mix); 2094 } 2095 switch (ptype) { 2096 case UPDOWNMIX_PROCESS: 2097 uaudio_mixer_add_processing_updown(sc, iot, id); 2098 break; 2099 2100 case DOLBY_PROLOGIC_PROCESS: 2101 case P3D_STEREO_EXTENDER_PROCESS: 2102 case REVERBATION_PROCESS: 2103 case CHORUS_PROCESS: 2104 case DYN_RANGE_COMP_PROCESS: 2105 default: 2106 DPRINTF("unit %d, type=%d is not implemented\n", 2107 d0->bUnitId, ptype); 2108 break; 2109 } 2110 } 2111 2112 static void 2113 uaudio_mixer_add_extension(struct uaudio_softc *sc, 2114 const struct uaudio_terminal_node *iot, int id) 2115 { 2116 const struct usb_audio_extension_unit_0 *d0 = iot[id].u.eu; 2117 const struct usb_audio_extension_unit_1 *d1 = 2118 (const void *)(d0->baSourceId + d0->bNrInPins); 2119 struct uaudio_mixer_node mix; 2120 2121 DPRINTFN(3, "bUnitId=%d bNrInPins=%d\n", 2122 d0->bUnitId, d0->bNrInPins); 2123 2124 if (sc->sc_uq_au_no_xu) { 2125 return; 2126 } 2127 if (d1->bControlSize == 0) { 2128 return; 2129 } 2130 if (d1->bmControls[0] & UA_EXT_ENABLE_MASK) { 2131 2132 memset(&mix, 0, sizeof(mix)); 2133 2134 mix.wIndex = MAKE_WORD(d0->bUnitId, sc->sc_mixer_iface_no); 2135 mix.nchan = 1; 2136 mix.wValue[0] = MAKE_WORD(UA_EXT_ENABLE, 0); 2137 uaudio_mixer_determine_class(&iot[id], &mix); 2138 mix.type = MIX_ON_OFF; 2139 2140 uaudio_mixer_add_ctl(sc, &mix); 2141 } 2142 } 2143 2144 static const void * 2145 uaudio_mixer_verify_desc(const void *arg, uint32_t len) 2146 { 2147 const struct usb_audio_mixer_unit_1 *d1; 2148 const struct usb_audio_extension_unit_1 *e1; 2149 const struct usb_audio_processing_unit_1 *u1; 2150 2151 union { 2152 const struct usb_descriptor *desc; 2153 const struct usb_audio_input_terminal *it; 2154 const struct usb_audio_output_terminal *ot; 2155 const struct usb_audio_mixer_unit_0 *mu; 2156 const struct usb_audio_selector_unit *su; 2157 const struct usb_audio_feature_unit *fu; 2158 const struct usb_audio_processing_unit_0 *pu; 2159 const struct usb_audio_extension_unit_0 *eu; 2160 } u; 2161 2162 u.desc = arg; 2163 2164 if (u.desc == NULL) { 2165 goto error; 2166 } 2167 if (u.desc->bDescriptorType != UDESC_CS_INTERFACE) { 2168 goto error; 2169 } 2170 switch (u.desc->bDescriptorSubtype) { 2171 case UDESCSUB_AC_INPUT: 2172 len += sizeof(*u.it); 2173 break; 2174 2175 case UDESCSUB_AC_OUTPUT: 2176 len += sizeof(*u.ot); 2177 break; 2178 2179 case UDESCSUB_AC_MIXER: 2180 len += sizeof(*u.mu); 2181 2182 if (u.desc->bLength < len) { 2183 goto error; 2184 } 2185 len += u.mu->bNrInPins; 2186 2187 if (u.desc->bLength < len) { 2188 goto error; 2189 } 2190 d1 = (const void *)(u.mu->baSourceId + u.mu->bNrInPins); 2191 2192 len += sizeof(*d1); 2193 break; 2194 2195 case UDESCSUB_AC_SELECTOR: 2196 len += sizeof(*u.su); 2197 2198 if (u.desc->bLength < len) { 2199 goto error; 2200 } 2201 len += u.su->bNrInPins; 2202 break; 2203 2204 case UDESCSUB_AC_FEATURE: 2205 len += (sizeof(*u.fu) + 1); 2206 break; 2207 2208 case UDESCSUB_AC_PROCESSING: 2209 len += sizeof(*u.pu); 2210 2211 if (u.desc->bLength < len) { 2212 goto error; 2213 } 2214 len += u.pu->bNrInPins; 2215 2216 if (u.desc->bLength < len) { 2217 goto error; 2218 } 2219 u1 = (const void *)(u.pu->baSourceId + u.pu->bNrInPins); 2220 2221 len += sizeof(*u1); 2222 2223 if (u.desc->bLength < len) { 2224 goto error; 2225 } 2226 len += u1->bControlSize; 2227 2228 break; 2229 2230 case UDESCSUB_AC_EXTENSION: 2231 len += sizeof(*u.eu); 2232 2233 if (u.desc->bLength < len) { 2234 goto error; 2235 } 2236 len += u.eu->bNrInPins; 2237 2238 if (u.desc->bLength < len) { 2239 goto error; 2240 } 2241 e1 = (const void *)(u.eu->baSourceId + u.eu->bNrInPins); 2242 2243 len += sizeof(*e1); 2244 2245 if (u.desc->bLength < len) { 2246 goto error; 2247 } 2248 len += e1->bControlSize; 2249 break; 2250 2251 default: 2252 goto error; 2253 } 2254 2255 if (u.desc->bLength < len) { 2256 goto error; 2257 } 2258 return (u.desc); 2259 2260 error: 2261 if (u.desc) { 2262 DPRINTF("invalid descriptor, type=%d, " 2263 "sub_type=%d, len=%d of %d bytes\n", 2264 u.desc->bDescriptorType, 2265 u.desc->bDescriptorSubtype, 2266 u.desc->bLength, len); 2267 } 2268 return (NULL); 2269 } 2270 2271 #ifdef USB_DEBUG 2272 static void 2273 uaudio_mixer_dump_cluster(uint8_t id, const struct uaudio_terminal_node *iot) 2274 { 2275 static const char *channel_names[16] = { 2276 "LEFT", "RIGHT", "CENTER", "LFE", 2277 "LEFT_SURROUND", "RIGHT_SURROUND", "LEFT_CENTER", "RIGHT_CENTER", 2278 "SURROUND", "LEFT_SIDE", "RIGHT_SIDE", "TOP", 2279 "RESERVED12", "RESERVED13", "RESERVED14", "RESERVED15", 2280 }; 2281 uint16_t cc; 2282 uint8_t i; 2283 const struct usb_audio_cluster cl = uaudio_mixer_get_cluster(id, iot); 2284 2285 cc = UGETW(cl.wChannelConfig); 2286 2287 DPRINTF("cluster: bNrChannels=%u iChannelNames=%u wChannelConfig=" 2288 "0x%04x:\n", cl.iChannelNames, cl.bNrChannels, cc); 2289 2290 for (i = 0; cc; i++) { 2291 if (cc & 1) { 2292 DPRINTF(" - %s\n", channel_names[i]); 2293 } 2294 cc >>= 1; 2295 } 2296 } 2297 2298 #endif 2299 2300 static struct usb_audio_cluster 2301 uaudio_mixer_get_cluster(uint8_t id, const struct uaudio_terminal_node *iot) 2302 { 2303 struct usb_audio_cluster r; 2304 const struct usb_descriptor *dp; 2305 uint8_t i; 2306 2307 for (i = 0; i < UAUDIO_RECURSE_LIMIT; i++) { /* avoid infinite loops */ 2308 dp = iot[id].u.desc; 2309 if (dp == NULL) { 2310 goto error; 2311 } 2312 switch (dp->bDescriptorSubtype) { 2313 case UDESCSUB_AC_INPUT: 2314 r.bNrChannels = iot[id].u.it->bNrChannels; 2315 r.wChannelConfig[0] = iot[id].u.it->wChannelConfig[0]; 2316 r.wChannelConfig[1] = iot[id].u.it->wChannelConfig[1]; 2317 r.iChannelNames = iot[id].u.it->iChannelNames; 2318 goto done; 2319 2320 case UDESCSUB_AC_OUTPUT: 2321 id = iot[id].u.ot->bSourceId; 2322 break; 2323 2324 case UDESCSUB_AC_MIXER: 2325 r = *(const struct usb_audio_cluster *) 2326 &iot[id].u.mu->baSourceId[iot[id].u.mu-> 2327 bNrInPins]; 2328 goto done; 2329 2330 case UDESCSUB_AC_SELECTOR: 2331 if (iot[id].u.su->bNrInPins > 0) { 2332 /* XXX This is not really right */ 2333 id = iot[id].u.su->baSourceId[0]; 2334 } 2335 break; 2336 2337 case UDESCSUB_AC_FEATURE: 2338 id = iot[id].u.fu->bSourceId; 2339 break; 2340 2341 case UDESCSUB_AC_PROCESSING: 2342 r = *((const struct usb_audio_cluster *) 2343 &iot[id].u.pu->baSourceId[iot[id].u.pu-> 2344 bNrInPins]); 2345 goto done; 2346 2347 case UDESCSUB_AC_EXTENSION: 2348 r = *((const struct usb_audio_cluster *) 2349 &iot[id].u.eu->baSourceId[iot[id].u.eu-> 2350 bNrInPins]); 2351 goto done; 2352 2353 default: 2354 goto error; 2355 } 2356 } 2357 error: 2358 DPRINTF("bad data\n"); 2359 memset(&r, 0, sizeof(r)); 2360 done: 2361 return (r); 2362 } 2363 2364 #ifdef USB_DEBUG 2365 2366 struct uaudio_tt_to_string { 2367 uint16_t terminal_type; 2368 const char *desc; 2369 }; 2370 2371 static const struct uaudio_tt_to_string uaudio_tt_to_string[] = { 2372 2373 /* USB terminal types */ 2374 {UAT_UNDEFINED, "UAT_UNDEFINED"}, 2375 {UAT_STREAM, "UAT_STREAM"}, 2376 {UAT_VENDOR, "UAT_VENDOR"}, 2377 2378 /* input terminal types */ 2379 {UATI_UNDEFINED, "UATI_UNDEFINED"}, 2380 {UATI_MICROPHONE, "UATI_MICROPHONE"}, 2381 {UATI_DESKMICROPHONE, "UATI_DESKMICROPHONE"}, 2382 {UATI_PERSONALMICROPHONE, "UATI_PERSONALMICROPHONE"}, 2383 {UATI_OMNIMICROPHONE, "UATI_OMNIMICROPHONE"}, 2384 {UATI_MICROPHONEARRAY, "UATI_MICROPHONEARRAY"}, 2385 {UATI_PROCMICROPHONEARR, "UATI_PROCMICROPHONEARR"}, 2386 2387 /* output terminal types */ 2388 {UATO_UNDEFINED, "UATO_UNDEFINED"}, 2389 {UATO_SPEAKER, "UATO_SPEAKER"}, 2390 {UATO_HEADPHONES, "UATO_HEADPHONES"}, 2391 {UATO_DISPLAYAUDIO, "UATO_DISPLAYAUDIO"}, 2392 {UATO_DESKTOPSPEAKER, "UATO_DESKTOPSPEAKER"}, 2393 {UATO_ROOMSPEAKER, "UATO_ROOMSPEAKER"}, 2394 {UATO_COMMSPEAKER, "UATO_COMMSPEAKER"}, 2395 {UATO_SUBWOOFER, "UATO_SUBWOOFER"}, 2396 2397 /* bidir terminal types */ 2398 {UATB_UNDEFINED, "UATB_UNDEFINED"}, 2399 {UATB_HANDSET, "UATB_HANDSET"}, 2400 {UATB_HEADSET, "UATB_HEADSET"}, 2401 {UATB_SPEAKERPHONE, "UATB_SPEAKERPHONE"}, 2402 {UATB_SPEAKERPHONEESUP, "UATB_SPEAKERPHONEESUP"}, 2403 {UATB_SPEAKERPHONEECANC, "UATB_SPEAKERPHONEECANC"}, 2404 2405 /* telephony terminal types */ 2406 {UATT_UNDEFINED, "UATT_UNDEFINED"}, 2407 {UATT_PHONELINE, "UATT_PHONELINE"}, 2408 {UATT_TELEPHONE, "UATT_TELEPHONE"}, 2409 {UATT_DOWNLINEPHONE, "UATT_DOWNLINEPHONE"}, 2410 2411 /* external terminal types */ 2412 {UATE_UNDEFINED, "UATE_UNDEFINED"}, 2413 {UATE_ANALOGCONN, "UATE_ANALOGCONN"}, 2414 {UATE_LINECONN, "UATE_LINECONN"}, 2415 {UATE_LEGACYCONN, "UATE_LEGACYCONN"}, 2416 {UATE_DIGITALAUIFC, "UATE_DIGITALAUIFC"}, 2417 {UATE_SPDIF, "UATE_SPDIF"}, 2418 {UATE_1394DA, "UATE_1394DA"}, 2419 {UATE_1394DV, "UATE_1394DV"}, 2420 2421 /* embedded function terminal types */ 2422 {UATF_UNDEFINED, "UATF_UNDEFINED"}, 2423 {UATF_CALIBNOISE, "UATF_CALIBNOISE"}, 2424 {UATF_EQUNOISE, "UATF_EQUNOISE"}, 2425 {UATF_CDPLAYER, "UATF_CDPLAYER"}, 2426 {UATF_DAT, "UATF_DAT"}, 2427 {UATF_DCC, "UATF_DCC"}, 2428 {UATF_MINIDISK, "UATF_MINIDISK"}, 2429 {UATF_ANALOGTAPE, "UATF_ANALOGTAPE"}, 2430 {UATF_PHONOGRAPH, "UATF_PHONOGRAPH"}, 2431 {UATF_VCRAUDIO, "UATF_VCRAUDIO"}, 2432 {UATF_VIDEODISCAUDIO, "UATF_VIDEODISCAUDIO"}, 2433 {UATF_DVDAUDIO, "UATF_DVDAUDIO"}, 2434 {UATF_TVTUNERAUDIO, "UATF_TVTUNERAUDIO"}, 2435 {UATF_SATELLITE, "UATF_SATELLITE"}, 2436 {UATF_CABLETUNER, "UATF_CABLETUNER"}, 2437 {UATF_DSS, "UATF_DSS"}, 2438 {UATF_RADIORECV, "UATF_RADIORECV"}, 2439 {UATF_RADIOXMIT, "UATF_RADIOXMIT"}, 2440 {UATF_MULTITRACK, "UATF_MULTITRACK"}, 2441 {UATF_SYNTHESIZER, "UATF_SYNTHESIZER"}, 2442 2443 /* unknown */ 2444 {0x0000, "UNKNOWN"}, 2445 }; 2446 2447 static const char * 2448 uaudio_mixer_get_terminal_name(uint16_t terminal_type) 2449 { 2450 const struct uaudio_tt_to_string *uat = uaudio_tt_to_string; 2451 2452 while (uat->terminal_type) { 2453 if (uat->terminal_type == terminal_type) { 2454 break; 2455 } 2456 uat++; 2457 } 2458 if (uat->terminal_type == 0) { 2459 DPRINTF("unknown terminal type (0x%04x)", terminal_type); 2460 } 2461 return (uat->desc); 2462 } 2463 2464 #endif 2465 2466 static uint16_t 2467 uaudio_mixer_determine_class(const struct uaudio_terminal_node *iot, 2468 struct uaudio_mixer_node *mix) 2469 { 2470 uint16_t terminal_type = 0x0000; 2471 const struct uaudio_terminal_node *input[2]; 2472 const struct uaudio_terminal_node *output[2]; 2473 2474 input[0] = uaudio_mixer_get_input(iot, 0); 2475 input[1] = uaudio_mixer_get_input(iot, 1); 2476 2477 output[0] = uaudio_mixer_get_output(iot, 0); 2478 output[1] = uaudio_mixer_get_output(iot, 1); 2479 2480 /* 2481 * check if there is only 2482 * one output terminal: 2483 */ 2484 if (output[0] && (!output[1])) { 2485 terminal_type = UGETW(output[0]->u.ot->wTerminalType); 2486 } 2487 /* 2488 * If the only output terminal is USB, 2489 * the class is UAC_RECORD. 2490 */ 2491 if ((terminal_type & 0xff00) == (UAT_UNDEFINED & 0xff00)) { 2492 2493 mix->class = UAC_RECORD; 2494 if (input[0] && (!input[1])) { 2495 terminal_type = UGETW(input[0]->u.it->wTerminalType); 2496 } else { 2497 terminal_type = 0; 2498 } 2499 goto done; 2500 } 2501 /* 2502 * if the unit is connected to just 2503 * one input terminal, the 2504 * class is UAC_INPUT: 2505 */ 2506 if (input[0] && (!input[1])) { 2507 mix->class = UAC_INPUT; 2508 terminal_type = UGETW(input[0]->u.it->wTerminalType); 2509 goto done; 2510 } 2511 /* 2512 * Otherwise, the class is UAC_OUTPUT. 2513 */ 2514 mix->class = UAC_OUTPUT; 2515 done: 2516 return (terminal_type); 2517 } 2518 2519 struct uaudio_tt_to_feature { 2520 uint16_t terminal_type; 2521 uint16_t feature; 2522 }; 2523 2524 static const struct uaudio_tt_to_feature uaudio_tt_to_feature[] = { 2525 2526 {UAT_STREAM, SOUND_MIXER_PCM}, 2527 2528 {UATI_MICROPHONE, SOUND_MIXER_MIC}, 2529 {UATI_DESKMICROPHONE, SOUND_MIXER_MIC}, 2530 {UATI_PERSONALMICROPHONE, SOUND_MIXER_MIC}, 2531 {UATI_OMNIMICROPHONE, SOUND_MIXER_MIC}, 2532 {UATI_MICROPHONEARRAY, SOUND_MIXER_MIC}, 2533 {UATI_PROCMICROPHONEARR, SOUND_MIXER_MIC}, 2534 2535 {UATO_SPEAKER, SOUND_MIXER_SPEAKER}, 2536 {UATO_DESKTOPSPEAKER, SOUND_MIXER_SPEAKER}, 2537 {UATO_ROOMSPEAKER, SOUND_MIXER_SPEAKER}, 2538 {UATO_COMMSPEAKER, SOUND_MIXER_SPEAKER}, 2539 2540 {UATE_ANALOGCONN, SOUND_MIXER_LINE}, 2541 {UATE_LINECONN, SOUND_MIXER_LINE}, 2542 {UATE_LEGACYCONN, SOUND_MIXER_LINE}, 2543 2544 {UATE_DIGITALAUIFC, SOUND_MIXER_ALTPCM}, 2545 {UATE_SPDIF, SOUND_MIXER_ALTPCM}, 2546 {UATE_1394DA, SOUND_MIXER_ALTPCM}, 2547 {UATE_1394DV, SOUND_MIXER_ALTPCM}, 2548 2549 {UATF_CDPLAYER, SOUND_MIXER_CD}, 2550 2551 {UATF_SYNTHESIZER, SOUND_MIXER_SYNTH}, 2552 2553 {UATF_VIDEODISCAUDIO, SOUND_MIXER_VIDEO}, 2554 {UATF_DVDAUDIO, SOUND_MIXER_VIDEO}, 2555 {UATF_TVTUNERAUDIO, SOUND_MIXER_VIDEO}, 2556 2557 /* telephony terminal types */ 2558 {UATT_UNDEFINED, SOUND_MIXER_PHONEIN}, /* SOUND_MIXER_PHONEOUT */ 2559 {UATT_PHONELINE, SOUND_MIXER_PHONEIN}, /* SOUND_MIXER_PHONEOUT */ 2560 {UATT_TELEPHONE, SOUND_MIXER_PHONEIN}, /* SOUND_MIXER_PHONEOUT */ 2561 {UATT_DOWNLINEPHONE, SOUND_MIXER_PHONEIN}, /* SOUND_MIXER_PHONEOUT */ 2562 2563 {UATF_RADIORECV, SOUND_MIXER_RADIO}, 2564 {UATF_RADIOXMIT, SOUND_MIXER_RADIO}, 2565 2566 {UAT_UNDEFINED, SOUND_MIXER_VOLUME}, 2567 {UAT_VENDOR, SOUND_MIXER_VOLUME}, 2568 {UATI_UNDEFINED, SOUND_MIXER_VOLUME}, 2569 2570 /* output terminal types */ 2571 {UATO_UNDEFINED, SOUND_MIXER_VOLUME}, 2572 {UATO_DISPLAYAUDIO, SOUND_MIXER_VOLUME}, 2573 {UATO_SUBWOOFER, SOUND_MIXER_VOLUME}, 2574 {UATO_HEADPHONES, SOUND_MIXER_VOLUME}, 2575 2576 /* bidir terminal types */ 2577 {UATB_UNDEFINED, SOUND_MIXER_VOLUME}, 2578 {UATB_HANDSET, SOUND_MIXER_VOLUME}, 2579 {UATB_HEADSET, SOUND_MIXER_VOLUME}, 2580 {UATB_SPEAKERPHONE, SOUND_MIXER_VOLUME}, 2581 {UATB_SPEAKERPHONEESUP, SOUND_MIXER_VOLUME}, 2582 {UATB_SPEAKERPHONEECANC, SOUND_MIXER_VOLUME}, 2583 2584 /* external terminal types */ 2585 {UATE_UNDEFINED, SOUND_MIXER_VOLUME}, 2586 2587 /* embedded function terminal types */ 2588 {UATF_UNDEFINED, SOUND_MIXER_VOLUME}, 2589 {UATF_CALIBNOISE, SOUND_MIXER_VOLUME}, 2590 {UATF_EQUNOISE, SOUND_MIXER_VOLUME}, 2591 {UATF_DAT, SOUND_MIXER_VOLUME}, 2592 {UATF_DCC, SOUND_MIXER_VOLUME}, 2593 {UATF_MINIDISK, SOUND_MIXER_VOLUME}, 2594 {UATF_ANALOGTAPE, SOUND_MIXER_VOLUME}, 2595 {UATF_PHONOGRAPH, SOUND_MIXER_VOLUME}, 2596 {UATF_VCRAUDIO, SOUND_MIXER_VOLUME}, 2597 {UATF_SATELLITE, SOUND_MIXER_VOLUME}, 2598 {UATF_CABLETUNER, SOUND_MIXER_VOLUME}, 2599 {UATF_DSS, SOUND_MIXER_VOLUME}, 2600 {UATF_MULTITRACK, SOUND_MIXER_VOLUME}, 2601 {0xffff, SOUND_MIXER_VOLUME}, 2602 2603 /* default */ 2604 {0x0000, SOUND_MIXER_VOLUME}, 2605 }; 2606 2607 static uint16_t 2608 uaudio_mixer_feature_name(const struct uaudio_terminal_node *iot, 2609 struct uaudio_mixer_node *mix) 2610 { 2611 const struct uaudio_tt_to_feature *uat = uaudio_tt_to_feature; 2612 uint16_t terminal_type = uaudio_mixer_determine_class(iot, mix); 2613 2614 if ((mix->class == UAC_RECORD) && (terminal_type == 0)) { 2615 return (SOUND_MIXER_IMIX); 2616 } 2617 while (uat->terminal_type) { 2618 if (uat->terminal_type == terminal_type) { 2619 break; 2620 } 2621 uat++; 2622 } 2623 2624 DPRINTF("terminal_type=%s (0x%04x) -> %d\n", 2625 uaudio_mixer_get_terminal_name(terminal_type), 2626 terminal_type, uat->feature); 2627 2628 return (uat->feature); 2629 } 2630 2631 const static struct uaudio_terminal_node * 2632 uaudio_mixer_get_input(const struct uaudio_terminal_node *iot, uint8_t index) 2633 { 2634 struct uaudio_terminal_node *root = iot->root; 2635 uint8_t n; 2636 2637 n = iot->usr.id_max; 2638 do { 2639 if (iot->usr.bit_input[n / 8] & (1 << (n % 8))) { 2640 if (!index--) { 2641 return (root + n); 2642 } 2643 } 2644 } while (n--); 2645 2646 return (NULL); 2647 } 2648 2649 const static struct uaudio_terminal_node * 2650 uaudio_mixer_get_output(const struct uaudio_terminal_node *iot, uint8_t index) 2651 { 2652 struct uaudio_terminal_node *root = iot->root; 2653 uint8_t n; 2654 2655 n = iot->usr.id_max; 2656 do { 2657 if (iot->usr.bit_output[n / 8] & (1 << (n % 8))) { 2658 if (!index--) { 2659 return (root + n); 2660 } 2661 } 2662 } while (n--); 2663 2664 return (NULL); 2665 } 2666 2667 static void 2668 uaudio_mixer_find_inputs_sub(struct uaudio_terminal_node *root, 2669 const uint8_t *p_id, uint8_t n_id, 2670 struct uaudio_search_result *info) 2671 { 2672 struct uaudio_terminal_node *iot; 2673 uint8_t n; 2674 uint8_t i; 2675 2676 if (info->recurse_level >= UAUDIO_RECURSE_LIMIT) { 2677 return; 2678 } 2679 info->recurse_level++; 2680 2681 for (n = 0; n < n_id; n++) { 2682 2683 i = p_id[n]; 2684 2685 if (info->bit_visited[i / 8] & (1 << (i % 8))) { 2686 /* don't go into a circle */ 2687 DPRINTF("avoided going into a circle at id=%d!\n", i); 2688 continue; 2689 } else { 2690 info->bit_visited[i / 8] |= (1 << (i % 8)); 2691 } 2692 2693 iot = (root + i); 2694 2695 if (iot->u.desc == NULL) { 2696 continue; 2697 } 2698 switch (iot->u.desc->bDescriptorSubtype) { 2699 case UDESCSUB_AC_INPUT: 2700 info->bit_input[i / 8] |= (1 << (i % 8)); 2701 break; 2702 2703 case UDESCSUB_AC_FEATURE: 2704 uaudio_mixer_find_inputs_sub 2705 (root, &iot->u.fu->bSourceId, 1, info); 2706 break; 2707 2708 case UDESCSUB_AC_OUTPUT: 2709 uaudio_mixer_find_inputs_sub 2710 (root, &iot->u.ot->bSourceId, 1, info); 2711 break; 2712 2713 case UDESCSUB_AC_MIXER: 2714 uaudio_mixer_find_inputs_sub 2715 (root, iot->u.mu->baSourceId, 2716 iot->u.mu->bNrInPins, info); 2717 break; 2718 2719 case UDESCSUB_AC_SELECTOR: 2720 uaudio_mixer_find_inputs_sub 2721 (root, iot->u.su->baSourceId, 2722 iot->u.su->bNrInPins, info); 2723 break; 2724 2725 case UDESCSUB_AC_PROCESSING: 2726 uaudio_mixer_find_inputs_sub 2727 (root, iot->u.pu->baSourceId, 2728 iot->u.pu->bNrInPins, info); 2729 break; 2730 2731 case UDESCSUB_AC_EXTENSION: 2732 uaudio_mixer_find_inputs_sub 2733 (root, iot->u.eu->baSourceId, 2734 iot->u.eu->bNrInPins, info); 2735 break; 2736 2737 case UDESCSUB_AC_HEADER: 2738 default: 2739 break; 2740 } 2741 } 2742 info->recurse_level--; 2743 } 2744 2745 static void 2746 uaudio_mixer_find_outputs_sub(struct uaudio_terminal_node *root, uint8_t id, 2747 uint8_t n_id, struct uaudio_search_result *info) 2748 { 2749 struct uaudio_terminal_node *iot = (root + id); 2750 uint8_t j; 2751 2752 j = n_id; 2753 do { 2754 if ((j != id) && ((root + j)->u.desc) && 2755 ((root + j)->u.desc->bDescriptorSubtype == UDESCSUB_AC_OUTPUT)) { 2756 2757 /* 2758 * "j" (output) <--- virtual wire <--- "id" (input) 2759 * 2760 * if "j" has "id" on the input, then "id" have "j" on 2761 * the output, because they are connected: 2762 */ 2763 if ((root + j)->usr.bit_input[id / 8] & (1 << (id % 8))) { 2764 iot->usr.bit_output[j / 8] |= (1 << (j % 8)); 2765 } 2766 } 2767 } while (j--); 2768 } 2769 2770 static void 2771 uaudio_mixer_fill_info(struct uaudio_softc *sc, struct usb_device *udev, 2772 void *desc) 2773 { 2774 const struct usb_audio_control_descriptor *acdp; 2775 struct usb_config_descriptor *cd = usbd_get_config_descriptor(udev); 2776 const struct usb_descriptor *dp; 2777 const struct usb_audio_unit *au; 2778 struct uaudio_terminal_node *iot = NULL; 2779 uint16_t wTotalLen; 2780 uint8_t ID_max = 0; /* inclusive */ 2781 uint8_t i; 2782 2783 desc = usb_desc_foreach(cd, desc); 2784 2785 if (desc == NULL) { 2786 DPRINTF("no Audio Control header\n"); 2787 goto done; 2788 } 2789 acdp = desc; 2790 2791 if ((acdp->bLength < sizeof(*acdp)) || 2792 (acdp->bDescriptorType != UDESC_CS_INTERFACE) || 2793 (acdp->bDescriptorSubtype != UDESCSUB_AC_HEADER)) { 2794 DPRINTF("invalid Audio Control header\n"); 2795 goto done; 2796 } 2797 /* "wTotalLen" is allowed to be corrupt */ 2798 wTotalLen = UGETW(acdp->wTotalLength) - acdp->bLength; 2799 2800 /* get USB audio revision */ 2801 sc->sc_audio_rev = UGETW(acdp->bcdADC); 2802 2803 DPRINTFN(3, "found AC header, vers=%03x, len=%d\n", 2804 sc->sc_audio_rev, wTotalLen); 2805 2806 if (sc->sc_audio_rev != UAUDIO_VERSION) { 2807 2808 if (sc->sc_uq_bad_adc) { 2809 2810 } else { 2811 DPRINTF("invalid audio version\n"); 2812 goto done; 2813 } 2814 } 2815 iot = malloc(sizeof(struct uaudio_terminal_node) * 256, M_TEMP, 2816 M_WAITOK | M_ZERO); 2817 2818 if (iot == NULL) { 2819 DPRINTF("no memory!\n"); 2820 goto done; 2821 } 2822 while ((desc = usb_desc_foreach(cd, desc))) { 2823 2824 dp = desc; 2825 2826 if (dp->bLength > wTotalLen) { 2827 break; 2828 } else { 2829 wTotalLen -= dp->bLength; 2830 } 2831 2832 au = uaudio_mixer_verify_desc(dp, 0); 2833 2834 if (au) { 2835 iot[au->bUnitId].u.desc = (const void *)au; 2836 if (au->bUnitId > ID_max) { 2837 ID_max = au->bUnitId; 2838 } 2839 } 2840 } 2841 2842 DPRINTF("Maximum ID=%d\n", ID_max); 2843 2844 /* 2845 * determine sourcing inputs for 2846 * all nodes in the tree: 2847 */ 2848 i = ID_max; 2849 do { 2850 uaudio_mixer_find_inputs_sub(iot, &i, 1, &((iot + i)->usr)); 2851 } while (i--); 2852 2853 /* 2854 * determine outputs for 2855 * all nodes in the tree: 2856 */ 2857 i = ID_max; 2858 do { 2859 uaudio_mixer_find_outputs_sub(iot, i, ID_max, &((iot + i)->usr)); 2860 } while (i--); 2861 2862 /* set "id_max" and "root" */ 2863 2864 i = ID_max; 2865 do { 2866 (iot + i)->usr.id_max = ID_max; 2867 (iot + i)->root = iot; 2868 } while (i--); 2869 2870 #ifdef USB_DEBUG 2871 i = ID_max; 2872 do { 2873 uint8_t j; 2874 2875 if (iot[i].u.desc == NULL) { 2876 continue; 2877 } 2878 DPRINTF("id %d:\n", i); 2879 2880 switch (iot[i].u.desc->bDescriptorSubtype) { 2881 case UDESCSUB_AC_INPUT: 2882 DPRINTF(" - AC_INPUT type=%s\n", 2883 uaudio_mixer_get_terminal_name 2884 (UGETW(iot[i].u.it->wTerminalType))); 2885 uaudio_mixer_dump_cluster(i, iot); 2886 break; 2887 2888 case UDESCSUB_AC_OUTPUT: 2889 DPRINTF(" - AC_OUTPUT type=%s " 2890 "src=%d\n", uaudio_mixer_get_terminal_name 2891 (UGETW(iot[i].u.ot->wTerminalType)), 2892 iot[i].u.ot->bSourceId); 2893 break; 2894 2895 case UDESCSUB_AC_MIXER: 2896 DPRINTF(" - AC_MIXER src:\n"); 2897 for (j = 0; j < iot[i].u.mu->bNrInPins; j++) { 2898 DPRINTF(" - %d\n", iot[i].u.mu->baSourceId[j]); 2899 } 2900 uaudio_mixer_dump_cluster(i, iot); 2901 break; 2902 2903 case UDESCSUB_AC_SELECTOR: 2904 DPRINTF(" - AC_SELECTOR src:\n"); 2905 for (j = 0; j < iot[i].u.su->bNrInPins; j++) { 2906 DPRINTF(" - %d\n", iot[i].u.su->baSourceId[j]); 2907 } 2908 break; 2909 2910 case UDESCSUB_AC_FEATURE: 2911 DPRINTF(" - AC_FEATURE src=%d\n", iot[i].u.fu->bSourceId); 2912 break; 2913 2914 case UDESCSUB_AC_PROCESSING: 2915 DPRINTF(" - AC_PROCESSING src:\n"); 2916 for (j = 0; j < iot[i].u.pu->bNrInPins; j++) { 2917 DPRINTF(" - %d\n", iot[i].u.pu->baSourceId[j]); 2918 } 2919 uaudio_mixer_dump_cluster(i, iot); 2920 break; 2921 2922 case UDESCSUB_AC_EXTENSION: 2923 DPRINTF(" - AC_EXTENSION src:\n"); 2924 for (j = 0; j < iot[i].u.eu->bNrInPins; j++) { 2925 DPRINTF("%d ", iot[i].u.eu->baSourceId[j]); 2926 } 2927 uaudio_mixer_dump_cluster(i, iot); 2928 break; 2929 2930 default: 2931 DPRINTF("unknown audio control (subtype=%d)\n", 2932 iot[i].u.desc->bDescriptorSubtype); 2933 } 2934 2935 DPRINTF("Inputs to this ID are:\n"); 2936 2937 j = ID_max; 2938 do { 2939 if (iot[i].usr.bit_input[j / 8] & (1 << (j % 8))) { 2940 DPRINTF(" -- ID=%d\n", j); 2941 } 2942 } while (j--); 2943 2944 DPRINTF("Outputs from this ID are:\n"); 2945 2946 j = ID_max; 2947 do { 2948 if (iot[i].usr.bit_output[j / 8] & (1 << (j % 8))) { 2949 DPRINTF(" -- ID=%d\n", j); 2950 } 2951 } while (j--); 2952 2953 } while (i--); 2954 #endif 2955 2956 /* 2957 * scan the config to create a linked 2958 * list of "mixer" nodes: 2959 */ 2960 2961 i = ID_max; 2962 do { 2963 dp = iot[i].u.desc; 2964 2965 if (dp == NULL) { 2966 continue; 2967 } 2968 DPRINTFN(11, "id=%d subtype=%d\n", 2969 i, dp->bDescriptorSubtype); 2970 2971 switch (dp->bDescriptorSubtype) { 2972 case UDESCSUB_AC_HEADER: 2973 DPRINTF("unexpected AC header\n"); 2974 break; 2975 2976 case UDESCSUB_AC_INPUT: 2977 uaudio_mixer_add_input(sc, iot, i); 2978 break; 2979 2980 case UDESCSUB_AC_OUTPUT: 2981 uaudio_mixer_add_output(sc, iot, i); 2982 break; 2983 2984 case UDESCSUB_AC_MIXER: 2985 uaudio_mixer_add_mixer(sc, iot, i); 2986 break; 2987 2988 case UDESCSUB_AC_SELECTOR: 2989 uaudio_mixer_add_selector(sc, iot, i); 2990 break; 2991 2992 case UDESCSUB_AC_FEATURE: 2993 uaudio_mixer_add_feature(sc, iot, i); 2994 break; 2995 2996 case UDESCSUB_AC_PROCESSING: 2997 uaudio_mixer_add_processing(sc, iot, i); 2998 break; 2999 3000 case UDESCSUB_AC_EXTENSION: 3001 uaudio_mixer_add_extension(sc, iot, i); 3002 break; 3003 3004 default: 3005 DPRINTF("bad AC desc subtype=0x%02x\n", 3006 dp->bDescriptorSubtype); 3007 break; 3008 } 3009 3010 } while (i--); 3011 3012 done: 3013 if (iot) { 3014 free(iot, M_TEMP); 3015 } 3016 } 3017 3018 static uint16_t 3019 uaudio_mixer_get(struct usb_device *udev, uint8_t what, 3020 struct uaudio_mixer_node *mc) 3021 { 3022 struct usb_device_request req; 3023 uint16_t val; 3024 uint16_t len = MIX_SIZE(mc->type); 3025 uint8_t data[4]; 3026 usb_error_t err; 3027 3028 if (mc->wValue[0] == -1) { 3029 return (0); 3030 } 3031 req.bmRequestType = UT_READ_CLASS_INTERFACE; 3032 req.bRequest = what; 3033 USETW(req.wValue, mc->wValue[0]); 3034 USETW(req.wIndex, mc->wIndex); 3035 USETW(req.wLength, len); 3036 3037 err = usbd_do_request(udev, NULL, &req, data); 3038 if (err) { 3039 DPRINTF("err=%s\n", usbd_errstr(err)); 3040 return (0); 3041 } 3042 if (len < 1) { 3043 data[0] = 0; 3044 } 3045 if (len < 2) { 3046 data[1] = 0; 3047 } 3048 val = (data[0] | (data[1] << 8)); 3049 3050 DPRINTFN(3, "val=%d\n", val); 3051 3052 return (val); 3053 } 3054 3055 static void 3056 uaudio_mixer_write_cfg_callback(struct usb_xfer *xfer, usb_error_t error) 3057 { 3058 struct usb_device_request req; 3059 struct uaudio_softc *sc = usbd_xfer_softc(xfer); 3060 struct uaudio_mixer_node *mc = sc->sc_mixer_curr; 3061 struct usb_page_cache *pc; 3062 uint16_t len; 3063 uint8_t repeat = 1; 3064 uint8_t update; 3065 uint8_t chan; 3066 uint8_t buf[2]; 3067 3068 DPRINTF("\n"); 3069 3070 switch (USB_GET_STATE(xfer)) { 3071 case USB_ST_TRANSFERRED: 3072 tr_transferred: 3073 case USB_ST_SETUP: 3074 tr_setup: 3075 3076 if (mc == NULL) { 3077 mc = sc->sc_mixer_root; 3078 sc->sc_mixer_curr = mc; 3079 sc->sc_mixer_chan = 0; 3080 repeat = 0; 3081 } 3082 while (mc) { 3083 while (sc->sc_mixer_chan < mc->nchan) { 3084 3085 len = MIX_SIZE(mc->type); 3086 3087 chan = sc->sc_mixer_chan; 3088 3089 sc->sc_mixer_chan++; 3090 3091 update = ((mc->update[chan / 8] & (1 << (chan % 8))) && 3092 (mc->wValue[chan] != -1)); 3093 3094 mc->update[chan / 8] &= ~(1 << (chan % 8)); 3095 3096 if (update) { 3097 3098 req.bmRequestType = UT_WRITE_CLASS_INTERFACE; 3099 req.bRequest = SET_CUR; 3100 USETW(req.wValue, mc->wValue[chan]); 3101 USETW(req.wIndex, mc->wIndex); 3102 USETW(req.wLength, len); 3103 3104 if (len > 0) { 3105 buf[0] = (mc->wData[chan] & 0xFF); 3106 } 3107 if (len > 1) { 3108 buf[1] = (mc->wData[chan] >> 8) & 0xFF; 3109 } 3110 pc = usbd_xfer_get_frame(xfer, 0); 3111 usbd_copy_in(pc, 0, &req, sizeof(req)); 3112 pc = usbd_xfer_get_frame(xfer, 1); 3113 usbd_copy_in(pc, 0, buf, len); 3114 3115 usbd_xfer_set_frame_len(xfer, 0, sizeof(req)); 3116 usbd_xfer_set_frame_len(xfer, 1, len); 3117 usbd_xfer_set_frames(xfer, len ? 2 : 1); 3118 usbd_transfer_submit(xfer); 3119 return; 3120 } 3121 } 3122 3123 mc = mc->next; 3124 sc->sc_mixer_curr = mc; 3125 sc->sc_mixer_chan = 0; 3126 } 3127 3128 if (repeat) { 3129 goto tr_setup; 3130 } 3131 break; 3132 3133 default: /* Error */ 3134 DPRINTF("error=%s\n", usbd_errstr(error)); 3135 if (error == USB_ERR_CANCELLED) { 3136 /* do nothing - we are detaching */ 3137 break; 3138 } 3139 goto tr_transferred; 3140 } 3141 } 3142 3143 static usb_error_t 3144 uaudio_set_speed(struct usb_device *udev, uint8_t endpt, uint32_t speed) 3145 { 3146 struct usb_device_request req; 3147 uint8_t data[3]; 3148 3149 DPRINTFN(6, "endpt=%d speed=%u\n", endpt, speed); 3150 3151 req.bmRequestType = UT_WRITE_CLASS_ENDPOINT; 3152 req.bRequest = SET_CUR; 3153 USETW2(req.wValue, SAMPLING_FREQ_CONTROL, 0); 3154 USETW(req.wIndex, endpt); 3155 USETW(req.wLength, 3); 3156 data[0] = speed; 3157 data[1] = speed >> 8; 3158 data[2] = speed >> 16; 3159 3160 return (usbd_do_request(udev, NULL, &req, data)); 3161 } 3162 3163 static int 3164 uaudio_mixer_signext(uint8_t type, int val) 3165 { 3166 if (!MIX_UNSIGNED(type)) { 3167 if (MIX_SIZE(type) == 2) { 3168 val = (int16_t)val; 3169 } else { 3170 val = (int8_t)val; 3171 } 3172 } 3173 return (val); 3174 } 3175 3176 static int 3177 uaudio_mixer_bsd2value(struct uaudio_mixer_node *mc, int32_t val) 3178 { 3179 if (mc->type == MIX_ON_OFF) { 3180 val = (val != 0); 3181 } else if (mc->type == MIX_SELECTOR) { 3182 if ((val < mc->minval) || 3183 (val > mc->maxval)) { 3184 val = mc->minval; 3185 } 3186 } else { 3187 3188 /* compute actual volume */ 3189 val = (val * mc->mul) / 255; 3190 3191 /* add lower offset */ 3192 val = val + mc->minval; 3193 3194 /* make sure we don't write a value out of range */ 3195 if (val > mc->maxval) 3196 val = mc->maxval; 3197 else if (val < mc->minval) 3198 val = mc->minval; 3199 } 3200 3201 DPRINTFN(6, "type=0x%03x val=%d min=%d max=%d val=%d\n", 3202 mc->type, val, mc->minval, mc->maxval, val); 3203 return (val); 3204 } 3205 3206 static void 3207 uaudio_mixer_ctl_set(struct uaudio_softc *sc, struct uaudio_mixer_node *mc, 3208 uint8_t chan, int32_t val) 3209 { 3210 val = uaudio_mixer_bsd2value(mc, val); 3211 3212 mc->update[chan / 8] |= (1 << (chan % 8)); 3213 mc->wData[chan] = val; 3214 3215 /* start the transfer, if not already started */ 3216 3217 usbd_transfer_start(sc->sc_mixer_xfer[0]); 3218 } 3219 3220 static void 3221 uaudio_mixer_init(struct uaudio_softc *sc) 3222 { 3223 struct uaudio_mixer_node *mc; 3224 int32_t i; 3225 3226 for (mc = sc->sc_mixer_root; mc; 3227 mc = mc->next) { 3228 3229 if (mc->ctl != SOUND_MIXER_NRDEVICES) { 3230 /* 3231 * Set device mask bits. See 3232 * /usr/include/machine/soundcard.h 3233 */ 3234 sc->sc_mix_info |= (1 << mc->ctl); 3235 } 3236 if ((mc->ctl == SOUND_MIXER_NRDEVICES) && 3237 (mc->type == MIX_SELECTOR)) { 3238 3239 for (i = mc->minval; (i > 0) && (i <= mc->maxval); i++) { 3240 if (mc->slctrtype[i - 1] == SOUND_MIXER_NRDEVICES) { 3241 continue; 3242 } 3243 sc->sc_recsrc_info |= 1 << mc->slctrtype[i - 1]; 3244 } 3245 } 3246 } 3247 } 3248 3249 int 3250 uaudio_mixer_init_sub(struct uaudio_softc *sc, struct snd_mixer *m) 3251 { 3252 DPRINTF("\n"); 3253 3254 if (usbd_transfer_setup(sc->sc_udev, &sc->sc_mixer_iface_index, 3255 sc->sc_mixer_xfer, uaudio_mixer_config, 1, sc, 3256 mixer_get_lock(m))) { 3257 DPRINTFN(0, "could not allocate USB " 3258 "transfer for audio mixer!\n"); 3259 return (ENOMEM); 3260 } 3261 if (!(sc->sc_mix_info & SOUND_MASK_VOLUME)) { 3262 mix_setparentchild(m, SOUND_MIXER_VOLUME, SOUND_MASK_PCM); 3263 mix_setrealdev(m, SOUND_MIXER_VOLUME, SOUND_MIXER_NONE); 3264 } 3265 mix_setdevs(m, sc->sc_mix_info); 3266 mix_setrecdevs(m, sc->sc_recsrc_info); 3267 return (0); 3268 } 3269 3270 int 3271 uaudio_mixer_uninit_sub(struct uaudio_softc *sc) 3272 { 3273 DPRINTF("\n"); 3274 3275 usbd_transfer_unsetup(sc->sc_mixer_xfer, 1); 3276 3277 return (0); 3278 } 3279 3280 void 3281 uaudio_mixer_set(struct uaudio_softc *sc, unsigned type, 3282 unsigned left, unsigned right) 3283 { 3284 struct uaudio_mixer_node *mc; 3285 3286 for (mc = sc->sc_mixer_root; mc; 3287 mc = mc->next) { 3288 3289 if (mc->ctl == type) { 3290 if (mc->nchan == 2) { 3291 /* set Right */ 3292 uaudio_mixer_ctl_set(sc, mc, 1, (int)(right * 255) / 100); 3293 } 3294 /* set Left or Mono */ 3295 uaudio_mixer_ctl_set(sc, mc, 0, (int)(left * 255) / 100); 3296 } 3297 } 3298 } 3299 3300 uint32_t 3301 uaudio_mixer_setrecsrc(struct uaudio_softc *sc, uint32_t src) 3302 { 3303 struct uaudio_mixer_node *mc; 3304 uint32_t mask; 3305 uint32_t temp; 3306 int32_t i; 3307 3308 for (mc = sc->sc_mixer_root; mc; 3309 mc = mc->next) { 3310 3311 if ((mc->ctl == SOUND_MIXER_NRDEVICES) && 3312 (mc->type == MIX_SELECTOR)) { 3313 3314 /* compute selector mask */ 3315 3316 mask = 0; 3317 for (i = mc->minval; (i > 0) && (i <= mc->maxval); i++) { 3318 mask |= (1 << mc->slctrtype[i - 1]); 3319 } 3320 3321 temp = mask & src; 3322 if (temp == 0) { 3323 continue; 3324 } 3325 /* find the first set bit */ 3326 temp = (-temp) & temp; 3327 3328 /* update "src" */ 3329 src &= ~mask; 3330 src |= temp; 3331 3332 for (i = mc->minval; (i > 0) && (i <= mc->maxval); i++) { 3333 if (temp != (1 << mc->slctrtype[i - 1])) { 3334 continue; 3335 } 3336 uaudio_mixer_ctl_set(sc, mc, 0, i); 3337 break; 3338 } 3339 } 3340 } 3341 return (src); 3342 } 3343 3344 /*========================================================================* 3345 * MIDI support routines 3346 *========================================================================*/ 3347 3348 static void 3349 umidi_bulk_read_callback(struct usb_xfer *xfer, usb_error_t error) 3350 { 3351 struct umidi_chan *chan = usbd_xfer_softc(xfer); 3352 struct umidi_sub_chan *sub; 3353 struct usb_page_cache *pc; 3354 uint8_t buf[4]; 3355 uint8_t cmd_len; 3356 uint8_t cn; 3357 uint16_t pos; 3358 int actlen; 3359 3360 usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL); 3361 3362 switch (USB_GET_STATE(xfer)) { 3363 case USB_ST_TRANSFERRED: 3364 3365 DPRINTF("actlen=%d bytes\n", actlen); 3366 3367 pos = 0; 3368 pc = usbd_xfer_get_frame(xfer, 0); 3369 3370 while (actlen >= 4) { 3371 3372 /* copy out the MIDI data */ 3373 usbd_copy_out(pc, pos, buf, 4); 3374 /* command length */ 3375 cmd_len = umidi_cmd_to_len[buf[0] & 0xF]; 3376 /* cable number */ 3377 cn = buf[0] >> 4; 3378 /* 3379 * Lookup sub-channel. The index is range 3380 * checked below. 3381 */ 3382 sub = &chan->sub[cn]; 3383 3384 if ((cmd_len != 0) && 3385 (cn < chan->max_cable) && 3386 (sub->read_open != 0)) { 3387 3388 /* Send data to the application */ 3389 usb_fifo_put_data_linear( 3390 sub->fifo.fp[USB_FIFO_RX], 3391 buf + 1, cmd_len, 1); 3392 } 3393 actlen -= 4; 3394 pos += 4; 3395 } 3396 3397 case USB_ST_SETUP: 3398 DPRINTF("start\n"); 3399 tr_setup: 3400 usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer)); 3401 usbd_transfer_submit(xfer); 3402 break; 3403 3404 default: 3405 DPRINTF("error=%s\n", usbd_errstr(error)); 3406 3407 if (error != USB_ERR_CANCELLED) { 3408 /* try to clear stall first */ 3409 usbd_xfer_set_stall(xfer); 3410 goto tr_setup; 3411 } 3412 break; 3413 } 3414 } 3415 3416 /* 3417 * The following statemachine, that converts MIDI commands to 3418 * USB MIDI packets, derives from Linux's usbmidi.c, which 3419 * was written by "Clemens Ladisch": 3420 * 3421 * Returns: 3422 * 0: No command 3423 * Else: Command is complete 3424 */ 3425 static uint8_t 3426 umidi_convert_to_usb(struct umidi_sub_chan *sub, uint8_t cn, uint8_t b) 3427 { 3428 uint8_t p0 = (cn << 4); 3429 3430 if (b >= 0xf8) { 3431 sub->temp_0[0] = p0 | 0x0f; 3432 sub->temp_0[1] = b; 3433 sub->temp_0[2] = 0; 3434 sub->temp_0[3] = 0; 3435 sub->temp_cmd = sub->temp_0; 3436 return (1); 3437 3438 } else if (b >= 0xf0) { 3439 switch (b) { 3440 case 0xf0: /* system exclusive begin */ 3441 sub->temp_1[1] = b; 3442 sub->state = UMIDI_ST_SYSEX_1; 3443 break; 3444 case 0xf1: /* MIDI time code */ 3445 case 0xf3: /* song select */ 3446 sub->temp_1[1] = b; 3447 sub->state = UMIDI_ST_1PARAM; 3448 break; 3449 case 0xf2: /* song position pointer */ 3450 sub->temp_1[1] = b; 3451 sub->state = UMIDI_ST_2PARAM_1; 3452 break; 3453 case 0xf4: /* unknown */ 3454 case 0xf5: /* unknown */ 3455 sub->state = UMIDI_ST_UNKNOWN; 3456 break; 3457 case 0xf6: /* tune request */ 3458 sub->temp_1[0] = p0 | 0x05; 3459 sub->temp_1[1] = 0xf6; 3460 sub->temp_1[2] = 0; 3461 sub->temp_1[3] = 0; 3462 sub->temp_cmd = sub->temp_1; 3463 sub->state = UMIDI_ST_UNKNOWN; 3464 return (1); 3465 3466 case 0xf7: /* system exclusive end */ 3467 switch (sub->state) { 3468 case UMIDI_ST_SYSEX_0: 3469 sub->temp_1[0] = p0 | 0x05; 3470 sub->temp_1[1] = 0xf7; 3471 sub->temp_1[2] = 0; 3472 sub->temp_1[3] = 0; 3473 sub->temp_cmd = sub->temp_1; 3474 sub->state = UMIDI_ST_UNKNOWN; 3475 return (1); 3476 case UMIDI_ST_SYSEX_1: 3477 sub->temp_1[0] = p0 | 0x06; 3478 sub->temp_1[2] = 0xf7; 3479 sub->temp_1[3] = 0; 3480 sub->temp_cmd = sub->temp_1; 3481 sub->state = UMIDI_ST_UNKNOWN; 3482 return (1); 3483 case UMIDI_ST_SYSEX_2: 3484 sub->temp_1[0] = p0 | 0x07; 3485 sub->temp_1[3] = 0xf7; 3486 sub->temp_cmd = sub->temp_1; 3487 sub->state = UMIDI_ST_UNKNOWN; 3488 return (1); 3489 } 3490 sub->state = UMIDI_ST_UNKNOWN; 3491 break; 3492 } 3493 } else if (b >= 0x80) { 3494 sub->temp_1[1] = b; 3495 if ((b >= 0xc0) && (b <= 0xdf)) { 3496 sub->state = UMIDI_ST_1PARAM; 3497 } else { 3498 sub->state = UMIDI_ST_2PARAM_1; 3499 } 3500 } else { /* b < 0x80 */ 3501 switch (sub->state) { 3502 case UMIDI_ST_1PARAM: 3503 if (sub->temp_1[1] < 0xf0) { 3504 p0 |= sub->temp_1[1] >> 4; 3505 } else { 3506 p0 |= 0x02; 3507 sub->state = UMIDI_ST_UNKNOWN; 3508 } 3509 sub->temp_1[0] = p0; 3510 sub->temp_1[2] = b; 3511 sub->temp_1[3] = 0; 3512 sub->temp_cmd = sub->temp_1; 3513 return (1); 3514 case UMIDI_ST_2PARAM_1: 3515 sub->temp_1[2] = b; 3516 sub->state = UMIDI_ST_2PARAM_2; 3517 break; 3518 case UMIDI_ST_2PARAM_2: 3519 if (sub->temp_1[1] < 0xf0) { 3520 p0 |= sub->temp_1[1] >> 4; 3521 sub->state = UMIDI_ST_2PARAM_1; 3522 } else { 3523 p0 |= 0x03; 3524 sub->state = UMIDI_ST_UNKNOWN; 3525 } 3526 sub->temp_1[0] = p0; 3527 sub->temp_1[3] = b; 3528 sub->temp_cmd = sub->temp_1; 3529 return (1); 3530 case UMIDI_ST_SYSEX_0: 3531 sub->temp_1[1] = b; 3532 sub->state = UMIDI_ST_SYSEX_1; 3533 break; 3534 case UMIDI_ST_SYSEX_1: 3535 sub->temp_1[2] = b; 3536 sub->state = UMIDI_ST_SYSEX_2; 3537 break; 3538 case UMIDI_ST_SYSEX_2: 3539 sub->temp_1[0] = p0 | 0x04; 3540 sub->temp_1[3] = b; 3541 sub->temp_cmd = sub->temp_1; 3542 sub->state = UMIDI_ST_SYSEX_0; 3543 return (1); 3544 default: 3545 break; 3546 } 3547 } 3548 return (0); 3549 } 3550 3551 static void 3552 umidi_bulk_write_callback(struct usb_xfer *xfer, usb_error_t error) 3553 { 3554 struct umidi_chan *chan = usbd_xfer_softc(xfer); 3555 struct umidi_sub_chan *sub; 3556 struct usb_page_cache *pc; 3557 uint32_t actlen; 3558 uint16_t nframes; 3559 uint8_t buf; 3560 uint8_t start_cable; 3561 uint8_t tr_any; 3562 int len; 3563 3564 usbd_xfer_status(xfer, &len, NULL, NULL, NULL); 3565 3566 /* 3567 * NOTE: Some MIDI devices only accept 4 bytes of data per 3568 * short terminated USB transfer. 3569 */ 3570 switch (USB_GET_STATE(xfer)) { 3571 case USB_ST_TRANSFERRED: 3572 DPRINTF("actlen=%d bytes\n", len); 3573 3574 case USB_ST_SETUP: 3575 tr_setup: 3576 DPRINTF("start\n"); 3577 3578 nframes = 0; /* reset */ 3579 start_cable = chan->curr_cable; 3580 tr_any = 0; 3581 pc = usbd_xfer_get_frame(xfer, 0); 3582 3583 while (1) { 3584 3585 /* round robin de-queueing */ 3586 3587 sub = &chan->sub[chan->curr_cable]; 3588 3589 if (sub->write_open) { 3590 usb_fifo_get_data_linear(sub->fifo.fp[USB_FIFO_TX], 3591 &buf, 1, &actlen, 0); 3592 } else { 3593 actlen = 0; 3594 } 3595 3596 if (actlen) { 3597 3598 tr_any = 1; 3599 3600 DPRINTF("byte=0x%02x from FIFO %u\n", buf, 3601 (unsigned int)chan->curr_cable); 3602 3603 if (umidi_convert_to_usb(sub, chan->curr_cable, buf)) { 3604 3605 DPRINTF("sub=0x%02x 0x%02x 0x%02x 0x%02x\n", 3606 sub->temp_cmd[0], sub->temp_cmd[1], 3607 sub->temp_cmd[2], sub->temp_cmd[3]); 3608 3609 usbd_copy_in(pc, nframes * 4, sub->temp_cmd, 4); 3610 3611 nframes++; 3612 3613 if ((nframes >= UMIDI_TX_FRAMES) || (chan->single_command != 0)) 3614 break; 3615 } else { 3616 continue; 3617 } 3618 } 3619 3620 chan->curr_cable++; 3621 if (chan->curr_cable >= chan->max_cable) 3622 chan->curr_cable = 0; 3623 3624 if (chan->curr_cable == start_cable) { 3625 if (tr_any == 0) 3626 break; 3627 tr_any = 0; 3628 } 3629 } 3630 3631 if (nframes != 0) { 3632 DPRINTF("Transferring %d frames\n", (int)nframes); 3633 usbd_xfer_set_frame_len(xfer, 0, 4 * nframes); 3634 usbd_transfer_submit(xfer); 3635 } 3636 break; 3637 3638 default: /* Error */ 3639 3640 DPRINTF("error=%s\n", usbd_errstr(error)); 3641 3642 if (error != USB_ERR_CANCELLED) { 3643 /* try to clear stall first */ 3644 usbd_xfer_set_stall(xfer); 3645 goto tr_setup; 3646 } 3647 break; 3648 } 3649 } 3650 3651 static struct umidi_sub_chan * 3652 umidi_sub_by_fifo(struct usb_fifo *fifo) 3653 { 3654 struct umidi_chan *chan = usb_fifo_softc(fifo); 3655 struct umidi_sub_chan *sub; 3656 uint32_t n; 3657 3658 for (n = 0; n < UMIDI_CABLES_MAX; n++) { 3659 sub = &chan->sub[n]; 3660 if ((sub->fifo.fp[USB_FIFO_RX] == fifo) || 3661 (sub->fifo.fp[USB_FIFO_TX] == fifo)) { 3662 return (sub); 3663 } 3664 } 3665 3666 panic("%s:%d cannot find usb_fifo!\n", 3667 __FILE__, __LINE__); 3668 3669 return (NULL); 3670 } 3671 3672 static void 3673 umidi_start_read(struct usb_fifo *fifo) 3674 { 3675 struct umidi_chan *chan = usb_fifo_softc(fifo); 3676 3677 usbd_transfer_start(chan->xfer[UMIDI_RX_TRANSFER]); 3678 } 3679 3680 static void 3681 umidi_stop_read(struct usb_fifo *fifo) 3682 { 3683 struct umidi_chan *chan = usb_fifo_softc(fifo); 3684 struct umidi_sub_chan *sub = umidi_sub_by_fifo(fifo); 3685 3686 DPRINTF("\n"); 3687 3688 sub->read_open = 0; 3689 3690 if (--(chan->read_open_refcount) == 0) { 3691 /* 3692 * XXX don't stop the read transfer here, hence that causes 3693 * problems with some MIDI adapters 3694 */ 3695 DPRINTF("(stopping read transfer)\n"); 3696 } 3697 } 3698 3699 static void 3700 umidi_start_write(struct usb_fifo *fifo) 3701 { 3702 struct umidi_chan *chan = usb_fifo_softc(fifo); 3703 3704 usbd_transfer_start(chan->xfer[UMIDI_TX_TRANSFER]); 3705 } 3706 3707 static void 3708 umidi_stop_write(struct usb_fifo *fifo) 3709 { 3710 struct umidi_chan *chan = usb_fifo_softc(fifo); 3711 struct umidi_sub_chan *sub = umidi_sub_by_fifo(fifo); 3712 3713 DPRINTF("\n"); 3714 3715 sub->write_open = 0; 3716 3717 if (--(chan->write_open_refcount) == 0) { 3718 DPRINTF("(stopping write transfer)\n"); 3719 usbd_transfer_stop(chan->xfer[UMIDI_TX_TRANSFER]); 3720 } 3721 } 3722 3723 static int 3724 umidi_open(struct usb_fifo *fifo, int fflags) 3725 { 3726 struct umidi_chan *chan = usb_fifo_softc(fifo); 3727 struct umidi_sub_chan *sub = umidi_sub_by_fifo(fifo); 3728 3729 if (fflags & FREAD) { 3730 if (usb_fifo_alloc_buffer(fifo, 4, (1024 / 4))) { 3731 return (ENOMEM); 3732 } 3733 mtx_lock(&chan->mtx); 3734 chan->read_open_refcount++; 3735 sub->read_open = 1; 3736 mtx_unlock(&chan->mtx); 3737 } 3738 if (fflags & FWRITE) { 3739 if (usb_fifo_alloc_buffer(fifo, 32, (1024 / 32))) { 3740 return (ENOMEM); 3741 } 3742 /* clear stall first */ 3743 mtx_lock(&chan->mtx); 3744 usbd_xfer_set_stall(chan->xfer[UMIDI_TX_TRANSFER]); 3745 chan->write_open_refcount++; 3746 sub->write_open = 1; 3747 3748 /* reset */ 3749 sub->state = UMIDI_ST_UNKNOWN; 3750 mtx_unlock(&chan->mtx); 3751 } 3752 return (0); /* success */ 3753 } 3754 3755 static void 3756 umidi_close(struct usb_fifo *fifo, int fflags) 3757 { 3758 if (fflags & FREAD) { 3759 usb_fifo_free_buffer(fifo); 3760 } 3761 if (fflags & FWRITE) { 3762 usb_fifo_free_buffer(fifo); 3763 } 3764 } 3765 3766 3767 static int 3768 umidi_ioctl(struct usb_fifo *fifo, u_long cmd, void *data, 3769 int fflags) 3770 { 3771 return (ENODEV); 3772 } 3773 3774 static void 3775 umidi_init(device_t dev) 3776 { 3777 struct uaudio_softc *sc = device_get_softc(dev); 3778 struct umidi_chan *chan = &sc->sc_midi_chan; 3779 3780 mtx_init(&chan->mtx, "umidi lock", NULL, MTX_DEF | MTX_RECURSE); 3781 } 3782 3783 static struct usb_fifo_methods umidi_fifo_methods = { 3784 .f_start_read = &umidi_start_read, 3785 .f_start_write = &umidi_start_write, 3786 .f_stop_read = &umidi_stop_read, 3787 .f_stop_write = &umidi_stop_write, 3788 .f_open = &umidi_open, 3789 .f_close = &umidi_close, 3790 .f_ioctl = &umidi_ioctl, 3791 .basename[0] = "umidi", 3792 }; 3793 3794 static int 3795 umidi_probe(device_t dev) 3796 { 3797 struct uaudio_softc *sc = device_get_softc(dev); 3798 struct usb_attach_arg *uaa = device_get_ivars(dev); 3799 struct umidi_chan *chan = &sc->sc_midi_chan; 3800 struct umidi_sub_chan *sub; 3801 int unit = device_get_unit(dev); 3802 int error; 3803 uint32_t n; 3804 3805 if (usb_test_quirk(uaa, UQ_SINGLE_CMD_MIDI)) 3806 chan->single_command = 1; 3807 3808 if (usbd_set_alt_interface_index(sc->sc_udev, chan->iface_index, 3809 chan->iface_alt_index)) { 3810 DPRINTF("setting of alternate index failed!\n"); 3811 goto detach; 3812 } 3813 usbd_set_parent_iface(sc->sc_udev, chan->iface_index, 3814 sc->sc_mixer_iface_index); 3815 3816 error = usbd_transfer_setup(uaa->device, &chan->iface_index, 3817 chan->xfer, umidi_config, UMIDI_N_TRANSFER, 3818 chan, &chan->mtx); 3819 if (error) { 3820 DPRINTF("error=%s\n", usbd_errstr(error)); 3821 goto detach; 3822 } 3823 if ((chan->max_cable > UMIDI_CABLES_MAX) || 3824 (chan->max_cable == 0)) { 3825 chan->max_cable = UMIDI_CABLES_MAX; 3826 } 3827 3828 for (n = 0; n < chan->max_cable; n++) { 3829 3830 sub = &chan->sub[n]; 3831 3832 error = usb_fifo_attach(sc->sc_udev, chan, &chan->mtx, 3833 &umidi_fifo_methods, &sub->fifo, unit, n, 3834 chan->iface_index, 3835 UID_ROOT, GID_OPERATOR, 0644); 3836 if (error) { 3837 goto detach; 3838 } 3839 } 3840 3841 mtx_lock(&chan->mtx); 3842 3843 /* clear stall first */ 3844 usbd_xfer_set_stall(chan->xfer[UMIDI_RX_TRANSFER]); 3845 3846 /* 3847 * NOTE: At least one device will not work properly unless the 3848 * BULK IN pipe is open all the time. This might have to do 3849 * about that the internal queues of the device overflow if we 3850 * don't read them regularly. 3851 */ 3852 usbd_transfer_start(chan->xfer[UMIDI_RX_TRANSFER]); 3853 3854 mtx_unlock(&chan->mtx); 3855 3856 return (0); /* success */ 3857 3858 detach: 3859 return (ENXIO); /* failure */ 3860 } 3861 3862 static int 3863 umidi_detach(device_t dev) 3864 { 3865 struct uaudio_softc *sc = device_get_softc(dev); 3866 struct umidi_chan *chan = &sc->sc_midi_chan; 3867 uint32_t n; 3868 3869 for (n = 0; n < UMIDI_CABLES_MAX; n++) { 3870 usb_fifo_detach(&chan->sub[n].fifo); 3871 } 3872 3873 mtx_lock(&chan->mtx); 3874 3875 usbd_transfer_stop(chan->xfer[UMIDI_RX_TRANSFER]); 3876 3877 mtx_unlock(&chan->mtx); 3878 3879 usbd_transfer_unsetup(chan->xfer, UMIDI_N_TRANSFER); 3880 3881 mtx_destroy(&chan->mtx); 3882 3883 return (0); 3884 } 3885 3886 DRIVER_MODULE(uaudio, uhub, uaudio_driver, uaudio_devclass, NULL, 0); 3887 MODULE_DEPEND(uaudio, usb, 1, 1, 1); 3888 MODULE_DEPEND(uaudio, sound, SOUND_MINVER, SOUND_PREFVER, SOUND_MAXVER); 3889 MODULE_VERSION(uaudio, 1); 3890