/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2010 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/*
* AUDIO CONTROL Driver:
*
* usb_ac is a multiplexor that sits on top of usb_as and hid and is
* responsible for (1) providing the entry points to audio mixer framework,
* (2) passing control commands to and from usb_as and hid and (3) processing
*
* 1. Mixer entry points are: usb_ac_setup(), usb_ac_teardown(),
* usb_ac_set_config(), usb_ac_set_format(), usb_ac_start_play(),
* usb_ac_pause_play(), usb_ac_stop_play, usb_ac_start_record(),
* usb_ac_stop_record().
* 2. usb_ac is a streams driver that passes streams messages down to
* usb_as that selects the correct alternate with passed format
* 3. usb_ac handles the set_config command through the default pipe
* of sound control interface of the audio device in a synchronous
* manner.
*
* Serialization: A competing thread can't be allowed to interfere with
* (1) pipe, (2) streams state.
* So we need some kind of serialization among the asynchronous
* threads that can run in the driver. The serialization is mostly
* etc. Once a routine takes control, it checks if the resource (pipe or
* stream or dev state) is still accessible. If so, it proceeds with
* its job and until it completes, no other thread requiring the same
* resource can run.
*
* PM model in usb_ac: Raise power during attach. If a device is not at full
* power, raise power in the entry points. After the command is over,
* pm_idle_component() is called. The power is lowered in detach().
*/
/* for getting the minor node info from hid */
/* debug support */
/*
* wait period in seconds for the HID message processing thread
* used primarily to check when the stream has closed
*/
/*
* table for converting term types of input and output terminals
* to OSS port types (pretty rough mapping)
*/
static const char *usb_audio_dtypes[] = {
NULL,
};
enum {
USB_PORT_LINEIN = 0,
};
static struct {
} usb_ac_term_type_map[] = {
/* Input Terminal Types */
/* Output Terminal Types */
/* Bi-directional Terminal Types */
/* Telephony Terminal Types */
/* External Terminal Types */
/* Embedded Function Terminal Types */
{ 0, 0 }
};
/*
* Module linkage routines for the kernel
*/
static int usb_ac_power(dev_info_t *, int, int);
uint_t);
/* module entry points */
int usb_ac_open(dev_info_t *);
void usb_ac_close(dev_info_t *);
/* descriptor handling */
static int usb_ac_handle_descriptors(usb_ac_state_t *);
static void usb_ac_free_all_units(usb_ac_state_t *);
static void usb_ac_setup_connections(usb_ac_state_t *);
/* power management */
static int usb_ac_pwrlvl0(usb_ac_state_t *);
static int usb_ac_pwrlvl1(usb_ac_state_t *);
static int usb_ac_pwrlvl2(usb_ac_state_t *);
static int usb_ac_pwrlvl3(usb_ac_state_t *);
static void usb_ac_pm_busy_component(usb_ac_state_t *);
static void usb_ac_pm_idle_component(usb_ac_state_t *);
/* event handling */
static int usb_ac_disconnect_event_cb(dev_info_t *);
static int usb_ac_reconnect_event_cb(dev_info_t *);
static int usb_ac_cpr_suspend(dev_info_t *);
static void usb_ac_cpr_resume(dev_info_t *);
};
/* misc. support */
static void usb_ac_serialize_access(usb_ac_state_t *);
static void usb_ac_release_access(usb_ac_state_t *);
static void usb_ac_show_traverse_path(usb_ac_state_t *);
int);
int, short *);
int, void *);
/* usb audio basic function entries */
static int usb_ac_restore_audio_state(usb_ac_state_t *, int);
static int usb_ac_ctrl_restore(usb_ac_state_t *);
/*
* Mux
*/
static int usb_ac_mux_walk_siblings(usb_ac_state_t *);
static void usb_ac_print_reg_data(usb_ac_state_t *,
static int usb_ac_setup_plumbed(usb_ac_state_t *, int, int);
static int usb_ac_mixer_registration(usb_ac_state_t *);
static void usb_ac_hold_siblings(usb_ac_state_t *);
static int usb_ac_online_siblings(usb_ac_state_t *);
static void usb_ac_rele_siblings(usb_ac_state_t *);
static int usb_ac_mux_plumbing(usb_ac_state_t *);
static void usb_ac_mux_plumbing_tq(void *);
static int usb_ac_mux_unplumbing(usb_ac_state_t *);
static void usb_ac_mux_unplumbing_tq(void *);
static int usb_ac_plumb(usb_ac_plumbed_t *);
static void usb_ac_unplumb(usb_ac_plumbed_t *);
static void usb_ac_reader(void *);
static int usb_ac_do_plumbing(usb_ac_state_t *);
static int usb_ac_do_unplumbing(usb_ac_state_t *);
static int usb_change_phy_vol(usb_ac_state_t *, int);
static void usb_restore_engine(usb_ac_state_t *);
/* anchor for soft state structures */
void *usb_ac_statep;
/*
* DDI Structures
*/
/* Device operations structure */
DEVO_REV, /* devo_rev */
0, /* devo_refcnt */
NULL, /* devo_getinfo */
nulldev, /* devo_identify - obsolete */
nulldev, /* devo_probe - not needed */
usb_ac_attach, /* devo_attach */
usb_ac_detach, /* devo_detach */
nodev, /* devo_reset */
NULL, /* devi_cb_ops */
NULL, /* devo_busb_ac_ops */
usb_ac_power, /* devo_power */
ddi_quiesce_not_needed, /* devo_quiesce */
};
/* Linkage structure for loadable drivers */
&mod_driverops, /* drv_modops */
"USB Audio Control Driver", /* drv_linkinfo */
&usb_ac_dev_ops /* drv_dev_ops */
};
/* Module linkage structure */
MODREV_1, /* ml_rev */
(void *)&usb_ac_modldrv, /* ml_linkage */
NULL /* NULL terminates the list */
};
static int usb_audio_register(usb_ac_state_t *);
static int usb_audio_unregister(usb_ac_state_t *);
static int usb_engine_open(void *, int, unsigned *, caddr_t *);
static void usb_engine_close(void *);
static uint64_t usb_engine_count(void *);
static int usb_engine_start(void *);
static void usb_engine_stop(void *);
static int usb_engine_format(void *);
static int usb_engine_channels(void *);
static int usb_engine_rate(void *);
static void usb_engine_sync(void *, unsigned);
static unsigned usb_engine_qlen(void *);
/* engine buffer size in terms of fragments */
};
/* standard entry points */
int
_init(void)
{
int rval;
/* initialize the soft state */
return (rval);
}
}
return (rval);
}
int
_fini(void)
{
int rval;
/* Free the soft state internal structures */
}
return (rval);
}
int
{
}
static int
{
switch (cmd) {
case DDI_ATTACH:
break;
case DDI_RESUME:
return (DDI_SUCCESS);
default:
return (DDI_FAILURE);
}
/*
* wait until all processes are started from main.
* USB enumerates early in boot (ie. consconfig time).
* If the plumbing takes place early, the file descriptors
* are owned by the init process and can never be closed anymore
* Consequently, hot removal is not possible and the dips
* never go away. By waiting some time, e.g. INIT_PROCESS_CNT,
* the problem is avoided.
*/
if (nproc < INIT_PROCESS_CNT) {
"usb_ac%d attach too early", instance);
return (DDI_FAILURE);
}
/*
* Allocate soft state information.
*/
goto fail;
}
/*
* get soft state space and initialize
*/
goto fail;
}
/* get log handle */
0);
"usb_client_attach failed");
return (DDI_FAILURE);
}
USB_PARSE_LVL_IF, 0) != USB_SUCCESS) {
"usb_get_dev_data failed");
return (DDI_FAILURE);
}
/* initialize mutex & cv */
/* parse all class specific descriptors */
goto fail;
}
/* we no longer need the descr tree */
/* we are online */
/*
* safe guard the postattach to be executed
* only two states arepossible: plumbed / unplumbed
*/
/* create components to power manage this device */
/* Register for events */
"usb_ac_attach: couldn't register for events");
goto fail;
}
"usb_ac_attach: End");
/* report device */
goto fail;
return (DDI_SUCCESS);
fail:
if (uacp) {
"attach failed");
/* wait for plumbing thread to finish */
}
}
return (DDI_FAILURE);
}
static int
{
switch (cmd) {
case DDI_DETACH:
/* wait for plumbing thread to finish */
/* do not allow detach if still busy */
if (uacp->usb_ac_busy_count) {
"usb_ac_detach:still busy, usb_ac_busy_count = %d",
return (USB_FAILURE);
}
(void) usb_audio_unregister(uacp);
/*
* unplumb to stop activity from other modules, then
* cleanup, which will also teardown audio framework state
*/
if (rval != USB_SUCCESS) {
}
case DDI_SUSPEND:
"usb_ac_detach: suspending");
default:
return (DDI_FAILURE);
}
}
/*
* usb_ac_cleanup:
* cleanup on attach failure and detach
*/
static int
{
"usb_ac_cleanup:begain");
/*
* Disable the event callbacks, after this point, event
* callbacks will never get called. Note we shouldn't hold
* the mutex while unregistering events because there may be a
* competing event callback thread. Event callbacks are done
* with ndi mutex held and this can cause a potential deadlock.
*/
if (uacpm->acpm_wakeup_enabled) {
if (rval != USB_SUCCESS) {
"usb_ac_cleanup: disable remote "
"wakeup failed, rval=%d", rval);
}
} else {
}
}
if (uacpm) {
}
/* free descriptors */
"usb_ac_cleanup: Ending");
return (USB_SUCCESS);
}
int
{
return (0);
}
void
{
if (uacp->usb_ac_busy_count > 0)
}
/*
* usb_ac_read_msg:
* Handle asynchronous response from opened streams
*/
static int
{
int val;
char val1;
/*
* typically an M_CTL is used between modules but in order to pass
* through the streamhead, an M_PROTO type must be used instead
*/
case M_PROTO:
case M_ERROR:
switch (plumb_infop->acp_driver) {
case USB_AH_PLUMBED:
"message from hid, instance=%d",
if (uacp->usb_ac_registered_with_mixer) {
/* Handle relative volume change */
case USB_AUDIO_VOL_CHANGE:
/* prevent unplumbing */
if (uacp->usb_ac_plumbing_state ==
(void) usb_change_phy_vol(
mutex_enter(&uacp->
}
/* FALLTHRU */
case USB_AUDIO_MUTE:
default:
break;
}
} else {
}
break;
default:
"message from unknown module(%s)",
}
break;
default:
}
return (error);
}
/*
* Power Management
* usb_ac_power:
* power entry point
*/
static int
{
"usb_ac_power: illegal level=%d pwr_states=%d",
goto done;
}
switch (level) {
case USB_DEV_OS_PWR_OFF:
break;
case USB_DEV_OS_PWR_1:
break;
case USB_DEV_OS_PWR_2:
break;
case USB_DEV_OS_FULL_PWR:
break;
}
done:
}
/*
* functions to handle power transition for various levels
* These functions act as place holders to issue USB commands
* to the devices to change their power levels
* Level 0 = Device is powered off
* Level 3 = Device if full powered
* Level 1,2 = Intermediate power level of the device as implemented
* by the hardware.
* Note that Level 0 is OS power-off and Level 3 is OS full-power.
*/
static int
{
int rval;
switch (uacp->usb_ac_dev_state) {
case USB_DEV_ONLINE:
/* Deny the powerdown request if the device is busy */
if (uacpm->acpm_pm_busy != 0) {
return (USB_FAILURE);
}
/* Issue USB D3 command to the device here */
/* FALLTHRU */
case USB_DEV_DISCONNECTED:
case USB_DEV_SUSPENDED:
case USB_DEV_PWRED_DOWN:
default:
return (USB_SUCCESS);
}
}
/* ARGSUSED */
static int
{
int rval;
/* Issue USB D2 command to the device here */
return (USB_FAILURE);
}
/* ARGSUSED */
static int
{
int rval;
return (USB_FAILURE);
}
static int
{
int rval;
switch (uacp->usb_ac_dev_state) {
case USB_DEV_PWRED_DOWN:
/* Issue USB D0 command to the device here */
/* FALLTHRU */
case USB_DEV_ONLINE:
/* we are already in full power */
/* FALLTHRU */
case USB_DEV_DISCONNECTED:
case USB_DEV_SUSPENDED:
return (USB_SUCCESS);
default:
"usb_ac_pwerlvl3: Illegal dev_state");
return (USB_FAILURE);
}
}
static void
{
"usb_ac_create_pm_components: begin");
/* Allocate the state structure */
uacpm->acpm_capabilities = 0;
USB_SUCCESS) {
"remote Wakeup enabled");
}
} else {
if (uacpm) {
}
"pm not enabled");
}
}
/*
* usb_ac_get_featureID:
* find out if there is at least one feature unit that supports
* the request controls.
* Return featureID or USB_AC_ID_NONE.
*/
static uint_t
{
}
/*
* usb_ac_feature_unit_check:
* check if a feature unit can support the required channel
* and control combination. Return USB_SUCCESS or USB_FAILURE.
* Called for each matching unit from usb_ac_traverse_connections.
*/
/*ARGSUSED*/
static int
{
int n_channel_controls;
/*
* check if this control is supported on this channel
*/
if (feature_descrp->bControlSize == 0) {
} else {
"#controls: %d index=%d", n_channel_controls,
if (channel > n_channel_controls) {
} else {
/*
* we only support MUTE and VOLUME
* which are in the first byte
*/
"control: 0x%x",
control) == 0) {
}
}
}
"usb_ac_feature_unit_check: dir=%d featureID=0x%x",
return ((featureID != USB_AC_ID_NONE) ?
}
/*
* Descriptor Management
*
* usb_ac_handle_descriptors:
* extract interesting descriptors from the config cloud
*/
static int
{
/* find USB_AUDIO_CS_INTERFACE type descriptor */
continue;
}
break;
}
}
"usb_ac_handle_descriptors:cannot find descriptor type %d",
return (rval);
}
(void *)&descr, sizeof (usb_audio_cs_if_descr_t));
/* is this a sane header descriptor */
if (!((len >= CS_AC_IF_HEADER_SIZE) &&
"invalid header");
return (rval);
}
"index %d, header: type=0x%x subtype=0x%x bcdADC=0x%x\n\t"
"total=0x%x InCol=0x%x",
/*
* we read descriptors by index and store them in ID array.
* the actual parsing is done in usb_ac_add_unit_descriptor()
*/
"index=%d", index);
continue;
}
/* add to ID array */
cvs->cvs_buf_len);
}
rval = USB_SUCCESS;
/* determine port types */
return (rval);
}
/*
* usb_ac_setup_connections:
* build a matrix reflecting all connections
*/
static void
{
/* allocate array for unit types for quick reference */
KM_SLEEP);
/* allocate array for traversal path */
KM_SLEEP);
/* allocate the connection matrix and set it up */
/* trick to create a 2 dimensional array */
for (i = 0; i < uacp->usb_ac_max_unit; i++) {
p[i] = a + i * uacp->usb_ac_max_unit;
}
uacp->usb_ac_connections = p;
uacp->usb_ac_connections_a = a;
/* traverse all units and set connections */
"--------traversing unit=0x%x type=0x%x--------",
/* store type in the first unused column */
/* save the Unit ID in the unit it points to */
case USB_AUDIO_FEATURE_UNIT:
{
"USB_AUDIO_FEATURE_UNIT:sourceID=0x%x type=0x%x",
if (d->bSourceID != 0) {
}
break;
}
{
"USB_AUDIO_OUTPUT_TERMINAL:sourceID=0x%x type=0x%x",
if (d->bSourceID != 0) {
}
break;
}
case USB_AUDIO_MIXER_UNIT:
{
int id;
"USB_AUDIO_MIXER_UNIT:sourceID=0x%x"
"type=0x%x c=%d",
d->baSourceID[id],
if (d->baSourceID[id] != 0) {
B_FALSE);
}
}
break;
}
case USB_AUDIO_SELECTOR_UNIT:
{
int id;
"USB_AUDIO_SELECTOR_UNIT:sourceID=0x%x"
if (d->baSourceID[id] != 0) {
B_FALSE);
}
}
break;
}
{
int id;
"USB_AUDIO_PROCESSING_UNIT:sourceID=0x%x"
if (d->baSourceID[id] != 0) {
B_FALSE);
}
}
break;
}
case USB_AUDIO_EXTENSION_UNIT:
{
int id;
"USB_AUDIO_EXTENSION_UNIT:sourceID=0x%x"
if (d->baSourceID[id] != 0) {
B_TRUE);
}
}
break;
}
case USB_AUDIO_INPUT_TERMINAL:
break;
default:
/*
* Ignore the rest because they are not support yet
*/
break;
}
}
#ifdef DEBUG
/* display topology in log buffer */
{
uint_t i, j, l;
char *buf;
"unit types:");
/* two strings so they won't be replaced accidentily by tab */
}
}
uacp->usb_ac_unit_type[i]);
}
"adjacency matrix:");
}
}
}
}
}
#endif
}
/*
* usb_ac_add_unit_descriptor:
* take the parsed descriptor in the buffer and store it in the ID unit
* array. we grow the unit array if the ID exceeds the current max
*/
static void
{
void *descr;
int len;
char *format;
/* doubling the length should allow for padding */
switch (buffer[2]) {
case USB_AUDIO_INPUT_TERMINAL:
break;
break;
case USB_AUDIO_MIXER_UNIT:
break;
case USB_AUDIO_SELECTOR_UNIT:
break;
case USB_AUDIO_FEATURE_UNIT:
break;
break;
case USB_AUDIO_EXTENSION_UNIT:
break;
default:
/* ignore this descriptor */
return;
}
/* ignore this descriptor */
return;
}
switch (buffer[2]) {
case USB_AUDIO_INPUT_TERMINAL:
{
"usb_ac_units[%d] ---input term: type=0x%x sub=0x%x"
"termid=0x%x\n\t"
"termtype=0x%x assoc=0x%x #ch=%d "
"chconf=0x%x ich=0x%x iterm=0x%x",
d->bTerminalID,
d->bDescriptorType, d->bDescriptorSubType,
d->bTerminalID, d->wTerminalType,
d->bAssocTerminal, d->bNrChannels,
d->wChannelConfig, d->iChannelNames,
d->iTerminal);
break;
}
{
"usb_ac_units[%d] ---output term: type=0x%x sub=0x%x"
" termid=0x%x\n\t"
"termtype=0x%x assoc=0x%x sourceID=0x%x iterm=0x%x",
d->bTerminalID,
d->bDescriptorType, d->bDescriptorSubType,
d->bTerminalID, d->wTerminalType,
d->bAssocTerminal, d->bSourceID,
d->iTerminal);
break;
}
case USB_AUDIO_MIXER_UNIT:
{
"usb_ac_units[%d] ---mixer unit: type=0x%x sub=0x%x"
" unitid=0x%x\n\t"
"#pins=0x%x sourceid[0]=0x%x",
d->bUnitID,
d->bDescriptorType, d->bDescriptorSubType,
break;
}
case USB_AUDIO_SELECTOR_UNIT:
{
"usb_ac_units[%d] ---selector unit: type=0x%x sub=0x%x"
" unitid=0x%x\n\t"
"#pins=0x%x sourceid[0]=0x%x",
d->bUnitID,
d->bDescriptorType, d->bDescriptorSubType,
break;
}
case USB_AUDIO_FEATURE_UNIT:
{
"usb_ac_units[%d] ---feature unit: type=0x%x sub=0x%x"
" unitid=0x%x\n\t"
"sourceid=0x%x size=0x%x",
d->bUnitID,
d->bDescriptorType, d->bDescriptorSubType,
break;
}
{
"usb_ac_units[%d] ---processing unit: type=0x%x sub=0x%x"
" unitid=0x%x\n\t"
"#pins=0x%x sourceid[0]=0x%x",
d->bUnitID,
d->bDescriptorType, d->bDescriptorSubType,
break;
}
case USB_AUDIO_EXTENSION_UNIT:
{
"usb_ac_units[%d] ---mixer unit: type=0x%x sub=0x%x"
" unitid=0x%x\n\t"
"#pins=0x%x sourceid[0]=0x%x",
d->bUnitID,
d->bDescriptorType, d->bDescriptorSubType,
break;
}
default:
break;
}
}
/*
* usb_ac_alloc_unit:
* check if the unit ID is less than max_unit in which case no
* extra entries are needed. If more entries are needed, copy over
* the existing array into a new larger array
*/
static void
{
if (uacp->usb_ac_units) {
/* existing array is big enough */
return;
}
}
/* allocate two extra ones */
unit += 2;
sizeof (usb_ac_unit_list_t), KM_SLEEP);
if (old) {
}
}
/*
* usb_ac_free_all_units:
* free the entire unit list
*/
static void
{
return;
}
if (unitp) {
if (unitp->acu_descriptor) {
}
}
}
sizeof (usb_ac_unit_list_t));
}
/*
* usb_ac_lookup_port_type:
* map term type to port type
* default just return LINE_IN + LINE_OUT
*/
static int
{
uint_t i;
/*
* type, it should not be common streaming type
*/
for (i = 0; ; i++) {
if (usb_ac_term_type_map[i].term_type == 0) {
break;
}
return (usb_ac_term_type_map[i].port_type);
}
}
return (USB_PORT_UNKNOWN);
}
/*
* usb_ac_update_port:
* called for each terminal
*/
/*ARGSUSED*/
static int
{
if (dir & USB_AUDIO_PLAY) {
"usb_ac_update_port: dir=%d wTerminalType=0x%x, name=%s",
} else {
"usb_ac_update_port: dir=%d wTerminalType=0x%x, name=%s",
}
return (USB_SUCCESS);
}
/*
* usb_ac_map_termtype_to_port:
* starting from a streaming termtype find all
* input or output terminals and OR into uacp->usb_ac_input_ports
* or uacp->usb_ac_output_ports;
*/
static void
{
}
/*
* usb_ac_set_port:
* find a selector port (record side only) and set the
* input to the matching pin
*/
static uint_t
{
/* we only support the selector for the record side */
if (dir & USB_AUDIO_RECORD) {
"usb_ac_set_port: id=%d count=%d port=%d",
}
return (USB_SUCCESS);
}
/*
* usb_ac_match_port:
* given the requested port type, find a correspondig term type
* Called from usb_ac_traverse_all_units()
*/
/*ARGSUSED*/
static int
{
if (dir & USB_AUDIO_PLAY) {
"usb_ac_match_port: "
"dir=%d type=0x%x port_type=%d port=%d",
} else {
"usb_ac_match_port: "
"dir=%d type=0x%x port_type=%d port=%d",
}
}
/*
* usb_ac_set_selector:
* Called from usb_ac_traverse_all_units()
* Find the correct pin and set selector to this pin
*/
/*ARGSUSED*/
static int
{
/*
* for each pin, find a term type that matches the
* requested port type
*/
if (d->baSourceID[pin] == 0) {
break;
}
break;
} else {
continue;
}
}
/* find units connected to this unit */
if (unit != USB_AC_ID_NONE) {
break;
}
}
if (unit != USB_AC_ID_NONE) {
if (!data) {
"usb_ac_set_selector: allocate data failed");
return (USB_FAILURE);
}
/* pins are 1-based */
USB_DEV_REQ_RCPT_IF, /* bmRequestType */
USB_AUDIO_SET_CUR, /* bRequest */
0, /* wValue */
/* feature unit and id */
1, /* wLength */
&data,
USB_FLAGS_SLEEP) == USB_SUCCESS) {
rval = USB_SUCCESS;
} else {
"set current pin selection failed");
}
} else {
"usb_ac_set_selector: nothing found");
}
return (rval);
}
/*
* usb_ac_set_control:
* apply func to all units of search_target type for both the
* requested channel and master channel
*/
static uint_t
{
if ((channel != 0) &&
(all_or_one == USB_AC_FIND_ALL))) {
/* try master channel */
channel = 0;
}
return (id);
}
/*
* usb_ac_traverse_all_units:
* traverse all units starting with all IT or OT depending on direction.
* If no unit is found for the particular channel, try master channel
* If a matching unit is found, apply the function passed by
* the caller
*/
static uint_t
{
/* keep track of recursion */
if ((*depth)++ > USB_AC_MAX_DEPTH) {
"Unit topology too complex, giving up");
return (USB_AC_ID_NONE);
}
/* is this an IT or OT? */
continue;
}
/* start at streaming term types */
if (dir & USB_AUDIO_PLAY) {
if (d->wTerminalType !=
continue;
}
} else {
if (d->wTerminalType !=
continue;
}
}
/* find units connected to this unit */
if ((all_or_one == USB_AC_FIND_ONE) &&
(id != USB_AC_ID_NONE)) {
break;
}
}
(*depth)--;
}
/*
* usb_ac_set_monitor_gain_control:
* search for a feature unit between output terminal (OT) and
* input terminal. We are looking for a path between
* for example a microphone and a speaker through a feature unit
* and mixer
*/
static uint_t
{
/* is this an OT and not stream type? */
(d->wTerminalType != USB_AUDIO_TERM_TYPE_STREAMING)) {
/* find units connected to this unit */
if ((all_or_one == USB_AC_FIND_ONE) &&
(id != USB_AC_ID_NONE)) {
break;
}
}
}
return (id);
}
/*
*/
static void
{
}
/* ARGSUSED */
static void
{
}
/*
* usb_ac_show_traverse_path:
* display entire path, just for debugging
*/
static void
{
int i;
for (i = 0; i < uacp->usb_ac_traverse_path_index; i++) {
"traverse path %d: unit=%d type=%d",
i, uacp->usb_ac_traverse_path[i],
}
}
/*
* usb_ac_check_path:
* check for a specified type in the traverse path
*/
static int
{
int i;
for (i = 0; i < uacp->usb_ac_traverse_path_index; i++) {
return (USB_SUCCESS);
}
}
return (USB_FAILURE);
}
/*
* usb_ac_traverse_connections:
* traverse all units and for each unit with the right type, call
* func. If the func returns a success and search == USB_AC_FIND_ONE,
* we are done. If all is set then we continue until we terminate
* and input or output terminal.
* For audio play, we traverse columns starting from an input terminal
* to an output terminal while for record we traverse rows from output
* terminal to input terminal.
*/
static uint_t
{
/* keep track of recursion depth */
if ((*depth)++ > USB_AC_MAX_DEPTH) {
"Unit topology too complex, giving up");
return (USB_AC_ID_NONE);
}
if (entry) {
"start=%d unit=%d entry=%d type=%d "
"done=%d found=%d",
/* did we find a matching type? */
"match: dir=%d unit=%d type=%d",
/* yes, no apply function to this unit */
(*count)++;
"func returned success, "
"unit=%d all=%d", unit,
/* are we done? */
if (all_or_one == USB_AC_FIND_ONE) {
break;
}
}
}
/* did we find the terminating unit */
continue;
}
if ((id != USB_AC_ID_NONE) &&
(all_or_one == USB_AC_FIND_ONE)) {
break;
}
}
}
(*depth)--;
}
/*
* Event Management
*
* usb_ac_disconnect_event_cb:
* The device has been disconnected. we either wait for
* detach or a reconnect event.
*/
static int
{
"usb_ac_disconnect_event_cb:start");
/* setting to disconnect state will prevent replumbing */
if (uacp->usb_ac_busy_count) {
"device was disconnected while busy. "
"Data may have been lost");
}
"usb_ac_disconnect_event_cb:done");
return (USB_SUCCESS);
}
/*
* usb_ac_cpr_suspend:
*/
static int
{
"usb_ac_cpr_suspend: Begin");
"usb_ac_cpr_suspend: End");
return (USB_SUCCESS);
}
/*
* usb_ac_reconnect_event_cb:
* The device was disconnected but this instance not detached, probably
* because the device was busy.
* if the same device, continue with restoring state
* We should either be in the unplumbed state or the plumbed open
* state.
*/
static int
{
"usb_ac_reconnect_event_cb:begain");
/* check the plumbing state */
if (uacp->usb_ac_plumbing_state ==
}
if (uacp->usb_ac_busy_count) {
"busy device has been reconnected");
}
"usb_ac_reconnect_event_cb:done");
return (USB_SUCCESS);
}
/*
* usb_ac_cpr_resume:
* Restore device state
*/
static void
{
"usb_ac_cpr_resume");
}
/*
* usb_ac_restore_device_state:
* Set original configuration of the device
* enable wrq - this starts new transactions on the control pipe
*/
static void
{
int rval;
"usb_ac_restore_device_state:");
/* Check if we are talking to the same device */
/* change the device state from suspended to disconnected */
return;
}
if (uacpm) {
if (uacpm->acpm_wakeup_enabled) {
USB_REMOTE_WAKEUP_ENABLE)) != USB_SUCCESS) {
"usb_ac_restore_device_state: "
"remote wakeup "
"enable failed, rval=%d", rval);
}
}
}
/* prevent unplumbing */
(void) usb_ac_restore_audio_state(uacp, 0);
}
}
/*
* usb_ac_am_restore_state
*/
static void
{
"usb_ac_am_restore_state: Begin");
if (uacp->usb_ac_plumbing_state ==
/*
* allow hid and usb_as to restore themselves
* (some handshake would have been preferable though)
*/
}
/* allow unplumbing */
"usb_ac_am_restore_state: End");
}
/*
* usb_ac_restore_audio_state:
*/
static int
{
switch (uacp->usb_ac_plumbing_state) {
case USB_AC_STATE_PLUMBED:
break;
case USB_AC_STATE_UNPLUMBED:
return (USB_SUCCESS);
default:
return (USB_FAILURE);
}
/*
* increment busy_count again, it will be decremented
* in usb_ac_am_restore_state
*/
if (flag & USB_FLAGS_SLEEP) {
usb_ac_am_restore_state((void *)uacp);
} else {
return (USB_FAILURE);
}
}
return (USB_SUCCESS);
}
/*
* Mixer Callback Management
* NOTE: all mixer callbacks are serialized. we cannot be closed while
* we are in the middle of a callback. There needs to be a
* teardown first. We cannot be unplumbed as long as we are
* still open.
*
* usb_ac_setup:
* Send setup to usb_as if the first setup
* Check power is done in usb_ac_send_as_cmd()
*/
static int
{
return (USB_FAILURE);
}
return (rval);
}
/*
* usb_ac_do_setup:
* Wrapper function for usb_ac_setup which can be called
* either from audio framework for usb_ac_set_format
*/
static int
{
/*
* Handle multiple setup calls. Pass the setup call to usb_as only
* the first time so isoc pipe will be opened only once
*/
if (streams_infop->acs_setup_teardown_count++) {
"usb_ac_do_setup: more than one setup, cnt=%d",
return (USB_SUCCESS);
}
/* Send setup command to usb_as */
USB_SUCCESS) {
"usb_ac_do_setup: failure");
return (USB_FAILURE);
}
return (USB_SUCCESS);
}
/*
* usb_ac_teardown:
* Send teardown to usb_as if the last teardown
* Check power is done in usb_ac_send_as_cmd()
* NOTE: allow teardown when disconnected
*/
static void
{
/* There should be at least one matching setup call */
/*
* only this is the last teardown so that isoc pipe is closed
* only once
*/
if (--(streams_infop->acs_setup_teardown_count)) {
"cnt=%d",
goto done;
}
/* Send teardown command to usb_as */
(void *)NULL) != USB_SUCCESS) {
"usb_ac_teardown: failure");
goto done;
}
done:
"usb_ac_teardown: End");
}
/*
* usb_ac_set_monitor_gain:
* called for each output terminal which supports
* from usb_ac_traverse_connections
*/
static int
{
"usb_ac_set_monitor_gain: ");
/* log how we got here */
/* we only care about the ITs connected to real hw inputs */
switch (d->wTerminalType) {
return (USB_FAILURE);
default:
break;
}
/*
* we can only do this if the microphone is mixed into the
* audio output so look for a mixer first
*/
USB_SUCCESS) {
int i, id;
/* now look for a feature unit */
i--) {
case USB_AUDIO_MIXER_UNIT:
/* the FU should be before the mixer */
return (USB_FAILURE);
case USB_AUDIO_FEATURE_UNIT:
/*
* now set the volume
*/
/* try master channel */
USB_SUCCESS) {
return (USB_FAILURE);
}
}
return (USB_SUCCESS);
default:
continue;
}
}
}
return (USB_FAILURE);
}
/*
* usb_ac_set_gain is called for each feature unit which supports
* the requested controls from usb_ac_traverse_connections
* we still need to check whether this unit supports the requested
* control.
*/
static int
{
"usb_ac_set_gain: id=%d dir=%d ch=%d cntl=%d gain=%d",
return (USB_FAILURE);
}
"usb_ac_set_gain: getting max gain failed");
return (USB_FAILURE);
}
"usb_ac_set_gain: getting min gain failed");
return (USB_FAILURE);
}
"usb_ac_set_gain: getting cur gain failed");
return (USB_FAILURE);
}
/*
* Set the gain for a channel. The audio mixer calculates the
* impact, if any, on the channel's gain.
*
* 0 <= gain <= AUDIO_MAX_GAIN
*
* channel #, 0 == left, 1 == right
*/
if (gain == 0) {
} else {
}
"usb_ac_set_gain: ch=%d dir=%d max=%d min=%d gain=%d",
featureID) != USB_SUCCESS) {
"usb_ac_set_gain: setting volume failed");
return (USB_FAILURE);
}
"usb_ac_set_gain: getting cur gain failed");
}
"usb_ac_set_gain done: "
return (USB_SUCCESS);
}
/*
* usb_ac_set_format
* This mixer callback initiates a command to be sent to
* usb_as to select an alternate with the passed characteristics
* and also to set the sample frequency.
* Note that this may be called when a playing is going on in
* the streaming interface. To handle that, first stop
* command, send the set_format command down and then reopen
* after a set_format command. (2) Check power is done in
* usb_ac_send_as_cmd().
*/
int
{
int old_setup_teardown_count = 0;
return (USB_FAILURE);
}
/* save format info */
/* isoc pipe not open and playing is not in progress */
if (old_setup_teardown_count) {
}
/*
* Set format for the streaming interface with lower write queue
* This boils down to set_alternate interface command in
* usb_as and the reply mp contains the currently active
* alternate number that is stored in the as_req structure
*/
"usb_ac_set_format: failed");
goto fail;
}
/* Set the sample rate */
&sample) != USB_SUCCESS) {
"usb_ac_set_format: setting format failed");
goto fail;
}
/* This should block until successful */
if (old_setup_teardown_count) {
}
return (USB_SUCCESS);
fail:
return (USB_FAILURE);
}
/*
* usb_ac_start_play
* Send a start_play command down to usb_as
* Check power is done in usb_ac_send_as_cmd()
*/
static int
{
int samples;
return (USB_FAILURE);
}
/* Check for continuous sample rate done in usb_as */
samples++;
}
/* Send setup command to usb_as */
(void *)&play_req) != USB_SUCCESS) {
"usb_ac_start_play: failure");
return (USB_FAILURE);
}
return (USB_SUCCESS);
}
/*
* usb_ac_stop_play:
* Stop the play engine
* called from mixer framework.
*/
void
{
}
return;
}
/* Send setup command to usb_as */
(void *)NULL) != USB_SUCCESS) {
"usb_ac_do_pause_play: failure");
}
}
/*
* usb_ac_start_record:
* Sends a start record command down to usb_as.
* Check power is done in usb_ac_send_as_cmd()
*/
static int
{
return (USB_FAILURE);
}
/* Send setup command to usb_as */
(void *)uacp) != USB_SUCCESS) {
"usb_ac_start_record: failure");
return (USB_FAILURE);
}
return (USB_SUCCESS);
}
/*
* usb_ac_stop_record:
* Wrapper function for usb_ac_do_stop_record and is
* called form mixer framework.
*/
static void
{
/* Send setup command to usb_as */
NULL) != USB_SUCCESS) {
"usb_ac_do_stop_record: failure");
}
}
/*
* Helper Functions for Mixer callbacks
*
* usb_ac_get_maxmin_volume:
* Send USBA command down to get the maximum or minimum gain balance
* Calculate min or max gain balance and return that. Return
* USB_FAILURE for failure cases
*/
/* ARGSUSED */
static int
{
USB_DEV_REQ_RCPT_IF, /* bmRequestType */
cmd, /* bRequest */
/* feature unit and id */
2, /* wLength */
&data,
USB_FLAGS_SLEEP) != USB_SUCCESS) {
"usb_ac_get_maxmin_volume: failed, "
"cr=%d, cb=0x%x cmd=%d, data=0x%p",
return (USB_FAILURE);
}
"usb_ac_get_maxmin_volume: max_or_min=0x%x", *max_or_minp);
return (USB_SUCCESS);
}
/*
* usb_ac_set_volume:
* Send USBA command down to set the gain balance
*/
/* ARGSUSED */
static int
int feature_unitID)
{
/* Construct the mblk_t from gain for sending to USBA */
if (!data) {
"usb_ac_set_volume: allocate data failed");
return (USB_FAILURE);
}
if ((rval = usb_pipe_sync_ctrl_xfer(
USB_DEV_REQ_RCPT_IF, /* bmRequestType */
USB_AUDIO_SET_CUR, /* bRequest */
/* feature unit and id */
2, /* wLength */
&data, 0,
"usb_ac_set_volume: failed, cr=%d cb=0x%x",
}
return (rval);
}
/*
* usb_ac_set_mute is called for each unit that supports the
* requested control from usb_ac_traverse_connections
*/
int
{
return (USB_FAILURE);
}
/* Construct the mblk_t for sending to USBA */
if (!data) {
"usb_ac_set_mute: allocate data failed");
return (USB_FAILURE);
}
if ((rval = usb_pipe_sync_ctrl_xfer(
USB_DEV_REQ_RCPT_IF, /* bmRequestType */
USB_AUDIO_SET_CUR, /* bRequest */
/* feature unit and id */
1, /* wLength */
&data,
0, /* attributes */
}
return (rval);
}
/*
* usb_ac_send_as_cmd:
* Allocate message blk, send a command down to usb_as,
* wait for the reply and free the message
*
* although not really needed to raise power if sending to as
* it seems better to ensure that both interfaces are at full power
*/
static int
{
int rv;
int rval;
if (rv != 0) {
"usb_ac_send_as_cmd: ldi_ioctl failed, error=%d", rv);
return (USB_FAILURE);
}
return (USB_SUCCESS);
}
/*
*/
static void
{
}
static void
{
}
static void
{
"usb_ac_pm_busy_component: %d",
DDI_SUCCESS) {
"usb_ac_pm_busy_component failed: %d",
}
}
}
static void
{
DDI_SUCCESS) {
"usb_ac_pm_idle_component: %d",
}
}
}
/*
* handle read from plumbed drivers
*/
static void
{
int rv;
"Device is not availabe");
break;
}
}
}
/*
* setup threads to read from the other usb modules that may send unsolicited
* or asynchronous messages, which is only hid currently
*/
static int
{
int acp_inst;
char *acp_name;
"usb_ac_plumb:begin");
rv = USB_SUCCESS;
goto OUT;
}
goto OUT;
DDI_SLEEP) != DDI_SUCCESS)
goto OUT;
"usb_ac_plumb: dispatched reader");
rv = USB_SUCCESS;
OUT:
"usb_ac_plumb: done, rv=%d", rv);
return (rv);
}
static void
{
"usb_ac_mux_plumbing_tq:failed");
}
static int
{
"usb_ac_do_plumbing: ddi_taskq_create failed");
goto OUT;
}
DDI_SLEEP) != DDI_SUCCESS) {
"usb_ac_do_plumbing: ddi_taskq_dispatch failed");
goto OUT;
}
rv = USB_SUCCESS;
OUT:
return (rv);
}
static void
{
"usb_ac_mux_unplumbing:failed");
}
static int
{
return (USB_SUCCESS);
"usb_ac_do_unplumbing: ddi_taskq_dispatch failed");
goto OUT;
}
"usb_ac_do_unplumbing: waiting for unplumb thread");
rv = USB_SUCCESS;
"usb_ac_do_unplumbing: unplumb thread done");
OUT:
}
return (rv);
}
/*
* teardown threads to the other usb modules
* and clear structures as part of unplumbing
*/
static void
{
"usb_ac_unplumb: begin");
"usb_ac_unplumb: destroying taskq");
}
/*
* we bzero the streams info and plumbed structure
* since there is no guarantee that the next plumbing
* will be identical
*/
/* bzero the relevant plumbing structure */
}
"usb_ac_unplumb: done");
}
/*ARGSUSED*/
static int
{
/* get the usb_ac dip */
/* Access to the global variables is synchronized */
"usb_ac_mux_plumbing:state = %d",
"usb_ac_mux_plumbing: audio streams driver"
" already plumbed");
return (USB_SUCCESS);
}
/* usb_as and hid should be attached but double check */
"usb_ac_mux_plumbing:no audio streams driver plumbed");
return (USB_FAILURE);
}
"usb_ac_mux_plumbing: raising power");
/* bring the device to full power */
/* avoid dips disappearing while we are plumbing */
/*
* walk all siblings and create the usb_ac<->usb_as and
* usb_ac<->hid streams. return of 0 indicates no or
*/
if (usb_ac_mux_walk_siblings(uacp) == 0) {
/* pretend that we are plumbed so we can unplumb */
(void) usb_ac_mux_unplumbing(uacp);
"usb_ac_mux_plumbing: no audio streams driver plumbed");
return (USB_FAILURE);
}
/* restore state if we have already registered with the mixer */
if (uacp->usb_ac_registered_with_mixer) {
"usb_ac_mux_plumbing:already registered with mixer,"
"restoring state");
"usb_ac_mux_plumbing: mixer registration failed");
(void) usb_ac_mux_unplumbing(uacp);
return (USB_FAILURE);
}
"usb_ac_mux_plumbing:done");
return (USB_SUCCESS);
}
static int
{
int inst;
int i;
int maxlinked = 0;
"usb_ac_mux_unplumbing: already unplumbed!");
return (USB_SUCCESS);
}
/* usb_ac might not have anything plumbed yet */
"usb_ac_mux_unplumbing: nothing plumbed");
return (USB_SUCCESS);
}
/* do not allow detach if still busy */
if (uacp->usb_ac_busy_count) {
"usb_ac_mux_unplumbing: mux still busy (%d)",
return (USB_FAILURE);
}
/* close ac-as and ac-hid streams */
"usb_ac_mux_unplumbing: maxlinked = %d", maxlinked);
for (i = 0; i < maxlinked; i++) {
/*
* we must save members of usb_ac_plumbed[] before calling
* usb_ac_unplumb() because it clears the structure
*/
"usb_ac_mux_unplumbing: [%d] - skipping", i);
continue;
}
"usb_ac_mux_unplumbing: [%d] - %s%d minor 0x%x", i,
"usb_ac_mux_unplumbing:[%d] - closing", i);
/*
* ldi_close will cause panic if ldi_getmsg
* is not finished. ddi_taskq_destroy will wait
* for the thread to complete.
*/
"usb_ac_mux_unplumbing: [%d] - unplumbed", i);
}
}
/* Wait till all activity in the default pipe has drained */
"usb_ac_mux_unplumbing: done");
return (USB_SUCCESS);
}
/*
* walk all siblings and create the ac<->as and ac<->hid streams
*/
static int
{
int drv_instance;
char *drv_name;
int error;
int count = 0;
"usb_ac_mux_walk_siblings: plumbing %s%d count=%d",
/* ignore own dip */
continue;
}
/* ignore other dip other than usb_as and hid */
} else {
continue;
}
if (!i_ddi_devi_attached(child_dip)) {
continue;
}
if (DEVI_IS_DEVICE_REMOVED(child_dip)) {
continue;
}
"usb_ac_mux_walk_siblings:: opening %s%d devt=(%d, 0x%x)",
if (error == 0) {
}
if (error) {
"usb_ac_mux_walk_siblings: open of devt=(%d, 0x%x)"
return (0);
}
/* get registration data */
USB_SUCCESS) {
"usb_ac_mux_walk_siblings:"
"usb_ac_get_reg_data failed on %s%d",
return (0);
}
int rval;
"usb_ac_mux_walk_siblings: pushing usb_ah on %s%d",
/* push usb_ah module on top of hid */
if (error) {
"usb_ac_mux_walk_siblings: ldi_ioctl"
"I_PUSH failed on %s%d, error=%d",
/* skip plumbing the hid driver */
continue;
}
} else {
/* should not be here */
"usb_ac_mux_walk_siblings:- unknown module %s%d",
count--;
/* skip plumbing an unknown module */
continue;
}
if (error != USB_SUCCESS) {
"usb_ac_mux_walk_siblings: usb_ac_plumb "
return (0);
}
"usb_ac_mux_walk_siblings:plumbed %d, minor 0x%x",
count++;
}
"usb_ac_mux_walk_siblings: %d drivers plumbed under usb_ac mux",
count);
return (count);
}
/*
* Register with mixer only after first plumbing.
* Also do not register if earlier reg data
* couldn't be received from at least one
* streaming interface
*/
static int
{
int n;
if (uacp->usb_ac_registered_with_mixer) {
return (USB_SUCCESS);
}
for (n = 0; n < USB_AC_MAX_AS_PLUMBED; n++) {
break;
}
}
/* Haven't found a streaming interface; fail mixer registration */
if (n > USB_AC_MAX_AS_PLUMBED) {
"usb_ac_mixer_registration:- no streaming interface found");
return (USB_FAILURE);
}
/*
* Fill out streaming interface specific stuff
* Note that we handle only one playing and one recording
* streaming interface at the most
*/
for (n = 0; n < USB_AC_MAX_AS_PLUMBED; n++) {
continue;
}
continue;
}
/* check if any channel supports vol. control for this fmt */
USB_AUDIO_VOLUME_CONTROL)) != -1) {
"usb_ac_mixer_registration:n= [%d]"
"- dir=%d featureID=%d",
break;
}
}
"usb_ac_mixer_registration:n= [%d] - mode=%d chs=%d"
"default_gain=%d id=%d",
}
/* the rest */
"usb_ac_mixer_registration: calling usb_audio_register");
"usb_ac_mixer_registration: usb_audio_register failed");
return (USB_FAILURE);
}
return (USB_SUCCESS);
}
/*
* Get registriations data when driver attach
*/
static int
{
for (n = 0; n < USB_AC_MAX_AS_PLUMBED; n++) {
/*
* We haven't received registration data
* from n-th streaming interface in the array
*/
break;
}
}
if (n >= USB_AC_MAX_AS_PLUMBED) {
"More than 2 streaming interfaces (play "
return (USB_FAILURE);
}
/* take the stream reg struct with the same index */
"usb_ac_get_reg_data:regdata from usb_as: streams_reg=0x%p, n=%d",
(void *)streams_reg, n);
"usb_ac_get_reg_data: ldi_ioctl failed for"
"mixer registration error=%d", error);
return (USB_FAILURE);
} else {
"usb_ac_get_reg_data:usb_ac_streams[%d]: "
"received_reg_data=%d type=%s", index,
"play" : "record"));
return (rval);
}
}
/*
* setup plumbed and stream info structure
*/
static int
{
"usb_ac_setup_plumbed: done - plb_idx=%d str_idx=%d ",
return (USB_SUCCESS);
}
/*
* function to dump registration data
*/
static void
{
int n;
for (n = 0; n < reg->reg_n_formats; n++) {
"format%d: alt=%d chns=%d prec=%d enc=%d", n,
}
for (n = 0; n < USB_AS_N_FORMATS; n++) {
"reg_formats[%d] ptr=0x%p", n,
(void *)®->reg_formats[n]);
}
"usb_ac_print_reg_data: End");
}
static int
{
"usb_ac_online_siblings:start");
"usb_ac_online_siblings: onlining %s%d ref=%d",
/* Online the child_dip of usb_as and hid, if not already */
NDI_SUCCESS) {
"usb_ac_online_siblings:failed to online"
/* only onlining usb_as is fatal */
"usb_as") == 0) {
rval = USB_FAILURE;
break;
}
}
}
}
return (rval);
}
/*
* hold all audio children before or after plumbing
* online usb_as and hid, if not already
*/
static void
{
int circ;
"usb_ac_hold_siblings:start");
/* hold all siblings and ourselves */
/* hold the children */
"usb_ac_hold_siblings: held %s%d ref=%d",
}
}
/*
* release all audio children before or after plumbing
*/
static void
{
int circ;
"usb_ac_rele_siblings: start");
/* release all siblings and ourselves */
"usb_ac_rele_siblings: released %s%d ref=%d",
}
}
static void
{
int i;
for (i = 0; i < USB_AC_ENG_MAX; i++) {
continue;
"usb_restore_engine:set format fail, i=%d", i);
return;
}
(void) usb_engine_start(engp);
}
}
(void) usb_ac_ctrl_restore(statep);
}
/*
* get the maximum format specification the device supports
*/
static void
{
int i;
/* format priority: channels, sample rate, precision, encoding */
for (i = 0; i < reg_data->reg_n_formats; i++) {
int n, keep;
continue;
keep = 1;
}
}
continue;
keep = 1;
continue;
keep = 1;
continue;
}
}
static void
{
return;
}
static int
{
if (asinfo->acs_rcvd_reg_data == 0) {
return (USB_SUCCESS);
}
if (dir == USB_AUDIO_PLAY) {
} else {
}
/* Set the format for the engine */
/* init the default gain */
} else {
}
"audio_engine_alloc failed");
goto OUT;
}
/*
* Set the format for this engine
*/
"set format failed, dir = %d", dir);
goto OUT;
}
rv = USB_SUCCESS;
OUT:
if (rv != USB_SUCCESS)
return (rv);
}
static int
{
"usb_ac_ctrl_set_defaults:begin");
for (int i = 0; i < CTL_NUM; i++) {
if (!ctrlp) {
continue;
}
"usb_ac_ctrl_set_defaults:control write failed");
rv = USB_FAILURE;
}
}
"usb_ac_ctrl_set_defaults:end");
return (rv);
}
static int
{
for (int i = 0; i < CTL_NUM; i++) {
if (ctrlp) {
"usb_ac_ctrl_restore:i = %d", i);
rv = USB_FAILURE;
}
}
}
return (rv);
}
/*
*/
static void
{
} else {
}
/*
* Wrap. If sz is exactly the remainder of the buffer
* (bufpos + sz == bufendp) then the second cpsz should be 0 and so
* the second memcpy() should have no effect, with bufpos updated
* to the head of the buffer.
*/
}
if (cpsz) {
}
engp->bufio_count++;
}
/*
* control read callback
*/
static int
{
return (0);
}
/*
* stereo level control callback
*/
static int
{
return (EINVAL);
}
rv = 0;
done:
return (rv);
}
static int
{
return (EINVAL);
}
rv = 0;
OUT:
return (rv);
}
/*
* mono level control callback
*/
static int
{
int gain;
return (EINVAL);
}
rv = 0;
OUT:
return (rv);
}
/*
* mono level control callback
*/
static int
{
int gain;
return (EINVAL);
}
rv = 0;
OUT:
return (rv);
}
static int
{
int gain;
return (EINVAL);
}
rv = 0;
return (rv);
}
static int
{
/* do nothing here */
return (0);
}
static int
{
int rv = 0;
return (EINVAL);
"usb_audio_write_rec_src: failed");
}
rv = 0;
OUT:
return (rv);
}
int
{
short muteval;
int rval;
count = 0;
/* only support AUDIO_PLAY */
return (rval);
}
/*
* port selection control callback
*/
/*
* audio control registration related routines
*/
static usb_audio_ctrl_t *
{
switch (num) {
case CTL_VOLUME_MONO:
desc.acd_minvalue = 0;
break;
case CTL_VOLUME_STERO:
desc.acd_minvalue = 0;
break;
case CTL_REC_MONO:
desc.acd_minvalue = 0;
break;
case CTL_REC_STERO:
desc.acd_minvalue = 0;
break;
case CTL_MONITOR_GAIN:
desc.acd_minvalue = 0;
break;
case CTL_MIC_BOOST:
desc.acd_minvalue = 0;
break;
case CTL_REC_SRC:
for (int i = 0; usb_audio_dtypes[i]; i++) {
}
break;
default:
break;
}
return (pc);
}
static void
{
}
static void
{
for (int i = 0; i < CTL_NUM; i++) {
if (ctrlp) {
}
}
}
static int
{
/* Init controls for play format */
} else {
}
}
/* Init controls for rec format */
} else {
}
/* Add monitor control */
{
(void) usb_audio_ctrl_alloc(statep,
CTL_MONITOR_GAIN, 0);
}
/* Add ports control */
{
}
}
rv = USB_SUCCESS;
OUT:
if (rv != USB_SUCCESS)
return (rv);
}
/*ARGSUSED*/
static int
{
int i;
return (USB_SUCCESS);
return (USB_SUCCESS);
return (USB_FAILURE);
}
for (i = 0; i < USB_AC_ENG_MAX; i++)
return (USB_SUCCESS);
}
static int
int n;
for (n = 0; n < USB_AC_MAX_AS_PLUMBED; n++) {
!= USB_SUCCESS) {
"usb_audio_register: add engine n =%d failed", n);
goto OUT;
}
}
"usb_audio_register: add controls failed");
goto OUT;
}
"usb_audio_register: set defaults failed");
goto OUT;
}
"audio_dev_register() failed");
goto OUT;
}
rv = USB_SUCCESS;
OUT:
if (rv != USB_SUCCESS) {
(void) usb_audio_unregister(statep);
}
return (rv);
}
int
{
unsigned frames;
unsigned i;
return (0);
}
/* break requests from the driver into fragment sized chunks */
/* must move data before updating framework */
}
return (samples);
}
void
{
unsigned frames;
unsigned i;
return;
}
/* break requests from the driver into fragment sized chunks */
/* must move data before updating framework */
}
}
/*
* **************************************************************************
* audio framework engine callbacks
*/
static int
{
"usb_ac_open() failed");
return (EIO);
}
/*
* In order to match the requested number of samples per interrupt
* from SADA drivers when computing the fragment size,
* we need to first truncate the floating point result from
* sample rate * channels / intr rate
* then adjust up to an even number, before multiplying it
* with the sample size
*/
engp->bufio_count = 0;
"device setup failed");
goto OUT;
}
rv = 0;
OUT:
if (rv != 0)
return (rv);
}
static void
{
}
}
}
}
static int
{
int rv = 0;
}
return (rv);
}
static void
{
}
static uint64_t
{
return (val);
}
static int
{
return (AUDIO_FORMAT_ULAW);
return (AUDIO_FORMAT_ALAW);
return (AUDIO_FORMAT_U8);
break;
default:
return (AUDIO_FORMAT_NONE);
}
case USB_AUDIO_PRECISION_8:
return (AUDIO_FORMAT_S8);
case USB_AUDIO_PRECISION_16:
return (AUDIO_FORMAT_S16_LE);
case USB_AUDIO_PRECISION_24:
return (AUDIO_FORMAT_S24_LE);
case USB_AUDIO_PRECISION_32:
return (AUDIO_FORMAT_S32_LE);
default:
break;
}
return (AUDIO_FORMAT_NONE);
}
static int
{
}
static int
{
}
/*ARGSUSED*/
static void
{
/* Do nothing */
}
static unsigned
{
}
/*
* **************************************************************************
* interfaces used by USB audio
*/
/*ARGSUSED*/
static int
{
if (left > AF_MAX_GAIN)
left = AF_MAX_GAIN;
if (right > AF_MAX_GAIN)
right = AF_MAX_GAIN;
if (left < AF_MIN_GAIN)
left = AF_MIN_GAIN;
if (right < AF_MIN_GAIN)
right = AF_MIN_GAIN;
"updateing control to value 0x%llx by driver failed",
(long long unsigned)cval);
return (USB_FAILURE);
}
return (USB_SUCCESS);
}