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