开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > VxWorks > 查看源码
usbSpeakerLib.c
资源名称：ixp425BSP.rar　[点击查看]
上传用户：luoyougen
上传日期：2008-05-12
资源大小：23136k
文件大小：67k
源码类别：

VxWorks

开发平台：

C/C++

usbSpeakerLib.c：源码内容
  1. /* usbSpeakerLib.c - USB speaker class drive with vxWorks SEQ_DEV interface */
  3. /* Copyright 2000-2002 Wind River Systems, Inc. */
  5. /*
  6. modification history
  7. --------------------
  8. 01g,29oct01,wef  Remove automatic buffer creations and repalce with OSS_MALLOC.
  9. 01f,18sep01,wef  merge from wrs.tor2_0.usb1_1-f for veloce
  10. 01e,08aug01,dat  Removing warnings
  11. 01d,31jan01,wef  Fixed tab stops
  12. 01c,12apr00,wef  Fixed uninitialized variable warning: controlSelector and
  13.  settingWidth in setChannelControl()
  14. 01b,20mar00,rcb  Re-write code which de-references potentiall non-aligned word 
  15.  fields to prevent faults on certain processors (e.g., MIPS).
  16. 01a,12jan00,rcb  written.
  17. */
  19. /*
  20. DESCRIPTION
  22. This module implements the class driver for USB speaker devices.  USB speakers
  23. are a subset of the USB audio class, and this module handles only those parts
  24. of the USB audio class definition which are relevant to the operation of USB
  25. speakers.  
  27. This module presents a modified VxWorks SEQ_DEV interface to its callers.  The
  28. SEQ_DEV interface was chosen because, of the existing VxWorks driver models, it
  29. best supports the streaming data transfer model required by isochronous devices
  30. such as USB speakers.  As with other VxWorks USB class drivers, the standard
  31. driver interface has been expanded to support features unique to the USB and to
  32. speakers in general.  Functions have been added to allow callers to recognize
  33. the dynamic attachment and removal of speaker devices. IOCTL functions have 
  34. been added to retrieve and control additional settings related to speaker
  35. operation.
  38. INITIALIZATION
  40. As with standard SEQ_DEV drivers, this driver must be initialized by calling
  41. usbSpeakerDevInit().  usbSpeakerDevInit() in turn initializes its connection 
  42. to the USBD and other internal resources needed for operation. Unlike some 
  43. SEQ_DEV drivers, there are no usbSpeakerLib.c data structures which need 
  44. to be initialized prior to calling usbSpeakerDevInit().
  46. Prior to calling usbSpeakerDevInit(), the caller must ensure that the USBD
  47. has been properly initialized by calling - at a minimum - usbdInitialize().
  48. It is also the caller's responsibility to ensure that at least one USB HCD
  49. (USB Host Controller Driver) is attached to the USBD - using the USBD function
  50. usbdHcdAttach() - before speaker operation can begin.  However, it is not 
  51. necessary for usbdHcdAttach() to be alled prior to initializating usbSpeakerLib.
  52. usbSpeakerLib.c uses the USBD dynamic attach services and is capable of 
  53. recognizing USB speaker attachment and removal on the fly.  Therefore, it is 
  54. possible for USB HCDs to be attached to or detached from the USBD at run time
  55. - as may be required, for example, in systems supporting hot swapping of
  56. hardware.
  59. RECOGNIZING & HANDLING USB SPEAKERS
  61. As noted earlier, the operation of USB speakers is defined in the USB Audio Class
  62. Specification. Speakers, loosely defined, are those USB audio devices which
  63. provide an "Output Terminal".  For each USB audio device, usbSpeakerLib examines
  64. the descriptors which enumerate the "units" and "terminals" contained within the
  65. device.  These descriptors define both which kinds of units/terminals are present
  66. and how they are connected.  
  68. If an "Output Terminal" is found, usbSpeakerLib traces the device's internal
  69. connections to determine which "Input Terminal" ultiminately provides the audio
  70. stream for the "Output Terminal" and which, if any, Feature Unit is responsible
  71. for controlling audio stream attributes like volume.  Once having built such an
  72. internal "map" of the device, usbSpeakerLib configures the device and waits for
  73. a caller to provide a stream of audio data.  If no "Output Terminal" is found,
  74. usbSpeakerLib ignores the audio device.
  76. After determining that the audio device contains an Output Terminal, 
  77. usbSpeakerLib builds a list of the audio formats supported by the device. 
  78. usbSpeakerLib supports only AudioStreaming interfaces (no MidiStreaming is 
  79. supported).  
  81. For each USB speaker attached to the system and properly recognized by 
  82. usbSpeakerLib, usbSpeakerLib creates a SEQ_DEV structure to control the speaker.
  83. Each speaker is uniquely identified by the pointer to its corresponding SEQ_DEV
  84. structure.
  87. DYNAMIC ATTACHMENT & REMOVAL OF SPEAKERS
  89. As with other USB devices, USB speakers may be attached to or detached from the
  90. system dynamically.  usbSpeakerLib uses the USBD's dynamic attach services in 
  91. order to recognize these events.  Callers of usbSpeakerLib may, in turn, register
  92. with usbSpeakerLib for notification when USB speakers are attached or removed
  93. using the usbSpeakerDynamicAttachRegister() function.  When a USB speaker is
  94. attached or removed, usbSpeakerLib invokes the attach notification callbacks 
  95. for all registered callers.  The callback is passed the pointer to the affected
  96. SEQ_DEV structure and a code indicated whether the speaker is being attached or
  97. removed.
  99. usbSpeakerLib maintains a usage count for each SEQ_DEV structure.  Callers can 
  100. increment the usage count by calling usbSpeakSeqDevLock() and can decrement the 
  101. usage count by calling usbSpeakerSeqDevUnlock().  When a USB speaker is removed
  102. from the system and its usage count is 0, usbSpeakerLib automatically removes 
  103. all data structures, including the SEQ_DEV structure itself, allocated on behalf
  104. of the device. Sometimes, however, callers rely on these data structures and 
  105. must properly recognize the removal of the device before it is safe to destroy 
  106. the underlying data structures.  The lock/unlock functions provide a mechanism
  107. for callers to protect these data structures as needed.
  110. DATA FLOW
  112. Before sending audio data to a speaker device, the caller must specify the data
  113. format (e.g., PCM, MPEG) using an IOCTL (see below).  The USB speaker itself
  114. must support the indicated (or a similar) data format.
  116. USB speakers rely on an uninterrupted, time-critical stream of audio data.  The
  117. data is sent to the speaker through an isochronous pipe.  In order for the data
  118. flow to continue uninterrupted, usbSpeakerLib internally uses a double-buffering
  119. scheme.  When data is presented to usbSpeakerLib's sd_seqWrt() function by the 
  120. caller, usbSpeakerLib copies the data into an internal buffer and immediately 
  121. releases the caller's buffer.  The caller should immediately try to pass the next 
  122. buffer to usbSpeakerLib.  When usbSpeakerLib's internal buffer is filled, it will 
  123. block the caller until such time as it can accept the new data.  In this manner,
  124. the caller and usbSpeakerLib work together to ensure that an adequate supply of
  125. audio data will always be available to continue isochronous transmission 
  126. uninterrupted.
  128. Audio play begins after usbSpeakerLib has accepted half a second of audio data
  129. or when the caller closes the audio stream, whichever happens first.  The caller
  130. must use the IOCTLs to "open" and "close" each audio stream.  usbSpeakerLib
  131. relies on these IOCTLs to manage its internal buffers correctly.
  134. IOCTLs
  136. usbSpeakerLib implements a number of IOCTLs unique to the handling of audio
  137. data and devices.  usbSpeakerLib provides IOCTLs to set the following controls:
  138. mute, volume, bass, mid-range, and treble.  usbSpeakerLib also provides IOCTLs
  139. to be used by callers to interrogate a speaker's audio format capabilities or 
  140. to specify the audio format for a subsequent data stream.
  143. INCLUDE FILES:
  144. seqIo.h usbAudio.h usbSpeakerLib.h
  145. */
  148. /* includes */
  150. #include "vxWorks.h"
  151. #include "string.h"
  152. #include "ioLib.h"
  153. #include "seqIo.h"
  154. #include "errno.h"
  156. #include "usb/usbPlatform.h"
  157. #include "usb/ossLib.h"  /* operations system srvcs */
  158. #include "usb/usb.h" /* general USB definitions */
  159. #include "usb/usbListLib.h" /* linked list functions */
  160. #include "usb/usbdLib.h" /* USBD interface */
  161. #include "usb/usbLib.h"  /* USB utility functions */
  162. #include "usb/usbAudio.h" /* USB audio class definitions */
  163. #include "drv/usb/usbSpeakerLib.h"  /* our API */
  166. /* defines */
  168. #define SPKR_CLIENT_NAME "usbSpeakerLib" /* our USBD client name */
  170. #define A_REALLY_BIG_INTEGER 0x7fffffff  /* large positive integer */
  172. #define MSEC_PER_SEC 1000L /* number of msec per second */
  173. #define FRAME_SKIP 20 /* frames to skip before play */
  174. /* (makes sure h/w doesn't run 
  175.  * ahead of us) 
  176.  */
  178. #define IRP_COUNT 2 /* number of IRPs for transmit */
  181. /* typedefs */
  183. /* ATTACH_REQUEST */
  185. typedef struct attach_request
  186.     {
  187.     LINK reqLink; /* linked list of requests */
  188.     USB_SPKR_ATTACH_CALLBACK callback; /* client callback routine */
  189.     pVOID callbackArg; /* client callback argument */
  190.     } ATTACH_REQUEST, *pATTACH_REQUEST;
  193. /* USB_SPKR_SEQ_DEV is the internal data structure we use to track each USB
  194.  * speaker.
  195.  */
  197. typedef struct usb_spkr_seq_dev
  198.     {
  199.     SEQ_DEV seqDev; /* must be first field */
  200.     BOOL reserved; /* TRUE if device reserved */
  202.     LINK devLink; /* linked list of structs */
  204.     UINT16 lockCount; /* Count of times structure locked */
  206.     USBD_NODE_ID nodeId; /* speaker node Id */
  207.     UINT16 configuration; /* configuration/interface reported as */
  209.     BOOL connected; /* TRUE if speaker currently connected */
  211.     UINT8 outputTerminalId; /* ID of output terminal */
  212.     UINT8 inputTerminalId; /* ID of input terminal */
  213.     UINT8 featureUnitId; /* ID of feature unit (optional) */
  215.     UINT8 channels; /* count of channels */
  216.     UINT16 channelConfig; /* channel configuration */
  218.     UINT16 capsLen; /* size of following array */
  219.     pUSB_SPKR_CHANNEL_CAPS pCaps;   /* Indicates feature support on each
  220.      * channel...channel 0 is the "master"
  221.      * and is global to all 
  222.      */
  224.     UINT16 fmtCount; /* count of audio formats */
  225.     pUSB_SPKR_AUDIO_FORMAT pFmt;    /* indicates nature of each format */
  227.     pUSB_SPKR_AUDIO_FORMAT pSelFmt; /* pointer to selected format */
  229.     UINT32 sampleFrequency; /* playback frequency */
  230.     UINT32 sampleSize; /* data always sent in blocks which are 
  231.  * multiples of this value 
  232.  */
  233.     UINT32 bytesPerSec;  /* playback bytes per second */
  235.     BOOL open; /* TRUE when audio stream is open */
  236.     BOOL streamFault; /* TRUE if stream fault detected */
  238.     pUINT8 pAudioBfr; /* bfr for audio data */
  239.     UINT32 audioBfrLen;  /* size of audio buffer */
  240.     UINT32 audioBfrHalf; /* one half the length of the buffer */
  241.     UINT32 audioBfrCount; /* count of data available */
  242.     UINT32 audioBfrIn; /* next location to receive data */
  243.     UINT32 audioBfrOut;  /* next location to transmit */
  244.     UINT32 audioBfrPending; /* nbr of bytes being transmitted */
  245.     UINT32 audioBfrTotal; /* total data passed through bfr */
  247.     BOOL foregroundWaiting; /* TRUE if foreground waiting for bfr */
  248.     SEM_HANDLE bfrNotFullSem; /* signalled when bfr goes from 
  249.  * full->not full 
  250.  */
  252.     USBD_PIPE_HANDLE isochPipeHandle; /* USBD handle for isoch data pipe */
  254.     UINT32 frameWindow;  /* size of host controller frame ctr */
  255.     UINT32 nextStartFrame; /* next frame for isoch transfer */
  256.     UINT32 blocksSent; /* blocks sent for this stream */
  258.     USB_IRP irp [IRP_COUNT]; /* IRPs to be used for transmit */
  259.     UINT16 nextIrp; /* index of next IRP to use */
  260.     UINT16 nextDoneIrp;  /* index of next IRP to complete */
  261.     UINT16 irpsInUse; /* count of IRPs in use */
  263.     } USB_SPKR_SEQ_DEV, *pUSB_SPKR_SEQ_DEV;
  266. /* forward function declarations */
  268. LOCAL VOID usbSpkrIrpCallback 
  269.     (
  270.     pVOID p
  271.     );
  274. /* locals */
  276. LOCAL UINT16 initCount = 0; /* Count of init nesting */
  278. LOCAL MUTEX_HANDLE speakerMutex; /* mutex used to protect 
  279.  * internal structs 
  280.  */
  282. LOCAL LIST_HEAD devList; /* linked list of USB_SPKR_SEQ_DEV */
  283. LOCAL LIST_HEAD reqList; /* Attach callback request list */
  285. LOCAL USBD_CLIENT_HANDLE usbdHandle; /* our USBD client handle */
  288. /***************************************************************************
  289. *
  290. * audioIfGetRequest - executes an audio-class-specific request
  291. *
  292. * Executes a request to an AudioControl or AudioStreaming interface.
  293. * The actual length of data transferred must be equal to the <length> passed
  294. * by the caller or an ERROR is returned.
  295. *
  296. * RETURNS: OK, else ERROR if not successful
  297. */
  299. LOCAL STATUS audioIfRequest
  300.     (
  301.     pUSB_SPKR_SEQ_DEV pSeqDev,
  302.     UINT8 requestType,
  303.     UINT8 request,
  304.     UINT8 entityId,
  305.     UINT16 value,
  306.     UINT16 length,
  307.     pVOID pBfr
  308.     )
  309.     
  310.     {
  311.     UINT16 actLen;
  313.     if (usbdVendorSpecific (usbdHandle, 
  314.     pSeqDev->nodeId, 
  315.     requestType,
  316.     request, 
  317.     value, 
  318.     entityId << 8, 
  319.     length, 
  320.     (pUINT8) pBfr, 
  321.     &actLen) 
  322.   != OK 
  323. || actLen != length)
  324. {
  325. return ERROR;
  326. }
  328.     return OK;
  329.     }
  332. /***************************************************************************
  333. *
  334. * findAudioByUnit - seaches a buffer for the indicated audio descriptor
  335. *
  336. * RETURNS: ptr to a matching descriptor or NULL if not found
  337. */
  339. LOCAL pVOID findAudioDescrByUnit
  340.     (
  341.     pUINT8 pBfr,
  342.     UINT16 bfrLen,
  343.     UINT8 unitId
  344.     )
  346.     {
  347.     pUSB_AUDIO_AC_COMMON pHdr;
  350.     /* The remaining buffer length must be at least three bytes to accommodate
  351.      * the USB_AUDIO_AC_COMMON structure. 
  352.      */
  354.     while (bfrLen >= sizeof (*pHdr))
  355. {
  356. pHdr = (pUSB_AUDIO_AC_COMMON) pBfr;
  358. if (pHdr->length == 0)
  359.     return NULL; /* must be invalid */
  361. pBfr += min (pHdr->length, bfrLen);
  362. bfrLen -= min (pHdr->length, bfrLen);
  364. if (pHdr->descriptorType == USB_DESCR_AUDIO_INTERFACE &&
  365.     pHdr->unitId == unitId)
  366.     return (pVOID) pHdr;
  367. }
  369.     return NULL;
  370.     }
  373. /***************************************************************************
  374. *
  375. * findAudioDescrSkip - seaches a buffer for the indicated audio descriptor
  376. *
  377. * Upon return, <ppBfr> points to the descriptor following the last searhed
  378. * descriptor and <pBfrLen> is updated with the number of bytes remaining in 
  379. * the bfr.
  380. *
  381. * RETURNS: ptr to a matching descriptor or NULL if not found
  382. */
  384. LOCAL pVOID findAudioDescrSkip
  385.     (
  386.     pUINT8 *ppBfr,
  387.     pUINT16 pBfrLen,
  388.     UINT8 descriptorType,
  389.     UINT8 descriptorSubType
  390.     )
  392.     {
  393.     pUSB_DESCR_HDR_SUBHDR pHdr;
  396.     /* The remaining buffer length must be at least three bytes to accommodate
  397.      * the descriptor length, descriptorType, and descriptorSubType fields. 
  398.      */
  400.     while (*pBfrLen >= sizeof (*pHdr))
  401. {
  402. pHdr = (pUSB_DESCR_HDR_SUBHDR) *ppBfr;
  404. if (pHdr->length == 0)
  405.     return NULL; /* must be invalid */
  407. *ppBfr += min (pHdr->length, *pBfrLen);
  408. *pBfrLen -= min (pHdr->length, *pBfrLen);
  410. if (pHdr->descriptorType == descriptorType &&
  411.     pHdr->descriptorSubType == descriptorSubType)
  412.     return (pVOID) pHdr;
  413. }
  415.     return NULL;
  416.     }
  419. /***************************************************************************
  420. *
  421. * findAudioDescr - seaches a buffer for the indicated audio descriptor
  422. *
  423. * RETURNS: ptr to a matching descriptor or NULL if not found
  424. */
  426. LOCAL pVOID findAudioDescr
  427.     (
  428.     pUINT8 pBfr,
  429.     UINT16 bfrLen,
  430.     UINT8 descriptorType,
  431.     UINT8 descriptorSubType
  432.     )
  434.     {
  435.     return findAudioDescrSkip (&pBfr, 
  436.        &bfrLen, 
  437.        descriptorType, 
  438.        descriptorSubType);
  439.     }
  442. /***************************************************************************
  443. *
  444. * setChannelControl - Sets the specified channel control
  445. *
  446. * <funcCode> is the IOCTL code specifying the control to set.  <channel>
  447. * is the channel number (channel 0 = master channel).  <value> is the
  448. * new setting value.
  449. *
  450. * RETURNS: OK if successful, ENOSYS if not supported, else EIO if failure
  451. */
  453. LOCAL STATUS setChannelControl
  454.     (
  455.     pUSB_SPKR_SEQ_DEV pSeqDev,
  456.     int funcCode,
  457.     UINT16 channel,
  458.     UINT16 value
  459.     )
  461.     {
  462.     pUSB_SPKR_CHANNEL_CAPS pChannelCaps;
  463.     pUSB_SPKR_CTL_CAPS pCtlCaps = NULL;
  464.     UINT8 controlSelector = 0;
  465.     UINT8 settingWidth = 0;
  466.     UINT16 * pSetting;
  468.     if ((pSetting = OSS_MALLOC (sizeof (UINT16))) == NULL)
  469. return EIO;
  471.     /* validate channel number.  0 = master channel.  1..n = other channels. */
  473.     if (channel > pSeqDev->channels)
  474. return EIO;
  476.     pChannelCaps = &pSeqDev->pCaps [channel];
  479.     /* Check the capabilities of the control */
  481.     switch (funcCode)
  482. {
  483. case USB_SPKR_IOCTL_SET_MUTE:   
  485.     pCtlCaps = NULL;
  486.     controlSelector = USB_AUDIO_FCS_VOLUME;
  487.     settingWidth = USB_AUDIO_MUTE_ATTR_WIDTH;
  488.     break;
  490. case USB_SPKR_IOCTL_SET_VOLUME: 
  492.     pCtlCaps = &pChannelCaps->volume;
  493.     controlSelector = USB_AUDIO_FCS_VOLUME;
  494.     settingWidth = USB_AUDIO_VOLUME_ATTR_WIDTH;
  495.     break;
  497. case USB_SPKR_IOCTL_SET_BASS:
  499.     pCtlCaps = &pChannelCaps->bass;
  500.     controlSelector = USB_AUDIO_FCS_BASS;
  501.     settingWidth = USB_AUDIO_BASS_ATTR_WIDTH;
  502.     break;
  504. case USB_SPKR_IOCTL_SET_MID:
  506.     pCtlCaps = &pChannelCaps->mid;
  507.     controlSelector = USB_AUDIO_FCS_MID;
  508.     settingWidth = USB_AUDIO_MID_ATTR_WIDTH;
  509.     break;
  511. case USB_SPKR_IOCTL_SET_TREBLE: 
  512.     
  513.     pCtlCaps = &pChannelCaps->treble;
  514.     controlSelector = USB_AUDIO_FCS_TREBLE;
  515.     settingWidth = USB_AUDIO_TREBLE_ATTR_WIDTH;
  516.     break;
  517. }
  519.     if (pCtlCaps != NULL)
  520. {
  521. if (!pCtlCaps->supported)
  522.     return ENOSYS;
  524. if (((INT16) value) < pCtlCaps->min || ((INT16) value) > pCtlCaps->max)
  525.     return EIO;
  526. }
  529.     /* Set the control */
  531.     *pSetting = TO_LITTLEW (value);
  533.     if (audioIfRequest (pSeqDev,
  534. USB_RT_HOST_TO_DEV | USB_RT_CLASS | USB_RT_INTERFACE,
  535. USB_REQ_AUDIO_SET_CUR, 
  536. pSeqDev->featureUnitId, 
  537. controlSelector << 8 | channel, 
  538. settingWidth, 
  539. pSetting) 
  540.       != OK)
  541. {
  542. OSS_FREE (pSetting);
  543. return EIO;
  544. }
  546.     pCtlCaps->cur = value;
  548.     OSS_FREE (pSetting);
  550.     return OK;
  551.     }
  554. /***************************************************************************
  555. *
  556. * getControlSetting - read an individual setting for specified control
  557. *
  558. * <settingWidth> specifies the control value width as 1 (byte) or 2 (word).
  559. * 
  560. * RETURNS: OK if successfull, else ERROR
  561. */
  563. LOCAL STATUS getControlSetting
  564.     (
  565.     pUSB_SPKR_SEQ_DEV pSeqDev,
  566.     UINT8 entityId,
  567.     UINT8 channel,
  568.     UINT8 controlSelector,
  569.     UINT8 request,
  570.     pUINT16 pAttribute,
  571.     UINT16 settingWidth
  572.     )
  574.     {
  575.     UINT16 * pAttributeBuf;
  577.     if ((pAttributeBuf = OSS_CALLOC (sizeof (UINT16))) == NULL)
  578. return ERROR;
  580.     if (audioIfRequest (pSeqDev,
  581. USB_RT_DEV_TO_HOST | USB_RT_CLASS | USB_RT_INTERFACE, 
  582. request, 
  583. entityId, 
  584. controlSelector << 8 | channel, 
  585. settingWidth, 
  586. pAttributeBuf) 
  587.       != OK)
  588. {
  589. OSS_FREE (pAttributeBuf);
  590. return ERROR;
  591. }
  593.     *pAttribute = FROM_LITTLEW (*pAttributeBuf); 
  594.     
  595.     OSS_FREE (pAttributeBuf);
  597.     return OK;
  598.     }
  601. /***************************************************************************
  602. *
  603. * getControlSettings - reads settings for the specified feature unit control
  604. *
  605. * If the information can be read successfully, <pCtlCaps>->supported is set 
  606. * to TRUE.
  607. *
  608. * RETURNS: N/A
  609. */
  611. LOCAL VOID getControlSettings
  612.     (
  613.     pUSB_SPKR_SEQ_DEV pSeqDev,
  614.     UINT8 entityId,
  615.     UINT8 channel,
  616.     UINT8 controlSelector,
  617.     pUSB_SPKR_CTL_CAPS pCtlCaps,
  618.     UINT16 settingWidth
  619.     )
  621.     {
  622.     /* Get the control's resolution. */
  624.     if (getControlSetting (pSeqDev, 
  625.    entityId, 
  626.    channel, 
  627.    controlSelector,
  628.    USB_REQ_AUDIO_GET_RES, 
  629.    &pCtlCaps->res, 
  630.    settingWidth) 
  631.  != OK)
  632. return;
  634.     /* Get the control's min setting */
  636.     if (getControlSetting (pSeqDev, 
  637.    entityId, 
  638.    channel, 
  639.    controlSelector,
  640.    USB_REQ_AUDIO_GET_MIN, 
  641.    (UINT16 *)&pCtlCaps->min, 
  642.    settingWidth) 
  643.  != OK)
  644. return;
  646.     /* Get the control's max setting */
  648.     if (getControlSetting (pSeqDev, 
  649.    entityId, 
  650.    channel, 
  651.    controlSelector,
  652.    USB_REQ_AUDIO_GET_MAX, 
  653.    (UINT16 *)&pCtlCaps->max, 
  654.    settingWidth) 
  655.  != OK)
  656. return;
  657.     
  658.     /* Get the control's current setting */
  660.     if (getControlSetting (pSeqDev, 
  661.    entityId, 
  662.    channel, 
  663.    controlSelector,
  664.    USB_REQ_AUDIO_GET_CUR, 
  665.    (UINT16 *)&pCtlCaps->cur, 
  666.    settingWidth) 
  667.  != OK)
  668. return;
  670.     pCtlCaps->supported = TRUE;
  671.     }
  674. /***************************************************************************
  675. *
  676. * recordChannelsCaps - record capabilities for the specified channel
  677. *
  678. * RETURNS: N/A
  679. */
  681. LOCAL VOID recordChannelCaps
  682.     (
  683.     pUSB_SPKR_SEQ_DEV pSeqDev,
  684.     UINT8 entityId,
  685.     UINT8 channel,
  686.     pUSB_SPKR_CHANNEL_CAPS pCaps,
  687.     UINT8 controls
  688.     )
  690.     {
  691.     if ((controls & USB_AUDIO_FCM_MUTE) != 0)
  692. pCaps->mute.supported = TRUE;
  694.     if ((controls & USB_AUDIO_FCM_VOLUME) != 0)
  695. getControlSettings (pSeqDev, 
  696.     entityId, 
  697.     channel,
  698.     USB_AUDIO_FCS_VOLUME, 
  699.     &pCaps->volume, 
  700.     USB_AUDIO_VOLUME_ATTR_WIDTH);
  702.     if ((controls & USB_AUDIO_FCM_BASS) != 0)
  703. getControlSettings (pSeqDev, 
  704.     entityId, 
  705.     channel,
  706.     USB_AUDIO_FCS_BASS, 
  707.     &pCaps->bass, 
  708.     USB_AUDIO_BASS_ATTR_WIDTH);
  710.     if ((controls & USB_AUDIO_FCM_MID) != 0)
  711. getControlSettings (pSeqDev, 
  712.     entityId, 
  713.     channel,
  714.     USB_AUDIO_FCS_MID, 
  715.     &pCaps->mid, 
  716.     USB_AUDIO_MID_ATTR_WIDTH);
  718.     if ((controls & USB_AUDIO_FCM_TREBLE) != 0)
  719. getControlSettings (pSeqDev, 
  720.     entityId, 
  721.     channel,     
  722.     USB_AUDIO_FCS_TREBLE, 
  723.     &pCaps->treble, 
  724.     USB_AUDIO_TREBLE_ATTR_WIDTH);
  725.     }
  728. /***************************************************************************
  729. *
  730. * buildAudioMap - determine what capabilities the audio device has
  731. *
  732. * Search the provided <pCfgBfr> for an AudioClass (AC) descriptor and 
  733. * from that descriptor determine what capabilities the device has. 
  734. *
  735. * RETURNS: OK if successful, else ERROR.
  736. */
  738. LOCAL STATUS buildAudioMap
  739.     (
  740.     pUSB_SPKR_SEQ_DEV pSeqDev,
  741.     pUINT8 pCfgBfr,
  742.     UINT16 cfgLen
  743.     )
  745.     {
  746.     pUSB_AUDIO_AC_DESCR pAcDescr;
  747.     pUSB_AUDIO_AC_COMMON pAcCommon;
  748.     pUSB_AUDIO_OUTPUT_TERM_DESCR pOutputTerm;
  749.     pUSB_AUDIO_INPUT_TERM_DESCR pInputTerm;
  750.     pUSB_AUDIO_FEATURE_UNIT_DESCR pFeatureUnit = NULL;
  751.     pUINT8 pBfr;
  752.     UINT16 bfrLen;
  753.     UINT16 totalLength;
  754.     UINT16 remLen;
  755.     UINT8 prevId;
  756.     pUINT8 pControl;
  757.     UINT16 i;
  760.     /* Find the first AudioControl (AC) descriptor */
  762.     pBfr = pCfgBfr;
  763.     bfrLen = cfgLen;
  765.     if ((pAcDescr = findAudioDescrSkip (&pBfr, 
  766. &bfrLen, 
  767. USB_DESCR_AUDIO_INTERFACE, 
  768. USB_DESCR_AUDIO_AC_HEADER)) 
  769.       == NULL)
  770. return ERROR;
  773.     /* Find an "Output Terminal".  Then, using the terminal/unit numbers as
  774.      * links, work backwards from the output terminal to find the "Input 
  775.      * Terminal" and "Feature Unit" (if any) associated with it.
  776.      */
  778.     totalLength = pAcDescr->totalLength [0] | (pAcDescr->totalLength [1] << 8);
  780.     remLen = min (totalLength - sizeof (*pAcDescr), bfrLen);
  782.     if ((pOutputTerm = findAudioDescr (pBfr, 
  783.        remLen, 
  784.        USB_DESCR_AUDIO_INTERFACE, 
  785.        USB_DESCR_AUDIO_AC_OUTPUT_TERMINAL)) 
  786.      == NULL)
  787. return ERROR;
  789.     pSeqDev->outputTerminalId = pOutputTerm->terminalId;
  791.     prevId = pOutputTerm->sourceId;
  793.     while (prevId != 0 && pSeqDev->inputTerminalId == 0)
  794. {
  795. if ((pAcCommon = findAudioDescrByUnit (pBfr, remLen, prevId)) == NULL)
  796.     return FALSE;
  798. switch (pAcCommon->descriptorSubType)
  799.     {
  800.     case USB_DESCR_AUDIO_AC_INPUT_TERMINAL:
  802. /* Record characteristics of the input terminal */
  804. pInputTerm = (pUSB_AUDIO_INPUT_TERM_DESCR) pAcCommon;
  805. pSeqDev->inputTerminalId = pInputTerm->terminalId;
  806. pSeqDev->channels = pInputTerm->channels;
  807. pSeqDev->channelConfig = pInputTerm->channelConfig [0] 
  808. | (pInputTerm->channelConfig [1] << 8);
  809. prevId = 0;
  811. /* If there is a feature unit descriptor, record its 
  812.  * capabilities on a channel-by-channel basis. 
  813.  */
  815. if (pFeatureUnit != NULL)
  816.     {
  817.     /* Allocate space for info on a per-channel basis.
  818.      *
  819.      * NOTE: Array position 0 is for "master" (ie. 
  820.      * global) channel.
  821.      */
  823.     pSeqDev->capsLen = 
  824.     (pSeqDev->channels + 1) * sizeof (USB_SPKR_CHANNEL_CAPS);
  826.     if ((pSeqDev->pCaps = OSS_CALLOC (pSeqDev->capsLen)) 
  827.      == NULL)
  828. return ERROR;
  831.     /* Record capabilities */
  833.     for (i = 0; i <= pSeqDev->channels; i++)
  834. {
  835. pControl = &pFeatureUnit->controls[i * pFeatureUnit->controlSize];
  837. recordChannelCaps (pSeqDev, 
  838.    pFeatureUnit->unitId, 
  839.    i, 
  840.    &pSeqDev->pCaps [i], 
  841.    *pControl);
  842. }
  843.     }
  845. break;
  847.     case USB_DESCR_AUDIO_AC_MIXER_UNIT:
  849. prevId = ((pUSB_AUDIO_MIXER_UNIT_DESCR) pAcCommon)->sourceId [0];
  850. break;
  852.     case USB_DESCR_AUDIO_AC_SELECTOR_UNIT:
  854. prevId = ((pUSB_AUDIO_SELECTOR_UNIT_DESCR) pAcCommon)->sourceId [0];
  855. break;
  857.     case USB_DESCR_AUDIO_AC_FEATURE_UNIT:
  859. /* Record capabilities of the feature unit */
  861. pFeatureUnit = (pUSB_AUDIO_FEATURE_UNIT_DESCR) pAcCommon;
  862. pSeqDev->featureUnitId = pFeatureUnit->unitId;
  863. prevId = pFeatureUnit->sourceId;
  864. break;
  866.     case USB_DESCR_AUDIO_AC_PROCESSING_UNIT:
  868. prevId = ((pUSB_AUDIO_PROCESS_UNIT_DESCR) pAcCommon)->sourceId [0];
  869. break;
  871.     case USB_DESCR_AUDIO_AC_EXTENSION_UNIT:
  873. prevId = ((pUSB_AUDIO_EXT_UNIT_DESCR) pAcCommon)->sourceId [0];
  874. break;
  876.     case USB_DESCR_AUDIO_AC_UNDEFINED:
  877.     case USB_DESCR_AUDIO_AC_HEADER:
  878.     case USB_DESCR_AUDIO_AC_OUTPUT_TERMINAL:
  879.     default:
  881. /* These terminal/unit types should not be encountered at
  882.  * this point in the algorithm.
  883.  */
  885. return ERROR;
  886.     }
  887. }
  889.     return OK;
  890.     }
  893. /***************************************************************************
  894. *
  895. * reallocateFormatList - increases room for format list by one entry
  896. *
  897. * RETURNS: OK, else ERROR if out of memory
  898. */
  900. LOCAL STATUS reallocateFormatList
  901.     (
  902.     pUSB_SPKR_SEQ_DEV pSeqDev
  903.     )
  905.     {
  906.     pUSB_SPKR_AUDIO_FORMAT pNewList;
  908.     pSeqDev->fmtCount++;
  910.     if ((pNewList = OSS_CALLOC (pSeqDev->fmtCount * 
  911. sizeof (USB_SPKR_AUDIO_FORMAT))) 
  912.        == NULL)
  913. return ERROR;
  915.     if (pSeqDev->fmtCount > 1 && pSeqDev->pFmt != NULL)
  916. {
  917. memcpy (pNewList, 
  918. pSeqDev->pFmt, 
  919. (pSeqDev->fmtCount - 1) * sizeof (USB_SPKR_AUDIO_FORMAT));
  921. OSS_FREE (pSeqDev->pFmt);
  922. }
  924.     pSeqDev->pFmt = pNewList;
  926.     return OK;
  927.     }
  930. /***************************************************************************
  931. *
  932. * parseInterface - parse an interface descriptor, looking for audio formats
  933. *
  934. * NOTE: <cfgLen> should count bytes only through the end of this interface.
  935. *
  936. * RETURNS: N/A
  937. */
  939. LOCAL VOID parseInterface
  940.     (
  941.     pUSB_SPKR_SEQ_DEV pSeqDev,
  942.     pUSB_INTERFACE_DESCR pIfDescr,
  943.     pUINT8 pCfgBfr,
  944.     UINT16 cfgLen
  945.     )
  947.     {
  948.     pUSB_AUDIO_AS_DESCR pAsDescr;
  949.     pUSB_AUDIO_TYPE_DESCR pType;
  950.     pUSB_AUDIO_STD_ISOCH_EP_DESCR pStdEp;
  951.     pUSB_SPKR_AUDIO_FORMAT pFmt;
  952.     USB_SPKR_AUDIO_FORMAT fmt = {0};
  955.     /* If this interface doesn't contain a class-specific AS (AudioStreaming)
  956.      * descriptor then ignore it.  If it does, but the AudioStream doesn't
  957.      * link to the inputTerminalId, then ignore it anyway.
  958.      */
  960.     if ((pAsDescr = findAudioDescrSkip (&pCfgBfr, 
  961. &cfgLen, 
  962. USB_DESCR_AUDIO_INTERFACE, 
  963. USB_DESCR_AUDIO_AS_GENERAL)) 
  964.        == NULL)
  965. return;
  967.     if (pAsDescr->terminalLink != pSeqDev->inputTerminalId)
  968. return;
  971.     /* We must now find a format type descriptor and an endpoint descriptor. */
  973.     if ((pType = findAudioDescr (pCfgBfr, 
  974.  cfgLen,
  975.  USB_DESCR_AUDIO_INTERFACE, 
  976.  USB_DESCR_AUDIO_AS_FORMAT_TYPE)) 
  977. == NULL)
  978. return;
  980.     if ((pStdEp = usbDescrParse (pCfgBfr, cfgLen, USB_DESCR_ENDPOINT)) == NULL)
  981. return;
  984.     /* Construct a format record from the accumulated data. */
  986.     fmt.interface = pIfDescr->interfaceNumber;
  987.     fmt.altSetting = pIfDescr->alternateSetting;
  988.     fmt.delay = pAsDescr->delay;
  989.     fmt.endpoint = pStdEp->endpointAddress;
  990.     fmt.maxPacketSize = pStdEp->maxPacketSize [0] 
  991. | (pStdEp->maxPacketSize [1] << 8);
  992.     fmt.formatTag = pAsDescr->formatTag [0] | (pAsDescr->formatTag [1] << 8);
  993.     fmt.formatType = pType->formatType;
  995.     switch (pType->formatType)
  996. {
  997. case USB_AUDIO_FORMAT_TYPE1:
  999.     fmt.channels = pType->ts.type1.nbrChannels;
  1000.     fmt.subFrameSize = pType->ts.type1.subFrameSize;
  1001.     fmt.bitRes = pType->ts.type1.bitResolution;
  1002.     break;
  1004. case USB_AUDIO_FORMAT_TYPE2:
  1006.     fmt.maxBitRate = pType->ts.type2.maxBitRate [0] |
  1007.     (pType->ts.type2.maxBitRate [1] << 8);
  1008.     fmt.samplesPerFrame = pType->ts.type2.samplesPerFrame [0] 
  1009.   | (pType->ts.type2.samplesPerFrame [1] << 8);
  1010.     break;
  1012. case USB_AUDIO_FORMAT_TYPE3:
  1014.     fmt.channels = pType->ts.type3.nbrChannels;
  1015.     fmt.subFrameSize = pType->ts.type3.subFrameSize;
  1016.     fmt.bitRes = pType->ts.type3.bitResolution;
  1017.     break;
  1019. default: /* We don't recognize this format */
  1021.     return;
  1022. }
  1025.     /* Copy new format record to SEQ_DEV structure. */
  1027.     if (reallocateFormatList (pSeqDev) != OK)
  1028. return;
  1030.     pFmt = &pSeqDev->pFmt [pSeqDev->fmtCount - 1];
  1031.     *pFmt = fmt;
  1032.     }
  1035. /***************************************************************************
  1036. *
  1037. * buildFormatList - builds a list of formats supported by the speaker
  1038. *
  1039. * RETURNS: OK if successful, else ERROR.
  1040. */
  1042. LOCAL STATUS buildFormatList
  1043.     (
  1044.     pUSB_SPKR_SEQ_DEV pSeqDev,
  1045.     pUINT8 pCfgBfr,
  1046.     UINT16 cfgLen
  1047.     )
  1049.     {
  1050.     pUSB_INTERFACE_DESCR pIfDescr;
  1051.     pUINT8 pTmp;
  1052.     UINT16 tmpLen;
  1053.     UINT16 rangeLen;
  1056.     /* Find each interface descriptor of type AudioStreaming.  Determine the 
  1057.      * length of the descriptor, and then parse each format type supported by 
  1058.      * the interface.
  1059.      */
  1061.     while ((pIfDescr = usbDescrParseSkip (&pCfgBfr, 
  1062.   &cfgLen, 
  1063.   USB_DESCR_INTERFACE)) 
  1064. != NULL)
  1065. {
  1066. if (pIfDescr->interfaceClass == USB_CLASS_AUDIO &&
  1067.     pIfDescr->interfaceSubClass == USB_SUBCLASS_AUDIO_AUDIOSTREAMING)
  1068.     {
  1069.     /* We found an AudioStreaming interface descriptor.  Now, determine 
  1070.      * how many bytes until the next interface descriptor. This 
  1071.      * determines the range of the configuration descriptor we will 
  1072.      * examine while parsing this interface.
  1073.      */
  1075.     pTmp = pCfgBfr;
  1076.     tmpLen = cfgLen;
  1078.     if (usbDescrParseSkip (&pTmp, 
  1079.    &tmpLen, 
  1080.    USB_DESCR_INTERFACE) 
  1081.  != NULL)
  1082. rangeLen = cfgLen - tmpLen;
  1083.     else
  1084. rangeLen = cfgLen;
  1086.     parseInterface (pSeqDev, pIfDescr, pCfgBfr, rangeLen);
  1087.     }
  1088. }
  1091.     return OK;
  1092.     }
  1095. /***************************************************************************
  1096. *
  1097. * selectFormat - selects an audio format to match the caller's request
  1098. *
  1099. * <pReqFmt> points to a USB_SPEAKER_AUDIO_FORMAT structure in which the
  1100. * "formatTag" field has been initialized to the desired format as
  1101. * USB_AUDIO_TYPEn_xxxx and "formatType" has been initialized with the 
  1102. * format type as USB_AUDIO_FORMAT_TYPEn.  
  1103. *
  1104. * Depending on the specified format, the fields "channels", "subFrameSize", 
  1105. * "bitRes", "sampleFrequency", "maxBitRate", and "samplesPerFrame" may also 
  1106. * need to be specified to qualify the format.  The other fields of the 
  1107. * structure *do not* need to be specified.
  1108. *
  1109. * The field "sampleFrequency", which must be set for Type I & Type 3 formats
  1110. * must be set with the desired playback frequency.  The frequency is 
  1111. * expressed as samples per sec.  For example, a sampleFrequency of 88,500 
  1112. * is 88,500 samples per second per channel.
  1113. *
  1114. * This function will attempt to find an audio format supported by the
  1115. * speaker which is an exact match for the specified format.  If found, that
  1116. * format will be selected.  If no exact match can be found, an error will be
  1117. * returned.
  1118. *
  1119. * RETURNS: OK if successful, else ERROR.
  1120. */
  1122. LOCAL STATUS selectFormat
  1123.     (
  1124.     pUSB_SPKR_SEQ_DEV pSeqDev,
  1125.     pUSB_SPKR_AUDIO_FORMAT pReqFmt
  1126.     )
  1128.     {
  1129.     pUSB_SPKR_AUDIO_FORMAT pFmt;
  1130.     UINT16 i;
  1132.     /* Set the format type to "unspecified". */
  1134.     pSeqDev->pSelFmt = NULL;
  1136.     pSeqDev->sampleFrequency = 0;
  1137.     pSeqDev->sampleSize = 0;
  1140.     /* Look for an exact match for the format */
  1142.     for (i = 0; i < pSeqDev->fmtCount; i++)
  1143. {
  1144. pFmt = &pSeqDev->pFmt [i];
  1146. switch (pReqFmt->formatType)
  1147.     {
  1148.     case USB_AUDIO_FORMAT_TYPE1:
  1149.     case USB_AUDIO_FORMAT_TYPE3:
  1151. if (pReqFmt->formatTag == pFmt->formatTag &&
  1152.     pReqFmt->channels == pFmt->channels &&
  1153.     pReqFmt->subFrameSize == pFmt->subFrameSize &&
  1154.     pReqFmt->bitRes == pFmt->bitRes)
  1156.     {
  1157.     pSeqDev->pSelFmt = pFmt;
  1158.     pSeqDev->sampleFrequency = pReqFmt->sampleFrequency;
  1159.     pSeqDev->sampleSize = pFmt->channels * pFmt->subFrameSize;
  1160.     pSeqDev->bytesPerSec = 
  1161.     pSeqDev->sampleFrequency * pSeqDev->sampleSize;
  1162.     return OK;
  1163.     }
  1164. break;
  1166.     case USB_AUDIO_FORMAT_TYPE2:
  1168.     if (pReqFmt->formatTag == pFmt->formatTag &&
  1169. pReqFmt->maxBitRate == pFmt->maxBitRate &&
  1170. pReqFmt->samplesPerFrame == pFmt->samplesPerFrame)
  1172. {
  1173. pSeqDev->pSelFmt = pFmt;
  1174. pSeqDev->sampleFrequency = pReqFmt->sampleFrequency;
  1175. pSeqDev->sampleSize = 1;
  1176. pSeqDev->bytesPerSec = 
  1177. pSeqDev->sampleFrequency * pSeqDev->sampleSize;
  1178. return OK;
  1179. }
  1180.     break;
  1182.     default:    /* not supported */
  1184.     return ERROR;
  1185.     }
  1186. }
  1189.     /* No compatible format was found. */
  1191.     return ERROR;
  1192.     }
  1195. /***************************************************************************
  1196. *
  1197. * parseAudioConfig - parse configuration descriptor for audio device
  1198. *
  1199. * Examine the configuration descriptor and build a map of the device's
  1200. * capabilities.  To be used by this speaker class driver, the device must
  1201. * have an "Output Terminal".  If it does, then determine which audio
  1202. * formats can be passed to the device.
  1203. *
  1204. * RETURNS: OK if successful, else ERROR
  1205. */
  1207. LOCAL STATUS parseAudioConfig
  1208.     (
  1209.     pUSB_SPKR_SEQ_DEV pSeqDev,
  1210.     pUINT8 pCfgBfr,
  1211.     UINT16 cfgLen,
  1212.     pUSB_CONFIG_DESCR pCfgDescr
  1213.     )
  1215.     {
  1216.     /* Find the Audio Control descriptor and build a map of the device */
  1218.     if (buildAudioMap (pSeqDev, pCfgBfr, cfgLen) != OK)
  1219. return ERROR;
  1221.     if (pSeqDev->outputTerminalId == 0 || pSeqDev->inputTerminalId == 0)
  1222. return ERROR;
  1225.     /* The audio device has the necessary Output Terminal.  Parse the
  1226.      * configuration descriptor and make a list of the supported audio
  1227.      * formats.
  1228.      */
  1230.     if (buildFormatList (pSeqDev, pCfgBfr, cfgLen) != OK)
  1231. return ERROR;
  1233.     if (pSeqDev->fmtCount == 0)
  1234. return ERROR;
  1236.     return OK;
  1237.     }
  1240. /***************************************************************************
  1241. *
  1242. * configureSeqDev - configure USB speaker for operation
  1243. *
  1244. * Examine the device's configuration & associated descriptors to determine
  1245. * the audio device's capability.  If the device is an audio device capable
  1246. * of output (e.g., it includes an "Output Terminal") then build a structure
  1247. * to describe the device and configure it.
  1248. *
  1249. * RETURNS: OK if successful, else ERROR if failed to configure channel
  1250. */
  1252. LOCAL STATUS configureSeqDev
  1253.     (
  1254.     pUSB_SPKR_SEQ_DEV pSeqDev
  1255.     )
  1257.     {
  1258.     pUSB_CONFIG_DESCR pCfgDescr;
  1259.     pUINT8 pCfgBfr;
  1260.     UINT16 cfgLen;
  1261.     STATUS retcode;
  1264.     /* Read the configuration descriptor so we can determine the device's
  1265.      * capabilities.
  1266.      */
  1268.     if (usbConfigDescrGet (usbdHandle, 
  1269.    pSeqDev->nodeId, 
  1270.    pSeqDev->configuration, 
  1271.    &cfgLen, 
  1272.    &pCfgBfr) 
  1273.  != OK)
  1274. return ERROR;
  1276.     if ((pCfgDescr = usbDescrParse (pCfgBfr, 
  1277.     cfgLen, 
  1278.     USB_DESCR_CONFIGURATION)) 
  1279.   == NULL)
  1280. {
  1281. retcode = ERROR;
  1282. }
  1283.     else
  1284. {
  1285. /* Parse the configuration descriptor to see if the device has the
  1286.  * capabilities we need to use it as a speaker.
  1287.  */
  1289. retcode = parseAudioConfig (pSeqDev, pCfgBfr, cfgLen, pCfgDescr);
  1290. }
  1293.     if (retcode == OK)
  1294. {
  1295. /* Select the configuration. */
  1297. if (usbdConfigurationSet (usbdHandle, 
  1298.   pSeqDev->nodeId,
  1299.   pCfgDescr->configurationValue, 
  1300.   pCfgDescr->maxPower * USB_POWER_MA_PER_UNIT) 
  1301. != OK)
  1302.     {
  1303.     retcode = ERROR;
  1304.     }
  1305. }
  1308.     /* Release the buffer allocated by usbConfigDescrGet(). */
  1310.     OSS_FREE (pCfgBfr);
  1312.     return retcode;
  1313.     }
  1316. /***************************************************************************
  1317. *
  1318. * destroyAudioStream - releases audio stream, bandwidth, resources
  1319. *
  1320. * Releases the resources allocated for an audio stream as long as play
  1321. * has completed.  If <unconditional> is TRUE, then the stream is 
  1322. * destroyed whether or not play has completed. 
  1323. *
  1324. * RETURNS: N/A
  1325. */
  1327. LOCAL VOID destroyAudioStream
  1328.     (
  1329.     pUSB_SPKR_SEQ_DEV pSeqDev,
  1330.     BOOL unconditional
  1331.     )
  1333.     {
  1334.     /* If still playing, return. */
  1336.     if (unconditional 
  1337. || pSeqDev->streamFault 
  1338. || (!pSeqDev->open && pSeqDev->audioBfrCount == 0))
  1339. {
  1340. /* Destroy the isoch. pipe. */
  1342. if (pSeqDev->isochPipeHandle != NULL)
  1343.     {
  1344.     usbdPipeDestroy (usbdHandle, pSeqDev->isochPipeHandle);
  1345.     pSeqDev->isochPipeHandle = NULL;
  1346.     }
  1348. /* Release buffer-not-full semaphore */
  1350. if (pSeqDev->bfrNotFullSem != NULL)
  1351.     {
  1352.     OSS_SEM_DESTROY (pSeqDev->bfrNotFullSem);
  1353.     pSeqDev->bfrNotFullSem = NULL;
  1354.     }
  1356. /* Release the audio data buffer */
  1358. if (pSeqDev->pAudioBfr != NULL)
  1359.     {
  1360.     OSS_FREE (pSeqDev->pAudioBfr);
  1361.     pSeqDev->pAudioBfr = NULL;
  1362.     }
  1363. }
  1364.     }
  1367. /***************************************************************************
  1368. *
  1369. * openAudioStream - Sets up speaker to begin receiving audio data
  1370. *
  1371. * RETURNS: OK if successful, else EIO if error.
  1372. */
  1374. LOCAL STATUS openAudioStream
  1375.     (
  1376.     pUSB_SPKR_SEQ_DEV pSeqDev
  1377.     )
  1379.     {
  1380.     pUSB_SPKR_AUDIO_FORMAT pFmt = pSeqDev->pSelFmt;
  1381.     UINT32 halfBfrLen;
  1384.     /* If the audio stream is already open or data is still in the bfr,
  1385.      * return an error.
  1386.      */
  1388.     if (pSeqDev->open || pSeqDev->audioBfrCount > 0)
  1389. return EIO;
  1391.     /* Return an error if no audio format specified. */
  1393.     if (pFmt == NULL)
  1394. return EIO;
  1397.     /* Select the audio interface/alt setting for the indicated format */
  1399.     if (usbdInterfaceSet (usbdHandle, 
  1400.   pSeqDev->nodeId,
  1401.   pFmt->interface, 
  1402.   pFmt->altSetting)
  1403. != OK)
  1404. return EIO;
  1407.     /* Calculate the size of the data buffer for the audio stream.  We 
  1408.      * calculate the buffer size to ensure one second of buffering capability
  1409.      * and to ensure that each half of the buffer accomodates an exactly
  1410.      * multiple of the sample size.
  1411.      */
  1413.     halfBfrLen = pSeqDev->bytesPerSec / 2;
  1414.     halfBfrLen = ((halfBfrLen + pSeqDev->sampleSize - 1) / pSeqDev->sampleSize)
  1415. * pSeqDev->sampleSize;
  1418.     /* Allocate resources for the stream. */
  1420.     pSeqDev->streamFault = FALSE;
  1422.     if ((pSeqDev->pAudioBfr = OSS_MALLOC (halfBfrLen * 2)) == NULL)
  1423. return EIO;
  1425.     pSeqDev->audioBfrLen = halfBfrLen * 2;
  1426.     pSeqDev->audioBfrHalf = halfBfrLen;
  1427.     pSeqDev->audioBfrCount = 0;
  1428.     pSeqDev->audioBfrIn = 0;
  1429.     pSeqDev->audioBfrOut = 0;
  1430.     pSeqDev->audioBfrPending = 0;
  1431.     pSeqDev->audioBfrTotal = 0;
  1433.     pSeqDev->foregroundWaiting = FALSE;
  1435.     if (OSS_SEM_CREATE (1, 0, &pSeqDev->bfrNotFullSem) != OK)
  1436. {
  1437. destroyAudioStream (pSeqDev, TRUE);
  1438. return EIO;
  1439. }
  1441.     pSeqDev->nextStartFrame = 0;
  1442.     pSeqDev->blocksSent = 0;
  1444.     pSeqDev->nextIrp = 0;
  1445.     pSeqDev->nextDoneIrp = 0;
  1446.     pSeqDev->irpsInUse = 0;
  1449.     /* Create the isochronous transmit pipe for the audio data. */
  1451.     if (usbdPipeCreate (usbdHandle, 
  1452. pSeqDev->nodeId, 
  1453. pFmt->endpoint,
  1454. pSeqDev->configuration, 
  1455. pFmt->interface, 
  1456. USB_XFRTYPE_ISOCH,
  1457. USB_DIR_OUT, 
  1458. pFmt->maxPacketSize, 
  1459. pSeqDev->bytesPerSec, 
  1460. 1, 
  1461. &pSeqDev->isochPipeHandle) 
  1462.       != OK)
  1463. {
  1464. destroyAudioStream (pSeqDev, TRUE);
  1465. return EIO;
  1466. }
  1469.     pSeqDev->open = TRUE;
  1471.     return OK;
  1472.     }
  1475. /***************************************************************************
  1476. *
  1477. * closeAudioStream - Marks end of audio stream.
  1478. *
  1479. * RETURNS: OK if successful, else EIO if error.
  1480. */
  1482. LOCAL STATUS closeAudioStream
  1483.     (
  1484.     pUSB_SPKR_SEQ_DEV pSeqDev
  1485.     )
  1487.     {
  1488.     /* If we're not playing, return an error. */
  1490.     if (!pSeqDev->open)
  1491. return EIO;
  1494.     /* tear down the isoch pipe, etc., if the audio transmission is 
  1495.      * complete...if still transmitting, the stream will be torn down
  1496.      * upon completion of the data transfer.
  1497.      */
  1499.     pSeqDev->open = FALSE;
  1501.     destroyAudioStream (pSeqDev, FALSE);
  1503.     return OK;
  1504.     }
  1507. /***************************************************************************
  1508. *
  1509. * updateTransmitter - starts/restarts double-buffered I/O
  1510. *
  1511. * NOTE: Caller must ensure speakerMutex is taken before calling this
  1512. * routine.
  1513. *
  1514. * RETURNS: OK if successful, else ERROR.
  1515. */
  1517. LOCAL STATUS updateTransmitter
  1518.     (
  1519.     pUSB_SPKR_SEQ_DEV pSeqDev
  1520.     )
  1522.     {
  1523.     pUSB_IRP pIrp;
  1524.     UINT32 currentFrame;
  1525.     UINT32 extLen;
  1526.     UINT32 frameCount;
  1527.     STATUS status = OK;
  1530.     /* If an IRP is available and there is data available but not yet
  1531.      * being transmitted, then send it.
  1532.      */
  1534.     while (!pSeqDev->streamFault 
  1535.     && pSeqDev->irpsInUse < IRP_COUNT 
  1536.     && ((pSeqDev->audioBfrCount - pSeqDev->audioBfrPending 
  1537.          >= pSeqDev->audioBfrHalf) 
  1538.     || !pSeqDev->open))
  1539. {
  1540. /* If this is the first block of data, initialize the starting
  1541.  * frame number.
  1542.  */
  1544. if (pSeqDev->blocksSent == 0)
  1545.     {
  1546.     if (usbdCurrentFrameGet (usbdHandle, 
  1547.      pSeqDev->nodeId,
  1548.      &currentFrame, 
  1549.      &pSeqDev->frameWindow) 
  1550.    != OK)
  1551. currentFrame = 0;
  1553.     pSeqDev->nextStartFrame = (currentFrame + FRAME_SKIP) %
  1554.     pSeqDev->frameWindow;
  1555.     }
  1558. /* Use the next IRP to transmit a block of data.  Each IRP always
  1559.  * transfers half of the data buffer or the entire block of 
  1560.  * remaining data if the stream has been closed.
  1561.  */
  1563. extLen = pSeqDev->audioBfrCount - pSeqDev->audioBfrPending;
  1564. extLen = min (extLen, pSeqDev->audioBfrHalf);
  1566. if (extLen < pSeqDev->audioBfrHalf && pSeqDev->open)
  1567.     break;
  1569. frameCount = ((extLen * MSEC_PER_SEC) + pSeqDev->bytesPerSec - 1) / 
  1570.     pSeqDev->bytesPerSec;
  1572. if (frameCount == 0)
  1573.     break;
  1576. /* Initialize the IRP. */
  1578. pIrp = &pSeqDev->irp [pSeqDev->nextIrp];
  1580. pSeqDev->irpsInUse++;
  1582. if (++pSeqDev->nextIrp == IRP_COUNT)
  1583.     pSeqDev->nextIrp = 0;
  1585. memset (pIrp, 0, sizeof (*pIrp));
  1587. pIrp->userPtr = pSeqDev;
  1588. pIrp->irpLen = sizeof (*pIrp);
  1589. pIrp->userCallback = usbSpkrIrpCallback;
  1590. pIrp->timeout = USB_TIMEOUT_NONE;
  1591. pIrp->startFrame = pSeqDev->nextStartFrame;
  1592. pIrp->dataBlockSize = pSeqDev->sampleSize;
  1594. pIrp->transferLen = extLen;
  1595. pIrp->bfrCount = 1;
  1596. pIrp->bfrList [0].pid = USB_PID_OUT;
  1597. pIrp->bfrList [0].pBfr = &pSeqDev->pAudioBfr [pSeqDev->audioBfrOut];
  1598. pIrp->bfrList [0].bfrLen = extLen;
  1600. pSeqDev->audioBfrPending += extLen;
  1602. if ((pSeqDev->audioBfrOut += extLen) == pSeqDev->audioBfrLen)
  1603.     pSeqDev->audioBfrOut = 0;
  1605. pSeqDev->nextStartFrame = 
  1606.     (pSeqDev->nextStartFrame + frameCount) % pSeqDev->frameWindow;
  1608. pSeqDev->blocksSent++;
  1611. /* Send the data */
  1613. if (usbdTransfer (usbdHandle, pSeqDev->isochPipeHandle, pIrp) != OK)
  1614.     {
  1615.     pSeqDev->streamFault = TRUE;
  1616.     status = ERROR;
  1617.     }
  1618. }
  1620.     return status;
  1621.     }
  1624. /***************************************************************************
  1625. *
  1626. * usbSpkrIrpCallback - invoked when IRPs complete
  1627. *
  1628. * Examines the result of each IRP.  Attempts to initiate new transmission.
  1629. *
  1630. * NOTE: By convention, the userPtr field in each IRP is a pointer to the
  1631. * corresponding USB_SPKR_SEQ_DEV structure.
  1632. *
  1633. * RETURNS: N/A
  1634. */
  1636. LOCAL VOID usbSpkrIrpCallback 
  1637.     (
  1638.     pVOID p
  1639.     )
  1641.     {
  1642.     pUSB_IRP pIrp = (pUSB_IRP) p;
  1643.     pUSB_SPKR_SEQ_DEV pSeqDev = (pUSB_SPKR_SEQ_DEV) pIrp->userPtr;
  1646.     OSS_MUTEX_TAKE (speakerMutex, OSS_BLOCK);
  1649.     /* Look for out-of-order IRP completion */
  1651.     if (pIrp != &pSeqDev->irp [pSeqDev->nextDoneIrp])
  1652. {
  1653. pSeqDev->streamFault = TRUE;
  1654. }
  1655.     else
  1656. {
  1657. /* Indicate an IRP has completed and update buffer pointers */
  1659. pSeqDev->irpsInUse--;
  1661. if (++pSeqDev->nextDoneIrp == IRP_COUNT)
  1662.     pSeqDev->nextDoneIrp = 0;
  1664. pSeqDev->audioBfrPending -= pIrp->transferLen;
  1665. pSeqDev->audioBfrCount -= pIrp->transferLen;
  1668. /* Examine the IRP result */
  1670. if (pIrp->result != S_usbHcdLib_IRP_CANCELED)
  1671.     updateTransmitter (pSeqDev);
  1672. else
  1673.     pSeqDev->streamFault = TRUE;
  1674. }
  1677.     /* The completion of any IRP, successfully or otherwise, unblocks 
  1678.      * the foreground thread. 
  1679.      */
  1681.     if (pSeqDev->foregroundWaiting)
  1682. {
  1683. pSeqDev->foregroundWaiting = FALSE;
  1684. OSS_SEM_GIVE (pSeqDev->bfrNotFullSem);
  1685. }
  1688.     /* The following call to destroyAudioStream() doesn't do anything
  1689.      * unless the audio play is complete or there has been an error.
  1690.      */
  1692.     destroyAudioStream (pSeqDev, FALSE);
  1695.     OSS_MUTEX_RELEASE (speakerMutex);
  1696.     }
  1699. /***************************************************************************
  1700. *
  1701. * usbSpkrSeqRd - SEQ_DEV sequential read routine
  1702. * 
  1703. * RETURNS: not supported, always returns ERROR.
  1704. */
  1706. LOCAL STATUS usbSpkrSeqRd
  1707.     (
  1708.     pUSB_SPKR_SEQ_DEV pSeqDev,     /* pointer to device descriptor */
  1709.     int numBytes,     /* number of bytes to read */
  1710.     char *buffer,     /* pointer to buffer to receive data */
  1711.     BOOL fixed     /* TRUE => fixed block size */
  1712.     )
  1714.     {
  1715.     return ERROR;
  1716.     }
  1719. /***************************************************************************
  1720. *
  1721. * usbSpkrSeqWt - SEQ_DEV sequential write routine
  1722. *
  1723. * RETURNS: OK if transfer successful, else ERROR.
  1724. */
  1726. LOCAL STATUS usbSpkrSeqWrt
  1727.     (
  1728.     pUSB_SPKR_SEQ_DEV pSeqDev,     /* pointer to device descriptor */
  1729.     int numBytes,     /* number of bytes or blocks to be written */
  1730.     char *buffer,     /* ptr to input data buffer */
  1731.     BOOL fixed     /* TRUE => fixed block size */
  1732.     )
  1734.     {
  1735.     UINT32 extLen;
  1738.     /* If the audio stream isn't open, we don't accept input */
  1740.     if (!pSeqDev->open)
  1741.     return EIO;
  1744.     /* Copy audio data to our internal buffer. */
  1746.     OSS_MUTEX_TAKE (speakerMutex, OSS_BLOCK);
  1748.     while (numBytes > 0 && !pSeqDev->streamFault)
  1749. {
  1750. /* If our internal buffer is full, wait for space to become avail. */
  1752. if (pSeqDev->audioBfrCount == pSeqDev->audioBfrLen)
  1753.     {
  1754.     pSeqDev->foregroundWaiting = TRUE;
  1756.     OSS_MUTEX_RELEASE (speakerMutex);
  1757.     OSS_SEM_TAKE (pSeqDev->bfrNotFullSem, OSS_BLOCK);
  1758.     OSS_MUTEX_TAKE (speakerMutex, OSS_BLOCK);
  1760.     if (pSeqDev->streamFault)
  1761.     break;
  1762.     }
  1765. /* Calculate length of next contiguous extent in buffer */
  1767. if (pSeqDev->audioBfrIn < pSeqDev->audioBfrOut)
  1768.     extLen = pSeqDev->audioBfrOut - pSeqDev->audioBfrIn;
  1769. else
  1770.     extLen = pSeqDev->audioBfrLen - pSeqDev->audioBfrIn;
  1772. extLen = min (extLen, pSeqDev->audioBfrLen - pSeqDev->audioBfrCount);
  1775. /* Copy data to buffer */
  1777. extLen = min (extLen, (unsigned)numBytes);
  1779. memcpy (&pSeqDev->pAudioBfr [pSeqDev->audioBfrIn], buffer, extLen);
  1781. buffer += extLen;
  1782. numBytes -= extLen;
  1784. pSeqDev->audioBfrCount += extLen;
  1785. pSeqDev->audioBfrTotal += extLen;
  1787. if ((pSeqDev->audioBfrIn += extLen) == pSeqDev->audioBfrLen)
  1788.     pSeqDev->audioBfrIn = 0;
  1791. /* Update transmitter. */
  1793. if (updateTransmitter (pSeqDev) != OK)
  1794.     return EIO;
  1795. }
  1798.     OSS_MUTEX_RELEASE (speakerMutex);
  1801.     if (numBytes == 0)
  1802. return OK;
  1803.     else
  1804. return EIO;
  1805.     }
  1808. /***************************************************************************
  1809. *
  1810. * usbSpkrIoctl - SEQ_DEV IOCTL routine
  1811. *
  1812. * RETURNS: OK if IOCTL handled successfully, ENOSYS if unsupported
  1813. *      request, or EIO for other errors.
  1814. */
  1816. LOCAL STATUS usbSpkrIoctl
  1817.     (
  1818.     pUSB_SPKR_SEQ_DEV pSeqDev,     /* pointer to device descriptor */
  1819.     int funcCode,     /* ioctl() function code */
  1820.     int arg /* function-specific argument */
  1821.     )
  1823.     {
  1824.     STATUS status = OK;
  1827.     /* Handle IOCTL */
  1829.     switch (funcCode)
  1830.     {
  1831.     case USB_SPKR_IOCTL_GET_FORMAT_COUNT:
  1833. /* Return could of supported audio formats */
  1835. *((pUINT16) arg) = pSeqDev->fmtCount;
  1836. break;
  1839.     case USB_SPKR_IOCTL_GET_FORMAT_LIST:
  1841. /* Return pointer to array of audio formats */
  1843. *((pUSB_SPKR_AUDIO_FORMAT *) arg) = pSeqDev->pFmt;
  1844. break;
  1847.     case USB_SPKR_IOCTL_GET_CHANNEL_COUNT:
  1849. /* Return count of audio channels + 1 for master channel */
  1851. *((pUINT16) arg) = pSeqDev->channels;
  1852. break;
  1855.     case USB_SPKR_IOCTL_GET_CHANNEL_CONFIG:
  1857. /* Return configuration of channels */
  1859. *((pUINT16) arg) = pSeqDev->channelConfig;
  1860. break;
  1863.     case USB_SPKR_IOCTL_GET_CHANNEL_CAPS:
  1865. /* Return pointer to capabilities array for all channels */
  1867. *((pUSB_SPKR_CHANNEL_CAPS *) arg) = pSeqDev->pCaps;
  1868. break;
  1871.     case USB_SPKR_IOCTL_SET_AUDIO_FORMAT:
  1873. /* Find a format matching the one indicated by the caller */
  1875. if (selectFormat (pSeqDev, (pUSB_SPKR_AUDIO_FORMAT) arg) != OK)
  1876.     status = ENOSYS;
  1877. break;
  1880.     case USB_SPKR_IOCTL_OPEN_AUDIO_STREAM:
  1882. /* Begin an audio stream. */
  1884. status = openAudioStream (pSeqDev);
  1886. break;
  1889.     case USB_SPKR_IOCTL_CLOSE_AUDIO_STREAM:
  1891. /* mark the end of an audio stream */
  1893. status = closeAudioStream (pSeqDev);
  1894. break;
  1897.     case USB_SPKR_IOCTL_AUDIO_STREAM_STATUS:
  1899. /* report whether the audio device is still busy. */
  1901. *((pUINT16) arg) = 0;
  1903. if (pSeqDev->open)
  1904.     *((pUINT16) arg) |= USB_SPKR_STATUS_OPEN;
  1906. if (pSeqDev->audioBfrCount)
  1907.     *((pUINT16) arg) |= USB_SPKR_STATUS_DATA_IN_BFR;
  1909. break;
  1912.     case USB_SPKR_IOCTL_SET_MUTE:
  1913.     case USB_SPKR_IOCTL_SET_VOLUME:
  1914.     case USB_SPKR_IOCTL_SET_BASS:
  1915.     case USB_SPKR_IOCTL_SET_MID:
  1916.     case USB_SPKR_IOCTL_SET_TREBLE:
  1918. /* Set indicated channel control.  MSW(arg) = channel,
  1919.  * LSW(arg) = value.
  1920.  */
  1922. status = setChannelControl (pSeqDev, 
  1923.     funcCode, 
  1924.     MSW (arg), 
  1925.     LSW (arg));
  1926. break;
  1929.     default:
  1930. status = ENOSYS;
  1931. break;
  1932.     }
  1934.     return status;
  1935.     }
  1938. /***************************************************************************
  1939. *
  1940. * usbSpkrSeqWrtFileMarks - SEQ_DEV sequential write file marks routine
  1941. *
  1942. * RETURNS: not implemented.  Always returns OK for compatibility.
  1943. */
  1945. LOCAL STATUS usbSpkrSeqWrtFileMarks
  1946.     (
  1947.     pUSB_SPKR_SEQ_DEV pSeqDev,     /* pointer to device descriptor */
  1948.     int numMarks,     /* number of file marks to write */
  1949.     BOOL shortMark     /* short or long file marks */
  1950.     )
  1952.     {
  1953.     return OK;
  1954.     }
  1957. /***************************************************************************
  1958. *
  1959. * usbSpkrRewind - SEQ_DEV rewind routine
  1960. *
  1961. * RETURNS: not implemented.  Always returns OK for compatibility.
  1962. */
  1964. LOCAL STATUS usbSpkrRewind
  1965.     (
  1966.     pUSB_SPKR_SEQ_DEV pSeqDev     /* pointer to device descriptor */
  1967.     )
  1969.     {
  1970.     return OK;
  1971.     }
  1974. /***************************************************************************
  1975. *
  1976. * usbSpkrReserve - SEQ_DEV reserve routine
  1977. *
  1978. * RETURNS: OK if device can be reserved, else ERROR.
  1979. */
  1981. LOCAL STATUS usbSpkrReserve
  1982.     (
  1983.     pUSB_SPKR_SEQ_DEV pSeqDev     /* pointer to device descriptor */
  1984.     )
  1986.     {
  1987.     STATUS status;
  1989.     OSS_MUTEX_TAKE (speakerMutex, OSS_BLOCK);
  1991.     if (!pSeqDev->reserved)
  1992. {
  1993. pSeqDev->reserved = TRUE;
  1994. status = OK;
  1995. }
  1996.     else
  1997. {
  1998. status = ERROR;
  1999. }
  2001.     OSS_MUTEX_RELEASE (speakerMutex);
  2003.     return status;
  2004.     }
  2007. /***************************************************************************
  2008. *
  2009. * usbSpkrRelease - SEQ_DEV release routine
  2010. *
  2011. * RETURNS: OK if device can be released, else ERROR.
  2012. */
  2014. LOCAL STATUS usbSpkrRelease
  2015.     (
  2016.     pUSB_SPKR_SEQ_DEV pSeqDev     /* pointer to device descriptor */
  2017.     )
  2019.     {
  2020.     STATUS status;
  2022.     OSS_MUTEX_TAKE (speakerMutex, OSS_BLOCK);
  2024.     if (pSeqDev->reserved)
  2025. {
  2026. pSeqDev->reserved = FALSE;
  2027. status = OK;
  2028. }
  2029.     else
  2030. {
  2031. status = ERROR;
  2032. }
  2034.     OSS_MUTEX_RELEASE (speakerMutex);
  2036.     return status;
  2037.     }
  2040. /***************************************************************************
  2041. *
  2042. * usbSpkrReadBlkLim - SEQ_DEV read block limit routine
  2043. *
  2044. * RETURNS: always returns OK.
  2045. */
  2047. LOCAL STATUS usbSpkrReadBlkLim
  2048.     (
  2049.     pUSB_SPKR_SEQ_DEV pSeqDev,     /* pointer to device descriptor */
  2050.     int *maxBlkLimit, /* maximum block size for device */
  2051.     int *minBlkLimit /* minimum block size for device */
  2052.     )
  2054.     {
  2055.     if (maxBlkLimit != NULL)
  2056. *maxBlkLimit = A_REALLY_BIG_INTEGER;
  2058.     if (minBlkLimit != 0)
  2059. *minBlkLimit = 0;
  2061.     return OK;
  2062.     }
  2065. /***************************************************************************
  2066. *
  2067. * usbSpkrLoad - SEQ_DEV load routine
  2068. *
  2069. * RETURNS: not implemented, always returns OK for compatibility.
  2070. */
  2072. LOCAL STATUS usbSpkrLoad
  2073.     (
  2074.     pUSB_SPKR_SEQ_DEV pSeqDev,     /* pointer to device descriptor */
  2075.     BOOL load     /* load or unload device */
  2076.     )
  2078.     {
  2079.     return OK;
  2080.     }
  2083. /***************************************************************************
  2084. *
  2085. * usbSpkrSpace - SEQ_DEV space routine
  2086. *
  2087. * RETURNS: not implemented, always returns OK for compatibility.
  2088. */
  2090. LOCAL STATUS usbSpkrSpace
  2091.     (
  2092.     pUSB_SPKR_SEQ_DEV pSeqDev,     /* pointer to device descriptor */
  2093.     int count,     /* number of spaces */
  2094.     int spaceCode     /* type of space */
  2095.     )
  2097.     {
  2098.     return OK;
  2099.     }
  2102. /***************************************************************************
  2103. *
  2104. * usbSpkrErase - SEQ_DEV erase routine
  2105. *
  2106. * RETURNS: not implemented, always returns OK for compatibility.
  2107. */
  2109. LOCAL STATUS usbSpkrErase
  2110.     (
  2111.     pUSB_SPKR_SEQ_DEV pSeqDev     /* pointer to device descriptor */
  2112.     )
  2114.     {
  2115.     return OK;
  2116.     }
  2119. /***************************************************************************
  2120. *
  2121. * destroyAttachRequest - disposes of an ATTACH_REQUEST structure
  2122. *
  2123. * RETURNS: N/A
  2124. */
  2126. LOCAL VOID destroyAttachRequest
  2127.     (
  2128.     pATTACH_REQUEST pRequest
  2129.     )
  2131.     {
  2132.     /* Unlink request */
  2134.     usbListUnlink (&pRequest->reqLink);
  2136.     /* Dispose of structure */
  2138.     OSS_FREE (pRequest);
  2139.     }
  2142. /***************************************************************************
  2143. *
  2144. * destroySeqDev - disposes of a USB_SPKR_SEQ_DEV structure
  2145. *
  2146. * Unlinks the indicated USB_SPKR_SEQ_DEV structure and de-allocates
  2147. * resources associated with the device.
  2148. *
  2149. * RETURNS: N/A
  2150. */
  2152. LOCAL VOID destroySeqDev
  2153.     (
  2154.     pUSB_SPKR_SEQ_DEV pSeqDev
  2155.     )
  2157.     {
  2158.     /* Unlink the structure. */
  2160.     usbListUnlink (&pSeqDev->devLink);
  2162.     /* Release audio stream-related info */
  2164.     destroyAudioStream (pSeqDev, TRUE);
  2166.     /* Release per-channel data */
  2168.     if (pSeqDev->pCaps != NULL)
  2169. OSS_FREE (pSeqDev->pCaps);
  2171.     /* Release audio format data */
  2173.     if (pSeqDev->pFmt != NULL)
  2174. OSS_FREE (pSeqDev->pFmt);
  2176.     /* Release structure. */
  2178.     OSS_FREE (pSeqDev);
  2179.     }
  2182. /***************************************************************************
  2183. *
  2184. * createSeqDev - creates a new USB_SPKR_SEQ_DEV structure
  2185. *
  2186. * Creates a new USB_SPKR_SEQ_DEV structure for the indicated <nodeId>.
  2187. * If successful, the new structure is linked into the devList upon 
  2188. * return.
  2189. *
  2190. * <configuration> and <interface> identify the configuration/interface
  2191. * that first reported itself as an audio device.
  2192. *
  2193. * RETURNS: pointer to newly created structure, or NULL if failure
  2194. */
  2196. LOCAL pUSB_SPKR_SEQ_DEV createSeqDev
  2197.     (
  2198.     USBD_NODE_ID nodeId,
  2199.     UINT16 configuration,
  2200.     UINT16 interface
  2201.     )
  2203.     {
  2204.     pUSB_SPKR_SEQ_DEV pSeqDev;
  2207.     /* Try to allocate space for a new speaker struct */
  2209.     if ((pSeqDev = OSS_CALLOC (sizeof (*pSeqDev))) == NULL)
  2210. return NULL;
  2212.     pSeqDev->seqDev.sd_seqRd = usbSpkrSeqRd;
  2213.     pSeqDev->seqDev.sd_seqWrt = usbSpkrSeqWrt;
  2214.     pSeqDev->seqDev.sd_ioctl = usbSpkrIoctl;
  2215.     pSeqDev->seqDev.sd_seqWrtFileMarks = usbSpkrSeqWrtFileMarks;
  2216.     pSeqDev->seqDev.sd_rewind = usbSpkrRewind;
  2217.     pSeqDev->seqDev.sd_reserve = usbSpkrReserve;
  2218.     pSeqDev->seqDev.sd_release = usbSpkrRelease;
  2219.     pSeqDev->seqDev.sd_readBlkLim = usbSpkrReadBlkLim;
  2220.     pSeqDev->seqDev.sd_load = usbSpkrLoad;
  2221.     pSeqDev->seqDev.sd_space = usbSpkrSpace;
  2222.     pSeqDev->seqDev.sd_erase = usbSpkrErase;
  2223.     pSeqDev->seqDev.sd_reset = NULL;
  2224.     pSeqDev->seqDev.sd_statusChk = NULL;
  2226.     pSeqDev->seqDev.sd_blkSize     = 0;
  2227.     pSeqDev->seqDev.sd_mode = O_WRONLY;
  2228.     pSeqDev->seqDev.sd_readyChanged = TRUE;
  2229.     pSeqDev->seqDev.sd_maxVarBlockLimit = A_REALLY_BIG_INTEGER;
  2230.     pSeqDev->seqDev.sd_density     = 0;
  2232.     pSeqDev->nodeId = nodeId;
  2233.     pSeqDev->configuration = configuration;
  2235.     pSeqDev->connected = TRUE;
  2238.     /* Try to configure the speaker. */
  2240.     if (configureSeqDev (pSeqDev) != OK)
  2241. {
  2242. destroySeqDev (pSeqDev);
  2243. return NULL;
  2244. }
  2247.     /* Link the newly created structure. */
  2249.     usbListLink (&devList, pSeqDev, &pSeqDev->devLink, LINK_TAIL);
  2251.     return pSeqDev;
  2252.     }
  2255. /***************************************************************************
  2256. *
  2257. * findSeqDev - Searches for a USB_SPKR_SEQ_DEV for indicated node ID
  2258. *
  2259. * RETURNS: pointer to matching USB_SPKR_SEQ_DEV or NULL if not found
  2260. */
  2262. LOCAL pUSB_SPKR_SEQ_DEV findSeqDev
  2263.     (
  2264.     USBD_NODE_ID nodeId
  2265.     )
  2267.     {
  2268.     pUSB_SPKR_SEQ_DEV pSeqDev = usbListFirst (&devList);
  2270.     while (pSeqDev != NULL)
  2271. {
  2272. if (pSeqDev->nodeId == nodeId)
  2273.     break;
  2275. pSeqDev = usbListNext (&pSeqDev->devLink);
  2276. }
  2278.     return pSeqDev;
  2279.     }
  2282. /***************************************************************************
  2283. *
  2284. * notifyAttach - Notifies registered callers of attachment/removal
  2285. *
  2286. * RETURNS: N/A
  2287. */
  2289. LOCAL VOID notifyAttach
  2290.     (
  2291.     pUSB_SPKR_SEQ_DEV pSeqDev,
  2292.     UINT16 attachCode
  2293.     )
  2295.     {
  2296.     pATTACH_REQUEST pRequest = usbListFirst (&reqList);
  2298.     while (pRequest != NULL)
  2299. {
  2300. (*pRequest->callback) (pRequest->callbackArg, 
  2301.        (SEQ_DEV *) pSeqDev, 
  2302.        attachCode);
  2304. pRequest = usbListNext (&pRequest->reqLink);
  2305. }
  2306.     }
  2309. /***************************************************************************
  2310. *
  2311. * usbSpeakerAttachCallback - called by USBD when speaker attached/removed
  2312. *
  2313. * The USBD will invoke this callback when a USB audio device is attached to or
  2314. * removed from the system.  <nodeId> is the USBD_NODE_ID of the node being
  2315. * attached or removed. <attachAction> is USBD_DYNA_ATTACH or USBD_DYNA_REMOVE.
  2316. * Audio devices report their class information at the interface level, so 
  2317. * <configuration> and <interface> will indicate the configuratin/interface that 
  2318. * reports itself as an audio device.  Finally, <deviceClass>, <deviceSubClass>,
  2319. * and <deviceProtocol> will identify the type of audio device (eg. a speaker).
  2320. *
  2321. * NOTE: The USBD will invoke this function once for each configuration/
  2322. * interface which reports itself as an audio device.  So, it is possible that
  2323. * a single device insertion/removal may trigger multiple callbacks.  We
  2324. * ignore all callbacks except the first for a given device.  We also ignore
  2325. * audio devices that are not speakers (eg., we ignore microphones and other
  2326. * input audio devices).
  2327. *
  2328. * RETURNS: N/A
  2329. */
  2331. LOCAL VOID usbSpeakerAttachCallback
  2332.     (
  2333.     USBD_NODE_ID nodeId, 
  2334.     UINT16 attachAction, 
  2335.     UINT16 configuration,
  2336.     UINT16 interface,
  2337.     UINT16 deviceClass, 
  2338.     UINT16 deviceSubClass, 
  2339.     UINT16 deviceProtocol
  2340.     )
  2342.     {
  2343.     pUSB_SPKR_SEQ_DEV pSeqDev;
  2346.     OSS_MUTEX_TAKE (speakerMutex, OSS_BLOCK);
  2348.     /* Depending on the attach code, add a new speaker or disabled one
  2349.      * that's already been created.
  2350.      */
  2352.     switch (attachAction)
  2353. {
  2354. case USBD_DYNA_ATTACH:
  2356.     /* A new device is being attached.  Check if we already 
  2357.      * have a structure for this device.
  2358.      */
  2360.     if (findSeqDev (nodeId) != NULL)
  2361. break;
  2363.     /* Create a new structure to manage this device.  If there's
  2364.      * an error, there's nothing we can do about it, so skip the
  2365.      * device and return immediately. 
  2366.      */
  2368.     if ((pSeqDev = createSeqDev (nodeId, 
  2369.  configuration, 
  2370.  interface)) 
  2371. == NULL)
  2372. break;
  2374.     /* Notify registered callers that a new speaker has been
  2375.      * added and a new channel created.
  2376.      */
  2378.     notifyAttach (pSeqDev, USB_SPKR_ATTACH);
  2380.     break;
  2383. case USBD_DYNA_REMOVE:
  2385.     /* A device is being detached. Check if we have any
  2386.      * structures to manage this device.
  2387.      */
  2389.     if ((pSeqDev = findSeqDev (nodeId)) == NULL)
  2390. break;
  2392.     /* The device has been disconnected. */
  2394.     pSeqDev->connected = FALSE;
  2396.     /* Notify registered callers that the speaker has been
  2397.      * removed and the channel disabled. 
  2398.      *
  2399.      * NOTE: We temporarily increment the channel's lock count
  2400.      * to prevent usbSpeakerSeqDevUnlock() from destroying the
  2401.      * structure while we're still using it.
  2402.      */
  2404.     pSeqDev->lockCount++;
  2406.     notifyAttach (pSeqDev, USB_SPKR_REMOVE);
  2408.     pSeqDev->lockCount--;
  2410.     /* If no callers have the channel structure locked, destroy
  2411.      * it now.  If it is locked, it will be destroyed later during
  2412.      * a call to usbSpeakerUnlock().
  2413.      */
  2415.     if (pSeqDev->lockCount == 0)
  2416. destroySeqDev (pSeqDev);
  2418.     break;
  2419. }
  2421.     OSS_MUTEX_RELEASE (speakerMutex);
  2422.     }
  2425. /***************************************************************************
  2426. *
  2427. * doShutdown - shuts down USB speaker SIO driver
  2428. *
  2429. * <errCode> should be OK or S_usbSpeakerLib_xxxx.  This value will be
  2430. * passed to ossStatus() and the return value from ossStatus() is the
  2431. * return value of this function.
  2432. *
  2433. * RETURNS: OK, or ERROR per value of <errCode> passed by caller
  2434. */
  2436. LOCAL STATUS doShutdown
  2437.     (
  2438.     int errCode
  2439.     )
  2441.     {
  2442.     pATTACH_REQUEST pRequest;
  2443.     pUSB_SPKR_SEQ_DEV pSeqDev;
  2446.     /* Dispose of any outstanding notification requests */
  2448.     while ((pRequest = usbListFirst (&reqList)) != NULL)
  2449. destroyAttachRequest (pRequest);
  2452.     /* Dispose of any open speaker connections. */
  2454.     while ((pSeqDev = usbListFirst (&devList)) != NULL)
  2455. destroySeqDev (pSeqDev);
  2456.     
  2458.     /* Release our connection to the USBD.  The USBD automatically 
  2459.      * releases any outstanding dynamic attach requests when a client
  2460.      * unregisters.
  2461.      */
  2463.     if (usbdHandle != NULL)
  2464. {
  2465. usbdClientUnregister (usbdHandle);
  2466. usbdHandle = NULL;
  2467. }
  2470.     /* Release resources. */
  2472.     if (speakerMutex != NULL)
  2473. {
  2474. OSS_MUTEX_DESTROY (speakerMutex);
  2475. speakerMutex = NULL;
  2476. }
  2479.     return ossStatus (errCode);
  2480.     }
  2483. /***************************************************************************
  2484. *
  2485. * usbSpeakerDevInit - initialize USB speaker SIO driver
  2486. *
  2487. * Initializes the USB speaker SIO driver.  The USB speaker SIO driver
  2488. * maintains an initialization count, so calls to this function may be
  2489. * nested.
  2490. *
  2491. * RETURNS: OK, or ERROR if unable to initialize.
  2492. *
  2493. * ERRNO:
  2494. *
  2495. *   S_usbSpeakerLib_OUT_OF_RESOURCES
  2496. *   S_usbSpeakerLib_USBD_FAULT
  2497. */
  2499. STATUS usbSpeakerDevInit (void)
  2500.     {
  2501.     /* If not already initialized, then initialize internal structures
  2502.      * and connection to USBD.
  2503.      */
  2505.     if (initCount == 0)
  2506.     {
  2507.     /* Initialize lists, structures, resources. */
  2509.     memset (&devList, 0, sizeof (devList));
  2510.     memset (&reqList, 0, sizeof (reqList));
  2511.     speakerMutex = NULL;
  2512.     usbdHandle = NULL;
  2515.     if (OSS_MUTEX_CREATE (&speakerMutex) != OK)
  2516. return doShutdown (S_usbSpeakerLib_OUT_OF_RESOURCES);
  2519.     /* Establish connection to USBD */
  2521.     if (usbdClientRegister (SPKR_CLIENT_NAME, &usbdHandle) != OK ||
  2522. usbdDynamicAttachRegister (usbdHandle, 
  2523.    USB_CLASS_AUDIO,
  2524.    USBD_NOTIFY_ALL, 
  2525.    USBD_NOTIFY_ALL,
  2526.    usbSpeakerAttachCallback) 
  2527.    != OK)
  2528. {
  2529. return doShutdown (S_usbSpeakerLib_USBD_FAULT);
  2530. }
  2531.     }
  2533.     initCount++;
  2535.     return OK;
  2536.     }
  2539. /***************************************************************************
  2540. *
  2541. * usbSpeakerDevShutdown - shuts down speaker SIO driver
  2542. *
  2543. * RETURNS: OK, or ERROR if unable to shutdown.
  2544. *
  2545. * ERRNO:
  2546. *   S_usbSpeakerLib_NOT_INITIALIZED
  2547. */
  2549. STATUS usbSpeakerDevShutdown (void)
  2550.     {
  2551.     /* Shut down the USB speaker SIO driver if the initCount goes to 0. */
  2553.     if (initCount == 0)
  2554. return ossStatus (S_usbSpeakerLib_NOT_INITIALIZED);
  2556.     if (--initCount == 0)
  2557. return doShutdown (OK);
  2559.     return OK;
  2560.     }
  2563. /***************************************************************************
  2564. *
  2565. * usbSpeakerDynamicAttachRegister - Register speaker attach callback
  2566. *
  2567. * <callback> is a caller-supplied function of the form:
  2568. *
  2569. * .CS
  2570. * typedef (*USB_SPKR_ATTACH_CALLBACK) 
  2571. *     (
  2572. *     pVOID arg,
  2573. *     SEQ_DEV *pSeqDev,
  2574. *     UINT16 attachCode
  2575. *     );
  2576. * .CE
  2577. *
  2578. * usbSpeakerLib will invoke <callback> each time a USB speaker
  2579. * is attached to or removed from the system.  <arg> is a caller-defined
  2580. * parameter which will be passed to the <callback> each time it is
  2581. * invoked.  The <callback> will also be passed a pointer to the 
  2582. * SEQ_DEV structure for the channel being created/destroyed and
  2583. * an attach code of USB_SPKR_ATTACH or USB_SPKR_REMOVE.
  2584. *
  2585. * RETURNS: OK, or ERROR if unable to register callback
  2586. *
  2587. * ERRNO:
  2588. *   S_usbSpeakerLib_BAD_PARAM
  2589. *   S_usbSpeakerLib_OUT_OF_MEMORY
  2590. */
  2592. STATUS usbSpeakerDynamicAttachRegister
  2593.     (
  2594.     USB_SPKR_ATTACH_CALLBACK callback, /* new callback to be registered */
  2595.     pVOID arg     /* user-defined arg to callback */
  2596.     )
  2598.     {
  2599.     pATTACH_REQUEST pRequest;
  2600.     pUSB_SPKR_SEQ_DEV pSeqDev;
  2601.     int status = OK;
  2604.     /* Validate parameters */
  2606.     if (callback == NULL)
  2607. return ossStatus (S_usbSpeakerLib_BAD_PARAM);
  2610.     OSS_MUTEX_TAKE (speakerMutex, OSS_BLOCK);
  2613.     /* Create a new request structure to track this callback request. */
  2615.     if ((pRequest = OSS_CALLOC (sizeof (*pRequest))) == NULL)
  2616. status = S_usbSpeakerLib_OUT_OF_MEMORY;
  2617.     else
  2618. {
  2619. pRequest->callback = callback;
  2620. pRequest->callbackArg = arg;
  2622. usbListLink (&reqList, pRequest, &pRequest->reqLink, LINK_TAIL);
  2625. /* Perform an initial notification of all currrently attached
  2626.  * speaker devices.
  2627.  */
  2629. pSeqDev = usbListFirst (&devList);
  2631. while (pSeqDev != NULL)
  2632.     {
  2633.     if (pSeqDev->connected)
  2634. (*callback) (arg, (SEQ_DEV *) pSeqDev, USB_SPKR_ATTACH);
  2636.     pSeqDev = usbListNext (&pSeqDev->devLink);
  2637.     }
  2638. }
  2640.     OSS_MUTEX_RELEASE (speakerMutex);
  2642.     return ossStatus (status);
  2643.     }
  2646. /***************************************************************************
  2647. *
  2648. * usbSpeakerDynamicAttachUnregister - Unregisters speaker attach callback
  2649. *
  2650. * This function cancels a previous request to be dynamically notified for
  2651. * speaker attachment and removal.  The <callback> and <arg> paramters must
  2652. * exactly match those passed in a previous call to 
  2653. * usbSpeakerDynamicAttachRegister().
  2654. *
  2655. * RETURNS: OK, or ERROR if unable to unregister callback
  2656. *
  2657. * ERRNO:
  2658. *   S_usbSpeakerLib_NOT_REGISTERED
  2659. */
  2661. STATUS usbSpeakerDynamicAttachUnRegister
  2662.     (
  2663.     USB_SPKR_ATTACH_CALLBACK callback, /* callback to be unregistered */
  2664.     pVOID arg     /* user-defined arg to callback */
  2665.     )
  2667.     {
  2668.     pATTACH_REQUEST pRequest;
  2669.     int status = S_usbSpeakerLib_NOT_REGISTERED;
  2671.     OSS_MUTEX_TAKE (speakerMutex, OSS_BLOCK);
  2673.     pRequest = usbListFirst (&reqList);
  2675.     while (pRequest != NULL)
  2676. {
  2677. if (callback == pRequest->callback && arg == pRequest->callbackArg)
  2678.     {
  2679.     /* We found a matching notification request. */
  2681.     destroyAttachRequest (pRequest);
  2682.     status = OK;
  2683.     break;
  2684.     }
  2686. pRequest = usbListNext (&pRequest->reqLink);
  2687. }
  2689.     OSS_MUTEX_RELEASE (speakerMutex);
  2691.     return ossStatus (status);
  2692.     }
  2695. /***************************************************************************
  2696. *
  2697. * usbSpeakerSeqDevLock - Marks SEQ_DEV structure as in use
  2698. *
  2699. * A caller uses usbSpeakerSeqDevLock() to notify usbSpeakerLib that
  2700. * it is using the indicated SEQ_DEV structure. usbSpeakerLib maintains
  2701. * a count of callers using a particular SEQ_DEV structure so that it 
  2702. * knows when it is safe to dispose of a structure when the underlying
  2703. * USB speaker is removed from the system.  So long as the "lock count"
  2704. * is greater than zero, usbSpeakerLib will not dispose of an SEQ_DEV
  2705. * structure.
  2706. *
  2707. * RETURNS: OK, or ERROR if unable to mark SEQ_DEV structure in use.
  2708. */
  2710. STATUS usbSpeakerSeqDevLock
  2711.     (
  2712.     SEQ_DEV *pChan /* SEQ_DEV to be marked as in use */
  2713.     )
  2715.     {
  2716.     pUSB_SPKR_SEQ_DEV pSeqDev = (pUSB_SPKR_SEQ_DEV) pChan;
  2717.     pSeqDev->lockCount++;
  2719.     return OK;
  2720.     }
  2723. /***************************************************************************
  2724. *
  2725. * usbSpeakerSeqDevUnlock - Marks SEQ_DEV structure as unused
  2726. *
  2727. * This function releases a lock placed on an SEQ_DEV structure.  When a
  2728. * caller no longer needs an SEQ_DEV structure for which it has previously
  2729. * called usbSpeakerSeqDevLock(), then it should call this function to
  2730. * release the lock.
  2731. *
  2732. * NOTE: If the underlying USB speaker device has already been removed
  2733. * from the system, then this function will automatically dispose of the
  2734. * SEQ_DEV structure if this call removes the last lock on the structure.
  2735. * Therefore, a caller must not reference the SEQ_DEV again structure after
  2736. * making this call.
  2737. *
  2738. * RETURNS: OK, or ERROR if unable to mark SEQ_DEV structure unused
  2739. *
  2740. * ERRNO:
  2741. *   S_usbSpeakerLib_NOT_LOCKED
  2742. */
  2744. STATUS usbSpeakerSeqDevUnlock
  2745.     (
  2746.     SEQ_DEV *pChan /* SEQ_DEV to be marked as unused */
  2747.     )
  2749.     {
  2750.     pUSB_SPKR_SEQ_DEV pSeqDev = (pUSB_SPKR_SEQ_DEV) pChan;
  2751.     int status = OK;
  2754.     OSS_MUTEX_TAKE (speakerMutex, OSS_BLOCK);
  2756.     if (pSeqDev->lockCount == 0)
  2757. status = S_usbSpeakerLib_NOT_LOCKED;
  2758.     else
  2759. {
  2760. /* If this is the last lock and the underlying USB speaker is
  2761.  * no longer connected, then dispose of the speaker.
  2762.  */
  2764. if (--pSeqDev->lockCount == 0 && !pSeqDev->connected)
  2765.     destroySeqDev (pSeqDev);
  2766. }
  2768.     OSS_MUTEX_RELEASE (speakerMutex);
  2770.     return ossStatus (status);
  2771.     }
  2774. /* end of file */