/*
* ======== WMD_CHNL_Close ========
* Purpose:
* Ensures all pending I/O on this channel is cancelled, discards all
* queued I/O completion notifications, then frees the resources allocated
* for this channel, and makes the corresponding logical channel id
* available for subsequent use.
*/
DSP_STATUS WMD_CHNL_Close(struct CHNL_OBJECT *hChnl)
{
DSP_STATUS status;
struct CHNL_OBJECT *pChnl = (struct CHNL_OBJECT *)hChnl;
/* Check args: */
if (!MEM_IsValidHandle(pChnl, CHNL_SIGNATURE)) {
status = DSP_EHANDLE;
goto func_cont;
}
{
/* Cancel IO: this ensures no further IO requests or
* notifications.*/
status = WMD_CHNL_CancelIO(hChnl);
}
func_cont:
if (DSP_SUCCEEDED(status)) {
/* Assert I/O on this channel is now cancelled: Protects
* from IO_DPC. */
DBC_Assert((pChnl->dwState & CHNL_STATECANCEL));
/* Invalidate channel object: Protects from
* CHNL_GetIOCompletion(). */
pChnl->dwSignature = 0x0000;
/* Free the slot in the channel manager: */
pChnl->pChnlMgr->apChannel[pChnl->uId] = NULL;
pChnl->pChnlMgr->cOpenChannels -= 1;
if (pChnl->hNtfy) {
NTFY_Delete(pChnl->hNtfy);
pChnl->hNtfy = NULL;
}
/* Reset channel event: (NOTE: hUserEvent freed in user
* context.). */
if (pChnl->hSyncEvent) {
SYNC_ResetEvent(pChnl->hSyncEvent);
SYNC_CloseEvent(pChnl->hSyncEvent);
pChnl->hSyncEvent = NULL;
}
/* Free I/O request and I/O completion queues: */
if (pChnl->pIOCompletions) {
FreeChirpList(pChnl->pIOCompletions);
pChnl->pIOCompletions = NULL;
pChnl->cIOCs = 0;
}
if (pChnl->pIORequests) {
FreeChirpList(pChnl->pIORequests);
pChnl->pIORequests = NULL;
pChnl->cIOReqs = 0;
}
if (pChnl->pFreeList) {
FreeChirpList(pChnl->pFreeList);
pChnl->pFreeList = NULL;
}
/* Release channel object. */
MEM_FreeObject(pChnl);
pChnl = NULL;
}
DBC_Ensure(DSP_FAILED(status) ||
!MEM_IsValidHandle(pChnl, CHNL_SIGNATURE));
return status;
}
/*
* ======== WMD_MSG_DeleteQueue ========
* Delete a MSG queue allocated in WMD_MSG_CreateQueue.
*/
void WMD_MSG_DeleteQueue(struct MSG_QUEUE *hMsgQueue)
{
struct MSG_MGR *hMsgMgr = hMsgQueue->hMsgMgr;
u32 refCount;
DBC_Require(MEM_IsValidHandle(hMsgQueue, MSGQ_SIGNATURE));
hMsgQueue->fDone = true;
/* Unblock all threads blocked in MSG_Get() or MSG_Put(). */
refCount = hMsgQueue->refCount;
while (refCount) {
/* Unblock thread */
SYNC_SetEvent(hMsgQueue->hSyncDone);
/* Wait for acknowledgement */
SYNC_WaitOnEvent(hMsgQueue->hSyncDoneAck, SYNC_INFINITE);
refCount = hMsgQueue->refCount;
}
/* Remove message queue from hMsgMgr->queueList */
(void)SYNC_EnterCS(hMsgMgr->hSyncCS);
LST_RemoveElem(hMsgMgr->queueList, (struct LST_ELEM *)hMsgQueue);
/* Free the message queue object */
DeleteMsgQueue(hMsgQueue, hMsgQueue->uMaxMsgs);
if (!hMsgMgr->msgFreeList)
goto func_cont;
if (LST_IsEmpty(hMsgMgr->msgFreeList))
SYNC_ResetEvent(hMsgMgr->hSyncEvent);
func_cont:
(void)SYNC_LeaveCS(hMsgMgr->hSyncCS);
}
/*
* ======== WMD_CHNL_GetIOC ========
* Optionally wait for I/O completion on a channel. Dequeue an I/O
* completion record, which contains information about the completed
* I/O request.
* Note: Ensures Channel Invariant (see notes above).
*/
DSP_STATUS WMD_CHNL_GetIOC(struct CHNL_OBJECT *hChnl, u32 dwTimeOut,
OUT struct CHNL_IOC *pIOC)
{
DSP_STATUS status = DSP_SOK;
struct CHNL_OBJECT *pChnl = (struct CHNL_OBJECT *)hChnl;
struct CHNL_IRP *pChirp;
DSP_STATUS statSync;
bool fDequeueIOC = true;
struct CHNL_IOC ioc = { NULL, 0, 0, 0, 0 };
u8 *pHostSysBuf = NULL;
struct WMD_DEV_CONTEXT *dev_ctxt;
struct DEV_OBJECT *dev_obj;
/* Check args: */
if (pIOC == NULL) {
status = DSP_EPOINTER;
} else if (!MEM_IsValidHandle(pChnl, CHNL_SIGNATURE)) {
status = DSP_EHANDLE;
} else if (dwTimeOut == CHNL_IOCNOWAIT) {
if (LST_IsEmpty(pChnl->pIOCompletions))
status = CHNL_E_NOIOC;
}
dev_obj = DEV_GetFirst();
DEV_GetWMDContext(dev_obj, &dev_ctxt);
if (!dev_ctxt)
status = DSP_EHANDLE;
if (DSP_FAILED(status))
goto func_end;
ioc.status = CHNL_IOCSTATCOMPLETE;
if (dwTimeOut != CHNL_IOCNOWAIT && LST_IsEmpty(pChnl->pIOCompletions)) {
if (dwTimeOut == CHNL_IOCINFINITE)
dwTimeOut = SYNC_INFINITE;
statSync = SYNC_WaitOnEvent(pChnl->hSyncEvent, dwTimeOut);
if (statSync == DSP_ETIMEOUT) {
/* No response from DSP */
ioc.status |= CHNL_IOCSTATTIMEOUT;
fDequeueIOC = false;
} else if (statSync == DSP_EFAIL) {
/* This can occur when the user mode thread is
* aborted (^C), or when _VWIN32_WaitSingleObject()
* fails due to unkown causes. */
/* Even though Wait failed, there may be something in
* the Q: */
if (LST_IsEmpty(pChnl->pIOCompletions)) {
ioc.status |= CHNL_IOCSTATCANCEL;
fDequeueIOC = false;
}
}
}
/* See comment in AddIOReq */
SYNC_EnterCS(pChnl->pChnlMgr->hCSObj);
omap_mbox_disable_irq(dev_ctxt->mbox, IRQ_RX);
if (fDequeueIOC) {
/* Dequeue IOC and set pIOC; */
DBC_Assert(!LST_IsEmpty(pChnl->pIOCompletions));
pChirp = (struct CHNL_IRP *)LST_GetHead(pChnl->pIOCompletions);
/* Update pIOC from channel state and chirp: */
if (pChirp) {
pChnl->cIOCs--;
/* If this is a zero-copy channel, then set IOC's pBuf
* to the DSP's address. This DSP address will get
* translated to user's virtual addr later. */
{
pHostSysBuf = pChirp->pHostSysBuf;
ioc.pBuf = pChirp->pHostUserBuf;
}
ioc.cBytes = pChirp->cBytes;
ioc.cBufSize = pChirp->cBufSize;
ioc.dwArg = pChirp->dwArg;
ioc.status |= pChirp->status;
/* Place the used chirp on the free list: */
LST_PutTail(pChnl->pFreeList,
(struct list_head *)pChirp);
} else {
ioc.pBuf = NULL;
ioc.cBytes = 0;
}
} else {
ioc.pBuf = NULL;
ioc.cBytes = 0;
ioc.dwArg = 0;
ioc.cBufSize = 0;
}
/* Ensure invariant: If any IOC's are queued for this channel... */
if (!LST_IsEmpty(pChnl->pIOCompletions)) {
/* Since DSPStream_Reclaim() does not take a timeout
* parameter, we pass the stream's timeout value to
* WMD_CHNL_GetIOC. We cannot determine whether or not
* we have waited in User mode. Since the stream's timeout
* value may be non-zero, we still have to set the event.
* Therefore, this optimization is taken out.
*
* if (dwTimeOut == CHNL_IOCNOWAIT) {
* ... ensure event is set..
* SYNC_SetEvent(pChnl->hSyncEvent);
* } */
SYNC_SetEvent(pChnl->hSyncEvent);
} else {
/* else, if list is empty, ensure event is reset. */
SYNC_ResetEvent(pChnl->hSyncEvent);
}
omap_mbox_enable_irq(dev_ctxt->mbox, IRQ_RX);
SYNC_LeaveCS(pChnl->pChnlMgr->hCSObj);
if (fDequeueIOC && (pChnl->uChnlType == CHNL_PCPY && pChnl->uId > 1)) {
if (!(ioc.pBuf < (void *) USERMODE_ADDR))
goto func_cont;
/* If the addr is in user mode, then copy it */
if (!pHostSysBuf || !ioc.pBuf) {
status = DSP_EPOINTER;
goto func_cont;
}
if (!CHNL_IsInput(pChnl->uMode))
goto func_cont1;
/*pHostUserBuf */
status = copy_to_user(ioc.pBuf, pHostSysBuf, ioc.cBytes);
if (status) {
if (current->flags & PF_EXITING)
status = 0;
}
if (status)
status = DSP_EPOINTER;
func_cont1:
kfree(pHostSysBuf);
}
func_cont:
/* Update User's IOC block: */
*pIOC = ioc;
func_end:
return status;
}
/*
* ======== WMD_CHNL_GetIOC ========
* Optionally wait for I/O completion on a channel. Dequeue an I/O
* completion record, which contains information about the completed
* I/O request.
* Note: Ensures Channel Invariant (see notes above).
*/
DSP_STATUS WMD_CHNL_GetIOC(struct CHNL_OBJECT *hChnl, u32 dwTimeOut,
OUT struct CHNL_IOC *pIOC)
{
DSP_STATUS status = DSP_SOK;
struct CHNL_OBJECT *pChnl = (struct CHNL_OBJECT *)hChnl;
struct CHNL_IRP *pChirp;
DSP_STATUS statSync;
bool fDequeueIOC = true;
struct CHNL_IOC ioc = { NULL, 0, 0, 0, 0 };
u8 *pHostSysBuf = NULL;
DBG_Trace(DBG_ENTER, "> WMD_CHNL_GetIOC pChnl %p CHNL_IsOutput %x "
"uChnlType %x\n", pChnl, CHNL_IsOutput(pChnl->uMode),
pChnl->uChnlType);
/* Check args: */
if (pIOC == NULL) {
status = DSP_EPOINTER;
} else if (!MEM_IsValidHandle(pChnl, CHNL_SIGNATURE)) {
status = DSP_EHANDLE;
} else if (dwTimeOut == CHNL_IOCNOWAIT) {
if (LST_IsEmpty(pChnl->pIOCompletions))
status = CHNL_E_NOIOC;
}
if (DSP_FAILED(status))
goto func_end;
ioc.status = CHNL_IOCSTATCOMPLETE;
if (dwTimeOut != CHNL_IOCNOWAIT && LST_IsEmpty(pChnl->pIOCompletions)) {
if (dwTimeOut == CHNL_IOCINFINITE)
dwTimeOut = SYNC_INFINITE;
statSync = SYNC_WaitOnEvent(pChnl->hSyncEvent, dwTimeOut);
if (statSync == DSP_ETIMEOUT) {
/* No response from DSP */
ioc.status |= CHNL_IOCSTATTIMEOUT;
fDequeueIOC = false;
} else if (statSync == DSP_EFAIL) {
/* This can occur when the user mode thread is
* aborted (^C), or when _VWIN32_WaitSingleObject()
* fails due to unkown causes. */
/* Even though Wait failed, there may be something in
* the Q: */
if (LST_IsEmpty(pChnl->pIOCompletions)) {
ioc.status |= CHNL_IOCSTATCANCEL;
fDequeueIOC = false;
}
}
}
/* See comment in AddIOReq */
SYNC_EnterCS(pChnl->pChnlMgr->hCSObj);
disable_irq(MAILBOX_IRQ);
if (fDequeueIOC) {
/* Dequeue IOC and set pIOC; */
DBC_Assert(!LST_IsEmpty(pChnl->pIOCompletions));
pChirp = (struct CHNL_IRP *)LST_GetHead(pChnl->pIOCompletions);
/* Update pIOC from channel state and chirp: */
if (pChirp) {
pChnl->cIOCs--;
/* If this is a zero-copy channel, then set IOC's pBuf
* to the DSP's address. This DSP address will get
* translated to user's virtual addr later. */
{
pHostSysBuf = pChirp->pHostSysBuf;
ioc.pBuf = pChirp->pHostUserBuf;
}
ioc.cBytes = pChirp->cBytes;
ioc.cBufSize = pChirp->cBufSize;
ioc.dwArg = pChirp->dwArg;
ioc.status |= pChirp->status;
/* Place the used chirp on the free list: */
LST_PutTail(pChnl->pFreeList, (struct LST_ELEM *)
pChirp);
} else {
ioc.pBuf = NULL;
ioc.cBytes = 0;
}
} else {
ioc.pBuf = NULL;
ioc.cBytes = 0;
ioc.dwArg = 0;
ioc.cBufSize = 0;
}
/* Ensure invariant: If any IOC's are queued for this channel... */
if (!LST_IsEmpty(pChnl->pIOCompletions)) {
/* Since DSPStream_Reclaim() does not take a timeout
* parameter, we pass the stream's timeout value to
* WMD_CHNL_GetIOC. We cannot determine whether or not
* we have waited in User mode. Since the stream's timeout
* value may be non-zero, we still have to set the event.
* Therefore, this optimization is taken out.
*
* if (dwTimeOut == CHNL_IOCNOWAIT) {
* ... ensure event is set..
* SYNC_SetEvent(pChnl->hSyncEvent);
* } */
SYNC_SetEvent(pChnl->hSyncEvent);
} else {
/* else, if list is empty, ensure event is reset. */
SYNC_ResetEvent(pChnl->hSyncEvent);
}
enable_irq(MAILBOX_IRQ);
SYNC_LeaveCS(pChnl->pChnlMgr->hCSObj);
if (fDequeueIOC && (pChnl->uChnlType == CHNL_PCPY && pChnl->uId > 1)) {
if (!(ioc.pBuf < (void *) USERMODE_ADDR))
goto func_cont;
/* If the addr is in user mode, then copy it */
if (!pHostSysBuf || !ioc.pBuf) {
status = DSP_EPOINTER;
DBG_Trace(DBG_LEVEL7,
"System buffer NULL in IO completion.\n");
goto func_cont;
}
if (!CHNL_IsInput(pChnl->uMode))
goto func_cont1;
/*pHostUserBuf */
status = copy_to_user(ioc.pBuf, pHostSysBuf, ioc.cBytes);
#ifndef RES_CLEANUP_DISABLE
if (status) {
if (current->flags & PF_EXITING) {
DBG_Trace(DBG_LEVEL7,
"\n2current->flags == PF_EXITING, "
" current->flags;0x%x\n",
current->flags);
status = 0;
} else {
DBG_Trace(DBG_LEVEL7,
"\n2current->flags != PF_EXITING, "
" current->flags;0x%x\n",
current->flags);
}
}
#endif
if (status) {
DBG_Trace(DBG_LEVEL7,
"Error copying kernel buffer to user, %d"
" bytes remaining. in_interupt %d\n",
status, in_interrupt());
status = DSP_EPOINTER;
}
func_cont1:
MEM_Free(pHostSysBuf);
}
func_cont:
/* Update User's IOC block: */
*pIOC = ioc;
func_end:
DBG_Trace(DBG_ENTER, "< WMD_CHNL_GetIOC pChnl %p\n", pChnl);
return status;
}
/*
* ======== WMD_MSG_Put ========
* Put a message onto a MSG queue.
*/
DSP_STATUS WMD_MSG_Put(struct MSG_QUEUE *hMsgQueue,
IN CONST struct DSP_MSG *pMsg, u32 uTimeout)
{
struct MSG_FRAME *pMsgFrame;
struct MSG_MGR *hMsgMgr;
bool fPutMsg = false;
struct SYNC_OBJECT *hSyncs[2];
u32 uIndex;
DSP_STATUS status = DSP_SOK;
DBC_Require(MEM_IsValidHandle(hMsgQueue, MSGQ_SIGNATURE));
DBC_Require(pMsg != NULL);
hMsgMgr = hMsgQueue->hMsgMgr;
if (!hMsgMgr->msgFreeList) {
status = DSP_EHANDLE;
goto func_end;
}
(void) SYNC_EnterCS(hMsgMgr->hSyncCS);
/* If a message frame is available, use it */
if (!LST_IsEmpty(hMsgMgr->msgFreeList)) {
pMsgFrame = (struct MSG_FRAME *)LST_GetHead(hMsgMgr->
msgFreeList);
if (pMsgFrame != NULL) {
pMsgFrame->msgData.msg = *pMsg;
pMsgFrame->msgData.dwId = hMsgQueue->dwId;
LST_PutTail(hMsgMgr->msgUsedList, (struct LST_ELEM *)
pMsgFrame);
hMsgMgr->uMsgsPending++;
fPutMsg = true;
}
if (LST_IsEmpty(hMsgMgr->msgFreeList))
SYNC_ResetEvent(hMsgMgr->hSyncEvent);
/* Release critical section before scheduling DPC */
(void)SYNC_LeaveCS(hMsgMgr->hSyncCS);
/* Schedule a DPC, to do the actual data transfer: */
IO_Schedule(hMsgMgr->hIOMgr);
} else {
if (hMsgQueue->fDone)
status = DSP_EFAIL;
else
hMsgQueue->refCount++;
(void)SYNC_LeaveCS(hMsgMgr->hSyncCS);
}
if (DSP_SUCCEEDED(status) && !fPutMsg) {
/* Wait til a free message frame is available, timeout,
* or done */
hSyncs[0] = hMsgMgr->hSyncEvent;
hSyncs[1] = hMsgQueue->hSyncDone;
status = SYNC_WaitOnMultipleEvents(hSyncs, 2, uTimeout,
&uIndex);
/* Enter critical section */
(void)SYNC_EnterCS(hMsgMgr->hSyncCS);
if (hMsgQueue->fDone) {
hMsgQueue->refCount--;
/* Exit critical section */
(void)SYNC_LeaveCS(hMsgMgr->hSyncCS);
/* Signal that we're not going to access hMsgQueue
* anymore, so it can be deleted. */
(void)SYNC_SetEvent(hMsgQueue->hSyncDoneAck);
status = DSP_EFAIL;
} else {
if (DSP_SUCCEEDED(status)) {
if (LST_IsEmpty(hMsgMgr->msgFreeList)) {
status = DSP_EPOINTER;
goto func_cont;
}
/* Get msg from free list */
pMsgFrame = (struct MSG_FRAME *)
LST_GetHead(hMsgMgr->msgFreeList);
/* Copy message into pMsg and put frame on the
* used list */
if (pMsgFrame != NULL) {
pMsgFrame->msgData.msg = *pMsg;
pMsgFrame->msgData.dwId =
hMsgQueue->dwId;
LST_PutTail(hMsgMgr->msgUsedList,
(struct LST_ELEM *)
pMsgFrame);
hMsgMgr->uMsgsPending++;
/* Schedule a DPC, to do the actual
* data transfer: */
IO_Schedule(hMsgMgr->hIOMgr);
}
}
hMsgQueue->refCount--;
/* Reset event if there are still frames available */
if (!LST_IsEmpty(hMsgMgr->msgFreeList))
SYNC_SetEvent(hMsgMgr->hSyncEvent);
func_cont:
/* Exit critical section */
(void) SYNC_LeaveCS(hMsgMgr->hSyncCS);
}
}
func_end:
return status;
}
/*
* ======== WMD_MSG_Get ========
* Get a message from a MSG queue.
*/
DSP_STATUS WMD_MSG_Get(struct MSG_QUEUE *hMsgQueue,
struct DSP_MSG *pMsg, u32 uTimeout)
{
struct MSG_FRAME *pMsgFrame;
struct MSG_MGR *hMsgMgr;
bool fGotMsg = false;
struct SYNC_OBJECT *hSyncs[2];
u32 uIndex;
DSP_STATUS status = DSP_SOK;
DBC_Require(MEM_IsValidHandle(hMsgQueue, MSGQ_SIGNATURE));
DBC_Require(pMsg != NULL);
hMsgMgr = hMsgQueue->hMsgMgr;
if (!hMsgQueue->msgUsedList) {
status = DSP_EHANDLE;
goto func_end;
}
/* Enter critical section */
(void)SYNC_EnterCS(hMsgMgr->hSyncCS);
/* If a message is already there, get it */
if (!LST_IsEmpty(hMsgQueue->msgUsedList)) {
pMsgFrame = (struct MSG_FRAME *)LST_GetHead(hMsgQueue->
msgUsedList);
if (pMsgFrame != NULL) {
*pMsg = pMsgFrame->msgData.msg;
LST_PutTail(hMsgQueue->msgFreeList,
(struct LST_ELEM *)pMsgFrame);
if (LST_IsEmpty(hMsgQueue->msgUsedList))
SYNC_ResetEvent(hMsgQueue->hSyncEvent);
else {
NTFY_Notify(hMsgQueue->hNtfy,
DSP_NODEMESSAGEREADY);
SYNC_SetEvent(hMsgQueue->hSyncEvent);
}
fGotMsg = true;
}
} else {
if (hMsgQueue->fDone)
status = DSP_EFAIL;
else
hMsgQueue->refCount++;
}
/* Exit critical section */
(void)SYNC_LeaveCS(hMsgMgr->hSyncCS);
if (DSP_SUCCEEDED(status) && !fGotMsg) {
/* Wait til message is available, timeout, or done. We don't
* have to schedule the DPC, since the DSP will send messages
* when they are available. */
hSyncs[0] = hMsgQueue->hSyncEvent;
hSyncs[1] = hMsgQueue->hSyncDone;
status = SYNC_WaitOnMultipleEvents(hSyncs, 2, uTimeout,
&uIndex);
/* Enter critical section */
(void)SYNC_EnterCS(hMsgMgr->hSyncCS);
if (hMsgQueue->fDone) {
hMsgQueue->refCount--;
/* Exit critical section */
(void)SYNC_LeaveCS(hMsgMgr->hSyncCS);
/* Signal that we're not going to access hMsgQueue
* anymore, so it can be deleted. */
(void)SYNC_SetEvent(hMsgQueue->hSyncDoneAck);
status = DSP_EFAIL;
} else {
if (DSP_SUCCEEDED(status)) {
DBC_Assert(!LST_IsEmpty(hMsgQueue->
msgUsedList));
/* Get msg from used list */
pMsgFrame = (struct MSG_FRAME *)
LST_GetHead(hMsgQueue->msgUsedList);
/* Copy message into pMsg and put frame on the
* free list */
if (pMsgFrame != NULL) {
*pMsg = pMsgFrame->msgData.msg;
LST_PutTail(hMsgQueue->msgFreeList,
(struct LST_ELEM *)pMsgFrame);
}
}
hMsgQueue->refCount--;
/* Reset the event if there are still queued messages */
if (!LST_IsEmpty(hMsgQueue->msgUsedList)) {
NTFY_Notify(hMsgQueue->hNtfy,
DSP_NODEMESSAGEREADY);
SYNC_SetEvent(hMsgQueue->hSyncEvent);
}
/* Exit critical section */
(void)SYNC_LeaveCS(hMsgMgr->hSyncCS);
}
}
func_end:
return status;
}