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