usb_as.c revision 7c478bd95313f5f23a4c958a745db2134aa03244
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (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 2005 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
/*
* Audio Streams Driver: This driver is responsible for
* (1) Processing audio data messages during play and record and
* management of isoc pipe, (2) Selecting correct alternate that matches
* a set of parameters and management of control pipe. This streams driver
* is pushed under usb_ac and interacts with usb_ac using streams messages.
* When a streams message has been received from usb_ac, it is immediately
* put on WQ. The write side service routine loops thru all the queued
* messages, processes them and sends up a reply. If the processing involves
* an async USBA command, the reqly is sent up after completion of the
* command.
*
* Note: (1) All streams messages from usb_ac are M_CTL messages.
* data (play) or sends data to mixer (record).
*
* Serialization: usb_as being a streams driver and having the requirement
* making non-blockings calls (USBA or streams or mixer) needs to drop
* mutexes over such calls. But at the same time, 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 grabs access, if 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_as: Raise power during attach and lower power in detach.
* If device is not fully powered, synchronous raise power in wsrv entry points.
*
* locking: Warlock is not aware of the automatic locking mechanisms for
* streams drivers. This driver is single threaded per queue instance.
*
* TODO:
* - mdb dcmds
* - dump
* - kstat
*/
#include <sys/audiovar.h>
/* debug support */
/*
* Module linkage routines for the kernel
*/
static int usb_as_power(dev_info_t *, int, int);
/*
* STREAMS module entry points
*/
static int usb_as_open();
static int usb_as_close();
static int usb_as_wsrv();
/* support functions */
static int usb_as_handle_descriptors(usb_as_state_t *);
static void usb_as_prepare_registration_data(usb_as_state_t *);
static void usb_as_free_alts(usb_as_state_t *);
static int usb_audio_fmt_convert(int);
static int usb_as_disconnect_event_cb(dev_info_t *);
static int usb_as_reconnect_event_cb(dev_info_t *);
static int usb_as_cpr_suspend(dev_info_t *);
static void usb_as_cpr_resume(dev_info_t *);
static int usb_as_pwrlvl0(usb_as_state_t *);
static int usb_as_pwrlvl1(usb_as_state_t *);
static int usb_as_pwrlvl2(usb_as_state_t *);
static int usb_as_pwrlvl3(usb_as_state_t *);
static void usb_as_pm_busy_component(usb_as_state_t *);
static void usb_as_pm_idle_component(usb_as_state_t *);
static void usb_as_continue_play(usb_as_state_t *);
/* anchor for soft state structures */
static void *usb_as_statep;
/*
* STREAMS Structures
*/
/* STREAMS driver id and limit value structure */
static struct module_info usb_as_modinfo = {
0xffff, /* module ID number */
"usb_as", /* module name */
USB_AUDIO_MIN_PKTSZ, /* minimum packet size */
USB_AUDIO_MAX_PKTSZ, /* maximum packet size */
USB_AS_HIWATER, /* high water mark */
USB_AS_LOWATER /* low water mark */
};
/* STREAMS queue processing procedures structures */
/* read queue */
static struct qinit usb_as_rqueue = {
NULL, /* put procedure */
NULL, /* service procedure */
usb_as_open, /* open procedure */
usb_as_close, /* close procedure */
NULL, /* unused */
&usb_as_modinfo, /* module parameters */
NULL /* module statistics */
};
/* write queue */
static struct qinit usb_as_wqueue = {
putq, /* put procedure */
usb_as_wsrv, /* service procedure */
NULL, /* open procedure */
NULL, /* close procedure */
NULL, /* unused */
&usb_as_modinfo, /* module parameters */
NULL /* module statistics */
};
/* STREAMS entity declaration structure */
static struct streamtab usb_as_str_info = {
&usb_as_rqueue, /* read queue */
&usb_as_wqueue, /* write queue */
NULL, /* mux lower read queue */
NULL, /* mux lower write queue */
};
/*
* DDI Structures
*/
/* Entry points structure */
static struct cb_ops usb_as_cb_ops = {
nulldev, /* cb_open */
nulldev, /* cb_close */
nodev, /* cb_strategy */
nodev, /* cb_print */
nodev, /* cb_dump */
nodev, /* cb_read */
nodev, /* cb_write */
nodev, /* cb_ioctl */
nodev, /* cb_devmap */
nodev, /* cb_mmap */
nodev, /* cb_segmap */
nochpoll, /* cb_chpoll */
ddi_prop_op, /* cb_prop_op */
&usb_as_str_info, /* cb_str */
CB_REV, /* cb_rev */
nodev, /* cb_aread */
nodev, /* cb_arwite */
};
/* Device operations structure */
static struct dev_ops usb_as_dev_ops = {
DEVO_REV, /* devo_rev */
0, /* devo_refcnt */
usb_as_getinfo, /* devo_getinfo */
nulldev, /* devo_identify - obsolete */
nulldev, /* devo_probe - not needed */
usb_as_attach, /* devo_attach */
usb_as_detach, /* devo_detach */
nodev, /* devo_reset */
&usb_as_cb_ops, /* devi_cb_ops */
NULL, /* devo_busb_as_ops */
usb_as_power /* devo_power */
};
/* Linkage structure for loadable drivers */
static struct modldrv usb_as_modldrv = {
&mod_driverops, /* drv_modops */
"USB Audio Streaming Driver %I%", /* drv_linkinfo */
&usb_as_dev_ops /* drv_dev_ops */
};
/* Module linkage structure */
static struct modlinkage usb_as_modlinkage = {
MODREV_1, /* ml_rev */
(void *)&usb_as_modldrv, /* ml_linkage */
NULL /* NULL terminates the list */
};
/* warlock directives */
static usb_event_t usb_as_events = {
};
/*
* Mixer registration Management
* use defaults as much as possible
*/
/* default sample rates that must be supported */
static uint_t usb_as_default_srs[] = {
8000, 9600, 11025, 16000, 18900, 22050,
32000, 33075, 37800, 44100, 48000, 0
};
static uint_t usb_as_mixer_srs[] = {
8000, 48000, 0
};
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
{
}
/*ARGSUSED*/
static int
{
int error = DDI_FAILURE;
int instance = USB_AS_MINOR_TO_INSTANCE(
switch (infocmd) {
case DDI_INFO_DEVT2DEVINFO:
error = DDI_SUCCESS;
}
} else {
}
break;
case DDI_INFO_DEVT2INSTANCE:
error = DDI_SUCCESS;
break;
default:
break;
}
return (error);
}
static int
{
switch (cmd) {
case DDI_ATTACH:
break;
case DDI_RESUME:
return (DDI_SUCCESS);
default:
return (DDI_FAILURE);
}
/*
* Allocate soft state information.
*/
return (DDI_FAILURE);
}
/*
* get soft state space and initialize
*/
return (DDI_FAILURE);
}
&usb_as_errmask, &usb_as_instance_debug, 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 */
/* parse all descriptors */
goto fail;
}
NULL, 0)) != DDI_SUCCESS) {
"usb_as_attach: couldn't create minor node");
goto fail;
}
/* we are online */
/* create components to power manage this device */
/* Register for events */
"usb_as_attach: couldn't register for events");
goto fail;
}
/* report device */
"usb_as_attach: End");
return (DDI_SUCCESS);
fail:
if (uasp) {
"attach failed");
}
return (DDI_FAILURE);
}
/*ARGSUSED*/
static int
{
int rval;
switch (cmd) {
case DDI_DETACH:
return (DDI_SUCCESS);
case DDI_SUSPEND:
default:
return (DDI_FAILURE);
}
}
static void
{
return;
}
"usb_as_cleanup: uaspm=0x%p", uaspm);
/*
* Disable the event callbacks first, after this point, event
* callbacks will never get called. Note we shouldn't hold
* 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 (uaspm->aspm_wakeup_enabled) {
/*
* We need to raise power first because
* we need to send down a command to disable
* remote wakeup
*/
"disable remote wake up failed");
}
} else {
}
}
if (uaspm) {
}
}
/*
* usb_as_open:
* Open entry point for plumbing only
*/
/*ARGSUSED*/
static int
{
return (ENXIO);
}
/* Do mux plumbing stuff */
"usb_as_open: Begin q=0x%p", q);
if (sflag) {
"usb_as_open: clone open not supported");
return (ENXIO);
}
/* fail open on a disconnected device */
return (ENODEV);
}
/* Initialize the queue pointers */
/*
* go to full power, and remain pm_busy till close
*/
qprocson(q);
"usb_as_open: End q=0x%p", q);
return (0);
}
/*
* usb_as_close:
* Close entry point for plumbing
*/
/*ARGSUSED*/
static int
{
"usb_as_close: q=0x%p", q);
/*
* Avoid races with other routines.
* For example, if a control transfer is going on, wait
* for that to be completed
* At this point default pipe cannot be open.
*/
qprocsoff(q);
/* we can now power down */
return (0);
}
static void
{
if (!canputnext(RD(q))) {
} else {
/*
* Pass an error message up.
*/
}
}
"usb_as_qreply_error: sending M_ERROR up q=0x%p,mp=0x%p", q, mp);
}
/*
* usb_as_wsrv
* write service routine, processes all the queued mblks.
* returns DDI_SUCCESS or DDI_FAILURE
*/
static int
usb_as_wsrv(queue_t *q)
{
int error;
"usb_as_wsrv: Begin q=0x%p", q);
/* process all message blocks on the queue */
case M_FLUSH:
/*
* Canonical flush handling :
* mp will be freed by usb_ac since it passes
* the same mp
*/
}
/* read queue not used so just send up */
} else {
}
break;
case M_IOCTL:
/* only ioctl is mixer registration data */
break;
case M_CTL:
/* process the message */
if (error != USB_SUCCESS) {
}
break;
default:
break;
}
}
"usb_as_wsrv: End q=0x%p", q);
return (DDI_SUCCESS);
}
/*
* usb_as_ioctl:
* usb_as handles only USB_AUDIO_MIXER_REGISTRATION ioctl
* NACK all other ioctl requests
* Returns USB_SUCCESS or USB_FAILURE
*/
static int
{
int error = USB_FAILURE;
"usb_as_ioctl: Begin q=0x%p, mp=0x%p", q, mp);
"usb_as_ioctl: no data block, q=0x%p, mp=0x%p", q, mp);
} else {
"usb_as_ioctl(mixer reg): q=0x%p, "
"mp=0x%p, b_cont_rptr=0x%p, b_cont_wptr=0x%p",
/*
* Copy the usb_as_reg structure to the structure
* that usb_ac passed. Note that this is a structure
* assignment and not a pointer assignment!
*/
*((usb_as_registration_t *)(*((
usb_as_registration_t **)mp->
sizeof (usb_as_registration_t *);
error = USB_SUCCESS;
break;
default:
"usb_as_ioctl: unknown IOCTL, cmd=%d",
break;
}
}
if (error == USB_FAILURE) {
} else {
}
/*
* Send the response up
*/
return (error);
}
/*
* usb_as_mctl_rcv:
* Handle M_CTL requests from usb_ac.
* Returns USB_SUCCESS/FAILURE
*/
static int
{
int error = USB_FAILURE;
"usb_as_mctl_rcv: Begin q=0x%p mp=0x%p", q, mp);
/*
* Uopn success, each function sends up a reply either immediately,
* or on callback. On failure, reply is send up in the wsrv.
*/
case USB_AUDIO_SET_FORMAT:
break;
break;
case USB_AUDIO_SETUP:
break;
case USB_AUDIO_TEARDOWN:
error = USB_SUCCESS;
break;
case USB_AUDIO_START_PLAY:
break;
case USB_AUDIO_STOP_PLAY:
case USB_AUDIO_PAUSE_PLAY:
error = USB_SUCCESS;
break;
case USB_AUDIO_START_RECORD:
break;
case USB_AUDIO_STOP_RECORD:
break;
default:
break;
}
return (error);
}
/*
* usb_as_set_sample_freq:
* Sets the sample freq by sending a control command to interface
* Although not required for continuous sample rate devices, some
* devices such as plantronics devices do need this.
* On the other hand, the TI chip which does not support continuous
* sample rate stalls on this request
* Therefore, we ignore errors and carry on regardless
*/
static int
{
int rval = USB_FAILURE;
"usb_as_set_sample_freq: mp=0x%p cont_sr=%d", mp,
"usb_as_set_sample_freq: freq = %d", freq);
}
if (data) {
USB_DEV_REQ_RCPT_EP, /* bmRequestType */
USB_AUDIO_SET_CUR, /* bRequest */
ep, /* wIndex */
3, /* wLength */
data,
ignore_errors)) != USB_SUCCESS) {
"usb_as_set_sample_freq: set sample freq failed");
}
}
return (rval);
}
/*
* usb_as_set_format:
* Matches channel, encoding and precision and find out
* the right alternate. Sets alternate interface.
*/
static int
{
int n;
if (uasp->usb_as_request_count) {
"usb_as_set_format: failing mp=0x%p, rq_cnt=%d",
return (USB_FAILURE);
}
"usb_as_set_format: mp=0x%p, reg=0x%p, format=0x%p",
for (n = 0; n < reg->reg_n_formats; n++) {
/*
* Found the alternate
*/
break;
}
}
if (n > reg->reg_n_formats) {
"usb_as_set_format: Didn't find a matching alt");
return (USB_FAILURE);
}
"usb_as_set_format: interface=%d alternate=%d",
/* bmRequestType */
USB_REQ_SET_IF, /* bRequest */
alt, /* wValue */
interface, /* wIndex */
0, /* wLength */
"usb_as_set_format: set_alternate failed");
}
return (rval);
}
/*
* usb_as_setup:
* Open isoc pipe. Will hang around till bandwidth
* is available.
*/
static int
{
int rval;
"usb_as_setup: Begin usb_as_setup, mp=0x%p", mp);
/* Set record packet size to max packet size */
} else {
uasp->usb_as_record_pkt_size = 0;
}
/* open isoc pipe, may fail if there is no bandwidth */
0, &uasp->usb_as_isoc_ph);
if (rval != USB_SUCCESS) {
switch (rval) {
case USB_NO_BANDWIDTH:
"no bandwidth available");
break;
case USB_NOT_SUPPORTED:
"high speed port is not supported");
break;
default:
"usb_as_setup: isoc pipe open failed (%d)",
rval);
}
return (USB_FAILURE);
}
/* return reply up */
uasp->usb_as_setup_cnt++;
"usb_as_setup: End");
return (USB_SUCCESS);
}
/*
* usb_as_teardown
*
*/
static void
{
"usb_as_teardown: Begin mp=0x%p", mp);
if (uasp->usb_as_isoc_ph) {
"usb_as_teardown: closing isoc pipe, ph=0x%p",
/* reply mp will be sent up in isoc close callback */
/* wait for callback to send up a reply */
/* reset setup flag */
uasp->usb_as_setup_cnt--;
} else {
"usb_as_teardown: Pipe already closed");
}
"usb_as_teardown: End");
}
/*
* usb_as_start_play:
* this function is called from usb_as_mctl_rcv
*/
static int
{
int samples;
int n_requests;
int rval = USB_FAILURE;
"usb_as_start_play: Begin mp=0x%p, req_cnt=%d",
"nothing to do or paused or idle (%d)",
rval = USB_SUCCESS;
} else {
"usb_as_start_play: samples=%d requestcount=%d ",
/* queue up as many requests as allowed */
USB_SUCCESS) {
break;
}
}
}
/*
* send mctl up for success. For failure, usb_as_wsrv
* will send an merr up.
*/
if (rval == USB_SUCCESS) {
}
"usb_as_start_play: End");
return (rval);
}
/*
* usb_as_continue_play:
* this function is called from the play callbacks
*/
static void
{
int samples;
int n_requests;
"usb_as_contine_play: Begin req_cnt=%d",
return;
}
"usb_as_continue_play: nothing to do (audio_state=%d)",
} else {
"usb_as_continue_play: samples=%d requestcount=%d ",
/* queue up as many requests as allowed */
USB_SUCCESS) {
break;
}
}
}
"usb_as_continue_play: End");
}
static void
{
"usb_as_handl_shutdown, mp=0x%p", mp);
}
"usb_as_handle_shutdown: am_play_shutdown");
uasp->usb_as_pkt_count = 0;
}
static int
{
int rval = USB_FAILURE;
int precision;
int pkt_len[USB_AS_N_FRAMES];
/* we only support two precisions */
rval = USB_FAILURE;
goto done;
}
/*
* calculate total bufsize by determining the pkt size for
* each frame
*/
}
"usb_as_play_isoc_data: allocb failed");
goto done;
}
if (uasp->usb_as_request_count == 0) {
/* Don't return failure for 0 bytes of data sent */
if (mp) {
/*
* Since we set rval to SUCCESS
* we treat it as a special case
* and free data here
*/
rval = USB_SUCCESS;
goto done;
}
} else {
"usb_as_play_isoc_data: no audio bytes, "
}
rval = USB_FAILURE;
goto done;
}
/* calculate how many frames we can actually fill */
}
}
"usb_as_play_isoc_data: n_pkts=%d, bufsize=%ld, n=%d",
/* allocate an isoc request packet */
goto done;
}
#if defined(_BIG_ENDIAN)
/* byte swap if necessary */
int i;
tmp = *p;
*p = *(p + 1);
*(p + 1) = tmp;
}
}
#endif
/* initialize the packet descriptor */
}
"usb_as_play_isoc_data: rq=0x%p data=0x%p cnt=0x%x "
isoc_req, 0)) != USB_SUCCESS) {
"usb_as_play_isoc_data: rval=%d", rval);
rval = USB_FAILURE;
} else {
}
done:
if (rval != USB_SUCCESS) {
if (isoc_req) {
}
}
"usb_as_play_isoc_data: SEND CNT=%d, RCV COUNT=%d",
return (rval);
}
/*ARGSUSED*/
static void
{
}
/*ARGSUSED*/
static void
{
int i;
"usb_as_play_cb: Begin ph=0x%p, isoc_req=0x%p",
for (i = 0; i < isoc_req->isoc_pkts_count; i++) {
USB_CR_OK) {
"usb_as_play_cb: \tpkt%d: len=%d status=%s", i,
}
}
if (isoc_req->isoc_error_count) {
"usb_as_play_cb: error_count = %d",
}
"usb_as_play_cb: SEND CNT=%d, RCV COUNT=%d",
}
static void
{
int i;
"usb_as_play_exc_cb: ph=0x%p, rq=0x%p data=0x%p pkts=0x%x "
for (i = 0; i < isoc_req->isoc_pkts_count; i++) {
USB_CR_OK) {
"usb_as_play_exc_cb: \tpkt%d: len=%d status=%d",
i,
}
}
"usb_as_play_exc_cb: SEND CNT=%d, RCV COUNT=%d",
"usb_as_play_exc_cb: End request_count=%d",
}
/*
* usb_as_start_record
*/
static int
{
int rval = USB_FAILURE;
"usb_as_start_record: mp=0x%p", mp);
/*
* A start_record should not happen when stop polling is
* happening
*/
/* Initialize the packet descriptor */
}
isoc_req, 0);
} else {
"usb_as_start_record: Isoc req allocation failed");
}
} else {
"usb_as_start_record: Record in progress");
rval = USB_SUCCESS;
}
if (rval != USB_SUCCESS) {
if (isoc_req) {
}
} else {
}
"usb_as_start_record: rval=%d", rval);
return (rval);
}
/*ARGSUSED*/
static int
{
"usb_as_stop_record: ");
/* if we are disconnected, the pipe will be closed anyways */
return (USB_SUCCESS);
}
switch (uasp->usb_as_audio_state) {
case USB_AS_ACTIVE:
/*
* Stop polling. When the completion reason indicate that
* polling is over, return response message up.
*/
break;
/* A stop polling in progress, wait for completion and reply */
break;
default:
}
return (USB_SUCCESS);
}
static void
{
int rval;
"usb_as_record_exc_cb: ph=0x%p, isoc_req=0x%p, cr=%d",
switch (completion_reason) {
case USB_CR_STOPPED_POLLING:
case USB_CR_PIPE_CLOSING:
case USB_CR_PIPE_RESET:
break;
case USB_CR_NO_RESOURCES:
/*
* keep the show going: Since we have the original
* request, we just resubmit it
*/
"usb_as_record_exc_cb: restart record rval=%d", rval);
return;
default:
/* Do not start if one is already in progress */
(void) usb_pipe_stop_isoc_polling(ph,
return;
} else {
}
break;
}
"usb_as_record_exc_cb: state=%d cr=0x%x",
}
/*ARGSUSED*/
static void
{
int precision;
"usb_as_record_cb: rq=0x%p data=0x%p pkts=0x%x",
#if defined(_BIG_ENDIAN)
#endif
#if defined(_BIG_ENDIAN)
/* do byte swap for precision 16 */
int j;
char t = *ptr;
*(ptr + 1) = t;
}
}
#endif
"\tpkt%d: "
"offset=%d pktsize=%d len=%d status=%d resid=%d",
USB_CR_OK) {
"record: pkt=%d offset=0x%x status=%s",
}
}
}
}
/*
* Support for sample rates that are not multiple of 1K. We have 3 such
* sample rates: 11025, 22050 and 44100.
*/
typedef struct usb_as_pktsize_table {
int extra;
/*
* usb_as_pktsize_info is the table that calculates the pktsize
* corresponding to the current frame and the current format.
* Since the int_rate is 1000, we have to do special arithmetic for
* sample rates not multiple of 1K. For example,
* if the sample rate is 48000(i.e multiple of 1K), we can send 48000/1000
* = 48 samples every packet per channel. Since we have to support sample
* rate like 11025, 22050 and 44100, we will have some extra samples
* at the end that we need to spread among the 1000 cycles. So if we make
* the pktsize as below for these sample rates, at the end of 1000 cycles,
* we will be able to send all the data in the correct rate:
*
* 11025: 39 samples of 11, 1 of 12
* 22050: 19 samples of 22, 1 of 23
* 44100: 9 samples of 44, 1 of 45
*
* frameno is a simple counter maintained in the soft state structure.
* So the pkt size is:
* pkt_size = ((frameno % cycle) ? pkt : (pkt + extra));
*
*/
static usb_as_pktsize_table_t usb_as_pktsize_info[] = {
{8000, 8, 1000, 0},
{9600, 10, 5, -2},
{11025, 11, 40, 1},
{16000, 16, 1000, 0},
{18900, 19, 10, -1},
{22050, 22, 20, 1},
{32000, 32, 1000, 0},
{33075, 33, 12, 1},
{37800, 38, 5, -1},
{44100, 44, 10, 1},
{48000, 48, 1000, 0},
{ 0 }
};
static int
{
int n;
int pkt_size = 0;
int extra;
int n_srs =
sizeof (usb_as_pktsize_info) / sizeof (usb_as_pktsize_table_t);
for (n = 0; n < n_srs; n++) {
break;
}
}
"usb_as_get_pktsize: %d", pkt_size);
return (pkt_size);
}
/*
* usb_as_send_ctrl_cmd:
* Opens the pipe; sends a control command down
*/
static int
{
"usb_as_send_ctrl_cmd: Begin bmRequestType=%d,\n\t"
"bRequest=%d, wValue=%d, wIndex=%d, wLength=%d, data=0x%p",
return (USB_FAILURE);
}
reqp->ctrl_attributes = 0;
/* Send async command down */
USB_SUCCESS) {
"usb_as_send_ctrl_cmd: usba xfer failed (req=%d)",
bRequest);
return (USB_FAILURE);
}
return (USB_SUCCESS);
}
static void
{
queue_t *q;
"usb_as_send_merr_up: data=0x%p", mp);
}
if (!canputnext(RD(q))) {
} else {
}
}
static void
{
queue_t *q;
"usb_as_send_mctl_up: data=0x%p", data);
/* Free the b_cont of the original mblk_t, if any */
}
/*
* If we have response to send up, attach it at the b_cont
* of the mctl message. Otherwise just send the mctl message
* up and the module above will decode the command
*/
case USB_AUDIO_SET_FORMAT:
/*
* we cannot easily recover if we can't get an mblk
* so we have to sleep here
*/
"usb_as_send_mctl_up: set_format returning,alt=%d",
break;
default:
/*
* Use the original mp to send the message up
* This should already have the right ioc_cmd in.
*/
} else {
}
break;
}
if (!canputnext(q)) {
} else {
}
}
/*
* usb_as_default_xfer_cb:
* Callback routine for the async control xfer. Reply mctl here.
*/
/*ARGSUSED*/
static void
{
"usb_as_default_xfer_cb: ph=0x%p, reqp=0x%p",
"usb_as_default_xfer_cb: End");
}
/*
* usb_as_isoc_close_cb()
* called from teardown usb_pipe_close
*/
static void
{
"usb_as_isoc_close_cb: ph=0x%p arg=0x%p cb_flags=0x%x",
/* pipe close cannot fail */
"usb_as_isoc_close_cb: End");
}
/*
* usb_as_default_exc_cb:
* Exception callback for the default pipe. Autoclearing took care
* of the recovery
*/
/*ARGSUSED*/
static void
{
"usb_as_default_xfer_exc_cb: End");
}
/*
* Power management
*/
/*ARGSUSED*/
static void
{
"usb_as_create_pm_components: begin");
/* Allocate the state structure */
uaspm->aspm_capabilities = 0;
"usb_as_pm_components: remote Wakeup enabled");
USB_SUCCESS) {
"enable remote wakeup failed");
} else {
}
}
"usb_as_create_pm_components: end");
}
/*
* usb_as_power:
* power entry point
*/
static int
{
int retval = USB_FAILURE;
"usb_as_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;
default:
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 (uasp->usb_as_dev_state) {
case USB_DEV_ONLINE:
/* Deny the powerdown request if the device is busy */
if (uaspm->aspm_pm_busy != 0) {
return (USB_FAILURE);
}
return (USB_FAILURE);
}
/* Issue USB D3 command to the device here */
/* FALLTHRU */
case USB_DEV_DISCONNECTED:
case USB_DEV_SUSPENDED:
/* allow a disconnected/cpr'ed device to go to low power */
return (USB_SUCCESS);
case USB_DEV_PWRED_DOWN:
default:
"usb_as_pwrlvl0: Illegal dev_state");
return (USB_FAILURE);
}
}
/* 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 (uasp->usb_as_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 */
/* fall thru */
case USB_DEV_DISCONNECTED:
case USB_DEV_SUSPENDED:
/* allow power change on a disconnected/cpr'ed device */
return (USB_SUCCESS);
default:
"usb_as_pwrlvl3: Illegal dev_state");
return (DDI_FAILURE);
}
}
/*
* Descriptor Management
*
* usb_as_handle_descriptors:
* read and parse all descriptors and build up usb_as_alts list
*
* the order is as follows:
* interface, general, format, endpoint, CV endpoint
*/
static int
{
int rval = USB_SUCCESS;
"usb_as_handle_descriptors: cfg=%d interface=%d",
/*
* find the number of alternates for this interface
* and allocate an array to store the descriptors for
* each alternate
*/
sizeof (usb_as_alt_descr_t), KM_SLEEP);
/*
* for each alternate read descriptors
*/
"interface (%d.%d):\n\t"
"l = 0x%x type = 0x%x n = 0x%x alt = 0x%x #ep = 0x%x\n\t"
"iclass = 0x%x subclass = 0x%x proto = 0x%x string = 0x%x",
/* read the general descriptor */
index = 0;
continue;
}
/* is this a sane header descriptor */
if (!((len >= AS_IF_DESCR_SIZE) &&
"invalid general cs interface descr");
continue;
}
"general (%d.%d): type=0x%x subtype=0x%x termlink=0x%x\n\t"
"delay=0x%x format=0x%x",
/*
* there should be one format descriptor of unknown size.
* the format descriptor contains just bytes, no need to
* parse
*/
index++;
/* is this a sane format descriptor */
"invalid format cs interface descr");
continue;
}
"format (%d.%d): len = %d "
"type = 0x%x subtype = 0x%x format = 0x%x\n\t"
"#channels = 0x%x subframe = 0x%x resolution = 0x%x\n\t"
"sample freq type = 0x%x",
"0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x "
"0x%x 0x%x 0x%x 0x%x",
if (format->bSamFreqType == 0) {
/* continuous sample rate limits */
n_srs = 2;
} else {
}
/* go thru all sample rates (3 bytes) each */
for (i = 0, n = 0; n < n_srs; i += 3, n++) {
"sr = %d", sr);
alt_sample_rates[n] = sr;
}
"no endpoint descriptor found");
continue;
}
}
"endpoint (%d.%d):\n\t"
"len = 0x%x type = 0x%x add = 0x%x "
"attr = 0x%x mps = 0x%x\n\t"
"int = 0x%x",
"no cv ep descriptor");
continue;
}
if ((len < AS_ISOC_EP_DESCR_SIZE) ||
"cs endpoint descriptor invalid (%d)", len);
continue;
}
"cs isoc endpoint (%d.%d):\n\t"
"type=0x%x sub=0x%x attr=0x%x units=0x%x delay=%x",
cs_ep->bLockDelay);
/* we are done */
}
done:
return (rval);
}
/*
* usb_as_free_alts:
* cleanup alternate list and deallocate all descriptors
*/
static void
{
int alt;
if (uasp->usb_as_alts) {
if (altp) {
if (altp->alt_sample_rates) {
sizeof (uint_t));
}
sizeof (usb_if_descr_t));
}
if (altp->alt_general) {
sizeof (usb_audio_as_if_descr_t));
}
if (altp->alt_format) {
}
sizeof (usb_ep_descr_t));
}
}
}
}
sizeof (usb_as_alt_descr_t));
}
}
/*
* usb_as_prepare_registration_data
*/
static void
{
int alt, n, i, t;
"usb_as_prepare_registration_data:");
/* there has to be at least two alternates, ie 0 and 1 */
if (n_alternates < 2) {
"not enough alternates %d", n_alternates);
return;
}
/* all endpoints need to have the same direction */
continue;
}
"alternates have different direction");
return;
}
}
/*
* we prefer that a valid format supports all our
* default sample rates. If not we delete sample rates
* to get a set that is supported by all formats.
*
* Continuous sample rate will be checked in set_format
* command for a particular alternate. This is interface
* specific registration data and not per alternate.
*/
/* copy over sample rate table but zero it first */
sizeof (usb_as_mixer_srs));
/* copy over sample rate table but zero it first */
sizeof (usb_as_default_srs));
/*
* we assume that alternate 0 is not interesting (no bandwidth),
* we check all formats and use the formats that we can support
*/
continue;
}
(n < USB_AS_N_FORMATS) &&
(sizeof (reg->reg_compat_srs_list)/
/* count how many mono and stereo we have */
}
}
if (n == 0) {
/* no valid formats */
"zero valid formats");
return;
}
/* dump what we have so far */
for (n = 0; n < reg->reg_n_formats; n++) {
"format%d: alt=%d chns=%d prec=%d enc=%d", n,
}
/*
* Fill out channels
* Note that we assumed all alternates have the same number
* of channels.
*/
n = 0;
if (channels[1]) {
}
if (channels[2]) {
}
/* fill out combinations */
for (i = n = 0; n < reg->reg_n_formats; n++) {
/* check if already there */
for (t = 0; t < n; t++) {
break;
}
}
/* if not, add this combination */
if (t == n) {
}
}
"combinations: %d %d %d %d %d %d %d %d",
}
/*
* usb_as_valid_format:
* check if this format can be supported
*/
static int
{
int n, i, j;
"usb_as_valid_format: %d %d %d %d %d",
switch (format->bNrChannels) {
case 1:
case 2:
break;
default:
return (USB_FAILURE);
}
switch (format->bSubFrameSize) {
case 1:
case 2:
break;
default:
return (USB_FAILURE);
}
switch (format->bBitResolution) {
case 8:
case 16:
break;
default:
return (USB_FAILURE);
}
switch (format->bFormatType) {
break;
default:
return (USB_FAILURE);
}
switch (format->bSamFreqType) {
case 0:
/* continuous */
break;
default:
/* count the number of sample rates we still have */
for (j = n = 0; j < n_srs; n++) {
if (srs[n] == 0) {
break;
} else {
j++;
}
}
/* check if our preferred sample rates are supported */
for (n = 0; n < n_srs; n++) {
if (sr == 0) {
break;
}
"checking sr=%d", sr);
for (i = 0; i < alt_descr->alt_n_sample_rates; i++) {
break;
}
}
if (i == alt_descr->alt_n_sample_rates) {
/*
* remove this sample rate except if it is
* the last one
*/
if (j > 1) {
srs[n] = 0;
} else {
return (USB_FAILURE);
}
}
}
"before srs (%d): %d %d %d %d %d %d %d %d %d %d %d %d",
/* now compact srs table, eliminating zero entries */
for (i = n = 0; n < n_srs; n++) {
if (srs[n]) {
/* move up & remove from the list */
if (i++ != n) {
srs[n] = 0;
}
}
}
/* last entry must always be zero */
srs[i] = 0;
"before srs (%d): %d %d %d %d %d %d %d %d %d %d %d %d",
break;
}
return (USB_SUCCESS);
}
/*
* convert usb audio format type to SADA type
*/
static int
{
switch (type) {
return (AUDIO_ENCODING_LINEAR);
return (AUDIO_ENCODING_LINEAR8);
return (AUDIO_ENCODING_ALAW);
return (AUDIO_ENCODING_ULAW);
default:
return (0);
}
}
/*
* Event Management
*
* usb_as_disconnect_event_cb:
* The device has been disconnected.
*/
static int
{
"usb_as_disconnect_event_cb: dip=0x%p", dip);
return (USB_SUCCESS);
}
/*
* usb_as_cpr_suspend:
*/
static int
{
"usb_as_cpr_suspend: Begin");
"usb_as_cpr_suspend: End");
return (USB_SUCCESS);
}
/*
* usb_as_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
*/
static int
{
"usb_as_reconnect_event_cb: dip=0x%p", dip);
return (USB_SUCCESS);
}
/*
* usb_as_cpr_resume:
* recover this device from suspended state
*/
static void
{
"usb_as_cpr_resume: dip=0x%p", dip);
}
/*
* usb_as_restore_device_state:
* Set original configuration of the device
* enable wrq - this starts new transactions on the control pipe
*/
static void
{
"usb_as_restore_device_state:");
/* Check if we are talking to the same device */
/* change the device state from suspended to disconnected */
return;
}
if (uaspm) {
if (uaspm->aspm_wakeup_enabled) {
"enable remote wake up failed");
}
}
}
}
static void
{
"usb_as_pm_busy_component: %d",
DDI_SUCCESS) {
"usb_as_pm_busy_component failed: %d",
}
}
}
static void
{
DDI_SUCCESS) {
"usb_as_pm_idle_component: %d",
}
}
}